Android---解析XML数据

本文译自：http://developer.android.com/training/basics/network-ops/xml.html

本文示例代码：http://download.csdn.net/detail/fireofstar/6547643

可扩展的标记语言（XML）是一组在计算机中可读的文档编码格式。XML是一种流行的用于互联网共享数据的格式。内容更新频繁的网站，如新闻网站或博客等，会经常提供XML资料，以便外部程序能够持续跟踪内容的变化。上传和解析XML数据是网络相关应用程序的普通任务，本文介绍如何解析XML文档，并使用它的数据。

选择解析器

我们推荐使用XmlPullParser，它是Android中一种高效且可维护的解析XML的方法。Android的历史上，这个接口有两个实现：

1. 由XmlPullParserFactory.newPullParser()方法提供的XmlPullParser；

2. 由Xml.newPullParser()方法提供的XmlPullParser；

这两个实现都是很好的选择。本例使用由Xml.newPullParser()提供的XmlPullParser。

分析XML数据

解析XML数据的第一步是判断你所感兴趣的字段。解析器会提取这些字段的数据，并忽略其他字段。

以下XML摘要来自示例程序所解析的XML资料。每次发送给StackOverflow.com的XML数据的entry标签中都要包含几个嵌套标签：

<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom" xmlns:creativeCommons="http://backend.userland.com/creativeCommonsRssModule" ...">   
<title type="text">newest questions tagged android - Stack Overflow</title>
...
    <entry>
    ...
    </entry>
    <entry>
        <id>http://stackoverflow.com/q/9439999</id>
        <re:rank scheme="http://stackoverflow.com">0</re:rank>
        <title type="text">Whereis my data file?</title>
        <category scheme="http://stackoverflow.com/feeds/tag?tagnames=android&sort=newest/tags" term="android"/>
        <category scheme="http://stackoverflow.com/feeds/tag?tagnames=android&sort=newest/tags" term="file"/>
        <author>
            <name>cliff2310</name>
            <uri>http://stackoverflow.com/users/1128925</uri>
        </author>
        <link rel="alternate" href="http://stackoverflow.com/questions/9439999/where-is-my-data-file" />
        <published>2012-02-25T00:30:54Z</published>
        <updated>2012-02-25T00:30:54Z</updated>
        <summary type="html">
            <p>I have an Application that requires adata file...</p>

        </summary>
    </entry>
    <entry>
    ...
    </entry>
...
</feed>

这个示例程序提取嵌套在entry标签中的title、link和summary标签。

实例化解析器

第二步是实例化解析器，并启动解析过程。在以下代码中，示例化一个不处理命名空间的解析器，并被他提供一个InputStream作为输入。调用nextTag()方法来启动解析处理，并调用示例中的readFeed()方法来提取并处理应用程序所感兴趣的数据：

publicclassStackOverflowXmlParser{
    // We don't use namespaces
    private static final String ns = null;
   
    public List parse(InputStream in) throws XmlPullParserException, IOException {
        try {
            XmlPullParser parser = Xml.newPullParser();
            parser.setFeature(XmlPullParser.FEATURE_PROCESS_NAMESPACES, false);
            parser.setInput(in, null);
            parser.nextTag();
            return readFeed(parser);
        } finally {
            in.close();
        }
    }
 ...
}

读取数据

ReadFeed()方法完成实际的数据处理工作。它会使用递归方法来查找“entry”标签的起始点。如果不是entry标签，就跳过它。一旦递归处理完整个XML数据，readFeed()方法就会返回一个包含entry实体（包括它所嵌套的数据）的列表，然后再通过解析器把这个列表返回。

