SAX解析和生成XML文档

时间：2022-10-31 13:40:04

一、前言

   SAX操作xml是基于事件来完成的，自己只负责调用解析的方法，然后具体解析操作都是交给DefaultHandler处理者来完成的，总的来说使用SAX解析和生成xml文档还是比较方便的 。


二、准备条件

   因为SAX是jdk自带的解析方式，所以不用添加jar包引用。


三、使用SAX实战


1、解析xml文档

实现思路：

   <1>先由SAXParserFactory这个工厂的实例生产一个SAXParser解析器；

   <2>然后根据读取的xml路径，传递给SAXParser这个解析器，再调用parse()方法；

   <3>在parse()方法中需要传递DefaultHandler这个类的扩展类的实例，因为它才会真正去一步步去解析xml文档的；

   <4>在DefaultHandler扩展类中需要重写startDocument()，endDocument()等等方法，因为他们方法内部有返回的具体文档的结果。

具体代码如下：

[java] view plaincopyprint?
  1. import java.io.BufferedOutputStream;  
  2. import java.io.File;  
  3. import java.io.FileInputStream;  
  4. import java.io.FileNotFoundException;  
  5. import java.io.FileOutputStream;  
  6. import java.io.IOException;  
  7. import java.io.InputStream;  
  8. import java.util.ArrayList;  
  9. import java.util.List;  
  10.   
  11. import javax.xml.parsers.ParserConfigurationException;  
  12. import javax.xml.parsers.SAXParser;  
  13. import javax.xml.parsers.SAXParserFactory;  
  14. import javax.xml.transform.OutputKeys;  
  15. import javax.xml.transform.Result;  
  16. import javax.xml.transform.Transformer;  
  17. import javax.xml.transform.TransformerConfigurationException;  
  18. import javax.xml.transform.sax.SAXTransformerFactory;  
  19. import javax.xml.transform.sax.TransformerHandler;  
  20. import javax.xml.transform.stream.StreamResult;  
  21.   
  22. import org.xml.sax.Attributes;  
  23. import org.xml.sax.InputSource;  
  24. import org.xml.sax.SAXException;  
  25. import org.xml.sax.helpers.AttributesImpl;  
  26. import org.xml.sax.helpers.DefaultHandler;  
  27.   
  28. /** 
  29.  * 使用SAX操作xml的简单例子 
  30.  * @author Administrator 
  31.  * 
  32.  */  
  33. public class SAXOperateXmlDemo {  
  34.     public void parseXml01(){  
  35.         String xmlPath = "D:\\project\\dynamicWeb\\src\\resource\\user01.xml";    
  36.         String xmlName = xmlPath.substring(xmlPath.lastIndexOf("\\"));  
  37.         try {  
  38.             //获取SAX分析器的工厂实例，专门负责创建SAXParser分析器  
  39.             SAXParserFactory saxParserFactory = SAXParserFactory.newInstance();  
  40.             //获取SAXParser分析器的实例   
  41.             SAXParser saxParser = saxParserFactory.newSAXParser();  
  42.             //和其他解析方式一样，也要间接通过InputStream输入流对象获取xml信息  
  43.             //1、直接指定绝对路径获取文件输入流对象  
  44.             //InputStream inputStream = new FileInputStream(xmlPath);  
  45.             //2、使用类的相对路径查找xml路径  
  46.             //InputStream inputStream = this.getClass().getResourceAsStream(xmlName);  
  47.             //3、也可以指定路径完成InputStream输入流的实例化操作    
  48.             InputStream inputStream = new FileInputStream(new File(xmlPath));    
  49.             //4、使用InputSource输入源作为参数也可以转换xml    
  50.             //InputSource inputSource = new InputSource(inputStream);  
  51.               
  52.             //解析xml文档   
  53.             saxParser.parse(inputStream, new XmlSAXHandler01());//这里传递了自定义的XmlSAXHandler()管理者参数来解析xml,不像以前都是直接调用返回的Document对象  
  54.         } catch (ParserConfigurationException e) {  
  55.             e.printStackTrace();  
  56.         } catch (SAXException e) {  
  57.             e.printStackTrace();  
  58.         } catch (FileNotFoundException e) {  
  59.             e.printStackTrace();  
  60.         } catch (IOException e) {  
  61.             e.printStackTrace();  
  62.         }  
  63.     }  
  64.   
  65.     public static void main(String[] args) {  
  66.         SAXOperateXmlDemo demo = new SAXOperateXmlDemo();  
  67.         demo.parseXml01();  
  68.     }  
  69. }  
  70.   
  71. /** 
  72.  * 解析SAX的处理者01 
  73.  * @author Administrator 
  74.  * 
  75.  */  
  76. class XmlSAXHandler01 extends DefaultHandler {    
  77.       
  78.     @Override  
  79.     public void startDocument() throws SAXException {  
  80.         System.out.println("---->startDocument() is invoked...");  
  81.         super.startDocument();  
  82.     }  
  83.       
  84.     @Override  
  85.     public void endDocument() throws SAXException {  
  86.         System.out.println("---->endDocument() is invoked...");  
  87.         super.endDocument();  
  88.     }  
  89.       
  90.     @Override  
  91.     public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {  
  92.         System.out.println("-------->startElement() is invoked...");  
  93.         super.startElement(uri, localName, qName, attributes);  
  94.     }  
  95.   
  96.     @Override  
  97.     public void endElement(String uri, String localName, String qName) throws SAXException {  
  98.         System.out.println("-------->endElement() is invoked...");  
  99.         super.endElement(uri, localName, qName);  
  100.     }  
  101.       
  102.     @Override  
  103.     public void characters(char[] ch, int start, int length) throws SAXException {  
  104.         System.out.println("------------>characters() is invoked...");  
  105.         super.characters(ch, start, length);  
  106.     }  
  107. }  

