XML ontleden. Items overslaan die je niet nodig hebt

Zo kun je, in delen zoals je wilt, een groot bestand naar de handler sturen.

Laten we nu eens kijken hoe deze gegevens worden verwerkt en hoe u deze kunt verkrijgen.

Laten we beginnen met de functie voor het openen van tags startElement ($ parser, $ naam, $ attrs)
Stel dat de verwerking de lijn heeft bereikt
< ingredient amount = "3" unit = "стакан" >Meel
Dan is binnen de functie de variabele $ naam gelijk aan ingrediënt dat wil zeggen, de naam van de open tag (het is nog niet zover dat de tag wordt gesloten).
In dit geval is er ook een reeks attributen van deze $ attrs-tag beschikbaar, waarin gegevens hoeveelheid = "3" en eenheid = "glas".

Daarna de verwerking van de gegevens van de open tag met de functie gegevens ($ parser, $ gegevens)
De $ datavariabele bevat alles tussen de openings- en sluitingstags, in ons geval is dit de tekst Meel

En de verwerking van onze string wordt voltooid door de functie endElement ($ parser, $ naam)
Dit is de naam van de gesloten tag, in ons geval is $ name gelijk aan ingrediënt

En daarna ging alles weer in een cirkel.

Het bovenstaande voorbeeld demonstreert alleen het principe van XML-verwerking, maar voor echt gebruik moet het worden verbeterd.
Meestal moet u grote XML ontleden om gegevens in de database in te voeren, en voor een correcte gegevensverwerking moet u weten tot welke open tag de gegevens behoren, tot welk tag-nestingsniveau en welke tags in de hogere hiërarchie open staan. Met deze informatie kunt u het bestand probleemloos verwerken.
Om dit te doen, moet u verschillende globale variabelen invoeren die informatie verzamelen over open tags, nesten en gegevens.
Hier is een voorbeeld dat u kunt gebruiken

