Parsing af XML. Springer varer over, du ikke har brug for

Således kan du i dele, som du ønsker, sende en stor fil til handleren.

Lad os nu se på, hvordan disse data behandles, og hvordan man får dem.

Lad os starte med åbningstags-funktionen startElement ($ parser, $ navn, $ attrs)
Antag, at behandlingen har nået linjen
< ingredient amount = "3" unit = "стакан" >Mel
Derefter, inde i funktionen, vil variablen $ navn være lig med ingrediens det vil sige navnet på det åbne tag (det er ikke kommet til at lukke tagget endnu).
Også i dette tilfælde vil en række attributter for dette $ attrs-tag være tilgængelige, hvori der vil være data mængde = "3" og enhed = "glas".

Derefter behandles dataene fra det åbne tag med funktionen data ($ parser, $ data)
$ datavariablen vil indeholde alt mellem åbnings- og afsluttende tags, i vores tilfælde er dette teksten Flour

Og behandlingen af ​​vores streng fuldføres af funktionen endElement ($ parser, $ navn)
Dette er navnet på det lukkede tag, i vores tilfælde vil $ navn være lig med ingrediens

Og herefter gik alt i ring igen.

Ovenstående eksempel demonstrerer kun princippet om XML-behandling, men til reel brug skal det forbedres.
Normalt er det nødvendigt at parse stor XML for at indtaste data i databasen, og for korrekt databehandling skal du vide hvilket åbent tag dataene tilhører, hvilket tag-nesting-niveau og hvilke tags der er åbne i hierarkiet højere. Med disse oplysninger kan du behandle filen korrekt uden problemer.
For at gøre dette skal du indtaste flere globale variabler, der vil indsamle oplysninger om åbne tags, indlejring og data.
Her er et eksempel, som du kan bruge