上面代码简单解析了一个xml，user01.xml文件的内容如下：

[html] view plaincopyprint?
  1. <?xml version="1.0" encoding="utf-8" ?>  
  2. <Root>Content</Root>  
接下来执行该类的main方法，console效果如下：

SAX解析和生成XML文档

根据控制台的显示可知：

   <1>解析类必须继承DefaultHandler这个类，重写自己需要获取节点信息的方法，不重写的情况下会调用父类的对应方法，所以不影响程序；

   <2>XmlSAXHandler01这个处理者来完成xml的解析工作，并且调用方式是按照xml层级关系来处理的，比如最开始调用startDocument()获取Document对象，然后再递归调用startElement()获取根节点以及子节点的信息，其中的characters()用于获取节点文本内容信息，待节点解析完毕之后会调用endElement()，同样整个xml解析完毕之后会调用endDocument()结束。


上面只是简单的获取了xml的根目录的元素，接下来使用DefaultHandler这个处理者怎么获取节点内的信息。

具体代码如下：

[java] view plaincopyprint?
  1.   
  2. public void parseXml02(){  
  3.        String xmlPath = "D:\\project\\dynamicWeb\\src\\resource\\user02.xml";    
  4.     try {  
  5.         //获取SAX分析器的工厂实例，专门负责创建SAXParser分析器  
  6.         SAXParserFactory saxParserFactory = SAXParserFactory.newInstance();  
  7.         //获取SAXParser分析器的实例   
  8.         SAXParser saxParser = saxParserFactory.newSAXParser();  
  9.            InputStream inputStream = new FileInputStream(new File(xmlPath));    
  10.           
  11.         //解析xml文档   
  12.         saxParser.parse(inputStream, new XmlSAXHandler02());  
  13.     } catch (ParserConfigurationException e) {  
  14.         e.printStackTrace();  
  15.     } catch (SAXException e) {  
  16.         e.printStackTrace();  
  17.     } catch (FileNotFoundException e) {  
  18.         e.printStackTrace();  
  19.     } catch (IOException e) {  
  20.         e.printStackTrace();  
  21.     }  
  22. }     
 对应的XMLSAXHandler02的代码如下：

