欢迎参加我们将于 6 月 3 日举行的 #Android11:Beta 版发布会

解析 XML 数据

可扩展标记语言 (XML) 是一组以机器可读的形式对文档进行编码的规则。XML 是一种在互联网上共享数据的常用格式。经常更新内容的网站(例如新闻网站或博客)通常会提供 XML Feed,以便外部程序及时了解内容更改。上传和解析 XML 数据是联网应用的常见任务。本节课将介绍如何解析 XML 文档并使用其数据。

要详细了解如何在 Android 应用中创建基于网络的内容,请参阅 Web 应用

选择解析器

建议使用 XmlPullParser,这是一种在 Android 上解析 XML 的高效且可维护的方式。以前,Android 有此接口的两个实现:

任一选择都可以。此部分中的示例使用 ExpatPullParser(通过 Xml.newPullParser())。

分析 Feed

解析 Feed 的第一步是确定您感兴趣的字段。解析器会提取这些字段的数据,并忽略其余字段。

以下是示例应用中正在解析的 Feed 摘录。每个发布到 StackOverflow.com 的帖子都会以包含多个嵌套标签的 entry 标签形式显示在 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 标签及其嵌套标签 titlelinksummary 的数据。

实例化解析器

下一步是实例化解析器并启动解析过程。在此代码段中,解析器被初始化为不处理命名空间,并使用提供的 InputStream 作为输入。它通过调用 nextTag() 开始解析过程,并调用 readFeed() 方法,该方法将提取并处理应用感兴趣的数据:

Kotlin

    // We don't use namespaces
    private val ns: String? = null

    class StackOverflowXmlParser {

        @Throws(XmlPullParserException::class, IOException::class)
        fun parse(inputStream: InputStream): List<*> {
            inputStream.use { inputStream ->
                val parser: XmlPullParser = Xml.newPullParser()
                parser.setFeature(XmlPullParser.FEATURE_PROCESS_NAMESPACES, false)
                parser.setInput(inputStream, null)
                parser.nextTag()
                return readFeed(parser)
            }
        }
     ...
    }
    

Java

    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,其中包含从 Feed 提取的条目(包括嵌套数据成员)。然后解析器会返回此 List

Kotlin

    @Throws(XmlPullParserException::class, IOException::class)
    private fun readFeed(parser: XmlPullParser): List<Entry> {
        val entries = mutableListOf<Entry>()

        parser.require(XmlPullParser.START_TAG, ns, "feed")
        while (parser.next() != XmlPullParser.END_TAG) {
            if (parser.eventType != XmlPullParser.START_TAG) {
                continue
            }
            // Starts by looking for the entry tag
            if (parser.name == "entry") {
                entries.add(readEntry(parser))
            } else {
                skip(parser)
            }
        }
        return entries
    }
    

Java

    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

解析 XML Feed 的步骤如下:

  1. 按照分析 Feed 中所述,确定您希望包含在应用中的标签。此示例提取了 entry 标签及其嵌套标签 titlelinksummary 的数据。
  2. 创建以下方法:

    • 您感兴趣的每个标签的“read”方法。例如 readEntry()readTitle() 等等。解析器会从输入流中读取标签。当遇到名为 entrytitlelinksummary 的标签时,它会调用该标签的相应方法。否则,它会跳过该标签。
    • 为每种不同类型的标签提取数据并将解析器推进到下一标签的方法。例如:
      • 对于 titlesummary 标签,解析器会调用 readText()。此方法通过调用 parser.getText() 提取这些标签的数据。
      • 对于 link 标签,解析器首先会确定链接是否为其感兴趣的类型,再提取该链接的数据。然后使用 parser.getAttributeValue() 提取该链接的值。
      • 对于 entry 标签,解析器会调用 readEntry()。此方法会解析条目的嵌套标签,并返回包含数据成员 titlelinksummaryEntry 对象。
    • 一种递归的辅助 skip() 方法。有关此主题的更多讨论内容,请参阅跳过您不关心的标签

以下代码段演示了解析器如何解析条目、标题、链接和摘要。

