xml解析（读取xml，保存文件到xml）

一时失言乱红尘 2022-09-23 03:51 221阅读 0赞

在Android中，实现对XML的解析有三种方式，分别为DOM解析器，SAX解析器和PULL解析器。

*  DOM解析器

DOM是基于树形结构的节点或信息片段的集合，允许开发人员使用DOM API遍历XML树，检索所需数据。

分析该结构通常需要加载整个文档和构造树形结构，然后才可以检索和更新节点信息。

Android完全支持DOM解析。利用DOM中的对象，可以对XML文档进行读取，搜索，修改，添加和删除等操作。

DOM的工作原理：使用DOM对XML文件进行操作时，首先要解析文件，将文件分为独立的元素，属性和注释等，

然后以节点树的形式在内存中对XML文件进行表示，就可以通过节点树访问文档的内容，并根据需要修改文档。

DOM实现时首先为XML文档的解析定义一组接口，解析器读入整个文档，然后构造一个驻留内存的树结构，

这样代码就可以使用DOM接口来操作整个树结构。

由于DOM在内存中以树形结构存放，因此检索和更新效率会更高。但是对于特别大的文档，解析和加载整个文档将会

很耗资源。当然，如果XML文件的内容比较小，采用DOM是可行的。

常用的DOM接口和类：

Document: 该接口定义分析并创建DOM文档的一系列方法，它是文档树的根，是操作DOM的基础。

Element: 该接口继承Node接口，提供了获取，修改XML元素名字和属性的方法。

Node: 该接口提供处理并获取节点和子节点值的方法。

NodeList: 提供获得节点个数和当前节点的方法。这样就可以迭代地访问各节点。

DOMParser: 该类是Apache的Xerces中的DOM解析器类，可直接解析XML文件。

示例:

<?xml version="1.0" encoding="UTF-8"?>  
        <persons>  
            <person id="1">  
                <name>叶问</name>  
                <age>23</age>  
            </person>  
            <person id="2">  
                <name>李小龙</name>  
                <age>17</age>  
            </person>  
        </persons>

public class DomXMLReader {
    
    public static List<Person> readXML( InputStream inStream) {
            List<Person> persons = new ArrayList<Person>;
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            try {
                 DocumentBuilder builer = factory.newDocumentBuilder();
                 Document dom = builder.parse(inStream);
                 Element root = dom.getDocumentElement();
                 NodeList items = root.getElementsByTagName("person");
                 //查找所有person节点
                for (int i = 0; i < items.getLength(); i++) {
                          Person person = new Person();
                          //得到第一个person节点
                          Element personNode = (Element) items.item(i);
                          //获取person节点的id属性值
                          person.setId(new Integer(personNode.getAttribute("id")));
                          //获取person节点下的所有子节点（标签之间的空白节点和name/age元素）
                          NodeList childsNodes = personNode.getChildNodews();
                          for( int j =0; j < childsNodes.getLength(); j++) {
                            Node node = (Node) childsNodes.item(j);
                            //判断是否为元素类型
                            if( node.getNodeType() == Node.ELEMENT_NODE) {
                                    Element childNode = (Element) node;
                                    if( "name".equals(childNode.getNodeName())) {
                                        //获取name元素下Text节点，然后从Text节点获取数据
                                        person.setName( childNode.getFirstChild().getNodeValue());
                                    } else if ("age".equals(childNode.getNodeName())) {
                                        person.setAge( new Short(childNode.getFirstChild().getNodeValue()));
                                    }
                                 }
                             }
                         persons.add(person);
                }
                inStream.close();
             } catch (Exception e) {
                e.printStackTrace();
             }
             return persons;
    }

*  SAX解析器：

SAX解析器是一种基于事件的解析器，事件驱动的流式解析方式是，从文件的开始顺序解析到文档结束，不可暂停或倒退。

它的核心是事件处理模式，主要是围绕着事件源以及事件处理器来工作的。当事件源产生事件后，调用事件处理器相应的处理方法，

一个事件就可以得到处理。在事件源调用事件处理器中特定方法的时候，还要传递给事件处理器相应事件的状态信息，这样事件处理器

才能根据提供的事件信息来决定自己的行为。

SAX解析器的优点是解析速度快，占用内存少。非常适合在Android移动设备中使用。

SAX的工作原理： 对文档进行顺序扫描，当扫描到文档（document）开始与结束，元素（element）开始与结束，文档（document）结束等

地方时通知事件处理函数，由事件处理函数做相应动作，然后继续同样的扫描直到文档结束。

在SAX接口中，事件源是org.xml.sax包中的XMLReader,它通过parser()方法来解析XML文档，并产生事件。

事件处理器是org.xml.sax包中ContentHandler, DTDHandler, ErrorHandler,以及EntityResolver这4个接口。

XMLReader通过相应事件处理器注册方法setXXXX()来完成的与ContentHandler, DTDHandler, ErrorHandler,

以及EntivityResolver这4个接口的连接。

常用的SAX接口和类：

Attributes: 用于得到属性的个数，名字和值。

ContentHandler: 定义与文档本身关联的事件（例如，开始和结束标记）。大多数应用程序都注册这些事件。

DTDHandler: 定义与DTD关联的事件。它没有定义足够的事件来完整地报告DTD。如果需要对DTD进行语法分析，请使用可选的DeclHandler。

DeclHandler是SAX的扩展。不是所有的语法分析器都支持它。

EntityResolver：定义与装入实体关联的事件。只有少数几个应用程序注册这些事件。

ErrorHandler：定义错误事件。许多应用程序注册这些事件以便用它们自己的方式报错。

DefaultHandler：它提供了这些接LI的缺省实现。在大多数情况下，为应用程序扩展DefaultHandler并覆盖相关的方法要比直接实现一个接口更容易。

![2012-02-28_010539.jpg][]

示例：

<?xml version="1.0" encoding="UTF-8"?>
    <persons>
        <person id="23">
            <name>李明</name>
            <age>30</age>
        </person>
        <person id="20">
            <name>李向梅</name>
            <age>25</age>
        </person>
    </persons>

public class Person implements Serializable{
        private Integer id;
        private String name;
        private Short age;
    