[java] view plaincopyprint?
  1. /** 
  2.  * 解析SAX的处理者02 
  3.  * @author Administrator 
  4.  * 
  5.  */  
  6. class XmlSAXHandler02 extends DefaultHandler {    
  7.       
  8.     @Override  
  9.     public void startDocument() throws SAXException {  
  10.         System.out.println("---->startDocument() is invoked...");  
  11.     }  
  12.       
  13.     @Override  
  14.     public void endDocument() throws SAXException {  
  15.         System.out.println("---->endDocument() is invoked...");  
  16.     }  
  17.       
  18.     @Override  
  19.     public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {  
  20.         System.out.println("-------->startElement() is invoked...");  
  21.         System.out.println("uri的属性值：" + uri);  
  22.         System.out.println("localName的属性值：" + localName);  
  23.         System.out.println("qName的属性值：" + qName);  
  24.         if(attributes.getLength()>0){  
  25.             System.out.println("element属性值-->" + attributes.getQName(0) + "：" + attributes.getValue(0)); //根据下标获取属性name和value，也可以直接传递属性name获取属性值：attributes.getValue("id")  
  26.         }  
  27.     }  
  28.   
  29.     @Override  
  30.     public void endElement(String uri, String localName, String qName) throws SAXException {  
  31.         System.out.println("-------->endElement() is invoked...");  
  32.         System.out.println("uri的属性值：" + uri);  
  33.         System.out.println("localName的属性值：" + localName);  
  34.         System.out.println("qName的属性值：" + qName);  
  35.     }  
  36.       
  37.     @Override  
  38.     public void characters(char[] ch, int start, int length) throws SAXException {  
  39.         System.out.println("------------>characters() is invoked...");  
  40.         System.out.println("节点元素文本内容：" + new String(ch, start, length));  
  41.     }  
  42. }  
 上面的xml在src下面，user02.xml具体如下：

[html] view plaincopyprint?
  1. <?xml version="1.0" encoding="utf-8" ?>  
  2. <Root>  
  3.     这个是根节点的内容  
  4.     <user id="001">用户信息</user>  
  5. </Root>  
接下来执行该类的main方法，console效果如下：

SAX解析和生成XML文档

根据控制台的显示可知：

   <1>XMLSAXHandler02在解析的时候执行方法是从最外层往内、从上往下依次解析的，并且每一次解析节点都是startElement()和endElement()成对出现的；

   <2>图中显示了每一个节点解析的信息，并且startElement()和endElement()的区别在于前面方法有携带属性，而后面方法没有；

   <3>图中之所以出现三个“节点元素文本内容”是XMLSAXHandler02也是把非标签的文本当前一个节点了，所以在解析的时候要排除这种情况，以免影响最终想要的结果。


另外发现：

   <1>查看父类的方法发现它们的方法体什么都没做；

   <2>SAX不支持重新修改XML的结构；

   <3>如果正常业务需求，解析xml之后不可能只是简单输出下内容，而是要返回成一个集合或者其他形式返回，目前情况可以使用全局的ArrayList集合来完成解析之后节点内容的封装。


   接下来需要实现如何封装SAX解析完毕的XML文档，都知道java是面向对象编程的，那么这个时候可以把文档中的每一个节点都看成一个对象，包括节点里面的属性也是一样，那么在解析XML的时候直接使用javabean封装一下，思路就非常清晰了，但是现在还有还一个问题：  如何在SAXParser调用parse()方法之后返回最终的结果集呢？就目前肯定不行的，其一方法没有返回值，其二解析操作完全交给DefaultHandler去做了，所以这种情况下肯定不能使用普通变量或者全局变量，因为使用了之后会随着当前操作类的实例化生命周期而存在，并且DefaultHandler在调用的时候又需要产生一个新的实例，这样前后就没有关联性了。 所以只能使用静态ArrayList来完成了。

具体操作如下：

1、前面说了构建节点对象和属性对象，具体代码如下：