Funktion webi_xml ($ fil)
{
global $ webi_depth; // tæller for at spore rededybden
$ webi_depth = 0;
global $ webi_tag_open; // vil indeholde en række af aktuelt åbne tags
$ webi_tag_open = matrix ();
global $ webi_data_temp; // dette array vil indeholde dataene for et tag

####################################################
### funktion til at arbejde med data
funktionsdata ($ parser, $ data)
{
global $ webi_depth;
global $ webi_tag_open;
global $ webi_data_temp;
// tilføj data til arrayet, der angiver det indlejrede og aktuelt åbne tag
$ webi_data_temp [$ webi_depth] [$ webi_tag_open [$ webi_depth]] ["data"]. = $ data;
}
############################################

####################################################
### åbning af tags funktion
funktion startElement ($ parser, $ navn, $ attrs)
{
global $ webi_depth;
global $ webi_tag_open;
global $ webi_data_temp;

// hvis indlejringsniveauet ikke længere er nul, er et tag allerede åbent
// og dataene fra det allerede er i arrayet, kan du behandle det
if ($ webi_depth)
{

" ;

Print "
" ;
print_r ($ webi_tag_open); // række åbne tags
Print "

// efter at have behandlet dataene, slet dem for at frigøre hukommelse
unset ($ GLOBALS ["webi_data_temp"] [$ webi_depth]);
}

// nu er åbningen af ​​næste tag startet, og videre behandling vil finde sted ved næste trin
$ webi_depth ++; // øge redegørelsen

$ webi_tag_open [$ webi_depth] = $ navn; // tilføj det åbne tag til informationsarrayet
$ webi_data_temp [$ webi_depth] [$ navn] ["attrs"] = $ attrs; // tilføj nu tag-attributterne

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

#################################################
## sluttag-funktion
function endElement ($ parser, $ navn) (
global $ webi_depth;
global $ webi_tag_open;
global $ webi_data_temp;

// det er her databehandling starter, for eksempel tilføjelse til databasen, lagring til en fil osv.
// $ webi_tag_open indeholder en kæde af åbne tags efter indlejringsniveau
// for eksempel $ webi_tag_open [$ webi_depth] indeholder navnet på det åbne tag, hvis oplysninger i øjeblikket behandles
// $ webi_depth tag-nesting-niveau
// $ webi_data_temp [$ webi_depth] [$ webi_tag_open [$ webi_depth]] ["attrs"] række af tag-attributter
// $ webi_data_temp [$ webi_depth] [$ webi_tag_open [$ webi_depth]] ["data"] tag data

Udskriv "data". $ 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"]);
Print "
" ;
print_r ($ webi_tag_open);
Print "

Frakoblet ($ GLOBALS ["webi_data_temp"]); // efter at have behandlet dataene, slet hele arrayet med data, da tagget blev lukket
unset ($ GLOBALS ["webi_tag_open"] [$ webi_depth]); // fjern information om dette åbne tag ... siden det lukkede

$ webi_depth -; // mindske indlejring
}
############################################

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

// specificer hvilke funktioner der vil fungere, når du åbner og lukker tags
xml_set_element_handler ($ xml_parser, "startElement", "endElement");

// angiv en funktion til at arbejde med data
xml_set_character_data_handler($ xml_parser, "data");

// åbne filen
$ fp = fopen ($ fil, "r");

$ perviy_vxod = 1; // flag for at kontrollere den første filpost
$ data = ""; // her indsamler vi data fra filen i dele og sender dem til xml-parseren

// loop indtil slutningen af ​​filen er fundet
mens (! feof ($ fp) og $ fp)
{
$ simvol = fgetc ($ fp); // læs et tegn fra filen
$ data. = $ simvol; // tilføje dette symbol til de data, der skal sendes

// hvis tegnet ikke er et slutmærke, så går vi tilbage til begyndelsen af ​​løkken og tilføjer endnu et tegn til dataene, og så videre, indtil slutmærket er fundet
if ($ simvol! = ">") (fortsæt;)
// hvis et afsluttende tag blev fundet, send nu disse indsamlede data til behandling

// tjek om dette er den første indtastning i filen, og slet derefter alt, der er før tagget// da der nogle gange kan findes skrald før begyndelsen af ​​XML (klodsede editorer, eller filen modtages af et script fra en anden server)
if ($ perviy_vxod) ($ data = strstr ($ data, "

// nu smider vi dataene ind i xml-parseren
if (! xml_parse ($ xml_parser, $ data, feof ($ fp))) (

// her kan du behandle og få fejl for gyldighed ...
// Så snart der opstår en fejl, stopper parsingen
ekko "
XML-fejl: ". Xml_error_string (xml_get_error_code ($ xml_parser));
ekko "på linje". xml_get_current_line_number ($ xml_parser);
pause;
}

// efter parsing, kasser de indsamlede data til næste trin i cyklussen.
$ data = "";
}
fclose ($ fp);
xml_parser_free ($ xml_parser);
// fjern globale variabler
unset ($ GLOBALS ["webi_depth"]);
unset ($ GLOBALS ["webi_tag_open"]);
unset ($ GLOBALS ["webi_data_temp"]);

Webi_xml ("1.xml");

?>

Hele eksemplet var ledsaget af kommentarer, nu test og eksperimenter.
Bemærk venligst, at i funktionen med at arbejde med data, indsættes data ikke blot i et array, men tilføjes ved hjælp af " .=" da dataene måske ikke kommer i sin helhed, og hvis du laver en simpel opgave, så vil du fra tid til anden modtage data i bidder.

Nå, det er alt, nu er der nok hukommelse, når du behandler en fil af enhver størrelse, men scriptets køretid kan øges på flere måder.
Indsæt funktionen i begyndelsen af ​​scriptet
sæt_tidsgrænse (6000);
eller
ini_set ("max_execution_time", "6000");

Eller tilføj teksten til din .htaccess-fil
php_value max_execution_time 6000

Disse eksempler vil øge køretiden for scriptet til 6000 sekunder.
Du kan kun øge tiden på denne måde i deaktiveret tilstand.

Hvis du har adgang til edit php.ini kan du øge tiden med
max_execution_time = 6000

For eksempel på hosting-masterhosten i skrivende stund er det forbudt at øge scripttiden, på trods af den deaktiverede fejlsikret tilstand, men hvis du er en professionel, kan du lave din egen php-assembly på masterhosten, men det handler ikke om det i denne artikel.

Nogle af eksemplerne i denne øvelse inkluderer en XML-streng. I stedet for at gentage det i hvert eksempel, læg den linje i en fil, som du inkluderer i hvert eksempel. Denne linje er vist i følgende eksempel. Derudover kan du oprette et XML-dokument og læse det med funktionen simplexml_load_file ().

Eksempel # 1 Eksempel.php-fil med XML-streng

$ xmlstr =<<





Frk. Koder
Onlivia Actora


Hr. Koder
El ActÓr


Så det er et sprog. Det er stadig et programmeringssprog. Eller
er det et scriptsprog? Alt afsløres i denne dokumentar
som en gyserfilm.




7
5


XML;
?>

SimpleXML er let at bruge! Prøv at hente en streng eller et tal fra det underliggende XML-dokument.

Eksempel # 2 Hentning af en del af et dokument

inkludere "eksempel.php";

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

Så det er et sprog. Det er stadig et programmeringssprog. Eller er det et scriptsprog? Alt afsløres i denne horror-lignende dokumentar.

I PHP kan du få adgang til et element i et XML-dokument, der indeholder ugyldige tegn (såsom en bindestreg) i navnet ved at omslutte det givne elementnavn i krøllede parenteser og apostrof.

Eksempel # 3 Hentning af en streng

inkludere "eksempel.php";

echo $ film -> film -> ("store-linjer") -> linje;
?>

Resultatet af dette eksempel:

PHP løser alle mine webproblemer

Eksempel # 4 Adgang til ikke-unikke elementer i SimpleXML

I tilfælde af, at der er flere forekomster af underordnede elementer i et overordnet element, skal du bruge standard iterationsmetoderne.

inkludere "eksempel.php";

$ film = nyt SimpleXMLElement ($ xmlstr);

/ * For hver node , vil vi vise navnet separat . */
foreach ($ film -> film -> tegn -> karakter som $ karakter) (
echo $ karakter -> navn, "spiller", $ karakter -> skuespiller, PHP_EOL;
}

?>

Resultatet af dette eksempel:

Frk. Coder spillet af Onlivia Actora Mr. Coder spillet af El ActÓr

Kommentar:

Ejendomme ( $ film-> film i det foregående eksempel) er ikke arrays. Det er en iterabel som et array.

Eksempel # 5 Brug af attributter

Indtil nu har vi kun fået navne og værdier af elementerne. SimpleXML kan også få adgang til et elements attributter. En elementattribut kan tilgås på samme måde som matrixelementer ( array).

inkludere "eksempel.php";

$ film = nyt SimpleXMLElement ($ xmlstr);

/ * Adgang til noden den første film.
* Vi viser også vurderingsskalaen. * /
foreach ($ film -> film [0] -> vurdering som $ rating) (
switch ((streng) $ rating ["type"]) ( // Få elementets attributter efter indeks
case "thumbs":
echo $ rating, "thumbs up";
pause;
case "stjerner":
echo $ rating, "stjerner";
pause;
}
}
?>

Resultatet af dette eksempel:

7 thumbs up 5 stjerner

Eksempel #6 Sammenligning af elementer og attributter med tekst

For at sammenligne et element eller en attribut med en streng, eller for at overføre det til en funktion som tekst, skal du caste det til en streng vha. (snor)... Ellers vil PHP behandle elementet som et objekt.

inkludere "eksempel.php";

$ film = nyt SimpleXMLElement ($ xmlstr);

if ((streng) $ film -> film -> titel == "PHP: The Rise of the Parser") {
Print "Min yndlingsfilm.";
}

echo htmlentities ((streng) $ film -> film -> titel);
?>

Resultatet af dette eksempel:

Min yndlingsfilm Php: The Emergence of the Parser

Eksempel # 7 Sammenligning af to elementer

To SimpleXMLElements betragtes som forskellige, selvom de peger på det samme objekt siden PHP 5.2.0.

inkludere "eksempel.php";

$ movies1 = nyt SimpleXMLElement ($ xmlstr);
$ movies2 = nyt SimpleXMLElement ($ xmlstr);
var_dump ($ film1 == $ film2); // falsk siden PHP 5.2.0
?>

Resultatet af dette eksempel:

Eksempel # 8 Brug af XPath

SimpleXML inkluderer indbygget XPath-understøttelse. Find alle varer :

inkludere "eksempel.php";

$ film = nyt SimpleXMLElement ($ xmlstr);

foreach ($ film -> xpath ("// karakter") som $ karakter) (
echo $ karakter -> navn, "spiller", $ karakter -> skuespiller, PHP_EOL;
}
?>

"// "fungerer som en skabelon. For at angive en absolut sti skal du udelade en af ​​skråstregene.

Resultatet af dette eksempel:

Frk. Coder spillet af Onlivia Actora Mr. Coder spillet af El ActÓr

Eksempel # 9 Indstillingsværdier

Data i SimpleXML behøver ikke at være uforanderlige. Objektet giver dig mulighed for at manipulere alle elementer.

inkludere "eksempel.php";
$ film = nyt SimpleXMLElement ($ xmlstr);

$ film -> film [0] -> karakterer -> karakter [0] -> navn = "Miss Coder";

echo $ film -> asXML ();
?>

Resultatet af dette eksempel:

Frøken koder Onlivia Actora Hr. Koder El ActÓr 7 5

Eksempel # 10 Tilføjelse af elementer og attributter

Siden PHP 5.1.3 har SimpleXML muligheden for nemt at tilføje underordnede elementer og attributter.

inkludere "eksempel.php";
$ film = nyt SimpleXMLElement ($ xmlstr);

$ karakter = $ film -> film [0] -> tegn -> addChild ("karakter");
$ karakter -> addChild ("navn", "Mr. Parser");
$ karakter -> addChild ("skuespiller", "John Doe");

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

echo $ film -> asXML ();
?>

Resultatet af dette eksempel:

Frk. Koder Onlivia Actora Hr. Koder El ActÓr Hr. ParserJohn Doe Så det er et sprog. Det er stadig et programmeringssprog. Eller er det et scriptsprog? Alt afsløres i denne horror-lignende dokumentar. PHP løser alle mine webopgaver 7 5 PG

Eksempel # 11 Interaktion med DOM

PHP kan konvertere XML-noder fra SimpleXML til DOM-format og omvendt. Dette eksempel viser, hvordan du kan ændre et DOM-element i SimpleXML.

$ dom = nyt DOMDocument;
$ dom -> loadXML ( "" );
hvis (! $ dom) (
ekko "Der opstod en fejl under parsing af dokumentet";
Afslut;
}

$ bøger = simplexml_import_dom ($ dom);

echo $ bøger -> bog [0] -> titel;
?>

Resultatet af dette eksempel:

for 4 år siden

Der er et almindeligt "trick", der ofte foreslås til at konvertere et SimpleXML-objekt til et array ved at køre det gennem json_encode () og derefter json_decode (). Jeg vil gerne forklare, hvorfor det er en dårlig idé.

Mest simpelt, fordi hele pointen med SimpleXML er at være nemmere at bruge og mere kraftfuld end et almindeligt array. For eksempel kan du skrivebar -> baz ["bing"]?> og det betyder det samme sombar [0] -> baz [0] ["bing"]?>, uanset hvor mange bar eller baz-elementer der er i XML; og hvis du skriverbar [0] -> baz [0]?> får du alt strengindholdet i den node - inklusive CDATA-sektioner - uanset om den også har underordnede elementer eller attributter. Du har også adgang til navnerumsinformation, muligheden for at lave simple redigeringer af XML'en og endda muligheden for at "importere" til et DOM-objekt for meget mere kraftfuld manipulation. Alt dette går tabt ved at omdanne objektet til et array i stedet for at læse og forstå eksemplerne på denne side.

Derudover, fordi den ikke er designet til dette formål, vil konverteringen til JSON og tilbage faktisk miste information i nogle situationer. For eksempel vil alle elementer eller attributter i et navneområde simpelthen blive kasseret, og alt tekstindhold vil blive kasseret, hvis et element også har underordnede eller attributter. Nogle gange betyder det ikke noget, men hvis du vænner dig til at konvertere alt til arrays, kommer det til at svie dig til sidst.

Selvfølgelig kunne du skrive en smartere konvertering, som "ikke havde disse begrænsninger, men på det tidspunkt får du overhovedet ingen værdi ud af SimpleXML, og du skal bare bruge XML Parser-funktionerne på lavere niveau eller XMLReader-klassen, for at skabe din struktur. Du vil stadig "ikke have den ekstra bekvemmelighedsfunktionalitet som SimpleXML, men det" er dit tab.

2 år siden

Hvis din xml-streng indeholder booleaner kodet med "0" og "1", vil du løbe ind i problemer, når du caster elementet direkte til bool:

$ xmlstr =<<

1
0

XML;
$ værdier = nyt SimpleXMLElement ($ xmlstr);
$ truevalue = (bool) $ values-> truevalue; // rigtigt
$ falsevalue = (bool) $ values-> falsevalue; // også sandt!!!

I stedet skal du først caste til streng eller int:

$ truevalue = (bool) (int) $ values-> truevalue; // rigtigt
$ falsevalue = (bool) (int) $ values-> falsevalue; // falsk

9 år siden

Hvis du har brug for at udlæse gyldig xml i dit svar, så glem ikke at indstille din header-indholdstype til xml ud over at ekko resultatet af asXML ():

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

// output xml i dit svar:
header ("Indholdstype: tekst / xml");
echo $ xml -> asXML ();
?>

9 år siden

Fra README-filen:

SimpleXML er beregnet til at være en nem måde at få adgang til XML-data på.

SimpleXML-objekter følger fire grundlæggende regler:

1) egenskaber angiver element-iteratorer
2) numeriske indekser angiver elementer
3) ikke-numeriske indekser angiver attributter
4) strengkonvertering giver adgang til TEKST-data

