Hur man analyserar XML-filer i Xcode

Även om en inbyggd XML parser lägger till verkligt värde för en ny stationär eller mobil applikation, kodning av funktionalitet kräver vanligtvis mycket utvecklingstid och betatestning. Apples Xcode-program innehåller en XML-parser som kringgår det mesta av detta manuella arbete.

Xcode-processen

Den inbyggda Xcode-processen innehåller steg för att initialisera de variabler som ska användas, starta XML-parserprocessen, mata den processen en fil, bedöma enskilda element och tecken (värde) inom dessa element, känna igen slutet på ett enskilt element och avsluta tolkningen bearbeta.

Använd XML Parser

För att illustrera detaljerna analyserar vi en exempelfil från internet genom att skicka en viss webbadress till den (URL).

Börja med att skapa rubrikfilen. Detta är ett exempel på en mycket grundläggande rubrikfil för en detaljvyskontroll med minimikraven för att analysera vår fil:

@interface RootViewController: UITableViewController {
DetailViewController * detailViewController;
NSXMLParser * rssParser;
NSMutableArray * artiklar;
NSMutableDictionary * objekt;
NSString * currentElement;
NSMutableString * ElementValue;
BOOL errorParsing;
}
@property (nonatomic, retain) IBOutlet DetailViewController * detailViewController;
- (ogiltigt) parseXMLFileAtURL: (NSString *) URL; 

ParseXMLFileAtURL-funktionen startar processen. När den är klar innehåller NSMutableArray-artiklarna data. Matrisen består av förändrade ordböcker med nycklar relaterade till fältnamnen i XML-filen.

Initiera sedan processen:

- (void) parserDidStartDocument: (NSXMLParser *) parser {
NSLog (@ "Fil hittades och tolkning startade");
}

Denna funktion körs i början av processen. Det finns inget behov av att lägga något i den här funktionen, men om du vill utföra en uppgift när filen börjar analyseras, är det här du skulle lägga din kod.

Instruera programmet att ladda ner något

Därefter instruerar du programmet att ladda ner något:

- (ogiltigt) parseXMLFileAtURL: (NSString *) URL
{
NSString * agentString = @ "Mozilla / 5.0 (Macintosh; U; Intel Mac OS X 10_5_6; en-us) AppleWebKit / 525.27.1 (KHTML, som Gecko) Version / 3.2.1 Safari / 525.27.1 ";
NSMutableURLRequest * request = [NSMutableURLRequest requestWithURL:
[NSURL URLWithString: URL]];
[begäran setValue: agentString forHTTPHeaderField: @ "User-Agent"];
xmlFile = [NSURLConnection sendSynchronousRequest: begäran returnResponse: nil error: nil];
artiklar = [[NSMutableArray alloc] init];
errorParsing = NEJ;
rssParser = [[NSXMLParser alloc] initWithData: xmlFile];
[rssParser setDelegate: själv];
// Du kan behöva slå på några av dessa beroende på vilken typ av XML-fil du analyserar
[rssParser setShouldProcessNamespaces: NO];
[rssParser setShouldReportNamespacePrefixes: NO];
[rssParser setShouldResolveExternalEntities: NO];
[rssParser-analys];
}

Denna funktion instruerar motorn att ladda ner en fil till en viss webbadress (URL) och starta processen för att analysera den. Vi säger till fjärrservern att vi är en Safari som körs på Mac för det fall servern försöker omdirigera iPhone / iPad till en mobilversion.

Alternativen i slutet är specifika för vissa XML-filer. De flesta RSS-filer och generiska XML-filer behöver inte aktiveras.

Felkontrollera resultatet

Utför några grundläggande felkontroller av resultatet:

- (void) parser: (NSXMLParser *) parser parseErrorOccurred: (NSError *) parseError {
NSString * errorString = [NSString stringWithFormat: @ "Felkod% i", [parseError-kod]];
NSLog (@ "Fel vid parsning av XML:% @", errorString);
errorParsing = JA;
} Denna felkontrollrutt anger ett binärt värde om det stöter på ett fel. Du kan behöva något mer specifikt här beroende på vad du gör. Om du helt enkelt behöver köra en kod efter bearbetning i händelse av fel, kommer 

Denna rutin för felkontroll ställer in ett binärt värde om det stöter på ett fel. Du kan behöva något mer specifikt här beroende på vad du gör. Om du bara behöver köra lite kod efter bearbetning i händelse av fel kan felanalysering av binär variabel anropas vid den tiden.

Analysera det hämtade innehållet

Därefter bryter programmet ner det hämtade innehållet och analyserar det:

- (void) parser: (NSXMLParser *) parser didStartElement: (NSString *) elementName namespaceURI: (NSString *) namespaceURI kvalificerat namn: (NSString *) qName attribut: (NSDictionary *) attributeDict {
currentElement = [elementName-kopia];
ElementValue = [[NSMutableString alloc] init];
if ([elementName isEqualToString: @ "item"]) {
artikel = [[NSMutableDictionary allokering] init];
}
}

Köttet i XML-parsern innehåller tre funktioner, en som körs i början av en individ element, en som körs under mitten av att analysera elementet, och en som körs i slutet av element.

I det här exemplet analyserar vi en fil som liknar RSS-filer som delar upp element i grupper under rubriken föremål i XML-filen. I början av behandlingen letar vi efter elementnamnet "objekt" och tilldelar vår artikelordbok när en ny grupp upptäcks. Annars initialiserar vi vår variabel för värdet:

- (void) parser: (NSXMLParser *) parser foundCharacters: (NSString *) string {
[ElementValue appendString: string];
}

När vi hittar tecken lägger vi helt enkelt till dem i vår variabel ElementValue:

- (ogiltig) parser: (NSXMLParser *) parser didEndElement: (NSString *) elementName namespaceURI: (NSString *) namespaceURI kvalificerat namn: (NSString *) qName {
if ([elementName isEqualToString: @ "item"]) {
[artiklar addObject: [artikelkopia]];
} annat {
[item setObject: ElementValue forKey: elementName];
}
}

Vad som händer när tolkningen är klar

När programmet har bearbetat ett element måste det göra en av två saker:

• Om slutelementet är Artikel, vi har avslutat vår grupp, så vi lägger till vår ordlista i vårt utbud av artiklar.
• Om elementet inte är det Artikel, ställer vi in ​​värdet i vår ordlista med en nyckel som matchar elementets namn. (Det betyder att vi inte behöver en enskild variabel för varje fält i XML-filen. Vi kan bearbeta dem lite mer dynamiskt.)

Detta är den sista funktionen som behövs för vår tolkningsrutin. det avslutar dokumentet. Sätt en slutlig kod här eller ange en felkorrigerande underrutin:

- (void) parserDidEndDocument: (NSXMLParser *) parser {
if (errorParsing == NO)
{
NSLog (@ "XML-behandling klar!");
} annat {
NSLog (@ "Fel inträffade under XML-bearbetning");
}
}

Spara data

En sak som många appar kanske vill göra här är att spara data eller XML-filen i en fil på enheten. På det sättet, om enheten inte är ansluten till internet nästa gång appen laddas, kan den fortfarande få den här informationen.

Naturligtvis kan vi inte glömma den viktigaste delen: att berätta för din ansökan att analysera filen (och ge den en webbadress för att hitta den på!). För att starta processen, lägg till den här kodraden till rätt plats där du vill göra XML-behandlingen:

 [själv parseXMLFileAtURL: @ " http://www.webaddress.com/file.xml"];