SAX解析XML总结

Myhandler继承自DefaultHandler

主要函数：

public void startElement(String uri, String localName, String qName,
Attributes attributes)

public void startDocument()

public void endElement(String uri, String localName, String qName)

public void endDocument()

public void characters(char[] ch, int start, int length)

属性集合中获取属性名和属性值

http://book.51cto.com/art/201107/279379.htm

attribute.getvalue(i)

attribute.getname(i)

主要函数

class MyHandler extends DefaultHandler {

     
    private String tag="";
    private String value="";
    private String currentName="";
    private StringBuffer str=new StringBuffer();
    private Properties props;
    
    private Rule rule=null;
    private List<Rule> rules=null;
    
    
    public MyHandler(){
        this.props=new Properties();
        this.rules=new ArrayList<Rule>();
    }
    public StringBuffer getstr()
    {
        return str;
    }
    public Properties getprops(){
        return props;
    }
    @Override
    public InputSource resolveEntity(String publicId, String systemId)
            throws IOException, SAXException {
        return super.resolveEntity(publicId, systemId);
    }
    /* 
     * 接收注释声明事件的通知。 
     * 参数意义如下： 
     *     name - 注释名称。 
     *     publicId - 注释的公共标识符，如果未提供，则为 null。 
     *     systemId - 注释的系统标识符，如果未提供，则为 null。 
     */  
    @Override
    public void notationDecl(String name, String publicId, String systemId)
            throws SAXException {
        super.notationDecl(name, publicId, systemId);
    }
    
    /* 
     * 接收未解析的实体声明事件的通知。 
     * 参数意义如下： 
     *     name - 未解析的实体的名称。 
     *     publicId - 实体的公共标识符，如果未提供，则为 null。 
     *     systemId - 实体的系统标识符。 
     *     notationName - 相关注释的名称。 
     */ 
    @Override
    public void unparsedEntityDecl(String name, String publicId,
            String systemId, String notationName) throws SAXException {
        super.unparsedEntityDecl(name, publicId, systemId, notationName);
    }

    /* 
     * 接收用来查找 SAX 文档事件起源的对象。 
     * 参数意义如下： 
     *     locator : 可以返回任何 SAX 文档事件位置的对象 
     */
    @Override
    public void setDocumentLocator(Locator locator) {
        super.setDocumentLocator(locator);
    }
    
    //一般将正式解析前的一些初始化工作放到这里面，收尾工作放在endDocument中  
    @Override
    public void startDocument() throws SAXException {
        System.err.println("开始解析文档");
    }
    //接受文档结尾的通知
    @Override
    public void endDocument() throws SAXException {
        System.err.println("解析结束");
    }

    @Override
    public void startPrefixMapping(String prefix, String uri)
            throws SAXException {
        super.startPrefixMapping(prefix, uri);
    }

    //结束前缀URI范围的映射
    @Override
    public void endPrefixMapping(String prefix) throws SAXException {
        super.endPrefixMapping(prefix);
    }

    /* 
     * 接收元素开始的通知。 
     * XML解析器遇到XML里面的tag时就会调用这个函数。经常在这个函数内是通过localName俩进行判断而操作一些数据。
     * 参数意义如下： 
     *    uri ：元素的命名空间 
     *    localName ：元素的本地名称（不带前缀） 
     *    qName ：元素的限定名（带前缀） 
     *    attributes ：元素的属性集合 
     */  
    
