XML解析的三种方式

1.PUll解析
public static List xmlParser(InputStream is) {
List list = new ArrayList();

    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 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 domXmlParser(InputStream is) {
List list = new ArrayList();
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;
}