Kotlin

    data class Entry(val title: String?, val summary: String?, val link: String?)

    // 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.
    @Throws(XmlPullParserException::class, IOException::class)
    private fun readEntry(parser: XmlPullParser): Entry {
        parser.require(XmlPullParser.START_TAG, ns, "entry")
        var title: String? = null
        var summary: String? = null
        var link: String? = null
        while (parser.next() != XmlPullParser.END_TAG) {
            if (parser.eventType != XmlPullParser.START_TAG) {
                continue
            }
            when (parser.name) {
                "title" -> title = readTitle(parser)
                "summary" -> summary = readSummary(parser)
                "link" -> link = readLink(parser)
                else -> skip(parser)
            }
        }
        return Entry(title, summary, link)
    }

    // Processes title tags in the feed.
    @Throws(IOException::class, XmlPullParserException::class)
    private fun readTitle(parser: XmlPullParser): String {
        parser.require(XmlPullParser.START_TAG, ns, "title")
        val title = readText(parser)
        parser.require(XmlPullParser.END_TAG, ns, "title")
        return title
    }

    // Processes link tags in the feed.
    @Throws(IOException::class, XmlPullParserException::class)
    private fun readLink(parser: XmlPullParser): String {
        var link = ""
        parser.require(XmlPullParser.START_TAG, ns, "link")
        val tag = parser.name
        val relType = parser.getAttributeValue(null, "rel")
        if (tag == "link") {
            if (relType == "alternate") {
                link = parser.getAttributeValue(null, "href")
                parser.nextTag()
            }
        }
        parser.require(XmlPullParser.END_TAG, ns, "link")
        return link
    }

    // Processes summary tags in the feed.
    @Throws(IOException::class, XmlPullParserException::class)
    private fun readSummary(parser: XmlPullParser): String {
        parser.require(XmlPullParser.START_TAG, ns, "summary")
        val summary = readText(parser)
        parser.require(XmlPullParser.END_TAG, ns, "summary")
        return summary
    }

    // For the tags title and summary, extracts their text values.
    @Throws(IOException::class, XmlPullParserException::class)
    private fun readText(parser: XmlPullParser): String {
        var result = ""
        if (parser.next() == XmlPullParser.TEXT) {
            result = parser.text
            parser.nextTag()
        }
        return result
    }
    ...
    

Java

    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;
    }
      ...
    }
    

跳过您不关心的标签

上述 XML 解析步骤之一是解析器跳过它不感兴趣的标签。下面是解析器的 skip() 方法:

Kotlin

    @Throws(XmlPullParserException::class, IOException::class)
    private fun skip(parser: XmlPullParser) {
        if (parser.eventType != XmlPullParser.START_TAG) {
            throw IllegalStateException()
        }
        var depth = 1
        while (depth != 0) {
            when (parser.next()) {
                XmlPullParser.END_TAG -> depth--
                XmlPullParser.START_TAG -> depth++
            }
        }
    }
    

Java

    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 停止,而不是在原始 START_TAG 后遇到的第一个标签处停止,它会跟踪嵌套深度。

因此,如果当前元素具有嵌套元素,则在解析器使用了原始 START_TAG 及其匹配的 END_TAG 之间的所有事件之前,depth 的值不会为 0。例如,看看解析器如何跳过 <author> 元素,该元素有 2 个嵌套元素 <name><uri>

  • 第一次经历 while 循环时,解析器在 <author> 之后遇到的下一个标签是 <name>START_TAGdepth 的值递增到 2。
  • 第二次经历 while 循环时,解析器遇到的下一个标签是 END_TAG </name>depth 的值递减为 1。
  • 第三次经历 while 循环时,解析器遇到的下一个标签是 START_TAG <uri>depth 的值递增到 2。
  • 第四次经历 while 循环时,解析器遇到的下一个标签是 END_TAG </uri>depth 的值递减为 1。
  • 第五次,也就是最后一次经历 while 循环时,解析器遇到的下一个标签是 END_TAG </author>depth 的值递减为 0,表示已成功跳过 <author> 元素。

使用 XML 数据

示例应用在 AsyncTask 内获取并解析 XML Feed。这样会使处理过程脱离主界面线程。处理完成后,应用会更新主 Activity (NetworkActivity) 中的界面。

在下面的代码段中,loadPage() 方法会执行以下操作:

  • 使用 XML Feed 的网址初始化字符串变量。
  • 如果用户的设置和网络连接允许,则调用 new DownloadXmlTask().execute(url)。此操作将实例化新的 DownloadXmlTask 对象(AsyncTask 子类)并运行其 execute() 方法,该方法会下载和解析 Feed 并返回要在界面中显示的字符串结果。