Functie webi_xml ($ bestand)
{
globaal $ web_depth; // teller om de nestdiepte bij te houden
$ webi_depth = 0;
globaal $ webi_tag_open; // bevat een array van momenteel geopende tags
$ webi_tag_open = array ();
globaal $ webi_data_temp; // deze array zal de gegevens van één tag bevatten

####################################################
### functie voor het werken met data
functiegegevens ($ parser, $ gegevens)
{
globaal $ web_depth;
globaal $ webi_tag_open;
globaal $ webi_data_temp;
// voeg gegevens toe aan de array die de geneste en momenteel geopende tag aangeeft
$ webi_data_temp [$ webi_depth] [$ webi_tag_open [$ webi_depth]] ["data"]. = $ data;
}
############################################

####################################################
### functie voor het openen van tags
functie startElement ($ parser, $ naam, $ attrs)
{
globaal $ web_depth;
globaal $ webi_tag_open;
globaal $ webi_data_temp;

// als het nestingniveau niet langer nul is, is er al één tag open
// en de gegevens ervan staan ​​al in de array, je kunt het verwerken
als ($ webi_depth)
{

" ;

afdrukken "
" ;
print_r ($ webi_tag_open); // reeks open tags
afdrukken "

// verwijder na het verwerken van de gegevens om geheugen vrij te maken
uitgeschakeld ($ GLOBALS ["webi_data_temp"] [$ webi_depth]);
}

// nu is het openen van de volgende tag begonnen en vindt verdere verwerking plaats bij de volgende stap
$ webi_depth ++; // nesting vergroten

$ webi_tag_open [$ webi_depth] = $ naam; // voeg de open tag toe aan de informatie-array
$ webi_data_temp [$ webi_depth] [$ naam] ["attrs"] = $ attrs; // voeg nu de tag-attributen toe

}
###############################################

#################################################
## eindtag-functie
functie endElement ($ parser, $ naam) (
globaal $ web_depth;
globaal $ webi_tag_open;
globaal $ webi_data_temp;

// dit is waar de gegevensverwerking begint, bijvoorbeeld toevoegen aan de database, opslaan in een bestand, enz.
// $ webi_tag_open bevat een reeks open tags op nestniveau
// bijvoorbeeld $ webi_tag_open [$ webi_depth] bevat de naam van de open tag waarvan de informatie momenteel wordt verwerkt
// $ webi_depth tag nesting niveau
// $ webi_data_temp [$ webi_depth] [$ webi_tag_open [$ webi_depth]] ["attrs"] reeks tagkenmerken
// $ webi_data_temp [$ webi_depth] [$ webi_tag_open [$ webi_depth]] ["data"] taggegevens

Druk "gegevens" af. $ webi_tag_open [$ webi_depth]. "-". ($ webi_data_temp [$ webi_depth] [$ webi_tag_open [$ webi_depth]] ["data"]). "
" ;
print_r ($ webi_data_temp [$ webi_depth] [$ webi_tag_open [$ webi_depth]] ["attrs"]);
afdrukken "
" ;
print_r ($ webi_tag_open);
afdrukken "

Uitgeschakeld ($ GLOBALS ["webi_data_temp"]); // verwijder na het verwerken van de gegevens de hele array met gegevens, aangezien de tag was gesloten
uitgeschakeld ($ GLOBALS ["webi_tag_open"] [$ webi_depth]); // verwijder informatie over deze open tag ... aangezien deze is gesloten

$ webi_diepte -; // verminder nesten
}
############################################

$ xml_parser = xml_parser_create ();
xml_parser_set_option ($ xml_parser, XML_OPTION_CASE_FOLDING, waar);

// specificeer welke functies werken bij het openen en sluiten van tags
xml_set_element_handler ($ xml_parser, "startElement", "endElement");

// specificeer een functie voor het werken met data
xml_set_character_data_handler($ xml_parser, "gegevens");

// open het bestand
$ fp = fopen ($ bestand, "r");

$ perviy_vxod = 1; // vlag om de eerste bestandsinvoer te controleren
$ gegevens = ""; // hier verzamelen we gegevens uit het bestand in delen en sturen het naar de xml-parser

// loop totdat het einde van het bestand is gevonden
terwijl (! feof ($ fp) en $ fp)
{
$ simvol = fgetc ($ fp); // lees één teken uit bestand
$ gegevens = $ simvol; // voeg dit symbool toe aan de te verzenden gegevens

// als het teken geen eindtag is, gaan we terug naar het begin van de lus en voegen we een ander teken toe aan de gegevens, enzovoort totdat de eindtag is gevonden
if ($ simvol! = ">") (vervolg;)
// als er een afsluitende tag is gevonden, stuur deze verzamelde gegevens nu voor verwerking

// controleer of dit het eerste item in het bestand is, verwijder dan alles wat voor de tag staat// aangezien soms rommel kan worden gevonden voor het begin van XML (onhandige editors, of het bestand wordt ontvangen door een script van een andere server)
if ($ perviy_vxod) ($ data = strstr ($ data, "

// nu gooien we de gegevens in de xml-parser
if (! xml_parse ($ xml_parser, $ data, feof ($ fp))) (

// hier kunt u fouten voor geldigheid verwerken en krijgen ...
// zodra er een fout wordt aangetroffen, stopt het parseren
echo "
XML-fout: ". Xml_error_string (xml_get_error_code ($ xml_parser));
echo "op lijn". xml_get_current_line_number ($ xml_parser);
pauze;
}

// gooi na het ontleden de verzamelde gegevens weg voor de volgende stap van de cyclus.
$ gegevens = "";
}
fclose ($fp);
xml_parser_free ($ xml_parser);
// verwijder globale variabelen
uitgeschakeld ($ GLOBALS ["webi_depth"]);
uitgeschakeld ($ GLOBALS ["webi_tag_open"]);
uitgeschakeld ($ GLOBALS ["webi_data_temp"]);

Webi_xml ("1.xml");

?>

Het hele voorbeeld ging vergezeld van opmerkingen, nu testen en experimenteren.
Houd er rekening mee dat in de functie van werken met gegevens, gegevens niet eenvoudig in een array worden ingevoegd, maar worden toegevoegd met " .=" aangezien de gegevens mogelijk niet in hun geheel komen en als u een eenvoudige opdracht maakt, ontvangt u van tijd tot tijd gegevens in brokken.

Dat is alles, nu is er genoeg geheugen bij het verwerken van een bestand van elke grootte, maar de looptijd van het script kan op verschillende manieren worden verhoogd.
Voeg aan het begin van het script de functie in
set_time_limit (6000);
of
ini_set ("max_execution_time", "6000");

Of voeg de tekst toe aan uw .htaccess-bestand
php_value max_execution_time 6000

Deze voorbeelden verhogen de looptijd van het script tot 6000 seconden.
U kunt de tijd op deze manier alleen in de uitgeschakelde modus verlengen.

Als je toegang hebt om php.ini te bewerken, kun je de tijd verlengen met
max_execution_time = 6000

Op de hosting masterhost is het op het moment van schrijven bijvoorbeeld verboden om de scripttijd te verlengen, ondanks de uitgeschakelde veilige modus, maar als je een professional bent, kun je je eigen php-assemblage maken op de masterhost, maar dit is niet daarover in dit artikel.

Sommige van de voorbeelden in deze zelfstudie bevatten een XML-tekenreeks. In plaats van het in elk voorbeeld te herhalen, plaatst u die regel in een bestand, dat u in elk voorbeeld opneemt. Deze lijn wordt getoond in het volgende voorbeeld. Bovendien kunt u een XML-document maken en lezen met de functie simplexml_load_file ().

Voorbeeld # 1 Voorbeeld.php-bestand met XML-tekenreeks

$ xmlstr =<<





Mevr. Codeur
Onlivia Actora


Dhr. Codeur
El ActÓr


Het is dus een taal. Het is en blijft een programmeertaal. Of
is het een scripttaal? Alles wordt onthuld in deze documentaire
als een horrorfilm.




7
5


xml;
?>

SimpleXML is gemakkelijk te gebruiken! Probeer een string of nummer uit het onderliggende XML-document te halen.

Voorbeeld #2 Ophalen van een deel van een document

omvatten "voorbeeld.php";

echo $ films -> film [0] -> plot;
?>

Het is dus een taal. Het is en blijft een programmeertaal. Of is het een scripttaal? Alles komt aan het licht in deze horrorachtige documentaire.

In PHP kunt u toegang krijgen tot een element in een XML-document dat ongeldige tekens (zoals een koppelteken) in de naam bevat door de gegeven elementnaam tussen accolades en apostrofs te plaatsen.

Voorbeeld # 3 Een string ophalen

omvatten "voorbeeld.php";

echo $ movies -> movie -> ("grote lijnen") -> lijn;
?>

Het resultaat van dit voorbeeld:

PHP lost al mijn webproblemen op

Voorbeeld #4 Toegang tot niet-unieke elementen in SimpleXML

In het geval dat er meerdere instanties van onderliggende elementen in één bovenliggend element zijn, moet u de standaard iteratiemethoden gebruiken.

omvatten "voorbeeld.php";

$ films = nieuw SimpleXMLElement ($ xmlstr);

/ * Voor elk knooppunt , we zullen de naam apart weergeven . */
foreach ($ films -> film -> tekens -> teken als $ teken) (
echo $ karakter -> naam, "spelend", $ karakter -> acteur, PHP_EOL;
}

?>

Het resultaat van dit voorbeeld:

Mevr. Coder gespeeld door Onlivia Actora Mr. Coder gespeeld door El ActÓr

Commentaar:

Eigenschappen ( $ films-> film in het vorige voorbeeld) zijn geen arrays. Het is een itereerbaar als een array.

Voorbeeld # 5 Kenmerken gebruiken

Tot nu toe kregen we alleen de namen en waarden van de elementen. SimpleXML heeft ook toegang tot de attributen van een element. Een elementattribuut kan op dezelfde manier worden benaderd als arrayelementen ( reeks).

omvatten "voorbeeld.php";

$ films = nieuw SimpleXMLElement ($ xmlstr);

/ * Toegang tot het knooppunt het eerste filmpje.
* We zullen ook de beoordelingsschaal weergeven. * /
foreach ($ films -> film [0] -> waardering als $ waardering) (
switch ((string) $ rating ["type"]) ( // Haal de attributen van het element op per index
geval "duimen":
echo $ waardering, "duim omhoog";
pauze;
geval "sterren":
echo $ waardering, "sterren";
pauze;
}
}
?>

Het resultaat van dit voorbeeld:

7 duimen omhoog5 sterren

Voorbeeld # 6 Elementen en attributen vergelijken met tekst

Om een ​​element of attribuut met een tekenreeks te vergelijken, of om het als tekst aan een functie door te geven, moet u het naar een tekenreeks casten met (snaar)... Anders behandelt PHP het element als een object.

omvatten "voorbeeld.php";

$ films = nieuw SimpleXMLElement ($ xmlstr);

if ((string) $ movies -> movie -> title == "PHP: De opkomst van de parser") {
afdrukken "Mijn favoriete film.";
}

echo htmlentities ((string) $ movies -> movie -> titel);
?>

Het resultaat van dit voorbeeld:

Mijn favoriete film Php: The Emergence of the Parser

Voorbeeld # 7 Twee items vergelijken

Twee SimpleXMLElements worden als verschillend beschouwd, zelfs als ze naar hetzelfde object verwijzen sinds PHP 5.2.0.

omvatten "voorbeeld.php";

$ movies1 = nieuw SimpleXMLElement ($ xmlstr);
$ movies2 = nieuw SimpleXMLElement ($ xmlstr);
var_dump ($ films1 == $ films2); // false sinds PHP 5.2.0
?>

Het resultaat van dit voorbeeld:

Voorbeeld # 8 XPath gebruiken

SimpleXML bevat ingebouwde XPath-ondersteuning. Vind alle items :

omvatten "voorbeeld.php";

$ films = nieuw SimpleXMLElement ($ xmlstr);

foreach ($ movies -> xpath ("// character") als $ character) (
echo $ karakter -> naam, "spelend", $ karakter -> acteur, PHP_EOL;
}
?>

"// "dient als een sjabloon. Om een ​​absoluut pad op te geven, laat u een van de schuine strepen naar voren weg.

Het resultaat van dit voorbeeld:

Mevr. Coder gespeeld door Onlivia Actora Mr. Coder gespeeld door El ActÓr

Voorbeeld # 9 Waarden instellen

Gegevens in SimpleXML hoeven niet onveranderlijk te zijn. Met het object kunt u alle elementen manipuleren.

omvatten "voorbeeld.php";
$ films = nieuw SimpleXMLElement ($ xmlstr);

$ movies -> movie [0] -> karakters -> karakter [0] -> naam = "Miss Coder";

echo $ films -> asXML ();
?>

Het resultaat van dit voorbeeld:

Miss codeur Onlivia Actora Dhr. Codeur El ActÓr 7 5

Voorbeeld #10 Elementen en attributen toevoegen

Sinds PHP 5.1.3 heeft SimpleXML de mogelijkheid om eenvoudig onderliggende elementen en attributen toe te voegen.

omvatten "voorbeeld.php";
$ films = nieuw SimpleXMLElement ($ xmlstr);

$ karakter = $ films -> film [0] -> tekens -> addChild ("karakter");
$ karakter -> addChild ("naam", "Mr. Parser");
$ karakter -> addChild ("acteur", "John Doe");

$ rating = $ films -> film [0] -> addChild ("beoordeling", "PG");
$ rating -> addAttribute ("type", "mpaa");

echo $ films -> asXML ();
?>

Het resultaat van dit voorbeeld:

Mevr. Codeur Onlivia Actora Dhr. Codeur El ActÓr Dhr. ParserJohn Doe Het is dus een taal. Het is en blijft een programmeertaal. Of is het een scripttaal? Alles komt aan het licht in deze horrorachtige documentaire. PHP lost al mijn webtaken op 7 5 PG

Voorbeeld # 11 Interactie met de DOM

PHP kan XML-knooppunten converteren van SimpleXML naar DOM-formaat en vice versa. Dit voorbeeld laat zien hoe u een DOM-element in SimpleXML kunt wijzigen.

$ dom = nieuw DOMDocument;
$ dom -> loadXML ( "" );
als (! $ dom) (
echo "Er is een fout opgetreden tijdens het ontleden van het document";
Uitgang;
}

$ boeken = simplexml_import_dom ($ dom);

echo $ boeken -> boek [0] -> titel;
?>

Het resultaat van dit voorbeeld:

4 jaar geleden

Er is een algemene "truc" die vaak wordt voorgesteld om een ​​SimpleXML-object naar een array te converteren, door het eerst door json_encode () en vervolgens door json_decode () te laten lopen. Ik wil graag uitleggen waarom dit een slecht idee is.

Heel eenvoudig, omdat het hele doel van SimpleXML is om gemakkelijker te gebruiken en krachtiger te zijn dan een gewone array. U kunt bijvoorbeeld schrijven:bar -> baz ["bing"]?> en het betekent hetzelfde alsbar [0] -> baz [0] ["bing"]?>, ongeacht het aantal bar- of baz-elementen in de XML; en als je schrijftbar [0] -> baz [0]?> je krijgt alle stringinhoud van dat knooppunt - inclusief CDATA-secties - ongeacht of het ook onderliggende elementen of attributen heeft. U hebt ook toegang tot naamruimte-informatie, de mogelijkheid om eenvoudige wijzigingen aan de XML aan te brengen en zelfs de mogelijkheid om te "importeren" in een DOM-object, voor veel krachtigere manipulatie. Dit gaat allemaal verloren door het object in een array te veranderen in plaats van de voorbeelden op deze pagina te lezen.

Bovendien, omdat het niet voor dit doel is ontworpen, zal de conversie naar JSON en terug in sommige situaties zelfs informatie verliezen. Alle elementen of attributen in een naamruimte worden bijvoorbeeld gewoon weggegooid en alle tekstinhoud wordt weggegooid als een element ook kinderen of attributen heeft. Soms maakt dit "niet uit, maar als je de gewoonte krijgt om alles naar arrays te converteren, zal het je uiteindelijk steken.

Natuurlijk zou je een slimmere conversie kunnen schrijven, die deze beperkingen niet had, maar op dat moment haal je helemaal geen waarde uit SimpleXML, en zou je gewoon de lagere XML Parser-functies of de XMLReader-klasse moeten gebruiken, om uw structuur te creëren. U heeft nog steeds "niet de extra gemaksfunctionaliteit van SimpleXML, maar dat" is uw verlies.

2 jaar geleden

Als uw xml-tekenreeks booleans bevat die zijn gecodeerd met "0" en "1", zult u problemen tegenkomen wanneer u het element rechtstreeks naar bool cast:

$ xmlstr =<<

1
0

xml;
$ waarden = nieuw SimpleXMLElement ($ xmlstr);
$ truevalue = (bool) $ values-> truevalue; // waar
$ valse waarde = (bool) $ waarden-> valse waarde; // ook waar!!!

In plaats daarvan moet je eerst naar string of int casten:

$ truevalue = (bool) (int) $ values-> truevalue; // waar
$ valse waarde = (bool) (int) $ waarden-> valse waarde; // false

9 jaar geleden

Als u geldige xml in uw antwoord moet uitvoeren, vergeet dan niet om uw header-inhoudstype in te stellen op xml, naast het weergeven van het resultaat van asXML ():

$ xml = simplexml_load_file ("...");
...
... xml-dingen
...

// voer xml uit in je reactie:
header ("Inhoudstype: tekst / xml");
echo $ xml -> asXML ();
?>

9 jaar geleden

Uit het README-bestand:

SimpleXML is bedoeld als een gemakkelijke manier om toegang te krijgen tot XML-gegevens.

SimpleXML-objecten volgen vier basisregels:

1) eigenschappen duiden element-iterators aan
2) numerieke indexen geven elementen aan
3) niet-numerieke indices duiden attributen aan
4) stringconversie geeft toegang tot TEKST-gegevens

