Analizza dati XML

Extensible Markup Language (XML) è un insieme di regole per la codifica di documenti in un formato leggibile da macchina. XML è un formato molto diffuso per la condivisione di dati su internet.

I siti web che aggiornano spesso i loro contenuti, come i siti di notizie o i blog, spesso forniscono un feed XML in modo che i programmi esterni possano rimanere aggiornati sulle modifiche ai contenuti. Il caricamento e l'analisi dei dati XML sono un'attività comune per le app connesse alla rete. Questo argomento spiega come analizzare i documenti XML e utilizzare i relativi dati.

Per scoprire di più sulla creazione di contenuti basati sul web nella tua app per Android, consulta Contenuti basati sul web.

Scegli un parser

Ti consigliamo di utilizzare XmlPullParser, che è un modo efficiente e gestibile per analizzare l'XML su Android. Android ha due implementazioni di questa interfaccia:

Entrambe le scelte sono corrette. L'esempio in questa sezione utilizza ExpatPullParser e Xml.newPullParser().

Analizza il feed

Il primo passaggio per analizzare un feed consiste nel decidere quali campi ti interessano. Il parser estrae i dati per questi campi e ignora il resto.

Di seguito è riportato un estratto di un feed analizzato nell'app di esempio. Ogni post su StackOverflow.com viene visualizzato nel feed come tag entry che contiene diversi tag nidificati:

<?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>

L'app di esempio estrae i dati per il tag entry e i relativi tag nidificati title, link e summary.

Crea un'istanza del parser

Il passaggio successivo nell'analisi di un feed consiste nell'istanziare un parser e avviare il processo di analisi. Questo snippet inizializza un parser per non elaborare gli spazi dei nomi e per utilizzare l'elemento InputStream fornito come input. Avvia il processo di analisi con una chiamata a nextTag() e richiama il metodo readFeed(), che estrae ed elabora i dati di interesse dell'app:

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

Leggi il feed

Il metodo readFeed() esegue il lavoro effettivo di elaborazione del feed. Cerca gli elementi con tag "entry" come punto di partenza per l'elaborazione ricorsiva del feed. Se un tag non è un tag entry, viene ignorato. Una volta elaborato in modo ricorsivo l'intero feed, readFeed() restituisce un List contenente le voci (inclusi i membri dei dati nidificati) estratte dal feed. Questo List viene poi restituito dal parser.

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

Analizza XML

I passaggi per analizzare un feed XML sono i seguenti:

  1. Come descritto in Analizza il feed, identifica i tag che vuoi includere nella tua app. Questo esempio estrae i dati per il tag entry e i relativi tag nidificati: title, link e summary.
  2. Crea i seguenti metodi:
    • Un metodo "read" per ogni tag che vuoi includere, ad esempio readEntry() e readTitle(). Il parser legge i tag dallo stream di input. Quando incontra un tag denominato, in questo esempio, entry, title, link o summary, chiama il metodo appropriato per quel tag. In caso contrario, il tag viene ignorato.
    • Metodi per estrarre i dati per ogni diverso tipo di tag e per far avanzare il parser al tag successivo. In questo esempio, i metodi pertinenti sono i seguenti:
      • Per i tag title e summary, l'analizzatore chiama readText(). Questo metodo estrae i dati per questi tag chiamando parser.getText().
      • Per il tag link, l'analizzatore sintattico estrae i dati per i link determinando innanzitutto se il link è del tipo che interessa. Poi utilizza parser.getAttributeValue() per estrarre il valore del link.
      • Per il tag entry, il parser chiama readEntry(). Questo metodo analizza i Nest Tag nidificati della voce e restituisce un oggetto Entry con i membri dati title, link e summary.
    • Un metodo helper skip() ricorsivo. Per ulteriori informazioni su questo argomento, consulta Salta i tag che non ti interessano.

Questo snippet mostra come l'analizzatore analizza voci, titoli, link e riepiloghi.

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

Salta i tag che non ti interessano

Il parser deve saltare i tag che non gli interessano. Ecco il metodo skip() del parser:

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

Ecco come funziona:

  • Genera un'eccezione se l'evento corrente non è un START_TAG.
  • Consuma START_TAG e tutti gli eventi fino a END_TAG corrispondente incluso.
  • Tiene traccia della profondità di nidificazione per assicurarsi che si fermi al tag END_TAG corretto e non al primo tag che incontra dopo il tag START_TAG originale.