Ved iteration af egenskaber gentager udvidelsen altid
alle noder med det elementnavn. Således metode børn () skal være
kaldet til at iterere over subnoder. Men gør også følgende:
foreach ($ obj-> node_name som $ elem) (
// gør noget med $ elem
}
resulterer altid i iteration af "node_name"-elementer. Så ikke længere
kontrol er nødvendig for at skelne antallet af noder af den type.

Når et element TEXT-data tilgås via en egenskab
så inkluderer resultatet ikke TEXT-dataene for underelementer.

Kendte problemer
============

På grund af motorproblemer er det i øjeblikket ikke muligt at få adgang
et underelement ved indeks 0: $ objekt-> egenskab.

8 år siden

Brug af ting som: is_object ($ xml-> modul-> admin) for at kontrollere, om der faktisk er en node kaldet "admin", virker "ikke som forventet, da simplexml altid returnerer et objekt - i så fald et tomt" - også selvom en bestemt node ikke eksisterer.
For mig ser den gode gamle tomme () funktion ud til at fungere fint i sådanne tilfælde.

8 år siden

Et hurtigt tip om xpath-forespørgsler og standardnavneområder. Det ser ud til, at XML-systemet bag SimpleXML fungerer på samme måde, som jeg tror, ​​XML-systemet .NET bruger: når man skal adressere noget i standardnavnerummet, bliver man nødt til at erklære navnerummet ved hjælp af registerXPathNamespace og derefter bruge dets præfiks til adressere ellers i standardnavnerummet levende element.

