Java-XML

 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 }

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>