privateList readFeed(XmlPullParser parser)throwsXmlPullParserException,IOException{
    List entries = new ArrayList();

    parser.require(XmlPullParser.START_TAG, ns, "feed");
    while (parser.next() != XmlPullParser.END_TAG) {
        if (parser.getEventType() != XmlPullParser.START_TAG) {
            continue;
        }
        String name = parser.getName();
        // Starts bylooking for the entry tag
        if (name.equals("entry")) {
            entries.add(readEntry(parser));
        } else {
            skip(parser);
        }
    } 
    return entries;
}

解析XML

以下是解析XML数据的步骤：

1. 在上文“分析数据”一节的描述中，标识处理了你的应用程序中想要的的标签。本例提取了entry标签，以及嵌套在这个标签中的title、link和summary标签。

2. 创建下列方法：

给每个你感兴趣的标签创建一个“read”方法。如readEntry()、readTitle()等。这个解析器从输入流中读取这些标签。当解析器遇到名叫entry、title、link或summary标签时，就会调用相应的方法，否则跳过这个标签。

这些方法会提取每种不同类型标签的数据，并把解析器移向下一个标签。例如：

对于title和summary标签，解析器会调用readText()方法。这个方法通过调用parser.getText()方法来提取这些标签中的数据。

对于link标签，解析器会首先判断该链接是否是它所感兴趣的链接，然后再使用parser.getAttributeValue()方法来提取链接的值。

对于entry标签，解析器会调用readEntry()方法。这个方法会解析entry的嵌套标签，并返回一个带有title、link、summary成员的Entry对象。

一个辅助器---用户递归的skip()方法。

以下代码显示了如何解析entry、title、link和summary的解析器：

publicstaticclassEntry{
    public final String title;
    public final String link;
    public final String summary;

    private Entry(String title, String summary, String link) {
        this.title = title;
        this.summary = summary;
        this.link = link;
    }
}
 
// Parses the contents of an entry. If it encounters a title,summary, or link tag, hands them off
// to their respective "read" methods for processing.Otherwise, skips the tag.
private Entry readEntry(XmlPullParser parser) throws XmlPullParserException, IOException {
    parser.require(XmlPullParser.START_TAG, ns, "entry");
    String title = null;
    String summary = null;
    String link = null;
    while (parser.next() != XmlPullParser.END_TAG) {
        if (parser.getEventType() != XmlPullParser.START_TAG) {
            continue;
        }
        String name = parser.getName();
        if (name.equals("title")) {
            title = readTitle(parser);
        } else if (name.equals("summary")) {
            summary = readSummary(parser);
        } else if (name.equals("link")) {
            link = readLink(parser);
        } else {
            skip(parser);
        }
    }
    return new Entry(title, summary, link);
}

// Processes title tags in the feed.
private String readTitle(XmlPullParser parser) throws IOException, XmlPullParserException {
    parser.require(XmlPullParser.START_TAG, ns, "title");
    String title = readText(parser);
    parser.require(XmlPullParser.END_TAG, ns, "title");
    return title;
}
 
// Processes link tags in the feed.
private String readLink(XmlPullParser parser) throws IOException, XmlPullParserException {
    String link = "";
    parser.require(XmlPullParser.START_TAG, ns, "link");
    String tag = parser.getName();
    String relType = parser.getAttributeValue(null, "rel"); 
    if (tag.equals("link")) {
        if (relType.equals("alternate")){
            link = parser.getAttributeValue(null, "href");
            parser.nextTag();
        }
    }
    parser.require(XmlPullParser.END_TAG, ns, "link");
    return link;
}

// Processes summary tags in the feed.
private String readSummary(XmlPullParser parser) throws IOException, XmlPullParserException {
    parser.require(XmlPullParser.START_TAG, ns, "summary");
    String summary = readText(parser);
    parser.require(XmlPullParser.END_TAG, ns, "summary");
    return summary;
}

// For the tags title and summary, extracts their text values.
private String readText(XmlPullParser parser) throws IOException, XmlPullParserException {
    String result = "";
    if (parser.next() == XmlPullParser.TEXT) {
        result = parser.getText();
        parser.nextTag();
    }
    return result;
}
  ...
}