Bij het itereren van eigenschappen itereert de extensie altijd over
alle knooppunten met die elementnaam. Dus methode kinderen () moeten zijn
opgeroepen om over subnodes te itereren. Maar doe ook het volgende:
foreach ($ obj-> node_name als $ elem) (
// doe iets met $ elem
}
resulteert altijd in herhaling van "node_name" -elementen. Dus niet verder
controle is nodig om het aantal knooppunten van dat type te onderscheiden.

Wanneer een element TEXT data wordt benaderd via een eigenschap
dan bevat het resultaat niet de TEKST-gegevens van subelementen.

Bekende problemen
============

Vanwege motorproblemen is het momenteel niet mogelijk om toegang te krijgen
een subelement door index 0: $ object-> eigenschap.

8 jaar geleden

Het gebruik van dingen als: is_object ($ xml-> module-> admin) om te controleren of er daadwerkelijk een knooppunt met de naam "admin" is, lijkt niet te werken zoals verwacht, aangezien simplexml altijd een object retourneert - in dat geval een lege - zelfs als een bepaald knooppunt niet bestaat.
Voor mij lijkt de goede oude lege () functie in dergelijke gevallen prima te werken.

8 jaar geleden

Een snelle tip over xpath-query's en standaardnaamruimten. Het lijkt erop dat het XML-systeem achter SimpleXML dezelfde werking heeft als ik denk dat het XML-systeem .NET gebruikt: wanneer men iets in de standaardnaamruimte moet adresseren, moet men de naamruimte declareren met registerXPathNamespace en vervolgens het voorvoegsel gebruiken om adresseer het anders in het standaard levende element van de naamruimte.