[java] view plaincopyprint?
  1. import java.util.List;  
  2.   
  3. /** 
  4.  * Xml节点对象 
  5.  * @author Administrator 
  6.  * 
  7.  */  
  8. public class Node {  
  9.   
  10.     private Long id;  
  11.     private String name;  
  12.     private String text;  
  13.     private List<Attribute> attributeList;  
  14.     private List<Node> nodeList;  
  15.       
  16.     public Long getId() {  
  17.         return id;  
  18.     }  
  19.     public void setId(Long id) {  
  20.         this.id = id;  
  21.     }  
  22.     public String getName() {  
  23.         return name;  
  24.     }  
  25.     public void setName(String name) {  
  26.         this.name = name;  
  27.     }  
  28.     public String getText() {  
  29.         return text;  
  30.     }  
  31.     public void setText(String text) {  
  32.         this.text = text;  
  33.     }  
  34.     public List<Attribute> getAttributeList() {  
  35.         return attributeList;  
  36.     }  
  37.     public void setAttributeList(List<Attribute> attributeList) {  
  38.         this.attributeList = attributeList;  
  39.     }  
  40.     public List<Node> getNodeList() {  
  41.         return nodeList;  
  42.     }  
  43.     public void setNodeList(List<Node> nodeList) {  
  44.         this.nodeList = nodeList;  
  45.     }  
  46. }  
 [java] view plaincopyprint?
  1. /** 
  2.  * Xml属性对象 
  3.  * @author Administrator 
  4.  * 
  5.  */  
  6. public class Attribute {  
  7.   
  8.     private String name;  
  9.     private String value;  
  10.       
  11.     public String getName() {  
  12.         return name;  
  13.     }  
  14.     public void setName(String name) {  
  15.         this.name = name;  
  16.     }  
  17.     public String getValue() {  
  18.         return value;  
  19.     }  
  20.     public void setValue(String value) {  
  21.         this.value = value;  
  22.     }  
  23. }  
 2、在SAXOperateXmlDemo这个操作类中添加两个常量，具体如下：

[java] view plaincopyprint?
  1. public static List<Node> nodeList = null;  
  2. public static Node node = null;  
不光集合需要全局静态化，节点对象也要全局静态化，因为解析过程中获取标签名称和标签内文本是分开操作的，如果不这样对象的属性值无法完整获取。

3、定义xml文档解析方法，具体如下：

[java] view plaincopyprint?
  1. public void parseXml03(){  
  2.        String xmlPath = "D:\\project\\dynamicWeb\\src\\resource\\user03.xml";    
  3.     try {  
  4.         //获取SAX分析器的工厂实例，专门负责创建SAXParser分析器  
  5.         SAXParserFactory saxParserFactory = SAXParserFactory.newInstance();  
  6.         //获取SAXParser分析器的实例   
  7.         SAXParser saxParser = saxParserFactory.newSAXParser();  
  8.            InputStream inputStream = new FileInputStream(new File(xmlPath));    
  9.           
  10.         //解析xml文档   
  11.         saxParser.parse(inputStream, new XmlSAXHandler03());  
  12.           
  13.         //迭代list   
  14.         if(SAXOperateXmlDemo.nodeList.size() > 0){  
  15.             for (Node node : SAXOperateXmlDemo.nodeList) {  
  16.                 System.out.println("-----------------------------------------");  
  17.                 System.out.println("【节点】" + node.getName() + "：" + node.getText());  
  18.                 List<Attribute> attributeList = node.getAttributeList();  
  19.                 if (attributeList != null) {  
  20.                     for (Attribute attribute : attributeList) {  
  21.                         System.out.println("【属性】" + attribute.getName() + "：" + attribute.getValue());                            
  22.                     }  
  23.                 }  
  24.             }  
  25.         }  
  26.           
  27.     } catch (ParserConfigurationException e) {  
  28.         e.printStackTrace();  
  29.     } catch (SAXException e) {  
  30.         e.printStackTrace();  
  31.     } catch (FileNotFoundException e) {  
  32.         e.printStackTrace();  
  33.     } catch (IOException e) {  
  34.         e.printStackTrace();  
  35.     }  
  36. }  

4、对应的解析处理者代码如下：