$ streng =<<


Joe
Jane

Jeg ved, at "svaret er - men hvad" er spørgsmålet?




XML;

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

$ noder = $ xml -> xpath ("// def: document / def: title");

?>

9 år siden

Mens SimpleXMLElement hævder at være iterable, ser det ikke ud til at implementere standard Iterator-grænsefladefunktionerne som :: next og :: nulstillet korrekt. Mens foreach () virker, virker som næste (), nuværende () eller hver () derfor ikke til at fungere, som du ville forvente - viseren ser aldrig ud til at bevæge sig eller bliver ved med at blive nulstillet.

6 år siden

Hvis kodningen af ​​XML-dokumentet er forskellig fra UTF-8, skal kodningserklæringen følge umiddelbart efter version = "..." og før standalone = "...". Dette er et krav i XML-standarden.

Hvis kodning af XML-dokument adskiller sig fra UTF-8. Kodningserklæringen skal følge umiddelbart efter versionen = "..." og før standalone = "...". Dette krav er standard XML.

Okay

Russisk sprog. russisk sprog


Fatal fejl: Uopfanget undtagelse "Exception" med meddelelsen "String could not be parsed as XML" in ...

Extensible Markup Language XML er et sæt regler for kodning af dokumenter i maskinlæsbar form. XML er et populært format til udveksling af data på internettet. Websteder, der ofte opdaterer deres indhold, såsom nyhedswebsteder eller blogs, leverer ofte et XML-feed for at holde eksterne programmer opmærksomme på indholdsændringer. Afsendelse og parsing af XML-data er en almindelig opgave for netværksapplikationer. Denne lektion forklarer, hvordan man parser XML-dokumenter og bruger deres data.

