Parsing XML. Hopp over elementer du ikke trenger

Dermed kan du, i deler som du ønsker, sende en stor fil til behandleren.

La oss nå se på hvordan disse dataene behandles og hvordan du får dem.

La oss starte med åpningstagger-funksjonen startElement ($ parser, $ navn, $ attrs)
Anta at behandlingen har nådd linjen
< ingredient amount = "3" unit = "стакан" >Mel
Deretter, inne i funksjonen, vil variabelen $ navn være lik ingrediens det vil si navnet på den åpne taggen (den har ikke kommet til å lukke taggen ennå).
I dette tilfellet vil også en rekke attributter for denne $ attrs-taggen være tilgjengelig, der det vil være data beløp = "3" og enhet = "glass".

Etter det, behandlingen av dataene til den åpne taggen med funksjonen data ($ parser, $ data)
$ datavariabelen vil inneholde alt mellom åpnings- og avslutningstaggen, i vårt tilfelle er dette teksten Flour

Og behandlingen av strengen vår fullføres av funksjonen endElement ($ parser, $ navn)
Dette er navnet på den lukkede taggen, i vårt tilfelle vil $ navn være lik ingrediens

Og etter det gikk alt i ring igjen.

Eksempelet ovenfor viser bare prinsippet for XML-behandling, men for reell bruk må det forbedres.
Vanligvis er det nødvendig å parse stor XML for å legge inn data i databasen, og for korrekt databehandling må du vite hvilken åpen tag dataene tilhører, hvilket tag nestet nivå og hvilke tagger som er åpne i hierarkiet høyere. Med denne informasjonen kan du behandle filen riktig uten problemer.
For å gjøre dette må du legge inn flere globale variabler som samler informasjon om åpne tagger, nesting og data.
Her er et eksempel du kan bruke

Funksjon webi_xml ($ fil)
{
global $ webi_depth; // teller for å spore hekkedybden
$ webi_depth = 0;
global $ webi_tag_open; // vil inneholde en rekke åpne tagger
$ webi_tag_open = array ();
global $ webi_data_temp; // denne matrisen vil inneholde dataene til én tag

####################################################
### funksjon for arbeid med data
funksjonsdata ($ parser, $ data)
{
global $ webi_depth;
global $ webi_tag_open;
global $ webi_data_temp;
// legg til data til matrisen som indikerer neste og åpne tag
$ webi_data_temp [$ webi_depth] [$ webi_tag_open [$ webi_depth]] ["data"]. = $ data;
}
############################################

####################################################
### åpningstaggerfunksjon
funksjon startElement ($ parser, $ navn, $ attrs)
{
global $ webi_depth;
global $ webi_tag_open;
global $ webi_data_temp;

// hvis nesting-nivået ikke lenger er null, er én tag allerede åpen
// og dataene fra den allerede er i arrayet, kan du behandle den
if ($ webi_depth)
{

" ;

skrive ut "
" ;
print_r ($ webi_tag_open); // rekke åpne tagger
skrive ut "

// etter å ha behandlet dataene, slett dem for å frigjøre minne
unset ($ GLOBALS ["webi_data_temp"] [$ webi_depth]);
}

// nå har åpningen av neste tag startet og videre behandling vil finne sted ved neste trinn
$ webi_depth ++; // øke hekkingen

$ webi_tag_open [$ webi_depth] = $ navn; // legg til den åpne taggen til informasjonsarrayen
$ webi_data_temp [$ webi_depth] [$ navn] ["attrs"] = $ attrs; // legg nå til tag-attributtene

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

#################################################
## slutttag-funksjon
funksjon endElement ($ parser, $ navn) (
global $ webi_depth;
global $ webi_tag_open;
global $ webi_data_temp;

// det er her databehandling starter, for eksempel å legge til databasen, lagre til en fil, etc.
// $ webi_tag_open inneholder en kjede med åpne tagger etter neste nivå
// for eksempel $ webi_tag_open [$ webi_depth] inneholder navnet på den åpne taggen hvis informasjon for øyeblikket behandles
// $ webi_depth tag neste nivå
// $ webi_data_temp [$ webi_depth] [$ webi_tag_open [$ webi_depth]] ["attrs"] rekke tag-attributter
// $ webi_data_temp [$ webi_depth] [$ webi_tag_open [$ webi_depth]] ["data"] tagdata

Skriv ut "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"]);
skrive ut "
" ;
print_r ($ webi_tag_open);
skrive ut "

Unset ($ GLOBALS ["webi_data_temp"]); // etter å ha behandlet dataene, slett hele arrayet med data, siden taggen ble lukket
unset ($ GLOBALS ["webi_tag_open"] [$ webi_depth]); // fjern informasjon om denne åpne taggen ... siden den ble lukket

$ webi_depth -; // redusere hekking
}
############################################

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

