使用dom4j解析xml文档实例

f5b3827f057883349d3bb218baf9fe08 >
" "
' '
& &
需求:149c3f90bcd5636542d487b100c6bdc1e7 在xml中的写法
-->
.60ba14e1224c62bfbc7f4aca6ab3ee6a
c04d927bf4117844d95514babd5a3f61dde4123f2ed5a21d0bae333af89830f9
c04d927bf4117844d95514babd5a3f61dde4123f2ed5a21d0bae333af89830f9
c04d927bf4117844d95514babd5a3f61dde4123f2ed5a21d0bae333af89830f9
4bb0e59fd50cbfe6f6ce2215b9d94243
可以使用CDATA区完成
CDATA区:里边的内容都会以文本的方式展示出来
格式:
f57201c7143eac412058268fa9ed9d7e
-->
13664dae6c7363b58b779d9ab5688d76
24d34ed601b8be4cf995bd573660f666,把开始标签复制过来,添加一个结束标签
2.鼠标放在根元素上/f2,根据提示写出xml文档
-->
a6fb8dec432a0f9c71b2a4643268a19c4bb0e59fd50cbfe6f6ce2215b9d94243
显示声明:
xmlns:my="www.itcast.cn/bean"
8e5877ef208939921dd22956295438fb69d6749806bbc6802eb0606d866f5249
3.声明schema约束文档的位置
先声明官方文档的位置
xmlns:xsi="www.w3.org/2001/XMLSchema-instance"
根据官方文档声明自定义schema文档的位置
xsi:schemaLocation="www.itcast.cn/bean bean-schema.xsd"
:命名空间
bean-schema.xsd:schema文档的位置
-->
使用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中文网其他相关文章！