Pertanto, se l'elemento corrente ha elementi nidificati, il valore di depth non sarà 0 finché l'analizzatore non avrà utilizzato tutti gli eventi tra l'elemento START_TAG originale e l'elemento END_TAG corrispondente. Ad esempio, considera come il parser salta l'elemento <author>, che ha due elementi nidificati, <name> e <uri>:

  • La prima volta che viene eseguito il loop while, il tag successivo che l'analizzatore incontra dopo <author> è START_TAG per <name>. Il valore di depth aumenta a 2.
  • La seconda volta che viene eseguito il loop while, il tag successivo che il parser incontra è END_TAG </name>. Il valore di depth viene ridotto a 1.
  • La terza volta che viene eseguito il loop while, il tag successivo che l'analizzatore incontra è START_TAG <uri>. Il valore di depth aumenta a 2.
  • La quarta volta che viene eseguito il loop while, il tag successivo che il parser incontra è END_TAG </uri>. Il valore di depth viene ridotto a 1.
  • La quinta e ultima volta che viene eseguito il loop while, il tag successivo che il parser incontra è END_TAG </author>. Il valore di depth diminuisce fino a 0, a indicare che l'elemento <author> è stato saltato correttamente.

Utilizza i dati XML

L'applicazione di esempio recupera e analizza il feed XML in modo asincrono. In questo modo, l'elaborazione viene spostata fuori dal thread principale dell'interfaccia utente. Al termine dell'elaborazione, l'app aggiorna la UI nella sua attività principale, NetworkActivity.

Nel seguente estratto, il metodo loadPage() esegue queste operazioni:

  • Inizializza una variabile di stringa con l'URL del feed XML.
  • Richiama il metodo downloadXml(url), se le impostazioni dell'utente e la connessione di rete lo consentono. Questo metodo scarica e analizza il feed e restituisce un risultato di stringa da visualizzare nell'UI.

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
    }
    ...
    // Asynchronously downloads the XML feed from stackoverflow.com.
    fun loadPage() {

        if (sPref.equals(ANY) && (wifiConnected || mobileConnected)) {
            downloadXml(SO_URL)
        } else if (sPref.equals(WIFI) && wifiConnected) {
            downloadXml(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;
    ...
    // Asynchronously downloads the XML feed from stackoverflow.com.
    public void loadPage() {

        if((sPref.equals(ANY)) && (wifiConnected || mobileConnected)) {
            downloadXml(URL);
        }
        else if ((sPref.equals(WIFI)) && (wifiConnected)) {
            downloadXml(URL);
        } else {
            // Show error.
        }
    }

Il metodo downloadXml chiama i seguenti metodi in Kotlin:

  • lifecycleScope.launch(Dispatchers.IO), che utilizza le coroutine di Kotlin per avviare il metodo loadXmlFromNetwork() sul thread di I/O. Passa l'URL del feed come parametro. Il metodo loadXmlFromNetwork() recupera ed elabora il feed. Al termine, restituisce una stringa di risultato.
  • withContext(Dispatchers.Main), che utilizza le coroutine Kotlin per tornare al thread principale, prende la stringa restituita e la visualizza nella UI.

Nel linguaggio di programmazione Java, la procedura è la seguente:

  • Un Executor esegue il metodo loadXmlFromNetwork() su un thread in background. Passa l'URL del feed come parametro. Il metodo loadXmlFromNetwork() recupera ed elabora il feed. Al termine, restituisce una stringa di risultato.
  • Un Handler chiama post per tornare al thread principale, prende la stringa restituita e la visualizza nell'UI.

Kotlin

// Implementation of Kotlin coroutines used to download XML feed from stackoverflow.com.
private fun downloadXml(vararg urls: String) {
    var result: String? = null
    lifecycleScope.launch(Dispatchers.IO) {
        result = try {
            loadXmlFromNetwork(urls[0])
        } catch (e: IOException) {
            resources.getString(R.string.connection_error)
        } catch (e: XmlPullParserException) {
            resources.getString(R.string.xml_error)
        }
        withContext(Dispatchers.Main) {
            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 Executor and Handler used to download XML feed asynchronously from stackoverflow.com.
private void downloadXml(String... urls) {
    ExecutorService executor = Executors.newSingleThreadExecutor();
    Handler handler = new Handler(Looper.getMainLooper());
    executor.execute(() -> {
        String result;
            try {
                result = loadXmlFromNetwork(urls[0]);
            } catch (IOException e) {
                result = getResources().getString(R.string.connection_error);
            } catch (XmlPullParserException e) {
                result = getResources().getString(R.string.xml_error);
            }
        String finalResult = result;
        handler.post(() -> {
            setContentView(R.layout.main);
            // Displays the HTML string in the UI via a WebView.
            WebView myWebView = (WebView) findViewById(R.id.webview);
            myWebView.loadData(finalResult, "text/html", null);
        });
    });
}

Il metodo loadXmlFromNetwork() richiamato da downloadXml è mostrato nello snippet successivo. Esegue le seguenti operazioni:

  1. Crea un'istanza di StackOverflowXmlParser. Crea anche variabili per un List di oggetti Entry (entries) e per title, url e summary, per contenere i valori estratti dal feed XML per questi campi.
  2. Chiama downloadUrl(), che recupera il feed e lo restituisce come InputStream.
  3. Utilizza StackOverflowXmlParser per analizzare InputStream. StackOverflowXmlParser compila un List di entries con i dati del feed.
  4. Elabora entries List e combina i dati del feed con il markup HTML.
  5. Restituisce una stringa HTML visualizzata nell'interfaccia utente dell'attività principale.

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