// spesifiser hvilke funksjoner som vil fungere når du åpner og lukker tagger
xml_set_element_handler ($ xml_parser, "startElement", "endElement");

// spesifiser en funksjon for arbeid med data
xml_set_character_data_handler($ xml_parser, "data");

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

$ perviy_vxod = 1; // flagg for å sjekke den første filoppføringen
$ data = ""; // her samler vi inn data fra filen i deler og sender den til xml-parseren

// loop til slutten av filen er funnet
mens (! feof ($ fp) og $ fp)
{
$ simvol = fgetc ($ fp); // les ett tegn fra filen
$ data. = $ simvol; // legg til dette symbolet i dataene som skal sendes

// hvis tegnet ikke er en sluttkode, går vi tilbake til begynnelsen av løkken og legger til ett tegn til i dataene, og så videre til sluttkoden blir funnet
if ($ simvol! = ">") (fortsett;)
// hvis en avsluttende tag ble funnet, send nå disse innsamlede dataene for behandling

// sjekk om dette er den første oppføringen i filen, og slett alt som er før taggen// siden noen ganger kan søppel bli funnet før begynnelsen av XML (klossete redaktører, eller filen mottas av et skript fra en annen server)
if ($ perviy_vxod) ($ data = strstr ($ data, "

// nå kaster vi dataene inn i xml-parseren
if (! xml_parse ($ xml_parser, $ data, feof ($ fp))) (

// her kan du behandle og få feil for gyldighet ...
// så snart en feil oppstår, stopper parsingen
ekko "
XML-feil: ". Xml_error_string (xml_get_error_code ($ xml_parser));
ekko "på linje". xml_get_current_line_number ($ xml_parser);
gå i stykker;
}

// etter parsing, forkast de innsamlede dataene for neste trinn i syklusen.
$ 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 ble ledsaget av kommentarer, nå test og eksperimenter.
Vær oppmerksom på at i funksjonen til å jobbe med data, blir data ikke bare satt inn i en matrise, men lagt til ved å bruke " .=" siden dataene kanskje ikke kommer i sin helhet og hvis du lager en enkel oppgave, vil du fra tid til annen motta data i biter.

Vel, det er alt, nå er det nok minne når du behandler en fil uansett størrelse, men skriptets kjøretid kan økes på flere måter.
Sett inn funksjonen i begynnelsen av skriptet
set_time_limit (6000);
eller
ini_set ("maks_utførelsestid", "6000");

Eller legg til teksten i .htaccess-filen
php_value max_execution_time 6000

Disse eksemplene vil øke kjøretiden til skriptet til 6000 sekunder.
Du kan øke tiden på denne måten bare i deaktivert modus.

Hvis du har tilgang til edit php.ini kan du øke tiden med
max_execution_time = 6000

For eksempel, på hosting masterhost, når dette skrives, er det forbudt å øke skripttiden, til tross for deaktivert sikker modus, men hvis du er en proff, kan du lage din egen php-assembly på masterhosten, men dette er ikke om det i denne artikkelen.

Noen av eksemplene i denne opplæringen inkluderer en XML-streng. I stedet for å gjenta det i hvert eksempel, legg den linjen i en fil, som du inkluderer i hvert eksempel. Denne linjen er vist i følgende eksempel. I tillegg kan du lage et XML-dokument og lese det med funksjonen simplexml_load_file ().

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

$ xmlstr =<<





Ms. Koder
Onlivia Actora


MR. Koder
El ActÓr


Så det er et språk. Det er fortsatt et programmeringsspråk. Eller
er det et skriptspråk? Alt avsløres i denne dokumentaren
som en skrekkfilm.




7
5


XML;
?>

SimpleXML er enkel å bruke! Prøv å hente en streng eller et nummer fra det underliggende XML-dokumentet.

Eksempel # 2 Henter en del av et dokument

inkludere "example.php";

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

Så det er et språk. Det er fortsatt et programmeringsspråk. Eller er det et skriptspråk? Alt avsløres i denne skrekklignende dokumentaren.

I PHP kan du få tilgang til et element i et XML-dokument som inneholder ugyldige tegn (som en bindestrek) i navnet ved å omslutte det gitte elementnavnet i krøllete klammeparenteser og apostrof.

Eksempel # 3 Hente en streng

inkludere "example.php";

echo $ movies -> movie -> ("great-lines") -> line;
?>

Resultatet av dette eksemplet:

PHP løser alle mine nettproblemer

Eksempel # 4 Tilgang til ikke-unike elementer i SimpleXML

I tilfelle det er flere forekomster av underordnede elementer i ett overordnet element, må du bruke standard iterasjonsmetoder.

inkludere "example.php";

$ filmer = nytt SimpleXMLElement ($ xmlstr);

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

?>

Resultatet av dette eksemplet:

Ms. Coder spilt av Onlivia Actora Mr. Coder spilt av El ActÓr

Kommentar:

Egenskaper ( $ filmer-> film i forrige eksempel) er ikke matriser. Det er en iterabel som en array.

Eksempel # 5 Bruke attributter

Til nå har vi bare fått navn og verdier på elementene. SimpleXML kan også få tilgang til attributtene til et element. Et elementattributt kan nås på samme måte som matriseelementer ( array).

inkludere "example.php";

$ filmer = nytt SimpleXMLElement ($ xmlstr);

/ * Tilgang til noden den første filmen.
* Vi vil også vise vurderingsskalaen. * /
foreach ($ filmer -> film [0] -> vurdering som $ vurdering) (
bryter ((streng) $ vurdering ["type"]) ( // Få attributtene til elementet etter indeks
case "thumbs":
ekko $ vurdering, "tommel opp";
gå i stykker;
sak "stjerner":
echo $ vurdering, "stjerner";
gå i stykker;
}
}
?>

Resultatet av dette eksemplet:

7 tommel opp5 stjerner

Eksempel # 6 Sammenligning av elementer og attributter med tekst

For å sammenligne et element eller attributt med en streng, eller sende det til en funksjon som tekst, må du caste det til en streng ved å bruke (streng)... Ellers vil PHP behandle elementet som et objekt.

inkludere "example.php";

$ filmer = nytt SimpleXMLElement ($ xmlstr);

if ((streng) $ filmer -> film -> tittel == "PHP: The Rise of the Parser") {
skrive ut "Min favorittfilm.";
}

echo htmlentities ((streng) $ filmer -> film -> tittel);
?>

Resultatet av dette eksemplet:

Min favorittfilm Php: The Emergence of the Parser

Eksempel # 7 Sammenligning av to elementer

To SimpleXMLElements anses som forskjellige selv om de peker til det samme objektet siden PHP 5.2.0.

inkludere "example.php";

$ movies1 = nytt SimpleXMLElement ($ xmlstr);
$ movies2 = nytt SimpleXMLElement ($ xmlstr);
var_dump ($ filmer1 == $ filmer2); // usann siden PHP 5.2.0
?>

Resultatet av dette eksemplet:

Eksempel # 8 Bruke XPath

SimpleXML inkluderer innebygd XPath-støtte. Finn alle gjenstander :

inkludere "example.php";

$ filmer = nytt SimpleXMLElement ($ xmlstr);

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

"// "fungerer som en mal. For å spesifisere en absolutt bane, utelate en av skråstrekene.

Resultatet av dette eksemplet:

Ms. Coder spilt av Onlivia Actora Mr. Coder spilt av El ActÓr

Eksempel # 9 Innstillingsverdier

Data i SimpleXML trenger ikke å være uforanderlig. Objektet lar deg manipulere alle elementer.

inkludere "example.php";
$ filmer = nytt SimpleXMLElement ($ xmlstr);

$ filmer -> film [0] -> tegn -> karakter [0] -> navn = "Frøken Koder";

echo $ filmer -> asXML ();
?>

Resultatet av dette eksemplet:

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

Eksempel # 10 Legge til elementer og attributter

Siden PHP 5.1.3 har SimpleXML muligheten til å enkelt legge til underordnede elementer og attributter.

inkludere "example.php";
$ filmer = nytt SimpleXMLElement ($ xmlstr);

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

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

echo $ filmer -> asXML ();
?>

Resultatet av dette eksemplet:

Ms. Koder Onlivia Actora MR. Koder El ActÓr MR. ParserJohn Doe Så det er et språk. Det er fortsatt et programmeringsspråk. Eller er det et skriptspråk? Alt avsløres i denne skrekklignende dokumentaren. PHP løser alle mine weboppgaver 7 5 PG

Eksempel # 11 Interaksjon med DOM

PHP kan konvertere XML-noder fra SimpleXML til DOM-format og omvendt. Dette eksemplet viser hvordan du kan endre et DOM-element i SimpleXML.

$ dom = nytt DOMDocument;
$ dom -> loadXML ( "" );
hvis (! $ dom) (
ekko "Det oppstod en feil under parsing av dokumentet";
exit;
}

$ bøker = simplexml_import_dom ($ dom);

echo $ bøker -> bok [0] -> tittel;
?>

Resultatet av dette eksemplet:

4 år siden

Det er et vanlig "triks" som ofte foreslås for å konvertere et SimpleXML-objekt til en matrise, ved å kjøre det gjennom json_encode () og deretter json_decode (). Jeg vil gjerne forklare hvorfor dette er en dårlig idé.

Enkelt sagt fordi hele poenget med SimpleXML er å være enklere å bruke og kraftigere enn en vanlig array. Du kan for eksempel skrivebar -> baz ["bing"]?> og det betyr det samme sombar [0] -> baz [0] ["bing"]?>, uavhengig av hvor mange bar eller baz-elementer det er i XML; og hvis du skriverbar [0] -> baz [0]?> får du alt strenginnholdet til den noden - inkludert CDATA-seksjoner - uavhengig av om den også har underordnede elementer eller attributter. Du har også tilgang til navneromsinformasjon, muligheten til å gjøre enkle redigeringer av XML, og til og med muligheten til å "importere" til et DOM-objekt, for mye kraftigere manipulasjon. Alt dette går tapt ved å gjøre objektet om til en array i stedet for å lese og forstå eksemplene på denne siden.

I tillegg, fordi den ikke er designet for dette formålet, vil konverteringen til JSON og tilbake faktisk miste informasjon i enkelte situasjoner. For eksempel vil alle elementer eller attributter i et navneområde ganske enkelt bli forkastet, og alt tekstinnhold vil bli forkastet hvis et element også har underordnede eller attributter. Noen ganger spiller dette ingen rolle, men hvis du har for vane å konvertere alt til arrays, kommer det til å svi deg til slutt.

Selvfølgelig kan du skrive en smartere konvertering, som "ikke hadde disse begrensningene, men på det tidspunktet får du ingen verdi ut av SimpleXML i det hele tatt, og bør bare bruke XML Parser-funksjonene på lavere nivå, eller XMLReader-klassen, for å lage din struktur. Du vil fortsatt "ikke ha den ekstra bekvemmelighetsfunksjonen til SimpleXML, men det" er ditt tap.

2 år siden

Hvis xml-strengen din inneholder booleaner kodet med "0" og "1", vil du få problemer når du caster elementet direkte til bool:

$ xmlstr =<<

1
0

XML;
$ verdier = nytt SimpleXMLElement ($ xmlstr);
$ truevalue = (bool) $ values-> truevalue; // sant
$ falsevalue = (bool) $ values-> falsevalue; // også sant!!!

I stedet må du kaste til streng eller int først:

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

9 år siden

Hvis du trenger å skrive ut gyldig xml i svaret ditt, ikke glem å sette overskriftens innholdstype til xml i tillegg til å gjengi resultatet av asXML ():

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

// output xml i svaret ditt:
header ("Innholdstype: tekst / xml");
echo $ xml -> asXML ();
?>

9 år siden

Fra README-filen:

SimpleXML er ment å være en enkel måte å få tilgang til XML-data.

SimpleXML-objekter følger fire grunnleggende regler:

1) egenskaper angir element-iteratorer
2) numeriske indekser angir elementer
3) ikke-numeriske indekser angir attributter
4) strengkonvertering lar deg få tilgang til TEKST-data