$ tekenreeks =<<


Joe
Jane

Ik weet dat dat het antwoord is, maar wat is de vraag?




xml;

$ xml = simplexml_load_string ($ string);
$ xml -> registerXPathNamespace ("def", "http://www.w3.org/2005/Atom");

$ nodes = $ xml -> xpath ("// def: document / def: titel");

?>

9 jaar geleden

Hoewel SimpleXMLElement beweert itereerbaar te zijn, lijkt het de standaard Iterator-interfacefuncties zoals :: next en :: reset niet correct te implementeren. Daarom, terwijl foreach () werkt, lijken functies zoals next (), current (), of each () niet te werken zoals je zou verwachten - de aanwijzer lijkt nooit te bewegen of wordt steeds opnieuw ingesteld.

6 jaar geleden

Als de codering van het XML-document afwijkt van UTF-8, moet de coderingsdeclaratie onmiddellijk volgen na versie = "..." en vóór standalone = "...". Dit is een vereiste van de XML-standaard.

Als codering XML-document verschilt van UTF-8. Coderingsdeclaratie moet onmiddellijk volgen na de versie = "..." en vóór standalone = "...". Deze vereiste is standaard XML.

OK

Russische taal. Russische taal


Fatale fout: niet-gevangen uitzondering "Uitzondering" met bericht "String kan niet worden geparseerd als XML" in ...

