xml解析

1.PUll解析

public static List<Cate> xmlParser(InputStream is) {

        List<Cate> list = new ArrayList<Cate>();

        try {

            // 构建XmlPullParser解析器实例

            XmlPullParser xmlParser = Xml.newPullParser();

            // setInput将数据流设置在解析器当中

            xmlParser.setInput(is, "utf-8");

            // 获得事件类型

            int eventType = xmlParser.getEventType();

            //用来存储标签名字的变量

            String tagName = "";

            Cate cate = null;

            while (eventType != XmlPullParser.END_DOCUMENT) {

                switch (eventType) {

                case XmlPullParser.START_DOCUMENT:

                    Log.i(TAG, "START_DOCUMENT");

                    break;

                case XmlPullParser.START_TAG:

                    Log.i(TAG, "START_TAG");

                    //通过getName()获得标签名称，此方法只适用于开始标签与结束标签事件

                    tagName = xmlParser.getName();

                    if (tagName.equals("cate")) {

                        cate = new Cate();

                        cate.setId(xmlParser.getAttributeValue(0));

                    }

                    break;

                case XmlPullParser.TEXT:

                    // 通过getText()方法获得文本节点的文本值

                    String text = xmlParser.getText();

                    if (cate != null) {

                     if (tagName.equals("cateurl")) {

                            cate.setCateurl(text);

                        } else if (tagName.equals("catetitle")) {

                            cate.setCatetitle(text);

                        } else if (tagName.equals("catecontent")) {

                            cate.setCatecontent(text);

                        } else if (tagName.equals("cateprice")) {

                            cate.setCateprice(text);

                        }

                    }

                    break;

                case XmlPullParser.END_TAG:

                    Log.i(TAG, "END_TAG");

                    tagName = xmlParser.getName();

                    if (tagName.equals("cate")) {

                        list.add(cate);

                        cate = null;

                    }

                    // 每到结束标签需要清空tagName，因为标签与标签之间存在空白的文本结点

                    tagName = "";

                    break;

                }

                // 触发进入下一次遍历事件

                eventType=xmlParser.next();

            }

        } catch (Exception e) {

            e.printStackTrace();

        }

        return list;

    }

2.Sax解析

private static final String TAG=SaxXmlParser.class.getSimpleName();

    //用来存存储解析实体类Cate的集合

    public List<Cate> list=null;

    private static final String CATE="cate";

    private static final String CATEURL="cateurl";

    private static final String CATETITILE ="catetitle";

    private static final String CATECONTENT="catecontent";

    private static final String CATEPRICE ="cateprice";

    /**

     * sax解析xml数据

     * @param is

     * @return

     */

    public List<Cate> saxXmlParser(InputStream is){

        try{

        //先构建sax解析器工厂实例

        SAXParserFactory saxParserFa=SAXParserFactory.newInstance();

        //获取解析器实例

        SAXParser saxParser=saxParserFa.newSAXParser();

        //获取读取事件源实例

        XMLReader xmlReader=saxParser.getXMLReader();

        //构建事件处理器实例

        CateHandler  cateHandler=new CateHandler();

        //将事件处理器设置给事件源

        xmlReader.setContentHandler(cateHandler);

        //通过设置parse（）方法注入数据流

        xmlReader.parse(new InputSource(is));

        }catch(Exception e){

            e.printStackTrace();

        }

       return list;

    }

    /**

     * 定义一个事件处理器

     * @author bee

     *

     */

    class CateHandler extends DefaultHandler{

         //美食实体类

        private Cate cate=null;

        //用来存储标签的名称

        private String tagName="";

        //解析到文档开始时触发

        @Override

        public void startDocument() throws SAXException {

            // TODO Auto-generated method stub

            super.startDocument();

             Log.i(TAG, "startDocument");

             list=new ArrayList<Cate>();

        }

       //解析到开始标签时开始触发

        @Override

        public void startElement(String uri, String localName, String qName,

                Attributes attributes) throws SAXException {

            // TODO Auto-generated method stub

            super.startElement(uri, localName, qName, attributes);

            Log.i(TAG, "startElement");

            //获取开始标签名称

            tagName=localName;

            if(CATE.equals(tagName)){

                cate=new Cate();

                cate.setId(attributes.getValue(0));

            }

        }

      //解析到文本节点时开始触发

        @Override

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

                throws SAXException {

            // TODO Auto-generated method stub

            super.characters(ch, start, length);

            Log.i(TAG, "characters");

            //获取文本内容

            String text=new String(ch,start,length);

            if(cate!=null){

                if(CATEURL.equals(tagName)){

                    cate.setCateurl(text);

                }else if(CATETITILE.equals(tagName)){

                    cate.setCatetitle(text);

                }else if(CATECONTENT.equals(tagName)){

                    cate.setCatecontent(text);

                }else if(CATEPRICE.equals(tagName)){

                    cate.setCateprice(text);

                }

            }

        }

       //解析到结束标签时候开始触发

        @Override

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

                throws SAXException {

            // TODO Auto-generated method stub

            super.endElement(uri, localName, qName);

            Log.i(TAG, "endElement");

            //获取结束标签名称

            tagName=localName;

            if(CATE.equals(tagName)){

                list.add(cate);

                cate=null;

            }

            //清空tagName，否则标签之间有意义的文本将替换掉原来有意义的数值

            tagName="";

        }

        //解析到文档结束时触发

        @Override

        public void endDocument() throws SAXException {

            // TODO Auto-generated method stub

            super.endDocument();

            Log.i(TAG, "endDocument");

        }

    }

3.DOM解析

public List<Cate> domXmlParser(InputStream is) {

        List<Cate> list = new ArrayList<Cate>();

        Cate cate = null;

        try {

            //实例化一个文档构建器工厂

            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

             //通过文档构建器工厂获取一个文档构建器

            DocumentBuilder buidler = factory.newDocumentBuilder();

            // 通过文档构建起构建一个文档实例

            Document document = buidler.parse(is);

            // 从文档中拿到拿到Element

            Element element = (Element) document.getDocumentElement();

            // 通过标签名拿到元素节点集合  获取所有名字为cate的节点

            NodeList nodeList = element.getElementsByTagName("cate");

            // 遍历节点列表

            for (int i = 0; i < nodeList.getLength(); i++) {

               // 遍历第一个节点

                Element bookElement = (Element) nodeList.item(i);

                //实例化封装实体类

                cate = new Cate();

                //设置cate标签属性

                cate.setId(bookElement.getAttribute("id"));

                //获取cate节点包括的子节点列表

                NodeList nodesList = bookElement.getChildNodes();

                //遍历子节点列表

                for (int j = 0; j < nodesList.getLength(); j++) {

                    //获得节点类型

                    int nodeEvent=nodesList.item(j).getNodeType();

                    if (nodeEvent== Node.ELEMENT_NODE) {

                        //获得节点名字

                        String nodeName = nodesList.item(j).getNodeName();

                        //获得节点内容

                        String text=nodesList.item(j).getFirstChild().getNodeValue();

                        if (nodeName.equals("cateurl")) {

                            cate.setCateurl(text);

                        } else if (nodeName.equals("catetitle")) {

                            cate.setCatetitle(text);

                        } else if (nodeName.equals("catecontent")) {

                            cate.setCatecontent(text);

                        } else if (nodeName.equals("cateprice")) {

                            cate.setCateprice(text);

                        }

                    }

                }// end for j

                list.add(cate);

            }//end for i

        } catch (Exception e) {

            e.printStackTrace();

        }

        return list;

    }