Når du itererer egenskaper, itererer utvidelsen alltid over
alle noder med det elementnavnet. Slik metode barn () må være
kalt til å iterere over subnoder. Men gjør også følgende:
foreach ($ obj-> node_name som $ elem) (
// gjør noe med $ elem
}
resulterer alltid i iterasjon av "node_name"-elementer. Så ikke lenger
sjekk er nødvendig for å skille antall noder av den typen.

Når et element får tilgang til TEXT-data via en egenskap
da inkluderer ikke resultatet TEXT-dataene til underelementene.

Kjente problemer
============

På grunn av motorproblemer er det foreløpig ikke mulig å få tilgang
et underelement ved indeks 0: $ objekt-> egenskap.

8 år siden

Å bruke ting som: is_object ($ xml-> modul-> admin) for å sjekke om det faktisk er en node kalt "admin", ser ikke ut til å fungere som forventet, siden simplexml alltid returnerer et objekt - i så fall en tom en - selv om en bestemt node ikke eksisterer.
For meg ser den gode gamle tomme () funksjonen ut til å fungere helt fint i slike tilfeller.

8 år siden

Et raskt tips om xpath-spørringer og standard navneområder. Det ser ut som XML-systemet bak SimpleXML fungerer på samme måte som jeg tror XML-systemet .NET bruker: når man trenger å adressere noe i standardnavneområdet, må man deklarere navneområdet ved å bruke registerXPathNamespace og deretter bruke prefikset til adresse ellers i standard navneområde levende element.