Extensible Markup Language XML is een set regels voor het coderen van documenten in machineleesbare vorm. XML is een populair formaat voor het uitwisselen van gegevens op internet. Sites die hun inhoud regelmatig bijwerken, zoals nieuwssites of blogs, bieden vaak een XML-feed om externe programma's op de hoogte te houden van wijzigingen in de inhoud. Het verzenden en parseren van XML-gegevens is een veelvoorkomende taak voor netwerktoepassingen. In deze les wordt uitgelegd hoe u XML-documenten kunt ontleden en hun gegevens kunt gebruiken.

Een parser kiezen

Kanaalanalyse

De eerste stap bij het ontleden van een feed is beslissen in welke gegevensvelden u geïnteresseerd bent. De parser extraheert de opgegeven velden en negeert al het andere.

Hier is een feedfragment dat in de voorbeeldtoepassing wordt onderzocht. Elk bericht op StackOverflow.com verschijnt in de feed als een entry-tag die verschillende geneste tags bevat:

... ... http://stackoverflow.com/q/9439999 0 klif2310 http://stackoverflow.com/users/1128925 2012-02-25T00: 30: 54Z 2012-02-25T00: 30: 54Z

De voorbeeld-app haalt gegevens uit de invoertag en de titel, link en samenvatting van de subtags.

