Android Training - 网络操作(3) - 解析XML数据

可扩展标记语言（XML）是使用机器可读形式按照一套规则编码的的文档。XML是互联网分享数据的通用格式。网站提供一个XML种子来让外部程序同步更新网站内容。上传和解析XML是网络应用程序常做的工作。下面就学习怎么解析并使用XML文件。

选择一个解析器

我们推荐XmlPullParser，它是Android上高效，并且可维护的解析XML的方法。以前Android有两个实现XmlPullParser接口的方法：

• 通过XmlPullParserFactory.newPullParser()取得KXmlParser。
• 通过Xml.newPullParser()取得ExpatPullParcer。

两个选择都很好，下面的例子使用第二种。

分析Feed

解析feed的第一步就是决定你感兴趣的字段，解析器可以挑选你需要的数据，忽略不需要的。

下面是从某个网站载录下来的部分feed文件：

<?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">Where is 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 a data file...</p>

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

我们提取entry标记中的内嵌标记title，link和summary的数据。

实例化解析器

下一步就是实例化一个解析器，然后开始解析。下面的例子中，解析器被初始化，但是不处理命名空间，并且使用提供的InputStream作为输入。解析过程从调用nextTag()开始，然后调用readFeed()方法：

public class StackOverflowXmlParser {
    // 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();
        }
    }
 ... 
}

读取Feed

readFeed()方法执行实际的处理feed的工作。它查找entry元素作为起点，然后递归地处理feed。如果不的entry标记，就跳过。整个feed被递归处理完后，readFeed()返回一个list，包含了整个提取后的数据：

private List readFeed(XmlPullParser parser) throws XmlPullParserException, 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 by looking for the entry tag
        if (name.equals("entry")) {
            entries.add(readEntry(parser));
        } else {
            skip(parser);
        }
    }  
    return entries;
}

解析XML

下面是解析的步骤：

1. 确定你要提取数据的标记和内嵌标记，例子中是entry，内嵌标记是title，link和summary。
2. 创建下面的方法：
   a. 为每个tag创建一个读取方法。例如，readEntry()，readTitle()等。当解析器在输入流中读取到对应的tag时，调用对应的方法，否则跳过这个tag。
   b. 这些方法读取不同的数据类型的tag，然后推进解析器到下一个tag，例如：
       b1.  对于title和summary标记，解析器使用readText()，这个方法使用parser.getText()方法提取数据内容。
       b2. 对应link标记，要取的是link里面的一个属性值，所以使用parser.getAttributeValue()。
       b3. 对应entry标记，解析器调用readEntry()，这个方法解析entry的内嵌标记，然后返回一个Entry对象。
   c. 帮助方法skip()是递归的。

下面是实例代码：

public static class Entry {
    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;
}
  ...
}

跳过你不关心的Tag

下面是skip()方法的实例：

private void skip(XmlPullParser parser) throws XmlPullParserException, IOException {
    if (parser.getEventType() != XmlPullParser.START_TAG) {
        throw new IllegalStateException();
    }
    int depth = 1;
    while (depth != 0) {
        switch (parser.next()) {
        case XmlPullParser.END_TAG:
            depth--;
            break;
        case XmlPullParser.START_TAG:
            depth++;
            break;
        }
    }
 }

它是怎么工作的呢：

• 如果当前事件不是一个START_TAG就抛出一个异常。
• 有START_TAG就一定有对应的END_TAG。
• 确保在正确的END_TAG停止，使用depth来跟踪嵌套深度。

如果当前元素含有内嵌元素，depth的值会到匹配的END_TAG才会为0，例如，考虑一下解析器是怎么跳过<author>元素的，它有两个元素，<name>和<uri>。

• 第一次while循环时，<author>的下一个START_TAG是<name>，那么depth会增加到2.
• 第二次循环，解析器遇见的tag就是END_TAG</name>，那么depth变成1.
• 第三次循环，解析器遇到START_TAG<uri>，值又增加到2.
• 第四次循环，解析器遇到END_TAG</uri>，值又变成1.
• 在第五次循环时，遇到了END_TAG</author>。值就减少到0，那么<author>元素被成功跳过。

使用XML数据

下面的实例使用AsyncTask获取并解析XML feed。它脱离主线程执行，当处理完成后更新UI。

下面代码中loadPage()做下面的工作：

• 初始化一个URL字符串变量。
• 如果网络允许，调用DownloadXmlTask().execute(url)实例化一个DownloadXmlTask对象，并运行execute()方法，下载并解析feed，返回一个字符串结果，然后显示到UI。

public class NetworkActivity extends Activity {
    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 a Wi-Fi connection.
    private static boolean wifiConnected = false; 
    // Whether there is a mobile connection.
    private static boolean mobileConnected = false;
    // Whether the display should be refreshed.
    public static boolean refreshDisplay = true; 
    public static String sPref = null;

    ...
      
    // Uses AsyncTask to download 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的实现：

• doInBackground()执行loadXmlFromNetWork()，传递URL参数获取feed和处理feed，完成时返回一个字符串。
• onPostExecute()使用返回的字符串返回到UI。

// Implementation of AsyncTask used to download XML feed from 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 (XmlPullParserException e) {
            return getResources().getString(R.string.xml_error);
        }
    }

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

在loadXmlFromNetwork()方法中的DownloadXmlTask做下面的事情：

1. 初始化StackOverflowXmlParser。创建Entry对象，和title，url，和summary来获取XML中的值。
2. 调用downloadUrl()获取InputStream。
3. 解析InputStream，填充entry的list。
4. 使用HTML合并entry数据。
5. 返回一个HTML代码的字符串，并且展示到界面。

// Uploads XML from stackoverflow.com, parses it, and combines 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 user set 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 the InputStream is closed after the app is
    // finished using it.
    } finally {
        if (stream != null) {
            stream.close();
        } 
     }
    
    // StackOverflowXmlParser returns a List (called "entries") of Entry objects.
    // Each Entry object represents a single post in the XML feed.
    // This section processes the entries list to combine each entry with HTML markup.
    // Each entry is displayed in the UI as a link that optionally includes
    // a text summary.
    for (Entry entry : entries) {       
        htmlString.append("<p><a href='");
        htmlString.append(entry.link);
        htmlString.append("'>" + entry.title + "</a></p>");
        // If the user set the preference to include summary text,
        // adds it to the display.
        if (pref) {
            htmlString.append(entry.summary);
        }
    }
    return htmlString.toString();
}

// Given a string representation of a URL, sets up a connection and 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();
    InputStream stream = conn.getInputStream();      
}