android sax解析xml檔（二）

在上篇文章中，简单介绍了sax解析xml的一种方式，它是继承defaultHandler方式，并重写其中的几个方法来实现的。

接下来说的第二种方式是用RootElement这个类来解析的，RootElement 内置了defaultHandler的子类，

RootElement 源码如下：

public class RootElement extends Element {  
  
    final Handler handler = new Handler();  
  
    /**  
     * Constructs a new root element with the given name.  
     *  
     * @param uri the namespace  
     * @param localName the local name  
     */  
    public RootElement(String uri, String localName) {  
        super(null, uri, localName, 0);  
    }  
  
    /**  
     * Constructs a new root element with the given name. Uses an empty string  
     * as the namespace.  
     *  
     * @param localName the local name  
     */  
    public RootElement(String localName) {  
        this("", localName);  
    }  
  
    /**  
     * Gets the SAX {@code ContentHandler}. Pass this to your SAX parser.  
     */  
    public ContentHandler getContentHandler() {  
        return this.handler;  
    }  
  
    class Handler extends DefaultHandler {  
  
        Locator locator;  
        int depth = -1;  
        Element current = null;  
        StringBuilder bodyBuilder = null;  
  
        @Override  
        public void setDocumentLocator(Locator locator) {  
            this.locator = locator;  
        }  
  
        @Override  
        public void startElement(String uri, String localName, String qName,  
                Attributes attributes) throws SAXException {  
            int depth = ++this.depth;  
  
            if (depth == 0) {  
                // This is the root element.  
                startRoot(uri, localName, attributes);  
                return;  
            }  
  
            // Prohibit mixed text and elements.  
            if (bodyBuilder != null) {  
                throw new BadXmlException("Encountered mixed content"  
                        + " within text element named " + current + ".",  
                        locator);  
            }  
  
            // If we're one level below the current element.  
            if (depth == current.depth + 1) {  
                // Look for a child to push onto the stack.  
                Children children = current.children;  
                if (children != null) {  
                    Element child = children.get(uri, localName);  
                    if (child != null) {  
                        start(child, attributes);  
                    }  
                }  
            }  
        }  
  
        void startRoot(String uri, String localName, Attributes attributes)  
                throws SAXException {  
            Element root = RootElement.this;  
            if (root.uri.compareTo(uri) != 0  
                    || root.localName.compareTo(localName) != 0) {  
                throw new BadXmlException("Root element name does"  
                        + " not match. Expected: " + root + ", Got: "  
                        + Element.toString(uri, localName), locator);  
            }  
  
            start(root, attributes);  
        }  
  
        void start(Element e, Attributes attributes) {  
            // Push element onto the stack.  
            this.current = e;  
  
            if (e.startElementListener != null) {  
                e.startElementListener.start(attributes);  
            }  
  
            if (e.endTextElementListener != null) {  
                this.bodyBuilder = new StringBuilder();  
            }  
              
            e.resetRequiredChildren();  
            e.visited = true;  
        }  
  
        @Override  
        public void characters(char[] buffer, int start, int length)  
                throws SAXException {  
            if (bodyBuilder != null) {  
                bodyBuilder.append(buffer, start, length);  
            }  
        }  
  
        @Override  
        public void endElement(String uri, String localName, String qName)  
                throws SAXException {  
            Element current = this.current;  
  
            // If we've ended the current element...  
            if (depth == current.depth) {  
                current.checkRequiredChildren(locator);  
  
                // Invoke end element listener.  
                if (current.endElementListener != null) {  
                    current.endElementListener.end();  
                }  
  
                // Invoke end text element listener.  
                if (bodyBuilder != null) {  
                    String body = bodyBuilder.toString();  
                    bodyBuilder = null;  
  
                    // We can assume that this listener is present.  
                    current.endTextElementListener.end(body);  
                }  
  
                // Pop element off the stack.  
                this.current = current.parent;  
            }  
  
            depth--;  
        }  
    }  
}

以上是RootElement类得源码，从源码可以看出，它只是将defaultHandler简单的处理一下。

具体应用可以参照我写的测试源码