De parser instantiëren

De volgende stap is om de parser te instantiëren en het parseerproces te starten. Dit fragment initialiseert de parser om naamruimten niet te verwerken en gebruikt de opgegeven InputStream als invoer. Het parseerproces wordt gestart door nextTag () aan te roepen en de methode readFeed () aan te roepen, die de gegevens ophaalt en verwerkt waarin de toepassing is geïnteresseerd:

Openbare klasse StackOverflowXmlParser (// We gebruiken geen namespaces private static final String ns = null; public List parse (InputStream in) gooit XmlPullParserException, IOException (try (XmlPullParser parser = Xml.newPullParser (, false_server.XmlFeature) ); parser.setInput (in, null); parser.nextTag (); return readFeed (parser);) eindelijk (in.close ();)) ...)

kanaal aftrekken

De methode readFeed () doet het eigenlijke werk van het verwerken van de feed. Items die zijn gemarkeerd met de tag "entry" zijn het startpunt voor recursieve kanaalverwerking. Als de volgende tag geen entry-tag is, wordt deze overgeslagen. Nadat de volledige feed recursief is verwerkt, retourneert readFeed () een lijst met de items (inclusief geneste gegevensitems) die uit de feed zijn opgehaald. Deze lijst wordt vervolgens geretourneerd door de parser.

Private List readFeed (XmlPullParser-parser) genereert XmlPullParserException, IOException (List-items = new ArrayList (); parser.require (XmlPullParser.START_TAG, ns, "feed"); terwijl (parser.next ()! = XmlPullParser.END_TAGParser. getEventType ()! = XmlPullParser.START_TAG) (doorgaan;) Stringnaam = parser.getName (); // Begint door te zoeken naar de entry-tag if (name.equals ("entry")) (entries.add ( readEntry (parser ));) else (overslaan (parser);)) retouren invoeren;)

XML parseren

De stappen voor het ontleden van een XML-feed zijn als volgt:

Dit fragment laat zien hoe de parser het item, de titel, de link en de samenvatting ontleedt.

Openbare statische klasse Entry (openbare finale String-titel; openbare finale String-link; openbare finale String-samenvatting; privé-invoer (String-titel, String-samenvatting, String-link) (this.title = title; this.summary = samenvatting; this.link = link ;)) // Parseert de inhoud van een item. Als het een titel, samenvatting of link-tag tegenkomt, geef ze // door aan hun respectievelijke "lees"-methoden voor verwerking. Anders wordt de tag overgeslagen. private Entry readEntry (XmlPullParser-parser) genereert XmlPullParserException, IOException (parser.require (XmlPullParser.START_TAG, ns, "entry"); String titel = null; String samenvatting = null; String link = null; while (parser.next ()! = XmlPullParser.END_TAG) (if (parser.getEventType ()! = XmlPullParser.START_TAG) (doorgaan;) Stringnaam = parser.getName (); if (name.equals ("titel")) (title = readTitle (parser) ;) else if (name.equals ("samenvatting")) (summary = readSummary (parser);) else if (name.equals ("link")) (link = readLink (parser);) else (skip (parser) ;)) retourneer nieuwe invoer (titel, samenvatting, link);) // Verwerkt titeltags in de feed. private String readTitle (XmlPullParser-parser) genereert IOException, XmlPullParserException (parser.require (XmlPullParser.START_TAG, ns, "title"); String title = readText (parser); parser.require (XmlPullParser title.END; "title"); ) // Verwerkt linktags in de feed. private String readLink (XmlPullParser-parser) genereert IOException, XmlPullParserException (String link = ""; parser.require (XmlPullParser.START_TAG, ns, "link"); String tag = parser.getName (); String relType = parser.e , "rel"); if (tag.equals ("link")) (if (relType.equals ("alternate")) (link = parser.getAttributeValue (null, "href"); parser.nextTag ();) ) parser.require (XmlPullParser.END_TAG, ns, "link"); retourlink;) // Verwerkt samenvattingstags in de feed. private String readSummary (XmlPullParser-parser) genereert IOException, XmlPullParserException (parser.require (XmlPullParser.START_TAG, ns, "summary"); String summary = readText (parser); parser.require (XmlPullParser", samenvatting ) // Extraheert voor de titel en samenvatting van de tags hun tekstwaarden. private String readText (XmlPullParser-parser) genereert IOException, XmlPullParserException (String result = ""; if (parser.next () == XmlPullParser.TEXT) (result = parser.getText (); parser.nextTag ();) retourneert resultaat; ) ...)

Items overslaan die je niet nodig hebt

In een van de hierboven beschreven XML-parseerstappen slaat de parser tags over waarin we niet geïnteresseerd zijn. Hieronder staat de code van de skip () methode-parser:

Private void skip (XmlPullParser-parser) genereert XmlPullParserException, IOException (if (parser.getEventType ()! = XmlPullParser.START_TAG) (gooi nieuwe IllegalStateException ();) int depth = 1; while ( depth! = 0) (switch (parser. next ()) (case XmlPullParser.END_TAG: depth--; break; case XmlPullParser.START_TAG: depth ++; break;)))

Dit is hoe het werkt:

• De methode genereert een uitzondering als de huidige gebeurtenis niet START_TAG is.
• Het verbruikt START_TAG en alle evenementen tot END_TAG.
• Om ervoor te zorgen dat het stopt bij de juiste END_TAG en niet bij de eerste ontmoetingstag na de oorspronkelijke START_TAG, houdt het de nestdiepte bij.

Dus als het huidige element geneste elementen heeft, is de dieptewaarde pas 0 als de parser alle gebeurtenissen tussen de oorspronkelijke START_TAG en de bijbehorende END_TAG heeft verwerkt. Overweeg bijvoorbeeld hoe de analysator mist een element dat 2 geneste elementen heeft, en :

• In de eerste doorgang door de while-lus, de volgende tag die de analysator daarna tegenkomt dit is START_TAG voor
• In de tweede passage door de while-lus is de volgende tag die de analysator tegenkomt END_TAG
• In de derde passage door de while-lus is de volgende tag die de analysator tegenkomt START_TAG ... De dieptewaarde wordt verhoogd naar 2.
• In de vierde passage door de while-lus is de volgende tag die de analysator tegenkomt END_TAG... De dieptewaarde neemt af naar 1.
• Bij de vijfde en laatste passage door de while-lus is de volgende tag die de analysator tegenkomt END_TAG... Diepte neemt af tot 0, wat aangeeft dat: het item is succesvol overgeslagen.

XML-gegevensverwerking

De voorbeeldtoepassing ontvangt en parseert een XML-feed in een AsyncTask. De verwerking vindt plaats buiten de hoofd-UI-thread. Wanneer de verwerking is voltooid, werkt de toepassing de gebruikersinterface bij in de hoofdactiviteit (Netwerkactiviteit).

In het onderstaande fragment doet de methode loadPage () het volgende:

• Initialiseert een tekenreeksvariabele met een URL-waarde die verwijst naar een XML-feed.
• Als gebruikersinstellingen en netwerkconnectiviteit het toelaten, roept nieuwe DownloadXmlTask ​​​​(). Uitvoeren (url). Hiermee wordt een nieuw DownloadXmlTask-object (AsyncTask-subklasse) gemaakt en wordt de methode execute () uitgevoerd, die het kanaal downloadt en parseert en een tekenreeksresultaat retourneert dat in de gebruikersinterface wordt weergegeven.

• doInBackground () voert de methode loadXmlFromNetwork () uit. Het geeft de URL van het kanaal door als parameter. De methode loadXmlFromNetwork () ontvangt en verwerkt het kanaal. Wanneer het klaar is met verwerken, geeft het de resulterende string terug.
• onPostExecute () neemt de geretourneerde tekenreeks en geeft deze weer in de gebruikersinterface.