$ streng =<<


Joe
Jane

Jeg vet at "svaret er - men hva" er spørsmå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 hevder å kunne itereres, ser det ikke ut til at det implementerer standard Iterator-grensesnittfunksjoner som :: neste og :: tilbakestilles på riktig måte. Mens foreach () fungerer, ser det ikke ut til at funksjoner som neste (), gjeldende () eller hver () fungerer som du forventer - pekeren ser aldri ut til å bevege seg eller blir stadig tilbakestilt.

6 år siden

Hvis kodingen av XML-dokumentet er forskjellig fra UTF-8, må kodingserklæringen følge umiddelbart etter versjon = "..." og før frittstående = "...". Dette er et krav i XML-standarden.

Hvis koding av XML-dokument er forskjellig fra UTF-8. Kodingserklæringen bør følge umiddelbart etter versjonen = "..." og før frittstående = "...". Dette kravet er standard XML.

Ok

Russisk språk. russisk språk


Fatal feil: Uoppdaget unntak "Unntak" med meldingen "Strengen kunne ikke analyseres som XML" i ...

Extensible Markup Language XML er et sett med regler for koding av dokumenter i maskinlesbar form. XML er et populært format for utveksling av data på Internett. Nettsteder som ofte oppdaterer innholdet, for eksempel nyhetssider eller blogger, tilbyr ofte en XML-feed for å holde eksterne programmer oppmerksomme på innholdsendringer. Sende og analysere XML-data er en vanlig oppgave for nettverksapplikasjoner. Denne leksjonen forklarer hvordan du analyserer XML-dokumenter og bruker dataene deres.

