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>