Kotlin

    class NetworkActivity : Activity() {

        companion object {

            const val WIFI = "Wi-Fi"
            const val ANY = "Any"
            const val SO_URL = "http://stackoverflow.com/feeds/tag?tagnames=android&sort=newest"
            // Whether there is a Wi-Fi connection.
            private var wifiConnected = false
            // Whether there is a mobile connection.
            private var mobileConnected = false

            // Whether the display should be refreshed.
            var refreshDisplay = true
            // The user's current network preference setting.
            var sPref: String? = null
        }

        ...

        // Uses AsyncTask subclass to download the XML feed from stackoverflow.com.
        // Uses AsyncTask to download the XML feed from stackoverflow.com.
        fun loadPage() {

            if (sPref.equals(ANY) && (wifiConnected || mobileConnected)) {
                DownloadXmlTask().execute(SO_URL)
            } else if (sPref.equals(WIFI) && wifiConnected) {
                DownloadXmlTask().execute(SO_URL)
            } else {
                // show error
            }
        }

        ...
    }
    

Java

    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()。它以参数形式传入 Feed 网址。方法 loadXmlFromNetwork() 获取并处理 Feed。完成后,它会传回一个结果字符串。
  • onPostExecute() 接受返回的字符串,并在界面中显示该字符串。

Kotlin

    // Implementation of AsyncTask used to download XML feed from stackoverflow.com.
    private inner class DownloadXmlTask : AsyncTask<String, Void, String>() {
        override fun doInBackground(vararg urls: String): String {
            return try {
                loadXmlFromNetwork(urls[0])
            } catch (e: IOException) {
                resources.getString(R.string.connection_error)
            } catch (e: XmlPullParserException) {
                resources.getString(R.string.xml_error)
            }
        }

        override fun onPostExecute(result: String) {
            setContentView(R.layout.main)
            // Displays the HTML string in the UI via a WebView
            findViewById<WebView>(R.id.webview)?.apply {
                loadData(result, "text/html", null)
            }
        }
    }
    

Java

    // 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);
        }
    }
    

以下是从 DownloadXmlTask 调用的方法 loadXmlFromNetwork()。它会执行以下操作:

  1. 实例化 StackOverflowXmlParser。此外,它还为 List 形式的 Entry 对象(entries,包括 titleurlsummary)创建变量,以保存从 XML Feed 中提取的这些字段的值。
  2. 调用 downloadUrl(),它会获取 Feed 并将其作为 InputStream 返回。
  3. 使用 StackOverflowXmlParser 解析 InputStreamStackOverflowXmlParser 用 Feed 中的数据填充 entries List
  4. 处理 entries List,并将 Feed 数据与 HTML 标记相结合。
  5. 通过 AsyncTask 方法 onPostExecute() 返回在主 Activity 界面中显示的 HTML 字符串。

Kotlin

    // Uploads XML from stackoverflow.com, parses it, and combines it with
    // HTML markup. Returns HTML string.
    @Throws(XmlPullParserException::class, IOException::class)
    private fun loadXmlFromNetwork(urlString: String): String {
        // Checks whether the user set the preference to include summary text
        val pref: Boolean = PreferenceManager.getDefaultSharedPreferences(this)?.run {
            getBoolean("summaryPref", false)
        } ?: false

        val entries: List<Entry> = downloadUrl(urlString)?.use { stream ->
            // Instantiate the parser
            StackOverflowXmlParser().parse(stream)
        } ?: emptyList()

        return StringBuilder().apply {
            append("<h3>${resources.getString(R.string.page_title)}</h3>")
            append("<em>${resources.getString(R.string.updated)} ")
            append("${formatter.format(rightNow.time)}</em>")
            // 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.
            entries.forEach { entry ->
                append("<p><a href='")
                append(entry.link)
                append("'>" + entry.title + "</a></p>")
                // If the user set the preference to include summary text,
                // adds it to the display.
                if (pref) {
                    append(entry.summary)
                }
            }
        }.toString()
    }

    // Given a string representation of a URL, sets up a connection and gets
    // an input stream.
    @Throws(IOException::class)
    private fun downloadUrl(urlString: String): InputStream? {
        val url = URL(urlString)
        return (url.openConnection() as? HttpURLConnection)?.run {
            readTimeout = 10000
            connectTimeout = 15000
            requestMethod = "GET"
            doInput = true
            // Starts the query
            connect()
            inputStream
        }
    }
    

Java

    // 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();
        return conn.getInputStream();
    }