Verwenden Sie dom4j, um ein Beispiel für ein XML-Dokument zu analysieren

 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 }

 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 }