跳过你不关心的标签

上述介绍的XML解析步骤之一是跳过你不感兴趣的的标签，以下是解析器的skip()方法：

privatevoid skip(XmlPullParser parser)throwsXmlPullParserException,IOException{
    if (parser.getEventType() != XmlPullParser.START_TAG) {
        throw new IllegalStateException();
    }
    intdepth = 1;
    while (depth != 0) {
        switch (parser.next()) {
        case XmlPullParser.END_TAG:
            depth--;
            break;
        case XmlPullParser.START_TAG:
            depth++;
            break;
        }
    }
 }

以下是它工作的方法：

1. 如果当前事件不是START_TAG，它会抛出一个异常；

2. 它处理START_TAG以及与之匹配的END_TAG之中的所有事件；

3. 确保在正确的END_TAG标签时停止，而不是遇到一个初始的START_TAG标签之后就停止，同时它会保持嵌套深度的轨迹。

如果当前元素有嵌套元素，depth的值直到处理完START_TAG和与之匹配的END_TAG之间的所有事件才等于0。例如，以下是跳过<author>元素，解析它所嵌套的两个元素:<name>和<uri>的方法：

1. 第一次通过while循环时，解析器会遇到<author>之后的<name>标签的START_TAG，这时depth的值被增加到2.

2. 第二次通过while循环时，解析器会遇到END_TAG标签</name>,这时depth的值会被减1。

3. 第三次通过while循环时，解析器会遇到<uri>的的START_TAG，这时depth值会被增加到2。

4. 第四次通过while循环时，解析器会遇到END_TAG标签</uri>，这时depth的值会被减1。

5. 第五次且最后一次通过while循环时，解析器会遇到END_TAG的</author>标签。这时depth的值会被减到0，这说明<author>元素已经被成功跳过了。

处理XML数据

示例应用程序在一个AsyncTask中获取和解析XML数据。这样处理会离开UI主线程。当处理结束时，应用程序会更新主Activity（NetworkActivity）中的UI。

在以下代码摘要中，loadPage()方法会做以下事情：

1. 给XML数据初始化一个带有URL的字符串变量；

2. 如果用户的设置和网络连接允许，它会调用new DownloadXmlTask().execute(url)方法。这个方法会示例化一个新的的DownloadXmlTask对象（AsyncTask的子类），并运行它的execute()方法，这个方法会下载并解析数据，然后返回一个在UI中显示的字符串结果。

