Java-XML
程序员文章站
2022-04-26 12:46:16
dom4j ......
1 import java.io.file;
2 import java.io.fileinputstream;
3 import java.io.inputstream;
4 import javax.xml.parsers.documentbuilder;
5 import javax.xml.parsers.documentbuilderfactory;
6 import org.w3c.dom.document;
7 import org.w3c.dom.element;
8 import org.w3c.dom.node;
9 import org.w3c.dom.nodelist;
10
11 /**
12 * 读取xml文件1
13 */
14 public class xmlreader {
15 public static void main(string[] args) {
16 xmlreader reader = new xmlreader();
17 }
18 public xmlreader(){
19 //得到 dom 解析器的工厂实例
20 documentbuilderfactory domfac = documentbuilderfactory.newinstance();
21 try {
22 //从 dom 工厂获得 dom 解析器
23 documentbuilder dombuilder = domfac.newdocumentbuilder();
24 //把要解析的 xml 文档转化为输入流，以便 dom 解析器解析它
25 inputstream is = new fileinputstream(new file("languages.xml"));
26 //解析 xml 文档的输入流，得到一个 document
27 document doc = dombuilder.parse(is);
28 //获到 xml 文档的根节点
29 element root = doc.getdocumentelement();
30 //获到节点的子节点
31 nodelist books = root.getchildnodes();
32 if(books!=null){
33 for (int i = 0; i < books.getlength(); i++) {
34 node book = books.item(i);
35 //node.text_node 文本节点
36 //node.document_node 文档节点
37 //node.entity_node 实体节点
38 //node.attribute_node 属性节点
39 //node.element_node 元素节点
40 if(book.getnodetype()==node.element_node) { //判断节点类型是元素节点时
41 //取得节点的属性值,节点的属性也是它的子节点。它的节点类型也是node.element_node
42 string email = book.getattributes().getnameditem("id").getnodevalue();
43
44 //轮循子节点
45 for(node node=book.getfirstchild();node!=null;node=node.getnextsibling()) {
46 //因为节点中包含了元素节点、属性节点、文本节点等。
47 if(node.getnodetype()==node.element_node) { //判断节点类型是元素节点时
48 if(node.getnodename().equals("name")) {
49 string name1 = node.getfirstchild().getnodevalue();
50 system.out.println(name1);
51 }
52 if(node.getnodename().equals("ide")) {
53 string price=node.getfirstchild().getnodevalue();
54 system.out.println(price);
55 }
56 }
57 }
58 }
59 }
60 }
61 } catch (exception e) {
62 e.printstacktrace();
63 }
64 }
65 }
1 //languages.xml 2 3 <?xml version="1.0" encoding="utf-8"?> 4 <languages cat="it"> 5 <lan id="1"> 6 <name>java</name> 7 <ide>eclipse</ide> 8 </lan> 9 </languages>
1 import java.io.file; 2 import java.io.ioexception; 3 4 import javax.xml.parsers.documentbuilder; 5 import javax.xml.parsers.documentbuilderfactory; 6 import javax.xml.parsers.parserconfigurationexception; 7 8 import org.w3c.dom.document; 9 import org.w3c.dom.element; 10 import org.w3c.dom.node; 11 import org.w3c.dom.nodelist; 12 import org.xml.sax.saxexception; 13 /** 14 * 读取xml文件2 15 * （ 1 ）获取 dom 解析器的工厂实例 documentbuilderfactory domfac=documentbuilderfactory.newinstance(); 16 * （ 2 ）从 dom 工厂获得 dom 解析器：documentbuilder dombuilder=domfac.newdocumentbuilder(); 17 * （ 3 ）把要解析的 xml 文档转化为输入流，以便 dom 解析器解析它：inputstream is = new fileinputstream("test1.xml"); 18 * （ 4 ）解析 xml 文档的输入流，得到一个 document：document doc = dombuilder.parse(is); 19 * 也可以根据file对象获取document对象：document document = builder.parse(new file("languages.xml")); 20 * （ 5 ）得到 xml 文档的根节点：element root=doc.getdocumentelement(); 21 * （ 6 ）得到节点的子节点：nodelist books=root.getchildnodes(); 22 */ 23 public class readxml { 24 public static void main(string[] args) { 25 try { 26 //获取 dom 解析器的工厂实例 27 documentbuilderfactory factory = documentbuilderfactory.newinstance(); 28 //从 dom 工厂获得 dom 解析器 29 documentbuilder builder = factory.newdocumentbuilder(); 30 //根据file对象获取document对象 31 document document = builder.parse(new file("./data/languages.xml")); 32 //根据document对象获取xml 文档的根节点 33 element root = document.getdocumentelement(); 34 35 string nodename = root.getnodename(); //获取节点名称 36 string attribute = root.getattribute("cat"); // 获取属性的值 37 38 nodelist list = root.getelementsbytagname("lan"); //根据节点名称获取节点集 39 for (int i = 0; i < list.getlength(); i++) { 40 element lan = (element) list.item(i); //获取节点集中的节点 41 string attribute2 = lan.getattribute("id"); //根据属性值 42 43 nodelist clist = lan.getchildnodes(); //获取节点下的所有子节点集 44 for (int j = 0; j < clist.getlength(); j++) { 45 node c = clist.item(j); //获取节点 46 if (c instanceof element) { 47 string elename = c.getnodename();//节点名称 48 string eletext = c.gettextcontent();//文本内容，标签之间的内容 49 system.out.println(elename + "=" + eletext); 50 } 51 } 52 } 53 } catch (parserconfigurationexception e) { 54 e.printstacktrace(); 55 } catch (saxexception e) { 56 e.printstacktrace(); 57 } catch (ioexception e) { 58 e.printstacktrace(); 59 } 60 } 61 }
1 import java.io.file;
2 import java.io.stringwriter;
3 import javax.xml.parsers.documentbuilder;
4 import javax.xml.parsers.documentbuilderfactory;
5 import javax.xml.parsers.parserconfigurationexception;
6 import javax.xml.transform.outputkeys;
7 import javax.xml.transform.transformer;
8 import javax.xml.transform.transformerconfigurationexception;
9 import javax.xml.transform.transformerexception;
10 import javax.xml.transform.transformerfactory;
11 import javax.xml.transform.dom.domsource;
12 import javax.xml.transform.stream.streamresult;
13 import org.w3c.dom.document;
14 import org.w3c.dom.element;
15
16 /**
17 * 创建并写入xml文件
18 * 使用dom方式生成xml文件有如下几步：
19 * 首先是创建dom树（即规定xml文件中的内容）：
20 * 创建documentbuilderfactory对象
21 * 通过documentbuilderfactory对象创建documentbuilder对象
22 * 通过documentbuilder对象的newdocument()方法创建一个document对象，该对象代表一个xml文件
23 * 通过document对象的createelement()方法创建根节点
24 * 通过document对象的createelement()方法创建n个子节点，并为他们赋值，再将这些子节点添加到根节点下
25 * 将根节点添加到document对象下
26 */
27 public class creatxml {
28 public static void main(string[] args) {
29 try {
30 //获取dom 解析器的工厂实例
31 documentbuilderfactory factory = documentbuilderfactory.newinstance();
32 //从 dom 工厂获得 dom 解析器
33 documentbuilder builder = factory.newdocumentbuilder();
34 //创建一个document对象，该对象代表一个xml文件
35 document document = builder.newdocument();
36 //设置xml声明中standalone为yes，即没有dtd和schema作为该xml的说明文档，且不显示该属性
37 document.setxmlstandalone(true);
38 //创建根节点
39 element root = document.createelement("languages");
40
41 root.setattribute("cat", "it");//节点添加属性和属性值
42
43 element lan1 = document.createelement("lan"); //创建节点
44 lan1.setattribute("id", "1"); //设置节点属性
45
46 element name1 = document.createelement("name");//创建节点
47 name1.settextcontent("java"); //设置节点之间的内容
48
49 element ide1 = document.createelement("ide");//创建节点
50 ide1.settextcontent("eclipse"); //设置节点之间的内容
51
52 //向节点中添加子节点
53 lan1.appendchild(name1);
54 lan1.appendchild(ide1);
55
56 //向根节点添加子节点
57 root.appendchild(lan1);
58
59 //向文件中添加根节点
60 document.appendchild(root);
61
62 /**
63 * 将dom树转换为xml文件：
64 * 创建transformerfactory类的对象
65 * 通过transformerfactory创建transformer对象
66 * 使用transformer对象的transform()方法将dom树转换为xml文件
67 * （该方法有两个参数，第一个参数为源数据，需要创建domsource对象并将document加载到其中；
68 * 第二个参数为目的文件，即要生成的xml文件，需要创建streamresult对象并指定目的文件）
69 */
70 //获取transformerfactory类的一个实例
71 transformerfactory transformerfactory = transformerfactory.newinstance();
72 //通过transformerfactory类的一个实例，创建transformer对象
73 transformer transformer = transformerfactory.newtransformer();
74 //设置输出时的编码
75 transformer.setoutputproperty("encoding", "utf-8");
76 transformer.setoutputproperty(outputkeys.indent, "yes");// 设置输出数据时换行
77
78
79 //将dom树转换为xml文件
80 //第一个参数为源数据，需要创建domsource对象并将document加载到其中
81 //第二个参数为目的文件，即要生成的xml文件，需要创建streamresult对象并指定目的文件
82 transformer.transform(new domsource(document), new streamresult(new file("./data/languages.xml")));
83
84
85 stringwriter writer = new stringwriter();
86 transformer.transform(new domsource(document), new streamresult(writer));
87 system.out.println(writer.tostring());//将流输出到控制台
88 } catch (parserconfigurationexception e) {
89 e.printstacktrace();
90 } catch (transformerconfigurationexception e) {
91 e.printstacktrace();
92 } catch (transformerexception e) {
93 e.printstacktrace();
94 }
95 }
96 }
1 import java.io.file;
2 import java.io.stringwriter;
3
4 import javax.xml.parsers.documentbuilder;
5 import javax.xml.parsers.documentbuilderfactory;
6 import javax.xml.parsers.parserconfigurationexception;
7 import javax.xml.transform.outputkeys;
8 import javax.xml.transform.transformer;
9 import javax.xml.transform.transformerconfigurationexception;
10 import javax.xml.transform.transformerexception;
11 import javax.xml.transform.transformerfactory;
12 import javax.xml.transform.transformerfactoryconfigurationerror;
13 import javax.xml.transform.dom.domsource;
14 import javax.xml.transform.stream.streamresult;
15
16 import org.w3c.dom.domexception;
17 import org.w3c.dom.document;
18
19 public class createconfigxmlutil {
20
21 public document getdocument() {
22 //创建一个document对象，该对象代表一个xml文件
23 document document = null;;
24 try {
25 //获取dom 解析器的工厂实例
26 documentbuilderfactory factory = documentbuilderfactory.newinstance();
27 //从 dom 工厂获得 dom 解析器
28 documentbuilder builder = factory.newdocumentbuilder();
29 document = builder.newdocument();
30 //设置xml声明中standalone为yes，即没有dtd和schema作为该xml的说明文档，且不显示该属性
31 document.setxmlstandalone(true);
32 } catch (domexception e) {
33 e.printstacktrace();
34 } catch (parserconfigurationexception e) {
35 e.printstacktrace();
36 }
37 return document;
38 }
39
40 /**
41 * @title: xmltofile
42 * @description: xml输出到文件
43 * @param document
44 * @param filepath
45 * @return void 返回类型
46 * @throws
47 */
48 public void xmltofile(document document,string filepath) {
49 /**
50 * 将dom树转换为xml文件：
51 * 创建transformerfactory类的对象
52 * 通过transformerfactory创建transformer对象
53 * 使用transformer对象的transform()方法将dom树转换为xml文件
54 * （该方法有两个参数，第一个参数为源数据，需要创建domsource对象并将document加载到其中；
55 * 第二个参数为目的文件，即要生成的xml文件，需要创建streamresult对象并指定目的文件）
56 */
57 try {
58 //获取transformerfactory类的一个实例
59 transformerfactory transformerfactory = transformerfactory.newinstance();
60 //通过transformerfactory类的一个实例，创建transformer对象
61 transformer transformer = transformerfactory.newtransformer();
62 //设置输出时的编码
63 transformer.setoutputproperty("encoding", "utf-8");
64 transformer.setoutputproperty(outputkeys.indent, "yes");// 设置输出数据时换行
65 //将dom树转换为xml文件
66 //第一个参数为源数据，需要创建domsource对象并将document加载到其中
67 //第二个参数为目的文件，即要生成的xml文件，需要创建streamresult对象并指定目的文件
68 //"./data/languages.xml"
69 transformer.transform(new domsource(document),
70 new streamresult(new file(filepath)));
71 } catch (transformerconfigurationexception e) {
72 e.printstacktrace();
73 } catch (illegalargumentexception e) {
74 e.printstacktrace();
75 } catch (transformerfactoryconfigurationerror e) {
76 e.printstacktrace();
77 } catch (transformerexception e) {
78 e.printstacktrace();
79 }
80 }
81
82 /**
83 * @title: xmltoconsole
84 * @description: xml输出到控制台
85 * @param document
86 * @return void 返回类型
87 * @throws
88 */
89 public static void xmltoconsole(document document) {
90 try {
91 //获取transformerfactory类的一个实例
92 transformerfactory transformerfactory = transformerfactory.newinstance();
93 //通过transformerfactory类的一个实例，创建transformer对象
94 transformer transformer = transformerfactory.newtransformer();
95 //设置输出时的编码
96 transformer.setoutputproperty("encoding", "utf-8");
97 transformer.setoutputproperty(outputkeys.indent, "yes");// 设置输出数据时换行
98 stringwriter writer = new stringwriter();
99 transformer.transform(new domsource(document), new streamresult(writer));
100 system.out.println(writer.tostring());//将流输出到控制台
101 } catch (transformerconfigurationexception e) {
102 e.printstacktrace();
103 } catch (illegalargumentexception e) {
104 e.printstacktrace();
105 } catch (transformerfactoryconfigurationerror e) {
106 e.printstacktrace();
107 } catch (transformerexception e) {
108 e.printstacktrace();
109 }
110 }
111 }
dom4j
1 //test-xml-1.xml 2 3 <?xml version="1.0" encoding="utf-8"?> 4 5 <root> 6 <author name="james" location="uk">james strachan 7 <author name="bob" location="us">bob mcwhirter</author> 8 </author> 9 </root>
1 public class dom4jxmlutil {
2
3 public static void main(string[] args) {
4 createxmlfile();
5 }
6
7 public static void createxmlfile() {
8 try {
9 document document = documenthelper.createdocument();
10 element root = document.addelement("root");
11
12 element ele = root.addelement("author")
13 .addattribute("name", "james") //节点属性 name=james
14 .addattribute("location", "uk")//节点属性 location=uk
15 .addtext("james strachan");//节点文本 james strachan
16
17 ele.addelement("author")
18 .addattribute("name", "bob")
19 .addattribute("location", "us")
20 .addtext("bob mcwhirter");
21
22 // 写入到一个新的文件中
23 writer(document,"./data/test-xml-1.xml");
24 } catch (exception e) {
25 e.printstacktrace();
26 }
27 }
28
29 /**
30 * 把document对象写入新的文件
31 */
32 public static void writer(document document,string filepath) throws exception {
33 // 紧凑的格式
34 // outputformat format = outputformat.createcompactformat();
35 // 排版缩进的格式
36 outputformat format = outputformat.createprettyprint();
37 // 设置编码
38 format.setencoding("utf-8");
39 // 创建xmlwriter对象,指定了写出文件及编码格式
40 // xmlwriter writer = new xmlwriter(new filewriter(new
41 // file("src//a.xml")),format);
42 xmlwriter writer = new xmlwriter(new outputstreamwriter(
43 new fileoutputstream(new file(filepath)), "utf-8"), format);
44 writer.write(document);// 写入
45 writer.flush();// 立即写入
46 writer.close();// 关闭操作
47 }
48
49 public void readxmldemo() throws exception {
50 // 创建saxreader对象
51 saxreader reader = new saxreader();
52 // 通过read方法读取一个文件 转换成document对象
53 document document = reader.read(new file("./data/test-xml-1.xml"));
54 element node = document.getrootelement();//获取根节点元素对象
55 //遍历所有的元素节点
56 listnodes(node);
57 //elementmethod(node);
58 }
59
60 /**
61 * 遍历当前节点元素下面的所有(元素的)子节点
62 */
63 public void listnodes(element node) {
64 string nodename = node.getname();//节点名称，标签名
65 system.out.println("当前节点名称："+nodename);
66 // 获取当前节点的所有属性节点
67 @suppresswarnings("unchecked")
68 list<attribute> list = node.attributes();//当前节点的所有属性节点，例如：name=james location=uk
69 // 遍历属性节点
70 for (attribute attr : list) {
71 string attrtext = attr.gettext();//属性值
72 string attrvalue = attr.getvalue();//属性值，与gettext()相同
73 string attrname = attr.getname();//属性名称
74 system.out.println(attrtext+"--"+attrvalue+"--"+attrname);
75 }
76
77 if (!(node.gettexttrim().equals(""))) {
78 string nodetext = node.gettext();//节点文本值
79 system.out.println(nodetext);
80 }
81 //node.elementiterator("author"); 指定某个节点，获取其下面子节点的迭代器
82 @suppresswarnings("unchecked")
83 iterator<element> it = node.elementiterator();//当前节点下子节点的迭代器
84 while (it.hasnext()) {
85 element e = it.next();// 获取某个子节点对象
86 listnodes(e);// 对子节点进行遍历
87 }
88 }
89
90 /**
91 * 介绍element中的element方法和elements方法的使用
92 */
93 public void elementmethod(element node) {
94 // 获取node节点中，子节点的元素名称为supercars的元素节点。
95 element e = node.element("supercars");
96 // 获取supercars元素节点中，子节点为carname的元素节点(可以看到只能获取第一个carname元素节点)
97 element carname = e.element("carname");
98
99 string ename = e.getname();
100 string ctext = carname.gettext();
101 system.out.println(ename+"--"+ctext);
102
103 // 获取supercars这个元素节点 中，所有子节点名称为carname元素的节点 。
104 @suppresswarnings("unchecked")
105 list<element> carnames = e.elements("carname");
106 for (element cname : carnames) {
107 string text = cname.gettext();
108 system.out.println(text);//获取节点的文本值，也就是标签之前的内容
109 }
110
111 @suppresswarnings("unchecked")
112 list<element> elements = e.elements();// 获取supercars这个元素节点 所有元素的子节点。
113 for (element el : elements) {
114 string text = el.gettext();
115 system.out.println(text);//获取节点的文本值，也就是标签之前的内容
116 }
117 }
118 }
1 <!-- xml解析 --> 2 <dependency> 3 <groupid>dom4j</groupid> 4 <artifactid>dom4j</artifactid> 5 <version>1.6.1</version> 6 </dependency>