        public Person() {
        }
    
        public Person(String name, Short age) {
            super();
            this.name = name;
            this.age = age;
        }
    
        public Integer getId() {
            return id;
        }
    
        public void setId(Integer id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Short getAge() {
            return age;
        }
    
        public void setAge(Short age) {
            this.age = age;
        }
    
    }

public class XMLContenteHandler extends DefaultHandler {
       <span style="color:#000000;">  //临时变量，解决sax读取XML时不能读取换行符号后面的内容的问题；注意temp=""不能写成temp或temp=null，避免脏数据</span>
         private String temp="";
         private String preTag;
         private Person person;
         private List<Person> persons;
    
         public void startDocument() throws SAXException {
            persons = new ArrayList<Person>();
         }
    
         public void characters(char[] ch, int start, int length) throws SAXException {
            if(person != null) {
                 String date = new String(ch, start, length);
                 if("name".equals(preTag)){
                   temp += date;
                 } else if("age".equals(preTag)){
                   temp += date;
                 }
            }
         }
    
         public void startElement(String uri, String localName, String name, Attributes attributes) throws SAXException {
             if("person".equals(localName)){
                person = new Person();
                person.setId(attributes.getIndex("id"));
             }
             preTag = localName;
          }
    
          public void endElement( String uri, String localName, String name) throws SAXException {
             if(person != null && "name".equals(localName)) {
               person.setName(temp);
               temp="";
             } else if(person != null && "age".equals(localName)){
               person.setAge(new Short(temp));
               temp="";
             } else if(person != null && "person".equals(localName)) {
               persons.add(person);
               person = null;
             }
             preTag =null;
           }
    
           public List<person> getPersons() {
              return persons;
           }
    }

public class SaxPersonService {
       // 业务层要对外抛出
       public static List<Person> readXML(InputStrean inStrean) throws Exception {
           
          SAXParserFactory spf = SAXParserFactory.newInstance();
          SAXParser saxParser = spf.newSAXParser();//创建解析器
          //设置解析器的相关特性，http://xnl.org/sax/features/namespaces = true;
          //表示开启命名空间特性
          //saxParser.setProperty("http://xnl.org/sax/features/namespaces", true);
          XMLContentHandler handler = new XMLContentHandler();
          saxParser.parse(inStream, handler);
          inStream.close();
          return handler.getPersons();
       }
    }

public class SaxPersonServiceTest extends AndroidTestCase{
        private final String TAG = "SaxPersonServiceTest";
        public void testReadXML() throws Exception{
            //ljq.xml放在src目录下
            InputStream inputStream = SaxPersonServiceTest.class.getClassLoader().getResourceAsStream("ljq.xml");
            List<Person> persons = SaxPersonService.readXML(inputStream);
            for(Person person : persons){
               Log.i(TAG, person.getId() + " : " + person.getName() + " : " + person.getAge());
            }
        }
    }

*  PULL解析器

PULL解析器的运行方式和SAX类似，都是基于事件的模式。不同的是，在PULL解析过程中返回的是数字，且我们需要自己获取产生的事件然后做相应的操作，而不像SAX那样由处理器触发一种事件的方法，执行我们的代码。

PULL解析器小巧轻便，解析速度快，简单易用，非常适合在Android移动设备中使用，Android系统内部在解析各种XML时也是用PULL解析器，Android官方推荐开发者们使用Pull解析技术。Pull解析技术是第三方开发的开源技术，它同样可以应用于JavaSE开发。

PULL 的工作原理：XML pull提供了开始元素和结束元素。当某个元素开始时，我们可以调用parser．nextText从XML文档中提取所有字符数据。当解释到一个文档结束时，自动生成EndDocument事件。

读取XML

XmlPullParser pullParser = Xml.newPullParser();

pullParser.setInput(xml, "UTF-8"); // 为破解器添加要解析的xml数据

int event = pullParser.getEventType(); //开始读取，获取事件返回值

pullParser.getName(); // 获取节点名称

pullParser.getAttributeValue(0); // 获取第一个属性的值

pullParser.nextText(); //获取标签之后的节点内容

event = pullParser.next(); // 解析器遇到结束标签不会自动向下解析,需要调用此方法进行继续执行

保存文件到XML

public static void save(List<Person> persons, OutputStream outStream)
    throws Exception, IllegalStateException, IOException {
    XmlSerializer serializer = Xml.newSerializer();//获取XML写入信息的序列化对象
    serializer.setOutput(outStream, "UTF-8");//设置要写入的OutputStream
    serializer.startDocument("UTF-8", true);//设置文档标签
    
    serializer.startTag(null, "persons");//设置开始标签，第一个参数为namespace
    for (Person person : persons) {
    serializer.startTag(null, "person");
    serializer.attribute(null, "id", person.getId().toString());
    
    serializer.startTag(null, "name");
    serializer.text(person.getName());
    serializer.endTag(null, "name");
    
    serializer.startTag(null, "age");
    serializer.text(person.getAge().toString());
    serializer.endTag(null, "age");
    
    serializer.endTag(null, "person");
    }
    serializer.endTag(null, "persons");
    serializer.endDocument();
    outStream.flush();
    outStream.close();
    }

[2012-02-28_010539.jpg]: /images/20220721/494c2119fbd64370b7792fa3af731d69.png