.
使用dom4j解析xml文档
* 1.SAXReader对象(dom4j核心类)
a) read(…) 加载执行xml文档
2. Document对象
a) Element e = getRootElement() 获得根元素
3. Element对象
a) Element [] eleArr = elements(…) 获得指定名称的所有子元素。可以不指定名称
b) element(…) 获得指定名称第一个子元素。可以不指定名称
c) getName() 获得当前元素的元素名
d) attributeValue(…) 获得指定属性名的属性值
e) elementText(…) 获得指定名称子元素的文本值
f) getText() 获得当前元素的文本内容
操作步骤:
1.创建dom4j核心对象SAXReader
2.使用SAXReader中read方法读取xml文档,生成Document对象
3.使用Document中方法getRootElement获取根元素Element
4.使用Element中的方法elements获取所有bean元素
5.遍历包含bean元素的集合,获取每一个bean元素
6.使用Element中的方法attributeValue获取bean元素上属性的值
7.使用Element中的方法elements获取所有property元素
8.遍历包含property元素的集合,获取每一个property元素
9.使用Element中的方法attributeValue获取property元素上属性的值
10.使用Element中的方法getText获取获取property元素上文本值
1 public class UseDom4jParseXML {
2 public static void main(String[] args) throws Exception {
3 //1.创建dom4j核心对象SAXReader
4 SAXReader sax = new SAXReader();
5 //2.使用SAXReader中read方法读取xml文档,生成Document对象
6 Document docu = sax.read("bean.xml");
7 //3.使用Document中方法getRootElement获取根元素Element
8 Element rootElement = docu.getRootElement();
9 //4.使用Element中的方法elements获取所有bean元素
10 List<Element> beanElementList = rootElement.elements();
11 //5.遍历包含bean元素的集合,获取每一个bean元素
12 for (Element beanElement : beanElementList) {
13 String beanName = beanElement.getName();
14 System.out.println(beanName);
15 //6.使用Element中的方法attributeValue获取bean元素上属性的值
16 String idValue = beanElement.attributeValue("id");
17 System.out.println("\tbean元素的属性id:"+idValue);
18 String classNameValue = beanElement.attributeValue("className");
19 System.out.println("\tbean元素的属性className:"+classNameValue);
20 //7.使用Element中的方法elements获取所有property元素
21 List<Element> propertyElementList = beanElement.elements();
22 //8.遍历包含property元素的集合,获取每一个property元素
23 for (Element propertyElement : propertyElementList) {
24 System.out.println("\t\t"+propertyElement.getName());
25 //9.使用Element中的方法attributeValue获取property元素上属性的值
26 String nameValue = propertyElement.attributeValue("name");
27 System.out.println("\t\t\tproperty元素的属性name:"+nameValue);
28 String valueValue = propertyElement.attributeValue("value");
29 System.out.println("\t\t\tproperty元素的属性value:"+valueValue);
30 //10.使用Element中的方法getText获取获取property元素上文本值
31 String text = propertyElement.getText();
32 System.out.println("\t\t\tproperty元素的文本:"+text);
33 }
34 }
35 }
36 }BeanUtils工具类
使用BeanUitls公共,给类中的成员变量注入(赋)值
1 /*
2 * 创建MyBeanUtils工具类,增强populate方法
3 */
4 public class MyBeanUtils {
5 //把构造方法私有,不让外界通过创建对象的方式调用方法
6 private MyBeanUtils() {
7 }
8
9 /*
10 * 定义一个方法(让用户使用自己定义的populate方法不用处理异常)
11 * 1.参数传递JavaBean对象的Class文件对象
12 * 2.内部通过反射创建Javabean对象
13 * 3.调用BeanUtils工具类的方法populate
14 * 4.对populate方法的异常进行try...catch处理
15 * 5.把对象返回给用户
16 * 6.把参数Class对象增加一个泛型,让用户传递什么类型的JavaBean,就返回什么类型的JavaBean
17 *
18 * 定义含有泛型的方法:调用方法时确定数据类型
19 * 修饰符 <定义泛型> 返回值类型 方法名(参数<使用泛型>){
20 * 方法体
21 * }
22 *
23 *
24 * 方法的参数:
25 * Class clazz
26 * Map<String,String[]> properties
27 * 方法的返回值类型:
28 * Object
29 */
30 public static <E> E populate03(Class<E> clazz, Map<String,String[]> properties){
31 try {
32 //2.内部通过反射创建Javabean对象
33 E obj = clazz.newInstance();
34 //3.调用BeanUtils工具类的方法populate
35 BeanUtils.populate(obj, properties);
36 //5.把对象返回给用户
37 return obj;
38 } catch (Exception e) {
39 //4.对populate方法的异常进行try...catch处理
40 e.printStackTrace();
41 //把编译异常,转换为运行时异常,给成员变量注入值失败,让程序停止下来
42 throw new RuntimeException("注入值失败");
43 }
44 }
45
46 /*
47 * 定义一个方法(让用户使用自己定义的populate方法不用处理异常)
48 * 1.参数传递JavaBean对象的Class文件对象
49 * 2.内部通过反射创建Javabean对象
50 * 3.调用BeanUtils工具类的方法populate
51 * 4.对populate方法的异常进行try...catch处理
52 * 5.把对象返回给用户
53 *
54 * 方法的参数:
55 * Class clazz
56 * Map<String,String[]> properties
57 * 方法的返回值类型:
58 * Object
59 */
60 public static Object populate02(Class clazz, Map<String,String[]> properties){
61 try {
62 //2.内部通过反射创建Javabean对象
63 Object obj = clazz.newInstance();
64 //3.调用BeanUtils工具类的方法populate
65 BeanUtils.populate(obj, properties);
66 //5.把对象返回给用户
67 return obj;
68 } catch (Exception e) {
69 //4.对populate方法的异常进行try...catch处理
70 e.printStackTrace();
71 //把编译异常,转换为运行时异常,给成员变量注入值失败,让程序停止下来
72 throw new RuntimeException("注入值失败");
73 }
74
75 }
76
77 /*
78 * 定义一个方法(让用户使用自己定义的populate方法不用处理异常)
79 * 1.调用BeanUtils工具类的方法populate
80 * 2.对populate方法的异常进行try...catch处理
81 *
82 * 方法的参数:
83 * Object bean
84 * Map<String,String[]> properties
85 * 方法的返回值类型:
86 * void
87 */
88 public static void populate01(Object bean, Map<String,String[]> properties){
89 try {
90 //1.调用BeanUtils工具类的方法populate
91 BeanUtils.populate(bean, properties);
92 } catch (Exception e) {
93 //2.对populate方法的异常进行try...catch处理
94 e.printStackTrace();
95 //把编译异常,转换为运行时异常,给成员变量注入值失败,让程序停止下来
96 throw new RuntimeException("注入值失败");
97 }
98 }
99 }
100 package cn.itcast.dmeo03.MyBeanUtils;
101
102 import java.util.HashMap;
103 import java.util.Map;
104
105 import org.junit.Test;
106
107 import cn.itcast.dmeo01.bean.User;
108
109 /*
110 * 使用自定义工具类MyBeanUtils
111 */
112 public class UseMyBeanUtils {
113 @Test
114 public void demo03(){
115 //创建Map集合,key是String类型,value是String类型的数组
116 Map<String,String[]> properties = new HashMap<String,String[]>();
117 properties.put("id", new String[]{"123"});
118 properties.put("username", new String[]{"root","admin"});
119 properties.put("password", new String[]{"root","123456"});
120 properties.put("hobbies", new String[]{"吃","睡","玩","敲代码"});
121 //调用MyBeanUtils工具类中的方法populate02
122 User u = MyBeanUtils.populate03(User.class, properties);
123 System.out.println(u);
124 }
125
126 @Test
127 public void demo02(){
128 //创建Map集合,key是String类型,value是String类型的数组
129 Map<String,String[]> properties = new HashMap<String,String[]>();
130 properties.put("id", new String[]{"123"});
131 properties.put("username", new String[]{"root","admin"});
132 properties.put("password", new String[]{"root","123456"});
133 properties.put("hobbies", new String[]{"吃","睡","玩","敲代码"});
134 //调用MyBeanUtils工具类中的方法populate02
135 User u = (User) MyBeanUtils.populate02(User.class, properties);
136 System.out.println(u);
137 }
138
139 @Test
140 public void demo01(){
141 //创建JavaBean对象
142 User u = new User();
143 //创建Map集合,key是String类型,value是String类型的数组
144 Map<String,String[]> properties = new HashMap<String,String[]>();
145 properties.put("id", new String[]{"123"});
146 properties.put("username", new String[]{"root","admin"});
147 properties.put("password", new String[]{"root","123456"});
148 properties.put("hobbies", new String[]{"吃","睡","玩","敲代码"});
149 //调用MyBeanUtils工具类中的方法populate01
150 MyBeanUtils.populate01(u, properties);
151 System.out.println(u);
152 }
153 } 1 /*
2 * 综合案例:XML+dom4j+反射+BeanUtils
3 * 1.使用xml存储JavaBean的全类名和属性名属性值
4 * 2.使用dom4j解析xml
5 * 3.使用反射技术根据解析出的全类名创建JavaBean对象
6 * 4.使用BeanUtils中的方法setProperty给成员变量注入值
7 */
8 public class UseDom4jparseXMLToJavaBean {
9 public static void main(String[] args) throws Exception {
10 //2.使用dom4j解析xml
11 //获取dom4j的核心类SAXReader
12 SAXReader sax = new SAXReader();
13 //使用SAXReader中的read读取xml,创建Document对象
14 Document docu = sax.read("src/cn/itcast/dmeo05/domain/data.xml");
15 //使用Document中的方法getRootElement获取根元素
16 Element rootElement = docu.getRootElement();
17 //使用Element中的方法elements获取所有的bean元素,放入集合中
18 List<Element> beanElementList = rootElement.elements();
19 //遍历beanElementList集合
20 for (Element beanElement : beanElementList) {
21 //获取beanElement上的变的属性className
22 String className = beanElement.attributeValue("className");
23 //3.使用反射技术根据解析出的全类名创建JavaBean对象
24 Class clazz = Class.forName(className);
25 Object obj = clazz.newInstance();
26 //使用Element中的方法elements获取所有的property元素,放入集合中
27 List<Element> propertyElementList = beanElement.elements();
28 //遍历propertyElementList集合
29 for (Element propertyElement : propertyElementList) {
30 //获取propertyElement上的属性name(属性名)和value(属性值)
31 String name = propertyElement.attributeValue("name");
32 String value = propertyElement.attributeValue("value");
33 //4.使用BeanUtils中的方法setProperty给成员变量注入值
34 BeanUtils.setProperty(obj, name, value);
35 }
36 //打印JavaBean对象
37 System.out.println(obj);
38 }
39 }
40
41 }以上是使用dom4j解析xml文档实例的详细内容。更多信息请关注PHP中文网其他相关文章！
