使用dom4j解析xml文档实例

Posted on Posted in 时事八卦, 最新资讯

<!–
xml转义字符:可以把一些具有特殊含义的字符,使用转义字符表示出来
< &lt;
> &gt;
" &quot;
' &apos;
& &amp;
需求:1<3 == 5>7 在xml中的写法
–>
.<!–
需求:
把以下内容以文本的形式显示出来,可以使用转义字符
<bean id="abc">
<property name="haha" value="123"></property>
<property name="haha" value="123"></property>
<property name="haha" value="123"></property>
</bean>
可以使用CDATA区完成
CDATA区:里边的内容都会以文本的方式展示出来
格式:
<![CDATA[
任意的内容(都是文本)
]]>
–>
<!–
使用dtd约束文档的步骤:
1.每一个dtd约束文档中都会有一行代码以<!DOCTYPE开头,复制过来放在xml文档中
a.!DOCTYPE:固定的dtd约束文档的格式
b.beans:规定xml文档中的根元素只能叫beans
c.SYSTEM:系统,dtd约束文档来源本地的操作系统
d."bean.dtd":约束文档的位置,我们使用的约束文档在当前文件夹下,可以使用"bean.dtd"
2.根据根元素的名字,写出根元素
3.鼠标放在根元素上/或者按f2,根据提示写出xml文档
?:代表元素只能出现0次或者1次
+:代表元素能出现1次或者1次以上
*:代表元素能出现0次,1次或者1次以上(任意次数)
():一组数据
|:选择关系,只能在多个元素之间选择一个
,顺序关系 规定:a,b,c 写xml文档只能按照a,b,c顺序编写
–>
<!–
1.每一个schema文档都会有一个根元素的开始标签<beans…>,把开始标签复制过来,添加一个结束标签
2.鼠标放在根元素上/f2,根据提示写出xml文档
–>
<!–
schema约束文档的使用
1.每一个schema约束文档,都必须有一个命名空间(namespace)
起名要求:全球唯一
使用域名(网址)命名:
bean-schema.xsd文档的中命名空间
targetNamespace="www.itcast.cn/bean"
2.在xml文档中声明命名空间
默认声明:
xmlns="www.itcast.cn/bean"
<bean></bean>
显示声明:
xmlns:my="www.itcast.cn/bean"
<my:bean></my:bean>
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中文网其它相关文章!

该文章由WP-AutoPost插件自动采集发布

原文地址:http://www.php.cn/java-article-370950.html

发表评论

电子邮件地址不会被公开。 必填项已用*标注