[java] view plaincopyprint?
  1. /** 
  2.  * 解析SAX的处理者03 
  3.  * @author Administrator 
  4.  * 
  5.  */  
  6. class XmlSAXHandler03 extends DefaultHandler {    
  7.       
  8.     @Override  
  9.     public void startDocument() throws SAXException {  
  10.         SAXOperateXmlDemo.nodeList = new ArrayList<Node>();  
  11.     }  
  12.       
  13.     @Override  
  14.     public void endDocument() throws SAXException {  
  15.           
  16.     }  
  17.       
  18.     @Override  
  19.     public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {  
  20.         SAXOperateXmlDemo.node = new Node();  
  21.         SAXOperateXmlDemo.node.setId(null);  
  22.         SAXOperateXmlDemo.node.setName(qName);  
  23.         //封装当前节点的属性   
  24.         List<Attribute> attributeList = new ArrayList<Attribute>();  
  25.         if(attributes.getLength()>0){  
  26.             for (int i = 0; i < attributes.getLength(); i++) {  
  27.                 Attribute attribute = new Attribute();  
  28.                 attribute.setName(attributes.getQName(i));  
  29.                 attribute.setValue(attributes.getValue(i));  
  30.                 attributeList.add(attribute);  
  31.             }  
  32.         }  
  33.         SAXOperateXmlDemo.node.setAttributeList(attributeList);  
  34.     }  
  35.   
  36.     @Override  
  37.     public void endElement(String uri, String localName, String qName) throws SAXException {  
  38.           
  39.     }  
  40.       
  41.     @Override  
  42.     public void characters(char[] ch, int start, int length) throws SAXException {  
  43.         if(SAXOperateXmlDemo.node != null){  
  44.             SAXOperateXmlDemo.node.setText(new String(ch, start, length));  
  45.             //因为startElement()在characters()的前面调用，所以必须放在后面才能把文本添加进去  
  46.             SAXOperateXmlDemo.nodeList.add(SAXOperateXmlDemo.node);  
  47.             SAXOperateXmlDemo.node = null;  
  48.             //在这里之所以重新置为null是在解析标签的时候节点与节点之间的回车符、Tab符或者空格以及普通文本等等这些字符串也算一个节点  
  49.             //如果不这样，那么解析的时候会把之前添加成功的节点内的文本给替换掉。  
  50.         }  
  51.     }  
  52. }  
5、代码中解析的user03.xml的结构如下：

[html] view plaincopyprint?
  1. <?xml version="1.0" encoding="utf-8" ?>  
  2. <Root>  
  3.     <user id="001">UserInfo_1</user>  
  4.     <user id="002">UserInfo_2</user>  
  5. </Root>  

接下来执行该解析xml的方法，控制台显示效果如下：

SAX解析和生成XML文档

根据控制台的显示可知：

   <1>使用全局静态变量完成完成了对Xml解析之后的封装工作，并且在输出的时候没有问题，但是需要注意的是去掉空文本节点这种特殊情况，否则会出现获取的节点内的内容为"\n\t" 等等结果；

   <2>虽然功能是完成了，但是如果Xml文档中录入的不是文本，而是添加的详细的子节点呢？这样每一个节点就是一个Node对象，在查询和使用的时候非常的不方便。


所以为了避免这种情况，作出如下改动：

   因为需求只需要获取User信息，那么不用每一个解析的节点都封装成一个对象，并且属性对象和节点对象可以合并，不用分太开这样不易于后期维护。

具体操作如下：

假设现在需要解析的xml文档如下：

[html] view plaincopyprint?
  1. <?xml version="1.0" encoding="utf-8" ?>  
  2. <Users>  
  3.     <user id="9527">  
  4.         <name>admin</name>  
  5.         <age>40</age>  
  6.         <hobby>manage someone!</hobby>  
  7.     </user>  
  8.     <user id="9632">  
  9.         <name>chenghui</name>  
  10.         <age>110</age>  
  11.         <hobby>code something!</hobby>  
  12.     </user>  
  13. </Users>  
然后创建User实体类封装，具体如下：

[java] view plaincopyprint?
  1. /** 
  2.  * xml节点对象 
  3.  * @author Administrator 
  4.  * 
  5.  */  
  6. public class User {  
  7.   
  8.     private Long id;  
  9.     private String name;  
  10.     private Long age;  
  11.     private String hobby;  
  12.       
  13.     public Long getId() {  
  14.         return id;  
  15.     }  
  16.     public void setId(Long id) {  
  17.         this.id = id;  
  18.     }  
  19.     public String getName() {  
  20.         return name;  
  21.     }  
  22.     public void setName(String name) {  
  23.         this.name = name;  
  24.     }  
  25.     public Long getAge() {  
  26.         return age;  
  27.     }  
  28.     public void setAge(Long age) {  
  29.         this.age = age;  
  30.     }  
  31.     public String getHobby() {  
  32.         return hobby;  
  33.     }  
  34.     public void setHobby(String hobby) {  
  35.         this.hobby = hobby;  
  36.     }         
  37. }  
 解析当前xml的方法具体如下：