/**  
     * sax解析xml的第二种方式  
     *      用XMLReader 也是sax的一种方式  
     * @return  
     */  
    private String saxParseSecond(){  
        //读取src下xml文件  
        InputStream inputStream =  
             this.getClass().getClassLoader().getResourceAsStream("saxTest.xml");  
        SAXParserFactory factory = SAXParserFactory.newInstance();  
        try {  
            SAXParser parse = factory.newSAXParser();  
            XMLReader reader = parse.getXMLReader();  
            reader.setContentHandler(getRootElement().getContentHandler());  
            reader.parse(new InputSource(inputStream));  
        } catch (ParserConfigurationException e) {  
            e.printStackTrace();  
        } catch (SAXException e) {  
            e.printStackTrace();  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
        return result;  
    }

/**   
     *    
     * @return 返回设置好处理机制的rootElement   
     */    
    private RootElement getRootElement(){    
            
        /*rootElement代表着根节点，参数为根节点的tagName*/    
        RootElement rootElement = new RootElement("classes");    
        /*获取一类子节点，并为其设置相应的事件   
         * 这里需要注意，虽然我们只设置了一次group的事件，但是我们文档中根节点下的所有   
         * group却都可以触发这个事件。   
         * */    
        Element groupElement = rootElement.getChild("group");    
        // 读到元素开始位置时触发，如读到<group>时    
        groupElement.setStartElementListener(new StartElementListener() {    
            @Override    
            public void start(Attributes attributes) {    
//                Log.i("TEST", "start");    
               String groupName =  attributes.getValue("name");  
               String groupNum =  attributes.getValue("num");  
               result = result+"groupName ="+groupName+"groupNum = "+groupNum+"\n";  
            }    
        });    
        //读到元素结束位置时触发，如读到</group>时    
        groupElement.setEndElementListener(new EndElementListener() {    
            @Override    
            public void end() {    
            }    
        });    
        Element personElement = groupElement.getChild("person");  
        //读取<person>标签触发  
        personElement.setStartElementListener(new StartElementListener() {  
              
            @Override  
            public void start(Attributes attributes) {  
                 String personName =  attributes.getValue("name");  
                 String age =  attributes.getValue("age");  
                 result = result+"personName ="+personName+"age = "+age+"\n";  
            }  
        });  
        //读取</person>标签触发  
        personElement.setEndElementListener(new EndElementListener() {  
              
            @Override  
            public void end() {  
                  
            }  
        });  
          
        Element chinese = personElement.getChild("chinese");    
//        chinese.setTextElementListener(new TextElementListener() {  
//            
//          @Override  
//          public void end(String body) {  
//              // TODO Auto-generated method stub  
//                
//          }  
//            
//          @Override  
//          public void start(Attributes attributes) {  
//              // TODO Auto-generated method stub  
//                
//          }  
//      });  
        // 读到文本的末尾时触发,这里的body即为文本的内容部分    
        chinese.setEndTextElementListener(new EndTextElementListener() {    
            @Override    
            public void end(String body) {    
                Pattern p = Pattern.compile("\\s*|\t|\r|\n");   
                Matcher m = p.matcher(body);   
                body = m.replaceAll("");   
                result = result+"chinese ="+body;  
            }    
        });    
            
        Element english = personElement.getChild("english");    
        english.setEndTextElementListener(new EndTextElementListener() {    
            @Override    
            public void end(String body) {    
                Pattern p = Pattern.compile("\\s*|\t|\r|\n");   
                Matcher m = p.matcher(body);   
                body = m.replaceAll("");   
               result = result+"english ="+body+"\n";  
            }    
        });    
        return rootElement;    
            
    }

我们都知道通过SAXParser对象解析xml的方式，这里我们又从代码中看到了利用另一个对象XMLReader进行解析，那么两者到底有什么联系和区别呢？

     其实SAXParser是在SAX 1.0 定义的，而XMLReader则是在2.0中才开始出现的。你可以认为XMLReader的出现是为了替代SAXParser解析的，两者本质上干的事情是一样的，只不过XMLReader的功能更加的强悍而已。  

关于XMLReader的获取方式，除了通过SAXParser的getXMLReader方法获得之外，我们还可以通过以下两种方式。

XMLReader parser=XMLReaderFactory.createXMLReader(); (1)
XMLReader parser=XMLReaderFactory.createXMLReader(String className); (2)

以上就是 android sax解析xml文件（二）的内容，更多相关内容请关注PHP中文网（www.php.cn）！