Java知识积累——Sax解析xml文档

整体思路：Sax解析是将xml文档按Stream读入，一点一点的解析，不像Dom解析那样把文档全部加载到内存中，因此更适合实际情况的使用。Sax解析需要继承DefaultHandler，重写其4个方法（startDocument、startElement、endElement、characters），分别用于处理xml的ElementNode（<>或</>）和TextNode（字符）。下面看一个例子：此程序将原本的xml文件中各个元素标签解析成对应的TagBean实例，每对标签会被解析成一个实例，并且按树状存储标签之间的关系。因为我的目的是要解析Spring IoC的配置信息，所以4个方法的处理都是基于Spring IoC配置规则而实现的，当你们解析特定的xml文档时，只要修改这4个方法的解析规则即可。

TagBean的代码：

public class TagBean {
    private String name;
    private Map<String,String> attrList = null;
    private ArrayList<TagBean> childList = new ArrayList<TagBean>();
    
    public void print(int count){
        for(int i = 0; i < count; i++){
            System.out.print(" ");
        }
        System.out.print(name+":");
        if(attrList != null){
            Iterator<String> keySetItr = attrList.keySet().iterator();
            while(keySetItr.hasNext()){
                String key = keySetItr.next();
                System.out.print(key +"--"+attrList.get(key)+"\t");
            }
            System.out.println();
        }else{
            System.out.println();
        }
        if(childList.size() > 0){
            int newCount = ++count;
            for(TagBean temp : childList){
                temp.print(newCount);
            }
        }else{
            return;
        }
    }
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Map<String, String> getAttrList() {
        if(attrList == null){
            attrList = new HashMap<String,String>();
        }
        return attrList;
    }
    public void setAttrList(Map<String, String> attrList) {
        this.attrList = attrList;
    }
    public ArrayList<TagBean> getChildList() {
        return childList;
    }
    public void setChildList(TagBean childTag){
        this.childList.add(childTag);
    }
    
}

解析服务的代码：

public class SaxParsingService extends DefaultHandler{
    private ArrayList<TagBean> tagList = null;  
    private TagBean tag = null;
    private Stack<String> tagNameStack = null;//标记当前在处理的tag的隶属关系，遇到<>时入栈，遇到 </>时出栈
    private Stack<TagBean> tagBeanStack = null;
    private TagBean rootTag = null;
      
    public TagBean getRootTag(InputStream xmlStream) throws Exception{  
        //获取sax分析器
        SAXParserFactory factory = SAXParserFactory.newInstance();  
        SAXParser parser = factory.newSAXParser();
        //根据具体程序要求进行分析
        SaxParsingService handler = new SaxParsingService();  
        parser.parse(xmlStream, handler);  //给分析器传入文件路径和分析规则
        return handler.getRootTag(); //分析结束，获得信息 
    }  
      
    public ArrayList<TagBean> getTagList(){  
        return tagList;
    }  
      
    @Override  //当文件解析开始时，会调用此函数
    public void startDocument() throws SAXException {  
        tagList = new ArrayList<TagBean>();
        tagNameStack = new Stack<String>();
        tagBeanStack = new Stack<TagBean>();
    }  
  
    @Override  //当碰到ElementNode时（如<books>），会调用此方法
    public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {  
        //System.out.println(qName+" start");
        tagNameStack.push(qName);
        
        tag = new TagBean();
        tag.setName(qName);
        
        //存储标签的属性信息
        int index = attributes.getLength();
        if(index > 0){
            Map<String,String> attrList = new HashMap<String,String>();
            for(int i = 0 ; i < index ; i++ ){
                attrList.put(attributes.getQName(i),attributes.getValue(i));
            }
            tag.setAttrList(attrList);
        }
        
        //将正在解析的节点名称赋给preTag
        //preTag = qName;
        
        //处理子标签问题
        tagBeanStack.push(tag);
        
        //保存beans的引用
        if("beans".equals(qName)){
            rootTag = tag;
        }
    }  
  
    @Override  //当遇到</>时调用此方法
    public void endElement(String uri, String localName, String qName)  throws SAXException {  
        //System.out.println(qName+" end");
        
        //处理了</>后，需要弹栈，并且构建子标签与父标签的关系
        tagNameStack.pop();
        tag = tagBeanStack.pop();
        if(!tag.getName().equals("beans")){
            tagBeanStack.peek().setChildList(tag);
        }
        
        //preTag = null;
    }  
      