[java] view plaincopyprint?
  1. public void parseXml04(){  
  2.        String xmlPath = "D:\\project\\dynamicWeb\\src\\resource\\user04.xml";    
  3.     try {  
  4.         //获取SAX分析器的工厂实例，专门负责创建SAXParser分析器  
  5.         SAXParserFactory saxParserFactory = SAXParserFactory.newInstance();  
  6.         //获取SAXParser分析器的实例   
  7.         SAXParser saxParser = saxParserFactory.newSAXParser();  
  8.            InputStream inputStream = new FileInputStream(new File(xmlPath));    
  9.           
  10.         //解析xml文档   
  11.         saxParser.parse(inputStream, new XmlSAXHandler04());  
  12.           
  13.         //迭代list   
  14.         if(SAXOperateXmlDemo.userList.size() > 0){  
  15.             for (User user : SAXOperateXmlDemo.userList) {  
  16.                 System.out.println("-----------------------------------------");  
  17.                 System.out.println("【Id】" + user.getId());  
  18.                 System.out.println("【姓名】" + user.getName());  
  19.                 System.out.println("【年龄】" + user.getAge());  
  20.                 System.out.println("【爱好】" + user.getHobby());  
  21.             }  
  22.         }  
  23.     } catch (ParserConfigurationException e) {  
  24.         e.printStackTrace();  
  25.     } catch (SAXException e) {  
  26.         e.printStackTrace();  
  27.     } catch (FileNotFoundException e) {  
  28.         e.printStackTrace();  
  29.     } catch (IOException e) {  
  30.         e.printStackTrace();  
  31.     }  
  32. }  

并且当前解析类需要添加两个全局静态变量，具体如下：

[java] view plaincopyprint?
  1. public static List<User> userList = null;  
  2. public static User user = null;  

对应的解析xml处理者代码如下：

[java] view plaincopyprint?
  1. /** 
  2.  * 解析SAX的处理者04 
  3.  * @author Administrator 
  4.  * 
  5.  */  
  6. class XmlSAXHandler04 extends DefaultHandler {    
  7.       
  8.     private String currentQName;  //因为startElement()才能获取到标签名称，但是标签的内容在characters()获取，而且他们的执行顺序一直是顺序的，所以可以使用currentQName来过渡一下获取上一次的标签名  
  9.       
  10.     @Override  
  11.     public void startDocument() throws SAXException {  
  12.         SAXOperateXmlDemo.userList = new ArrayList<User>();  
  13.     }  
  14.       
  15.     @Override  
  16.     public void endDocument() throws SAXException {  
  17.           
  18.     }  
  19.       
  20.     @Override  
  21.     public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {  
  22.         if(qName.equals("user")){  
  23.             SAXOperateXmlDemo.user = new User(); //每次解析到user标签了才会创建user对象的实例  
  24.             //添加user标签中的id属性   
  25.             if(attributes.getLength() > 0){  
  26.                 SAXOperateXmlDemo.user.setId(Long.valueOf(attributes.getValue("id")));  
  27.             }  
  28.         }  
  29.         this.currentQName = qName;  
  30.     }  
  31.   
  32.     @Override  
  33.     public void endElement(String uri, String localName, String qName) throws SAXException {  
  34.         //需要说明的是，因为每一个非空标签都有characters(),那么无法知道user子标签循环完了  
  35.         //但是可以这样，如果不考虑子标签顺序可以判断是否解析到了最后一个子标签来判断  
  36.         //或者直接在user标签的endElement()中添加即可。   
  37.         if(qName.equals("user")){    
  38.             SAXOperateXmlDemo.userList.add(SAXOperateXmlDemo.user);  
  39.             SAXOperateXmlDemo.user = null;  
  40.         }  
  41.         this.currentQName = null;  
  42.     }  
  43.       
  44.     @Override  
  45.     public void characters(char[] ch, int start, int length) throws SAXException {  
  46.         String content = new String(ch, start, length);  
  47.         //System.out.println(currentQName + "：" + content);  
  48.         if(SAXOperateXmlDemo.user != null && currentQName != null){  
  49.             if(currentQName.equals("name")){  
  50.                 SAXOperateXmlDemo.user.setName(content);  
  51.             }else if(currentQName.equals("age")){  
  52.                 SAXOperateXmlDemo.user.setAge(Long.valueOf(content));  
  53.             }else if(currentQName.equals("hobby")){  
  54.                 SAXOperateXmlDemo.user.setHobby(content);  
  55.             }  
  56.         }  
  57.     }  
  58. }  
 直接运行该解析方法，控制台显示效果如下：