Velge en parser

Kanalanalyse

Det første trinnet i å analysere en feed er å bestemme hvilke datafelt du er interessert i. Parseren trekker ut de angitte feltene og ignorerer alt annet.

Her er en feedkodebit som vil bli utforsket i eksempelapplikasjonen. Hvert innlegg på StackOverflow.com vises i feeden som en oppføringskode som inneholder flere nestede tagger:

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

Eksempelappen trekker ut data fra oppføringstaggen og dens undertagger tittel, lenke og sammendrag.

Instantiering av parseren

Det neste trinnet er å instansiere parseren og starte parsingsprosessen. Denne kodebiten initialiserer parseren slik at den ikke håndterer navneområder og bruker den oppgitte InputStream som input. Parseprosessen startes ved å kalle nextTag () og kaller opp readFeed ()-metoden, som henter og behandler dataene applikasjonen er interessert i:

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

Trekk fra kanal

ReadFeed ()-metoden gjør selve arbeidet med å håndtere feeden. Elementer merket med «entry»-taggen er utgangspunktet for rekursiv kanalbehandling. Hvis den neste etiketten ikke er en inngangsetikett, hoppes den over. Etter at hele feeden har blitt rekursivt behandlet, returnerer readFeed () en liste som inneholder oppføringene (inkludert nestede dataelementer) som er hentet fra feeden. Denne listen returneres deretter av parseren.