    @Override
    public void startElement(String uri, String localName, String qName,
            Attributes attributes) throws SAXException {
        System.out.print("
"+"Element: " + qName + ", attr: ");
        //print(attributes);
        int i=attributes.getLength();
        for(int j=0;j<i;j++)
        {
            String strName=attributes.getLocalName(j);
            String strValue=attributes.getValue(j);
            System.out.println(strName+":"+strValue);
        }
        this.currentName=qName;
    }
    
    /*
     * @接受元素尾部通知(non-Javadoc)
     * @see org.xml.sax.helpers.DefaultHandler#endElement(java.lang.String, java.lang.String, java.lang.String)
     * @uri 元素命名空间
     * @localName 元素本地名称
     * @qName 元素限定名
     */
    
    @Override
    public void endElement(String uri, String localName, String qName)
            throws SAXException {
        super.endElement(uri, localName, qName);
        //props.put(qName.toLowerCase(), currentName.toString().trim());
    }

    /*接受字符数据的通知
     * 在DOM中 ch[begin:end] 相当于Text节点的节点值（nodeValue）
     * 碰到节点开始和结束之间的字符
     * 回调方法。解析器执行完startElement()后，解析完节点的内容后就会执行这个方法，并且参数ch[]就是节点的内容。
     */
    @Override
    public void characters(char[] ch, int start, int length)
            throws SAXException {
        //super.characters(ch, start, length);
        this.str.append(ch,start,length);
    }

    @Override
    public void ignorableWhitespace(char[] ch, int start, int length)
            throws SAXException {
        super.ignorableWhitespace(ch, start, length);
    }

    //接受处理指令的通知
    
    @Override
    public void processingInstruction(String target, String data)
            throws SAXException {
        super.processingInstruction(target, data);
    }

    /* 
     * 接收跳过的实体的通知。 
     * 参数意义如下：  
     *     name : 所跳过的实体的名称。如果它是参数实体，则名称将以 '%' 开头， 
     *            如果它是外部 DTD 子集，则将是字符串 "[dtd]" 
     */  
    @Override
    public void skippedEntity(String name) throws SAXException {
        super.skippedEntity(name);
    }

    
    /* 
     * 接收warning的通知。 
     */ 
    @Override
    public void warning(SAXParseException e) throws SAXException {
        super.warning(e);
    }
    
    /* 
     * 接收可恢复的错误的通知 
     */ 
    @Override
    public void error(SAXParseException e) throws SAXException {
        super.error(e);
    }

    /* 
     * 接收不可恢复的错误的通知。 
     */
    @Override
    public void fatalError(SAXParseException e) throws SAXException {
        super.fatalError(e);
    }
    
    private void print(Attributes attrs) {
        if (attrs == null) return;
        System.err.print("[");
        for (int i = 0; i < attrs.getLength(); i++) {
            System.err.print(attrs.getQName(i) + " = " + attrs.getValue(i));
            if (i != attrs.getLength() - 1) {
                System.err.print(", ");
            }
        }
        System.err.println("]");
    }
}

XML文件

<?xml version="1.0" encoding="UTF-8"?>
<rules>
<message name="高度">
   <part name="heigth" type="xs:integer"/>
</message>

<message name="长度">
   <part name="length" type="xs:integer"/>
</message>

<message name="结果">
   <part name="result" type="xs:string"/>
</message>
<services name="规则1">
 <operation name="高度判断">
     <optlist>
        <input message="heigth" opt="大于" baseValue="30"/>
        <output message="heigth" Value="高度过高" />
     </optlist>
     <optlist>
        <input message="heigth" opt="大于" baseValue="20"/>
        <input message="heigth" opt="小于" baseValue="30"/>
        <output message="heigth" Value="高度合适" />
     </optlist>
     <optlist>
        <input message="heigth" opt="小于" baseValue="20"/>
        <output message="heigth" Value="高度偏低" />
     </optlist>
 </operation>
</services>
</rules>

自己写的解析程序

public class TestSAX extends DefaultHandler{

    public static void main(String[] args) {
        read();
        write();
    }
    
       private String strOperationtag="";
       private String strMessageName="";
       private String strOptName="";
       private String strBaseValue="";
       private String value="28";
       private boolean tag;
       private int signtag;
       private String currentName="";
       private StringBuffer str=new StringBuffer();
       