Valg af en parser

Kanalanalyse

Det første trin i at parse et feed er at beslutte, hvilke datafelter du er interesseret i. Parseren udtrækker de angivne felter og ignorerer alt andet.

Her er et feed-uddrag, der vil blive udforsket i eksempelapplikationen. Hvert indlæg på StackOverflow.com vises i feedet som et indgangstag, der indeholder flere indlejrede tags:

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

Eksempelappen udtrækker data fra indgangstagget og dets undertags titel, link og oversigt.

Instantiering af parseren

Det næste trin er at instansiere parseren og starte parsingsprocessen. Dette uddrag initialiserer parseren til ikke at håndtere navneområder og bruger den leverede InputStream som input. Parsingprocessen startes ved at kalde nextTag () og kalder readFeed () metoden, som henter og behandler de data, applikationen er interesseret i:

Offentlig klasse StackOverflowXmlParser (// Vi bruger ikke navnerum private static final String ns = null; public List parse (InputStream in) kaster XmlPullPullParserException, IOException (try (XmlPullParser parser = Xml.newPullParser (); parsull_arsersetParserset.Xml. ); parser.setInput (in, null); parser.nextTag (); returner readFeed (parser);) til sidst (in.close ();)) ...)

Træk kanal fra

ReadFeed () metoden udfører selve arbejdet med at håndtere feedet. Elementer markeret med "entry"-tagget er udgangspunktet for rekursiv kanalbehandling. Hvis det næste mærke ikke er et indgangsmærke, springes det over. Når hele feedet er blevet rekursivt behandlet, returnerer readFeed () en liste, der indeholder de indgange (inklusive indlejrede dataelementer), der hentes fra feedet. Denne liste returneres derefter af parseren.

Private List readFeed (XmlPullParser parser) kaster XmlPullParserException, IOException (List entries = new ArrayList (); parser.require (XmlPullParser.START_TAG, ns, "feed"); while (parser.next ()! = Xmlser.END_Pull getEventType ()! = XmlPullParser.START_TAG) (fortsæt;) Strengnavn = parser.getName (); // Starter med at lede efter entry-tagget if (name.equals ("entry")) (entries.add ( readEntry (parser) ));) else (spring over (parser);)) returnere poster;)

Parsing af XML

Trinene til at parse et XML-feed er som følger:

Dette uddrag viser, hvordan parseren analyserer indgang, titel, link og oversigt.

Offentlig statisk klasseindgang (offentlig endelig strengtitel; offentlig endelig strenglink; offentlig endelig strengoversigt; privat post (strengtitel, strengoversigt, strenglink) (this.title = titel; this.summary = resumé; this.link = link ;)) // Parser indholdet af en post. Hvis den støder på en titel, et resumé eller et link-tag, skal du videregive dem // til deres respektive "læse"-metoder til behandling. Ellers springer tagget over. private Entry readEntry (XmlPullParser parser) kaster XmlPullParserException, IOException (parser.require (XmlPullParser.START_TAG, ns, "entry"); String title = null; String summary = null; String link = null.next (parser!) = XmlPullParser.END_TAG) (if (parser.getEventType ()! = XmlPullParser.START_TAG) (fortsæt;) String name = parser.getName (); if (name.equals ("title")) (title = readTitle (parser) ;) else if (name.equals ("resumé")) (summary = readSummary (parser);) else if (name.equals ("link")) (link = readLink (parser);) else (spring over (parser) ;)) returner ny indgang (titel, resumé, link);) // Behandler title tags i feedet. private String readTitle (XmlPullParser parser) kaster IOException, XmlPullParserException (parser.require (XmlPullParser.START_TAG, ns, "title"); String title = readText (parser); parser.require (XmlPullParser"); return.END "title"; ) // Behandler link-tags i feedet. private String readLink (XmlPullParser parser) kaster IOException, XmlPullParserException (String link = ""; parser.require (XmlPullParser.START_TAG, ns, "link"); String tag = parser.getName (); String triburelType = parser.getueA (tnullteValueA) , "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;) // Behandler summary tags i feedet. private String readSummary (XmlPullParser parser) kaster IOException, XmlPullParserException (parser.require (XmlPullParser.START_TAG, ns, "summary"); String summary = readText (parser); parser.require (XmlPullPar summary, "END_TAG summary"); ) // For tags titel og oversigt, udtrækker deres tekstværdier. private String readText (XmlPullParser parser) kaster IOException, XmlPullParserException (String result = ""; if (parser.next () == XmlPullParser.TEXT) (result = parser.getText (); parser.nextTag ();) returner resultat; ) ...)

Springer varer over, du ikke har brug for

I et af XML-parsing-trinene beskrevet ovenfor springer parseren tags over, som vi ikke er interesserede i. Nedenfor er koden for skip ()-metodens parser:

Privat void spring (XmlPullParser parser) kaster XmlPullParserException, IOException (if (parser.getEventType ()! = XmlPullParser.START_TAG) (smid ny IllegalStateException ();) int depth = 1; while (parserswitch! = (0)) næste ()) (case XmlPullParser.END_TAG: depth--; break; case XmlPullParser.START_TAG: depth ++; break;)))

