基础加强_XML

.

使用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("	bean元素的属性id:"+idValue);
18             String classNameValue = beanElement.attributeValue("className");
19             System.out.println("	bean元素的属性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("		"+propertyElement.getName());
25                 //9.使用Element中的方法attributeValue获取property元素上属性的值
26                 String nameValue = propertyElement.attributeValue("name");
27                 System.out.println("			property元素的属性name:"+nameValue);
28                 String valueValue = propertyElement.attributeValue("value");
29                 System.out.println("			property元素的属性value:"+valueValue);
30                 //10.使用Element中的方法getText获取获取property元素上文本值
31                 String text = propertyElement.getText();
32                 System.out.println("			property元素的文本:"+text);
33             }
34         }
35     }
36 }

BeanUtils工具类
使用BeanUitls公共,给类中的成员变量注入(赋)值

 1 public class Demo01BeanUtils {
 2     @Test
 3     public void demo03() throws Exception{
 4         /*
 5          * BeanUitls中的方法populate给成员变量一起注入多个值
 6          * populate(Object bean, Map<String,String[]> properties)       
 7          *         将Map数据封装到指定Javabean中，一般用于将表单的所有数据封装到javabean
 8          *         相当于遍历Map集合,根据Map集合的key(属性名),依次使用Map集合value,给成员变量注入值
 9          * 
10          *     参数:
11          *         Object bean:要赋值的JavaBean对象
12          *         Map<String,String[]> properties:Map集合
13          *             key:String,成员变量的名字(属性名)
14          *             value:String[],字符串类型的数组
15          *                 如果成员变量是一个数组,那么就会把value数组的所有值赋值给成员变量
16          *                 如果成员变量不是一个数组,那么就会使用value数组的第一个值,赋值给成员变量
17          * 数组创建的方式:
18          *     动态初始化:
19          *         String[] arr = new String[数组的长度];
20          *     静态初始化:
21          *         String[] arr = new String[]{元素值1,元素值2,...};
22          *         String[] arr = {元素值1,元素值2,...}; 数组的定义和赋值必须写在一行
23          */
24         //创建JavaBean对象
25         User u = new User();
26         //创建Map集合,key是String类型,value是String类型的数组
27         Map<String,String[]> properties = new HashMap<String,String[]>();
28         properties.put("id", new String[]{"123","456"});
29         properties.put("username", new String[]{"root","admin"});
30         properties.put("password", new String[]{"root","123456"});
31         properties.put("hobbies", new String[]{"吃","睡","玩","敲代码"});
32         //使用BeanUtils中的populate给多个成员变量注入多个值
33         BeanUtils.populate(u, properties);
34         
35         System.out.println(u);
36     }
37     
38     @Test
39     public void demo02() throws Exception{
40         /*
41          * static void setProperty(Object obj,String name,Object value)    设置属性值
42          *         相当于调用了JavaBean中的setXXX方法
43          * static String getProperty(Object obj,String name)    获得属性值
44          *         相当于调用了JavaBean中的getXXX方法
45          * 方法的参数:
46          *         Object obj:要赋值/获取值的JavaBean对象
47          *         String name:成员变量的名字(属性名)
48          *         Object value:给成员变量赋的实际使用的值
49          * 
50          * BeanUtils工具类可以操作的数据类型有:基本数据类型,基本数据类型的包装类,String类型,以上3种类型的一维数组
51          * 不管属性是什么数据类型,使用BeanUtils工具类都可以使用字符格式的数类型来赋值(内部会把字符串转换为基本类型,相当于使用了
52          * 包装类中的方法parseXXX())
53          */
54         //创建JavaBean对象
55         User u = new User();
56         //使用BeanUtils中的setProperty方法给成员变量注入值
57         BeanUtils.setProperty(u, "id", "123");
58         BeanUtils.setProperty(u, "username", "root");
59         BeanUtils.setProperty(u, "password", "root");
60         System.out.println(u);
61         
62         //使用BeanUtils中的getProperty方法获取属性值
63         String id = BeanUtils.getProperty(u, "id");
64         System.out.println(id);
65         String username = BeanUtils.getProperty(u, "username");
66         System.out.println(username);
67         System.out.println(BeanUtils.getProperty(u, "password"));
68     }
69     
70     @Test
71     public void demo01(){
72         //不使用工具类,给成员变量赋值/获取值
73         User u = new User();
74         u.setId(Integer.parseInt("123"));
75         u.setUsername("root");
76         u.setPassword("root");
77         
78         System.out.println(u.getId());
79         System.out.println(u.getUsername());
80         System.out.println(u.getPassword());
81     }
82 }

  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 }

相关推荐