       private Rule rule=null;
       private List<Rule> rules=null;
    public static void read() {
        try {
            // 得到SAX解析工厂
            SAXParserFactory factory = SAXParserFactory.newInstance();
            //创建解析器
            SAXParser parser = factory.newSAXParser();
            //获得输入流
            InputStream in = TestSAX.class.getClassLoader().getResourceAsStream("test.xml");
            //开始解析
            parser.parse(in, new TestSAX());
        } catch (ParserConfigurationException e) {
            e.printStackTrace();
        } catch (SAXException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    public static void write() {
        System.err.println("纯SAX对于写操作无能为力");
    }
       /* 
        * 接收注释声明事件的通知。 
        * 参数意义如下： 
        *     name - 注释名称。 
        *     publicId - 注释的公共标识符，如果未提供，则为 null。 
        *     systemId - 注释的系统标识符，如果未提供，则为 null。 
        */  
       @Override
       public void notationDecl(String name, String publicId, String systemId)
               throws SAXException {
           super.notationDecl(name, publicId, systemId);
       }
       

       /* 
        * 接收用来查找 SAX 文档事件起源的对象。 
        * 参数意义如下： 
        *     locator : 可以返回任何 SAX 文档事件位置的对象 
        */
       @Override
       public void setDocumentLocator(Locator locator) {
           super.setDocumentLocator(locator);
       }
       
       //一般将正式解析前的一些初始化工作放到这里面，收尾工作放在endDocument中  
       @Override
       public void startDocument() throws SAXException {
           System.err.println("开始解析文档");
       }
       //接受文档结尾的通知
       @Override
       public void endDocument() throws SAXException {
           System.err.println("解析结束");
       }

       /* 
        * 接收元素开始的通知。 
        * XML解析器遇到XML里面的tag时就会调用这个函数。经常在这个函数内是通过localName俩进行判断而操作一些数据。
        * 参数意义如下： 
        *    uri ：元素的命名空间 
        *    localName ：元素的本地名称（不带前缀） 
        *    qName ：元素的限定名（带前缀） 
        *    attributes ：元素的属性集合 
        */  
       
       @Override
       public void startElement(String uri, String localName, String qName,
               Attributes attributes) throws SAXException {
           //System.out.print("
"+"Element: " + qName + ", attr: ");
           //print(attributes);
           int i=attributes.getLength();
           for(int j=0;j<i;j++)
           {
               //String strName=attributes.getLocalName(j);
               //String strValue=attributes.getValue(j);
               //System.out.println(strName+":"+strValue);
           }
           if(qName=="operation")
           {
               strOperationtag=attributes.getValue(0);
           }
           if(qName=="input")
           {
               strMessageName=attributes.getValue(0);
               strOptName=attributes.getValue(1);
               strBaseValue=attributes.getValue(2);
           }
           switch(strOptName)
           {
               case("大于"):
                   if(Double.parseDouble(value)>Double.parseDouble(strBaseValue))
                   {
                       signtag=1;
                   }
                   break;
               case("小于"):
                   if(Double.parseDouble(value)<Double.parseDouble(strBaseValue))
                   {
                       signtag=2;
                   }
                   break;
               case("等于"):
                   signtag=3;break;
               case("大于等于"):
                   signtag=4;break;
               default:
                   signtag=0;break;
           }
           if(signtag!=0)
           {
               if(qName=="output")
               {
                   System.out.println(attributes.getValue(1));
                   signtag=0;
                   strBaseValue="";
                   strMessageName="";
                   strOptName="";
               }
           }
           
       }
       
       /*
        * @接受元素尾部通知(non-Javadoc)
        * @see org.xml.sax.helpers.DefaultHandler#endElement(java.lang.String, java.lang.String, java.lang.String)
        * @uri 元素命名空间
        * @localName 元素本地名称
        * @qName 元素限定名
        */
       
       @Override
       public void endElement(String uri, String localName, String qName)
               throws SAXException {
           //super.endElement(uri, localName, qName);
           if(qName=="operation")
           {
               strOperationtag="";
           }
       }

       /*接受字符数据的通知
        * 在DOM中 ch[begin:end] 相当于Text节点的节点值（nodeValue）
        * 碰到节点开始和结束之间的字符
        * 回调方法。解析器执行完startElement()后，解析完节点的内容后就会执行这个方法，并且参数ch[]就是节点的内容。
        */
       @Override
       public void characters(char[] ch, int start, int length)
               throws SAXException {
           //super.characters(ch, start, length);
           this.str.append(ch,start,length);
       }


       private void print(Attributes attrs) {
           if (attrs == null) return;
           System.err.print("[");
           for (int i = 0; i < attrs.getLength(); i++) {
               System.err.print(attrs.getQName(i) + " = " + attrs.getValue(i));
               if (i != attrs.getLength() - 1) {
                   System.err.print(", ");
               }
           }
           System.err.println("]");
       }
    
}

 参考资料：

http://yangjunfeng.iteye.com/blog/401377

http://www.blogjava.net/DLevin/archive/2012/11/18/391545.html

http://www.ibm.com/developerworks/cn/xml/x-saxapi/