Sådan fungerer det:

• Metoden kaster en undtagelse, hvis den aktuelle hændelse ikke er START_TAG.
• Den bruger START_TAG og alle begivenheder op til END_TAG.
• For at sikre, at det stopper ved det korrekte END_TAG og ikke det første møde-tag efter det oprindelige START_TAG, holder det styr på rededybden.

Hvis det aktuelle element har indlejrede elementer, vil dybdeværdien ikke være 0, før parseren har behandlet alle hændelser mellem den oprindelige START_TAG og dens tilsvarende END_TAG. Overvej for eksempel, hvordan analysatoren misser et element, der har 2 indlejrede elementer, og :

• I den første passage gennem while-løkken, den næste tag, som analysatoren støder på efter dette er START_TAG for
• I den anden passage gennem while-løkken er det næste tag, som analysatoren støder på, END_TAG
• I den tredje passage gennem while-løkken er det næste tag, som analysatoren støder på, START_TAG ... Dybdeværdien øges til 2.
• I den fjerde passage gennem while-løkken er det næste tag, som analysatoren støder på, END_TAG... Dybdeværdien falder til 1.
• På den femte og sidste passage gennem while-løkken er det næste tag, som analysatoren støder på, END_TAG... Dybden falder til 0, hvilket indikerer det elementet blev sprunget over.

XML databehandling

Eksempelapplikationen modtager og analyserer et XML-feed til en AsyncTask. Behandling udføres uden for hovedgrænsefladetråden. Når behandlingen er færdig, opdaterer applikationen brugergrænsefladen i hovedaktiviteten (NetworkActivity).

I uddraget nedenfor gør loadPage ()-metoden følgende:

• Initialiserer en strengvariabel med en URL-værdi, der peger på et XML-feed.
• Hvis brugerindstillinger og netværksforbindelse tillader det, kalder ny DownloadXmlTask ​​​​(). Udfør (url). Dette opretter et nyt DownloadXmlTask-objekt (AsyncTask-underklasse) og udfører dets execute ()-metode, som downloader og analyserer kanalen og returnerer et strengresultat, der vil blive vist i brugergrænsefladen.

• doInBackground () udfører metoden loadXmlFromNetwork (). Den videregiver kanalens URL som en parameter. Metoden loadXmlFromNetwork () modtager og behandler kanalen. Når den er færdig med at behandle, sender den den resulterende streng tilbage.
• onPostExecute () tager den returnerede streng og viser den i brugergrænsefladen.