publicclassNetworkActivityextendsActivity{
    public static final String WIFI = "Wi-Fi";
    public static final String ANY = "Any";
    private static final String URL = "http://stackoverflow.com/feeds/tag?tagnames=android&sort=newest";
   
    // Whether there is aWi-Fi connection.
    private static boolean wifiConnected = false;
    // Whether there is amobile connection.
    private static boolean mobileConnected = false;
    // Whether the displayshould be refreshed.
    public static boolean refreshDisplay = true;
    public static String sPref = null;

    ...
     
    // Uses AsyncTask todownload the XML feed from stackoverflow.com.
    public void loadPage() {  
     
        if((sPref.equals(ANY)) && (wifiConnected || mobileConnected)) {
            new DownloadXmlTask().execute(URL);
        }
        else if ((sPref.equals(WIFI)) && (wifiConnected)) {
            new DownloadXmlTask().execute(URL);
        } else {
            // show error
        }  
    }

下面是AsyncTask的子类---DownloadXmlTask类，它实现了以下AsyncTask的方法：

1. doInBackground()会执行loadXmlFromNetwork()方法，它把数据的URL做为参数来传递。loadXmlFromNetwork()方法来获取和处理数据。当它处理完，会返回一个结果字符串。

2. onPostExecute()方法会返回字符串，并在UI中显示。

// Implementation of AsyncTask used to download XML feedfrom stackoverflow.com.
private class DownloadXmlTask extends AsyncTask<String, Void, String> {
    @Override
    protected String doInBackground(String... urls) {
        try {
            return loadXmlFromNetwork(urls[0]);
        } catch (IOException e) {
            return getResources().getString(R.string.connection_error);
        } catch (XmlPullParserExceptione) {
            return getResources().getString(R.string.xml_error);
        }
    }

    @Override
    protected void onPostExecute(String result) {  
        setContentView(R.layout.main);
        // Displaysthe HTML string in the UI via a WebView
        WebView myWebView = (WebView) findViewById(R.id.webview);
        myWebView.loadData(result, "text/html", null);
    }
}

以下是DownloadXmlTask中调用的loadXmlFromNetwork()方法，它完成以下工作：

1. 示例化一个StackOverflowXmlParser对象，还要给它创建List<Entry>、title、url、summary变量，用这些变量来保存从XML数据的相应字段中提取的值。

2. 调用downloadUrl()方法，它会获取数据并返回一个InputStream对象；

3. 使用StackOverflowXmlParser对象来解析InputStream。StackOverflowXmlParser会从数据中获取entry元素的数据，并相应的数据填充到List<Entry>变量中；

4. 助理List<Entry>变量中的数据，并把这些数据跟HTML标签组合；

5. 通过AsyncTask的onPostExecute()方法把组合后的HTML字符串返回给要显示它的Activity。

// Uploads XML from stackoverflow.com, parses it, andcombines it with
// HTML markup. Returns HTML string.
private String loadXmlFromNetwork(String urlString) throws XmlPullParserException, IOException {
    InputStream stream = null;
    // Instantiate the parser
    StackOverflowXmlParser stackOverflowXmlParser = new StackOverflowXmlParser();
    List<Entry> entries = null;
    String title = null;
    String url = null;
    String summary = null;
    Calendar rightNow = Calendar.getInstance();
    DateFormat formatter = new SimpleDateFormat("MMM dd h:mmaa");
       
    // Checks whether the userset the preference to include summary text
    SharedPreferences sharedPrefs = PreferenceManager.getDefaultSharedPreferences(this);
    boolean pref = sharedPrefs.getBoolean("summaryPref", false);
       
    StringBuilder htmlString = new StringBuilder();
    htmlString.append("<h3>" + getResources().getString(R.string.page_title) + "</h3>");
    htmlString.append("<em>" + getResources().getString(R.string.updated) + " " +
            formatter.format(rightNow.getTime()) + "</em>");
       
    try{
        stream = downloadUrl(urlString);        
        entries = stackOverflowXmlParser.parse(stream);
    // Makes sure that theInputStream is closed after the app is
    // finished using it.
    } finally {
        if (stream != null) {
            stream.close();
        }
     }
   
    // StackOverflowXmlParserreturns a List (called "entries") of Entry objects.
    // Each Entry objectrepresents a single post in the XML feed.
    // This section processesthe entries list to combine each entry with HTML markup.
    // Each entry is displayedin the UI as a link that optionally includes
    // a text summary.
    for(Entryentry : entries) {      
        htmlString.append("<p><ahref='");
        htmlString.append(entry.link);
        htmlString.append("'>" + entry.title + "</a></p>");
        // If theuser set the preference to include summary text,
        // adds itto the display.
        if (pref) {
            htmlString.append(entry.summary);
        }
    }
    return htmlString.toString();
}

// Given a string representation of a URL, sets up a connectionand gets
// an input stream.
private InputStream downloadUrl(String urlString) throws IOException {
    URL url = new URL(urlString);
    HttpURLConnection conn = (HttpURLConnection) url.openConnection();
    conn.setReadTimeout(10000 /* milliseconds */);
    conn.setConnectTimeout(15000 /* milliseconds */);
    conn.setRequestMethod("GET");
    conn.setDoInput(true);
    // Starts the query
    conn.connect();
    return conn.getInputStream();
}