అనేక అనువర్తనాలకు వెన్నుముక ఒక సాధారణ పని XML ఫైళ్లు అన్వయించడం సామర్ధ్యం. మరియు, అదృష్టవశాత్తూ, Xcode ఆబ్జెక్టివ్- C లో ఒక XML ఫైల్ను అన్వయించడం చాలా సులభం.
ఒక XML ఫైల్ ఒక వెబ్సైట్ కోసం RSS ఫీడ్కు మీ అనువర్తనం గురించి ప్రాథమిక డేటా నుండి ఏదైనా కలిగి ఉండవచ్చు. అవి మీ అనువర్తనం లోపల రిమోట్ విధానంలో సమాచారాన్ని నవీకరించుటకు గొప్ప మార్గం. అందువల్ల జాబితాలో కొత్త ఐటెమ్ను జోడించడానికి ఆపిల్కు కొత్త బైనరీని సమర్పించాల్సిన అవసరాన్ని తప్పించుకుంటుంది.
కాబట్టి Xcode లో మనము XML ఫైళ్ళను ఎలా ప్రాసెస్ చేద్దాము? ఈ ప్రక్రియలో వేరియబుల్స్ను ప్రారంభించటానికి దశలను కలిగి ఉంది, XML పార్సర్ ప్రాసెస్ను ప్రారంభించి, ఆ ప్రక్రియను ఒక ఫైల్, ఒక మూలకం యొక్క ప్రారంభము, మూలకం లోపల అక్షరాలు (విలువ) ఒక వ్యక్తి మూలకం ముగింపు, మరియు పార్సింగ్ ప్రక్రియ యొక్క ముగింపు.
ఈ ఉదాహరణలో, మేము ఒక నిర్దిష్ట వెబ్ చిరునామా ( URL ) ను దాటడం ద్వారా ఇంటర్నెట్ నుండి ఫైల్ను పార్సింగ్ చేస్తాము.
మనము హెడర్ ఫైల్ ను నిర్మించటం మొదలు పెడతాము. మా ఫైల్ను అన్వయించడం కోసం కనీస అవసరాలతో ఒక డెవలప్ట్ వ్యూ కంట్రోలర్ కోసం చాలా ప్రాథమిక శీర్షిక ఫైల్ యొక్క ఉదాహరణ:
@ ఇంటర్ఫేస్ RootViewController: UITableViewController {
వివరాలువీక్షణా కంట్రోలర్ * వివరాలు ViewController;
NSXMLParser * rssParser;
NSMutableArray * కథనాలు;
NSMutableDictionary * అంశం;
NSString * ప్రస్తుత ఎలిమెంట్;
NSMutableString * ElementValue;
BOOL లోపం పార్సింగ్;
}
@ ప్రాపర్టీ (nonatomic, నిలుపు) IBOutlet వివరాలు ViewController * detailViewController;
- (శూన్యమైన) parseXMLFileAtURL: (NSString *) URL;
ParseXMLFileAtURL ఫంక్షన్ మాకు ప్రక్రియ ప్రారంభమవుతుంది. ఇది ముగిసినప్పుడు, NSMutableArray "వ్యాసాలు" మా డేటాను కలిగి ఉంటుంది. శ్రేణి XML ఫైల్లో ఫీల్డ్ పేర్లకు సంబంధించిన కీలతో mutable నిఘంటువులు రూపొందించబడింది.
ఇప్పుడు మనకు అవసరమైన వేరియబుల్స్ ను సెటప్ చేసాము, మేము .m ఫైల్లోని ప్రక్రియ యొక్క సమావేశానికి వెళ్తాము:
- (శూన్యమైన) parserDidStartDocument: (NSXML పార్సర్ *) పార్సర్ {
NSLog (@ "ఫైల్ దొరకలేదు మరియు పార్సింగ్ ప్రారంభమైంది");
}
ఈ ఫంక్షన్ ప్రక్రియ ప్రారంభంలో నడుస్తుంది. ఈ ఫంక్షన్ లో దేనిని పెట్టవలసిన అవసరం లేదు, కానీ ఫైల్ పార్సప్ చేయబడినప్పుడు మీరు ఒక పనిని చేయాలనుకుంటే, ఇది మీ కోడ్ను ఎక్కడ ఉంచాలో ఉంటుంది.
- (శూన్యమైన) parseXMLFileAtURL: (NSString *) URL
{
NSString * agentString = @ "Mozilla / 5.0 (Macintosh; U; Intel Mac OS X 10_5_6; en-us) AppleWebKit / 525.27.1 (KHTML, జిక్కో వంటి) వెర్షన్ / 3.2.1 సఫారి / 525.27.1";
NSMutableURLRequest * request = [NSMutableURLRequest requestWithURL:
[NSURL URLWithString: URL]];
[అభ్యర్థన setValue: agentString forHTTpheaderField: @ "వాడుకరి ఏజెంట్"];
xmlFile = [NSURL కనెక్షన్ పంపండి SynchronousRequest: అభ్యర్ధన తిరిగి రావడంవల్ల ప్రతిస్పందన: nil లోపం: nil];
వ్యాసాలు = [[NSMutableArray alloc] init];
errorParsing = NO;
rssParser = [[NSXML పార్సర్ కేటాయింపు] initWithData: xmlFile];
[rssParser setDelegate: self];
మీరు పార్సింగ్ చేస్తున్న XML ఫైల్ రకాన్ని బట్టి వీటిలో కొన్నింటిని మీరు తిరగండి
[rssParser setShouldProcessNamespaces: NO];
[rssParser setShouldReportNamespacePrefixes: NO];
[rssParser setShouldResolveExternalEntities: NO];
[rssParser parse];
}
ఈ ఫంక్షన్ ఒక నిర్దిష్ట వెబ్ చిరునామా (URL) వద్ద ఒక ఫైల్ను డౌన్లోడ్ చేయడానికి ఇంజిన్ను నిర్దేశిస్తుంది మరియు దానిని అన్వయించడం కోసం ప్రక్రియను ప్రారంభించండి.
సర్వర్ ఒక మొబైల్ సంస్కరణకు ఐఫోన్ / ఐప్యాడ్ను మళ్ళించటానికి ప్రయత్నించినప్పుడు మేము Mac లో నడుస్తున్న సఫారి అని రిమోట్ సర్వర్కు చెబుతున్నాము.
చివరలో ఉన్న ఎంపికలు కొన్ని XML ఫైల్స్కు ప్రత్యేకమైనవి. చాలా RSS ఫైళ్లు మరియు జెనరిక్ XML ఫైల్స్ వాటిని ఆన్ చేయడం అవసరం లేదు.
- (శూన్యమైన) పార్సర్: (NSXML పార్సర్ *) పార్సర్ పార్సెర్ఆర్ఆర్ఆర్ఆర్ఆర్ఆర్: (NSERror *) parseError {
NSString * errorString = [NSStting stringWithFormat: @ "లోపం కోడ్% i", [parseError code];
NSLog (@ "XML అన్వయించడంలో లోపం:% @", errorString);
errorParsing = YES;
}
ఇది ఒక దోషాన్ని ఎదుర్కొంటున్నట్లయితే ఒక సాధారణ విలువను తనిఖీ చేస్తోంది, అది బైనరీ విలువను సెట్ చేస్తుంది. మీరు ఏమి చేస్తున్నారో దానిపై ఆధారపడి ఇక్కడ మరింత ప్రత్యేకమైనది అవసరం కావచ్చు. లోపం విషయంలో ప్రాసెస్ చేసిన తర్వాత మీరు కొన్ని కోడ్ను అమలు చేస్తే, ఆ సమయంలో లోపలి పార్సరీ బైనరీ వేరియబుల్ని పిలుస్తారు.
- (NSSXMLParser *) పార్సెర్ didStartElement: (NSString *) elementName namespaceURI: (NSString *) namespaceURI అర్హత Name: (NSString *) qName attributes: (NSDictionary *) attributeDict {
currentElement = [elementName copy];
ElementValue = [[NSMutableString alloc] init];
([elementName isEqualToString: @ "అంశం"]) {
item = [[NSMutableDictionary alloc] init];
}
}
XML పార్సర్ యొక్క మాంసం మూడు విధులను కలిగి ఉంటుంది, ఇది ఒక వ్యక్తి మూలకం ప్రారంభంలో నడుస్తుంది, ఇది మూలకం పార్సింగ్ మధ్యలో నడుస్తుంది, మరియు మూలకం చివరిలో నడుస్తుంది.
ఈ ఉదాహరణ కోసం, మన XML ఫైల్లో "అంశాలను" శీర్షిక కింద ఉన్న సమూహాలకు విచ్ఛిన్నమయ్యే RSS ఫైల్స్ వలె ఒక ఫైల్ను పార్సింగ్ చేస్తాము. ప్రాసెసింగ్ ప్రారంభంలో, మేము మూలకం పేరు "అంశం" కోసం తనిఖీ చేస్తున్నాము మరియు ఒక కొత్త సమూహం కనుగొనబడినప్పుడు మా ఐటమ్ నిఘంటువుని కేటాయిస్తుంది. లేకపోతే, మేము విలువ కోసం మా వేరియబుల్ ప్రారంభించడం.
- (శూన్యమైన) పార్సర్: (NSXML పార్సర్ *) పార్సర్ కనుగొనబడింది. పాత్రలు: (NSString *) స్ట్రింగ్ {
[ElementValue appendString: స్ట్రింగ్];
}
ఈ సులభమైన భాగం. మేము అక్షరాలు చూసినప్పుడు, మేము వాటిని మా వేరియబుల్ "ElementValue" కి జోడించండి.
- (శూన్యమైన) పార్సర్: (NSXMLParser *) పార్సర్ didEndElement: (NSString *) మూలకంపేరు namespaceURI: (NSString *) namespaceURI అర్హత Name: (NSString *) qName {
([elementName isEqualToString: @ "అంశం"]) {
[వ్యాసాలు addObject: [అంశం కాపీ]];
} else {
[అంశం setObject: ElementValue forKey: elementName];
}
}
మేము ఒక మూలకాన్ని ప్రాసెస్ చేస్తున్నప్పుడు, రెండు విషయాలలో ఒకటి చేయవలసి ఉంటుంది: (1) అంశ అంశం "అంశం" అయితే, మేము మా గుంపును పూర్తి చేశాము, కాబట్టి మన నిఘంటువును " ".
లేదా (2) మూలకం "ఐటెమ్" కానట్లయితే, మూలకం పేరుతో సరిపోయే కీతో మన నిఘంటువులో విలువను సెట్ చేస్తాము. (దీని అర్ధం మేము XML ఫైల్లోని ప్రతి మైదానంలో ఒక వ్యక్తి వేరియబుల్ అవసరం లేదు, వాటిని మనం మరికొన్ని డైనమిక్గా ప్రాసెస్ చేయవచ్చు.)
- (శూన్యమైన) parserDidEndDocument: (NSXML పార్సర్ *) పార్సర్ {
ఉంటే (లోపం పార్సింగు == NO)
{
NSLog (@ "XML ప్రాసెసింగ్ పూర్తయింది!");
} else {
NSLog (@ "XML ప్రాసెసింగ్ సమయంలో లోపం ఏర్పడింది");
}
}
ఈ మా పార్సింగ్ సాధారణ అవసరమైన చివరి ఫంక్షన్. ఇది కేవలం పత్రాన్ని ముగుస్తుంది. మీరు ప్రక్రియను పూర్తి చేయాలని కోరుకునే ఏ కోడ్ అయినా లేదా ఏదైనా ప్రత్యేకమైన లోపంలో మీరు చేయాలనుకోవచ్చు.
అనేక అనువర్తనాలు ఇక్కడ చేయాలనుకునే ఒక విషయం, డేటా మరియు / లేదా XML ఫైల్ పరికరంలోని ఫైల్కు సేవ్ చేయడం. ఆ విధంగా, వారు ఇంటర్నెట్ను తదుపరిసారి లోడ్ చేస్తే వారు ఇంటర్నెట్కు కనెక్ట్ చేయకపోతే, వారు ఇప్పటికీ ఈ సమాచారాన్ని పొందగలరు.
వాస్తవానికి, అతి ముఖ్యమైన భాగాన్ని మేము మర్చిపోలేము: ఫైల్ను అన్వయించడం కోసం మీ దరఖాస్తును చెప్పడం (దాన్ని కనుగొనడానికి ఒక వెబ్ చిరునామాను ఇవ్వడం!).
ప్రక్రియను ప్రారంభించడానికి, మీరు XML ప్రాసెసింగ్ చేయాలనుకునే సరైన స్థలానికి ఈ కోడ్ కోడ్ను మీరు జోడించాలి:
[స్వీయ parseXMLFileAtURL: @ "http://www.webaddress.com/file.xml"];