-
编程语言
站-
热门城市 全国站>
-
其他省市
-
-
400-636-0069
小标
2018-07-13
来源 ：
阅读 959
评论 0
摘要：本文主要向大家介绍了如何使用java语言-Dom4j解析XML文档，通过具体的内容向大家展示，希望对大家学习JAVA语言有所帮助。
本文主要向大家介绍了如何使用java语言-Dom4j解析XML文档，通过具体的内容向大家展示，希望对大家学习JAVA语言有所帮助。
<!--
xml转义字符:可以把一些具有特殊含义的字符,使用转义字符表示出来
< <
> >
" "
' '
& &
需求: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 }
/**
* 无参的构造方法:
* 当我们没有定义构造方法时，编译器会自动
* 帮我们添加一个默认的构造方法。
* 默认构造方法:
* 无参数，且没有任何实现代码。如下。
* 若我们定义过任何构造方法，编译器不会为
* 我们添加该默认构造方法，若需要，则手动
* 书写
*/
public Emp(){
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public int getSalary() {
return salary;
}
public void setSalary(int salary) {
this.salary = salary;
}
public String toString(){
return id+","+name+","+age+","+gender+","+salary;
}
}
1.2
解析代码
package demoXml;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
/**
* 使用DOM解析XML文件
* @author Administrator
*
*/
public class XMLDemo1 {
public static void main(String []args){
try{
/*
* 解析XML文件的基本流程
* 1:创建SAXReader,用来读取XML
* 文件
* 2:指定xml文件使得SAXReader读取，
* 并解析问文档对象Document
* 3:获取根元素
* 4:获取每一个元素，从而达到解析的
* 目的。
*/
//1
//org.dom4j.xxxx
SAXReader reader
= new SAXReader();
//2
/*
* 常用的读取方法
* Document read(InputStream in)
* Document read(Reader read)
* Document read(File file)
*/
File xmlFile
= new File("emp.xml");
//2
/*
* read方法的作用：
* 读取给定的xml，并将其解析转换为
* 一个Document对象。
* 实际上这里已经完成了对整个xml
* 解析的工作。并将所有内容封装到了
* Document对象中。
* Document对象可以描述当前xml文档
*/
Document doc
= reader.read(xmlFile);
//3
Element root
= doc.getRootElement();
//4
/*
* Element element(String name)
* 获取当前标签下第一个名为给定
* 名字的标签
*
* List elements(String name)
* 获取当前标签下所有给定名字的
* 标签
*
* List elements()
* 获取当前标签下的所有子标签。
*/
List<Element> elements
= root.elements();
/*
* 创建一个集合，用于保存xml中
* 的每一个用户信息。我们先将
* 用户信息取出，然后创建一个Emp
* 实例，将信息设置到该实例的相应
* 属性上。最终将所有emp对象存入
* 该集合。
*/
List<Emp> list
= new ArrayList<Emp>();
/*
* 遍历每一个emp标签
*/
for(Element emp : elements){
//创建一个Emp对象，用于保存信息
Emp e = new Emp();
//解析emp标签
//获取name的值
/*
* 首先，获取名为"name"的子标签
* 其次，获取前后标签中间的文本
*/
Element ename
= emp.element("name");
String name
= ename.getText();
//获取年龄
/*
* String elementText(String name)
* 获取当前标签中名为给定名字的子标签
* 中间的文本
* 该方法与上面获取“name”的两句话等效
*/
String ageStr
= emp.elementText("age");
int age
= Integer.parseInt(ageStr);
//解析性别
String gender
= emp.elementText("gender");
//解析工资
int salary
= Integer.parseInt(
emp.elementText("salary")
);
e.setAge(age);
e.setName(name);
e.setGender(gender);
e.setSalary(salary);
/*
* 通过Element获取元素属性
*
* Attribute attribute(String name)
* 获取当前标签中指定名字的属性
*/
//获取id属性
Attribute attr
= emp.attribute("id");
//获取该属性的值
/*
* Attribute表示一个属性，常用方法:
*
* String getValue()
* 获取该属性的值
*
* String getName()
* 获取该属性的名字
*/
int id =Integer.parseInt(
attr.getValue()
);
e.setId(id);
//将Emp对象存入集合
list.add(e);
}
System.out.println(
"解析了"+list.size()+
"个员工信息");
//输出每一个员工信息
for(Emp e : list){
System.out.println(e);
}
}catch(Exception e){
}
}
}
二写入XML
package demoXml;
import java.io.FileOutputStream;
import java.util.ArrayList;
import java.util.List;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.XMLWriter;
/**
* 使用DOM写出一个XML
* @author Administrator
*
*/
public class XMLDemo2 {
public static void main(String[] args){
List<Emp> list
= new ArrayList<Emp>();
list.add(
new Emp(1,"jack",33,"男",5000)
);
list.add(
new Emp(2,"boss",55,"男",55000)
);
list.add(
new Emp(3,"marry",22,"女",3500)
);
list.add(
new Emp(4,"kate",25,"女",6000)
);
list.add(
new Emp(5,"tom",32,"男",8500)
);
/*
* 生成一个xml的基本步骤
* 1:创建文档对象Document
* 2:为Document添加根节点
* 3:为根节点组建树状结构
* 4:创建XMLWriter
* 5:为XMLWriter指定写出目标
* 6:写出xml
*/
//1
//通过DocumentHelper创建Document对象
Document doc
= DocumentHelper.createDocument();
//2
/*
* Document的方法
* Element addElement(String name)
* 该方法用于向文档中添加给定名字的
* 根元素，返回的Element实例就表示该
* 根元素
* 需要注意的是，该方法只能调用一次。
* 调用第二次会抛出异常。
*/
Element root
= doc.addElement("list");
/*
* 循环添加每一个员工信息
*/
for(Emp e : list){
/*
* Element同样支持方法:
* Element addElement(String name)
* 向当前标签中添加给定名字的子标签
*/
//向根标签中添加emp标签
Element emp
= root.addElement("emp");
//向emp标签中添加子标签name
Element name
= emp.addElement("name");
name.addText(e.getName());
//向emp标签中添加子标签age
emp.addElement("age")
.addText(e.getAge()+"");
emp.addElement("gender")
.addText(e.getGender());
emp.addElement("salary")
.addText(e.getSalary()+"");
/*
* 为标签添加属性
* Element addAttribute(
* String name,String value
* )
* 为当前标签添加给定名字以及对应值的
* 属性
* 返回值仍然为当前标签。
* 这样做的目的是可以连续添加若干属性
* 就好像StringBuilder的append的
* 返回值效果和作用。
*/
emp.addAttribute("id",e.getId()+"");
}
/*
* 当退出循环后，那么Document中的
* 结构就已经构建完了
* 需要将其写出为xml
*/
try{
XMLWriter writer
= new XMLWriter();
FileOutputStream out
= new FileOutputStream(
"myemp.xml");
writer.setOutputStream(out);
/*
* 将Document对象写出到文件中
* 这时会将Document转换为xml格式
* 写入文件。
*/
writer.write(doc);
writer.close();
}catch(Exception e){
}
}
}
三
DOM4J对XPATH的支持
package demoXml;
import java.io.File;
import java.util.List;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
/**
* DOM4J对XPATH的支持
* @author Administrator
*
*/
public class XMLDemo3 {
public static void main(String[] args){
try{
//读取xml文件转换为Document
SAXReader reader
= new SAXReader();
Document doc
= reader.read(
new File("myemp.xml")
);
String path
= "/list/emp[gender='女']" +
"/salary[.>4000]";
/*
* List selectNodes(String xpath)
* 根据给定的XPATH查询对应的节点
*/
List list
= doc.selectNodes(path);
for(Object o : list){
Element e = (Element)o;
System.out.println(e.getText());
}
}catch(Exception e){
e.printStackTrace();
}
}
}
本文由职坐标整理并发布，希望对同学们有所帮助。了解更多详情请关注编程语言JAVA频道！
喜欢 | 1
不喜欢 | 0
您输入的评论内容中包含违禁敏感词
我知道了
请输入正确的手机号码
请输入正确的验证码
您今天的短信下发次数太多了，明天再试试吧！
我们会在第一时间安排职业规划师联系您！
您也可以联系我们的职业规划师咨询：
版权所有 职坐标-一站式IT培训就业服务领导者 沪ICP备13042190号-4
上海海同信息科技有限公司 Copyright ©2015 www.zhizuobiao.com，All Rights Reserved.
沪公网安备 31011502005948号
索取资料
答疑解惑
技术交流
职业测评
面试技巧
高薪秘笈