    @Override  //当遇到TextNode时调用，比如空格、值
    public void characters(char[] ch, int start, int length) throws SAXException {  
        //System.out.println("char here");
        String content = new String(ch,start,length);  
        content = content.trim();
        
        if(content.length() > 0){
            tagNameStack.peek();
            tag = tagBeanStack.peek();
            tag.getAttrList().put(tagNameStack.peek(), content);
        }
        
    }
    
    public TagBean getRootTag(){
        return this.rootTag;
    }
}

程序入口，Main类：

public class Main {
      public void testSAX() throws Throwable{  
          SaxParsingService sax;  
          InputStream input = null;
          try {
             sax = new SaxParsingService();
             input = this.getClass().getClassLoader().getResourceAsStream(“test.xml”);
             
             //解析input的xml文件，存储成树结构的tag链
             TagBean rootTag = sax.getRootTag(input);
             
             //输出解析后存储的标签树结构
             rootTag.print(0);
         } catch (Exception e) {
             e.printStackTrace();
         } finally{
             input.close();
         }
      }
      public static void main(String[] args) throws Throwable {
        new Main().testSAX();
      }
}

需要解析的文档：

<?xml version="1.0" encoding="UTF-8"?>
<beans 
    xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">
    <bean id = "beanB" class = "org.beans.BeanB">
        <property name = "ba">
            <ref bean = "beanA"/>
        </property>
        <property name = "content">
            <value>There is no problem!</value>
        </property>
        <property name="bc" ref="beanC"/>
        <property name="listRef">
            <list>
                <value>First</value>
                <value>Second</value>
            </list>
        </property>
        <property name="listBeanRef">
            <list>
                <ref bean = "beanA1"/>
                <ref bean = "beanA2"/>
            </list>
        </property>
        <property name="max" value="15" />
        <property name = "valueProps">
            <props>
                <prop key = "strValueKey1">something1</prop>
                <prop key = "strValueKey2">something2</prop>
            </props>
        </property>
        <property name="mapRef">
            <map>
                <entry>
                    <key>
                        <value>key1</value>
                    </key>
                    <value>v1</value>
                </entry>
                <entry key="key2">
                    <value>v2</value>
                </entry>
                <entry key="key3" value="v3"/>
            </map>
        </property>
    </bean>
    <bean id = "beanA" class = "org.beans.BeanA"/>
    <bean id = "beanC" class = "org.beans.BeanC">
        <constructor-arg >
            <value>11</value>
        </constructor-arg>
        <constructor-arg>
            <ref bean = "beanA3"/>
        </constructor-arg>
    </bean>
    <bean id = "beanA1" class = "org.beans.BeanA">
        <constructor-arg index = "1" value = "22"/>
        <constructor-arg index = "0" ref = "beanA4"/>    
    </bean>
    <bean id = "beanA2" class = "org.beans.BeanA">
        <constructor-arg index = "1" >
            <value>33</value>
        </constructor-arg>
        <constructor-arg  ref = "beanA4"/>
        <constructor-arg>
            <value>44</value>
        </constructor-arg>
        <constructor-arg index = "0" value = "55"/>
    </bean>
</beans>

解析后，调用rootTag的print方法，打印的树状数据结构：

beans:xmlns:xsi--http://www.w3.org/2001/XMLSchema-instance    xmlns--http://www.springframework.org/schema/beans    xsi:schemaLocation--http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd    
 bean:id--beanB    class--org.beans.BeanB    
  property:name--ba    
   ref:bean--beanA    
  property:name--content    
   value:value--There is no problem!    
  property:ref--beanC    name--bc    
  property:name--listRef    
   list:
    value:value--First    
    value:value--Second    
  property:name--listBeanRef    
   list:
    ref:bean--beanA1    
    ref:bean--beanA2    
  property:name--max    value--15    
  property:name--valueProps    
   props:
    prop:prop--something1    key--strValueKey1    
    prop:prop--something2    key--strValueKey2    
  property:name--mapRef    
   map:
    entry:
     key:
      value:value--key1    
     value:value--v1    
    entry:key--key2    
     value:value--v2    
    entry:value--v3    key--key3    
 bean:id--beanA    class--org.beans.BeanA    
 bean:id--beanC    class--org.beans.BeanC    
  constructor-arg:
   value:value--11    
  constructor-arg:
   ref:bean--beanA3    
 bean:id--beanA1    class--org.beans.BeanA    
  constructor-arg:index--1    value--22    
  constructor-arg:ref--beanA4    index--0    
 bean:id--beanA2    class--org.beans.BeanA    
  constructor-arg:index--1    
   value:value--33    
  constructor-arg:ref--beanA4    
  constructor-arg:
   value:value--44    
  constructor-arg:index--0    value--55

如有疑问，可留言沟通~