SAX解析和生成XML文档

好了，现在满足需求了  解析自己需要的节点然后封装成集合展示出来。


2、生成xml文档

SAX能够解析xml，同样肯定能生成xml，而且使用起来也不是很复杂。

实现思路：

   <1>创建保存xml的结果流对象StreamResult；

   <2>然后利用SAXTransformerFactory这个工厂创建TransformerHandler这个操作者；

   <3>操作这个TransformerHandler获取Transformer，利用Transformer创建节点信息；

具体代码如下：

[java] view plaincopyprint?
  1. public void buildXml01(){  
  2.     try {  
  3.         //创建保存xml的结果流对象   
  4.         Result reultXml = new StreamResult(new FileOutputStream(new File("c:\\user.xml")));  
  5.         //获取sax生产工厂对象实例   
  6.         SAXTransformerFactory saxTransformerFactory = (SAXTransformerFactory) SAXTransformerFactory.newInstance();  
  7.         //获取sax生产处理者对象实例   
  8.         TransformerHandler transformerHandle = saxTransformerFactory.newTransformerHandler();  
  9.         transformerHandle.setResult(reultXml);  
  10.         //获取sax生产器   
  11.         Transformer transformer = transformerHandle.getTransformer();  
  12.         //transformer.setOutputProperty(OutputKeys.ENCODING,"UTF-8");//xml的编码格式  
  13.         transformer.setOutputProperty(OutputKeys.INDENT,"yes");//换行  
  14.         //开始封装document文档对象，这里和解析一样都是成双成对的构造标签  
  15.         transformerHandle.startDocument();  
  16.         AttributesImpl attrImple = new AttributesImpl();  
  17.         transformerHandle.startElement("", "", "Users",attrImple);  
  18.           
  19.         attrImple.addAttribute("", "", "id", "string", "123");  
  20.         transformerHandle.startElement("", "", "user", attrImple);  
  21.         transformerHandle.characters("这个是用户的信息".toCharArray(), 0, "这个是用户的信息".length());  
  22.         transformerHandle.endElement("", "", "user");  
  23.           
  24.         transformerHandle.endElement("", "", "Users");  
  25.         //因为没有appendChild等等添加子元素的方法，sax提供的是构造在startElement()和endElement()区间内的标签为包含的节点的父节点  
  26.         transformerHandle.endDocument();  
  27.           
  28.         System.out.println("xml文档生成成功！");  
  29.           
  30.     } catch (FileNotFoundException e) {  
  31.         e.printStackTrace();  
  32.     } catch (TransformerConfigurationException e) {  
  33.         e.printStackTrace();  
  34.     } catch (SAXException e) {  
  35.         e.printStackTrace();  
  36.     }  
  37. }  
 执行该生成方法，控制台显示效果如下：
SAX解析和生成XML文档

然后看看生成的XML，结构如下：

SAX解析和生成XML文档


结果显示达到了期望，但是有一个问题：

   如果使用transformer.setOutputProperty(OutputKeys.ENCODING,"UTF-8"); 重新指定了编码，插入的中文会变成乱码，现在没有想到解决方案。。

   但是如果不指定编码 却没有问题，显示结果是上图中的默认的UTF-8。

标签：

相关文章