Private List readFeed (XmlPullParser parser) kaster XmlPullParserException, IOException (List entries = new ArrayList (); parser.require (XmlPullParser.START_TAG, ns, "feed"); while (parser.next ()! = XmlPullPull.Pull. getEventType ()! = XmlPullParser.START_TAG) (fortsett;) Strengnavn = parser.getName (); // Starter med å se etter oppføringskoden if (name.equals ("entry")) (entries.add ( readEntry (parser) ));) else (hopp over (parser);)) returner oppføringer;)

Parsing XML

Trinnene for å analysere en XML-feed er som følger:

Dette utdraget viser hvordan parseren analyserer oppføring, tittel, kobling og sammendrag.

Offentlig statisk klasseoppføring (offentlig endelig strengtittel; offentlig endelig strenglenke; offentlig endelig strengsammendrag; privat oppføring (strengtittel, strengsammendrag, strenglenke) (this.title = tittel; this.summary = sammendrag; this.link = lenke ;)) // Analyserer innholdet i en oppføring. Hvis den støter på en tittel, et sammendrag eller en lenkekode, overlater du dem // til deres respektive "lese"-metoder for behandling. Ellers hopper du over taggen. 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) (fortsett;) String name = parser.getName (); if (name.equals ("title")) (title = readTitle (parser) ;) else if (name.equals ("sammendrag")) (summary = readSummary (parser);) else if (name.equals ("link")) (link = readLink (parser);) else (hopp over (parser) ;)) returner ny oppføring (tittel, sammendrag, lenke);) // Behandler tittelkoder i feeden. 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 lenketagger i feeden. 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 sammendragstagger i feeden. private String readSummary (XmlPullParser-parser) kaster IOException, XmlPullParserException (parser.require (XmlPullParser.START_TAG, ns, "summary"); String summary = readText (parser); parser.require (XmlPullParser summary; "return_TAG summary"); ) // For taggenes tittel og sammendrag, trekker ut tekstverdiene deres. private String readText (XmlPullParser parser) kaster IOException, XmlPullParserException (String result = ""; if (parser.next () == XmlPullParser.TEXT) (result = parser.getText (); parser.nextTag ();) return result; ) ...)

Hopp over elementer du ikke trenger

I et av XML-parsingstrinnene beskrevet ovenfor, hopper parseren over tagger som vi ikke er interessert i. Nedenfor er koden til skip ()-metodeparseren:

Privat void-hopp (XmlPullParser-parser) kaster XmlPullParserException, IOException (if (parser.getEventType ()! = XmlPullParser.START_TAG) (kast ny IllegalStateException ();) int dybde = 1; while (depth! = (0) neste ()) (case XmlPullParser.END_TAG: depth--; break; case XmlPullParser.START_TAG: depth ++; break;)))

Slik fungerer det:

• Metoden gir et unntak hvis den gjeldende hendelsen ikke er START_TAG.
• Den bruker START_TAG og alle hendelser opp til END_TAG.
• For å være sikker på at den stopper ved riktig END_TAG og ikke det første møtemerket etter den opprinnelige START_TAG, holder den styr på hekkedybden.

Derfor, hvis det gjeldende elementet har nestede elementer, vil ikke dybdeverdien være 0 før parseren har behandlet alle hendelser mellom den opprinnelige START_TAG og dens tilsvarende END_TAG. Tenk for eksempel på hvordan analysatoren bommer et element som har 2 nestede elementer, og :

• I den første passeringen gjennom while-løkken, den neste taggen som analysatoren møter etter dette er START_TAG for
• I den andre passeringen gjennom while-løkken er den neste taggen som analysatoren møter END_TAG
• I den tredje passeringen gjennom while-løkken er den neste taggen som analysatoren møter START_TAG ... Dybdeverdien økes til 2.
• I den fjerde passeringen gjennom while-løkken er den neste taggen som analysatoren møter END_TAG... Dybdeverdien synker til 1.
• På den femte og siste passeringen gjennom while-løkken er den neste taggen som analysatoren møter END_TAG... Dybden reduseres til 0, noe som indikerer det elementet ble hoppet over.

XML databehandling

Eksempelapplikasjonen mottar og analyserer en XML-feed til en AsyncTask. Behandlingen gjøres utenfor hovedgrensesnitttråden. Når behandlingen er fullført, oppdaterer applikasjonen brukergrensesnittet i hovedaktiviteten (NetworkActivity).

I utdraget nedenfor gjør loadPage ()-metoden følgende:

• Initialiserer en strengvariabel med en URL-verdi som peker til en XML-feed.
• Hvis brukerinnstillinger og nettverkstilkobling tillater det, kaller nye DownloadXmlTask ​​(). Kjør (url). Dette oppretter et nytt DownloadXmlTask-objekt (AsyncTask-underklasse) og utfører dens execute ()-metode, som laster ned og analyserer kanalen og returnerer et strengresultat som vil vises i brukergrensesnittet.

• doInBackground () utfører loadXmlFromNetwork ()-metoden. Den sender URL-en til kanalen som en parameter. loadXmlFromNetwork ()-metoden mottar og behandler kanalen. Når den er ferdig med behandlingen, sender den tilbake den resulterende strengen.
• onPostExecute () tar den returnerte strengen og viser den i brukergrensesnittet.