Pangunahing paggamit ng SimpleXML. Pag-parse ng XML Data Halimbawa #5 Paggamit ng Mga Katangian

Kaya, sa mga bahagi ayon sa gusto mo, maaari kang magpadala ng isang malaking file sa processor.

Ngayon tingnan natin kung paano pinoproseso ang data na ito at kung paano ito makukuha.

Magsimula tayo sa pambungad na tag function startElement ($parser, $name, $attrs)
Ipagpalagay natin na ang pagpoproseso ay umabot na sa linya
< ingredient amount = "3" unit = "стакан" >harina
Pagkatapos sa loob ng function ang variable na $name ay magiging katumbas ng sangkap ibig sabihin, ang pangalan ng bukas na tag (hindi pa ito sumasara sa tag).
Gayundin sa kasong ito, isang hanay ng mga katangian ng tag na ito na $attrs ay magiging available, na maglalaman ng data halaga = "3" at unit = "salamin".

Pagkatapos nito, ang data ng bukas na tag ay naproseso ng function data ($parser, $data)
Ang variable na $data ay maglalaman ng lahat ng nasa pagitan ng pambungad at pagsasara ng mga tag, sa aming kaso ito ang tekstong Muka

At ang pagproseso ng aming string sa pamamagitan ng function ay nagtatapos endElement ($parser, $name)
Ito ang pangalan ng closed tag, sa aming kaso $name ay magiging katumbas ng sangkap

At pagkatapos noon ang lahat ay naglibot muli.

Ang halimbawa sa itaas ay nagpapakita lamang ng prinsipyo ng pagpoproseso ng XML, ngunit para sa tunay na aplikasyon kailangan itong baguhin.
Karaniwan, kailangan mong i-parse ang malaking XML upang maipasok ang data sa database, at para maayos na maproseso ang data na kailangan mong malaman kung aling bukas na tag ang data kabilang, kung anong antas ng tag nesting, at kung aling mga tag ang bukas sa hierarchy sa itaas. Gamit ang impormasyong ito, maaari mong iproseso nang tama ang file nang walang anumang mga problema.
Para magawa ito, kailangan mong magpakilala ng ilang pandaigdigang variable na mangongolekta ng impormasyon tungkol sa mga bukas na tag, nesting at data.
Narito ang isang halimbawa na maaari mong gamitin

Function webi_xml ($file)
{
pandaigdigang $webi_depth ; // counter para subaybayan ang lalim ng nesting
$webi_depth = 0 ;
pandaigdigang $webi_tag_open ; // ay maglalaman ng hanay ng mga kasalukuyang bukas na tag
$webi_tag_open = array();
pandaigdigang $webi_data_temp ; // ang array na ito ay maglalaman ng data ng isang tag

####################################################
### function ng data
data ng function ($parser, $data)
{
global $webi_depth ;
pandaigdigang $webi_tag_open ;
pandaigdigang $webi_data_temp ;
// magdagdag ng data sa array na nagpapahiwatig ng nesting at kasalukuyang bukas na tag
$webi_data_temp [ $webi_depth ][ $webi_tag_open [ $webi_depth ]][ "data" ].= $data ;
}
############################################

####################################################
### opening tag function
function startElement ($parser, $name, $attrs)
{
global $webi_depth ;
pandaigdigang $webi_tag_open ;
pandaigdigang $webi_data_temp ;

// kung hindi na zero ang nesting level, bukas na ang isang tag
// at ang data mula dito ay nasa array na, maaari mo itong iproseso
kung ($webi_depth)
{

" ;

print"
" ;
print_r($webi_tag_open); // hanay ng mga bukas na tag
print"

// pagkatapos iproseso ang data, tanggalin ito upang magbakante ng memorya
unset($GLOBALS [ "webi_data_temp" ][ $webi_depth ]);
}

// ngayon ang susunod na tag ay binuksan at ang karagdagang pagproseso ay magaganap sa susunod na hakbang
$webi_depth++; // dagdagan ang pugad

$webi_tag_open [ $webi_depth ]= $name ; // magdagdag ng bukas na tag sa hanay ng impormasyon
$webi_data_temp [ $webi_depth ][ $name ][ "attrs" ]= $attrs ; // ngayon magdagdag ng mga katangian ng tag

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

#################################################
## closing tag function
function endElement ($parser, $name) (
global $webi_depth ;
pandaigdigang $webi_tag_open ;
pandaigdigang $webi_data_temp ;

// Nagsisimula ang pagproseso ng data dito, halimbawa pagdaragdag sa database, pag-save sa isang file, atbp.
// Ang $webi_tag_open ay naglalaman ng isang hanay ng mga bukas na tag ayon sa antas ng nesting
// halimbawa $webi_tag_open[$webi_depth] ay naglalaman ng pangalan ng bukas na tag na ang impormasyon ay kasalukuyang pinoproseso
// $webi_depth tag nesting level
// $webi_data_temp[$webi_depth][$webi_tag_open[$webi_depth]]["attrs"] hanay ng mga attribute ng tag
// $webi_data_temp[$webi_depth][$webi_tag_open[$webi_depth]]["data"] data ng tag

I-print ang "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"

Unset($GLOBALS [ "webi_data_temp" ]); // pagkatapos iproseso ang data, tatanggalin namin ang buong array na may data, dahil sarado ang tag
unset($GLOBALS [ "webi_tag_open" ][ $webi_depth ]); // tanggalin ang impormasyon tungkol sa bukas na tag na ito... mula noong nagsara ito

$webi_depth --; // bawasan ang nesting
}
############################################

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

// ipahiwatig kung aling mga function ang gagana kapag binubuksan at isinasara ang mga tag
xml_set_element_handler($xml_parser, "startElement", "endElement");

// tukuyin ang isang function para sa pagtatrabaho sa data
xml_set_character_data_handler($xml_parser, "data");

// buksan ang file
$fp = fopen($file, "r");

$perviy_vxod = 1 ; // flag para suriin ang unang entry sa file
$data = "" ; // dito kinokolekta namin ang data mula sa file sa mga bahagi at ipadala ito sa xml parser

// loop hanggang sa dulo ng file ay matagpuan
habang (! feof ($fp ) at $fp )
{
$simvol = fgetc ($fp); // basahin ang isang character mula sa file
$data .= $simvol ; // idagdag ang character na ito sa data na ipapadala

// kung ang character ay hindi ang end tag, pagkatapos ay bumalik sa simula ng loop at magdagdag ng isa pang character sa data, at iba pa hanggang sa makita ang end tag
if($simvol != ">") ( continue;)
// kung natagpuan ang pansarang tag, ngayon ay ipapadala namin ang nakolektang data na ito para sa pagproseso

// suriin kung ito ang unang entry sa file, pagkatapos ay tatanggalin namin ang lahat na bago ang tag// dahil kung minsan ay maaaring may basura bago ang simula ng XML (mga clumsy na editor, o ang file ay natanggap ng isang script mula sa ibang server)
if($perviy_vxod ) ($data = strstr ($data , "

// ngayon itapon ang data sa xml parser
kung (! xml_parse ($xml_parser, $data, feof ($fp))) (

// dito maaari kang magproseso at makatanggap ng mga error sa validity...
// sa sandaling magkaroon ng error, hihinto ang pag-parse
echo"
XML Error: " . xml_error_string(xml_get_error_code($xml_parser));
echo "sa linya" . xml_get_current_line_number ($xml_parser);
masira;
}

// pagkatapos ng pag-parse, itapon ang nakolektang data para sa susunod na hakbang ng cycle.
$data = "" ;
}
fclose($fp);
xml_parser_free($xml_parser);
// pag-alis ng mga pandaigdigang variable
unset($GLOBALS [ "webi_depth" ]);
unset($GLOBALS [ "webi_tag_open" ]);
unset($GLOBALS [ "webi_data_temp" ]);

Webi_xml("1.xml");

?>

Ang buong halimbawa ay sinamahan ng mga komento, ngayon ay pagsubok at eksperimento.
Mangyaring tandaan na sa pag-andar ng pagtatrabaho sa data, ang data ay hindi lamang ipinasok sa isang array, ngunit sa halip ay idinagdag gamit ang " .=" dahil ang data ay maaaring hindi dumating sa kabuuan nito, at kung gagawa ka lamang ng isang takdang-aralin, pagkatapos ay pana-panahong matatanggap mo ang data sa mga tipak.

Well, iyon lang, ngayon ay may sapat na memorya kapag nagpoproseso ng isang file ng anumang laki, ngunit ang oras ng pagpapatakbo ng script ay maaaring tumaas sa maraming paraan.
Magpasok ng isang function sa simula ng script
set_time_limit(6000);
o
ini_set ("max_execution_time" , "6000" );

O magdagdag ng text sa .htaccess file
php_value max_execution_time 6000

Ang mga halimbawang ito ay magpapataas sa oras ng pagpapatakbo ng script sa 6000 segundo.
Maaari mong dagdagan ang oras sa ganitong paraan lamang kapag naka-off ang safe mode.

Kung mayroon kang access upang i-edit ang php.ini maaari mong dagdagan ang oras sa paggamit
max_execution_time = 6000

Halimbawa, sa Masterhost hosting, sa oras ng pagsulat ng artikulong ito, ang pagtaas ng oras ng script ay ipinagbabawal, sa kabila ng safe mode na naka-off, ngunit kung ikaw ay isang pro, maaari kang gumawa ng iyong sariling PHP build sa Masterhost, ngunit iyon ay wala sa artikulong ito.

Stage 1. Pagpasa sa pagsubok (pakikipag-ugnayan sa GIS GMP test circuit) #GIS GMP test service address:
gisgmp.wsdlLocation=http://213.59.255.182:7777/gateway/services/SID0003663?wsdl
gisgmp.wsdlLocation.endPoint=http://213.59.255.182:7777/gateway/services/SID0003663
Ang address na ito ay nakarehistro sa mga setting ng SP Bilang karagdagan, kailangan mong irehistro ito sa file ng mga setting ng pag-log, na tumutukoy sa halaga TRACE. Matapos ipasok ang tinukoy na mga halaga, kailangan mong simulan ang SP at ang ACC client (i-restart kung ito ay nailunsad na Susunod, mula sa ROR o sa Accounting Office/AU Application para sa pagbabayad ng mga pondo, kailangan mong gawin ang aksyon). "Gumawa ng Impormasyon sa Pagbabayad", kung naipasa ang mga kontrol ng system, malilikha ang Impormasyon tungkol sa pagbabayad. Na sa ibang pagkakataon ay kailangang i-unload.
Pagkatapos mag-upload, kailangan mong suriin ang status gamit ang pagkilos na "Humiling ng katayuan sa pagproseso." Pagkatapos nito ay lumipat ang ED na Impormasyon sa Pagbabayad sa katayuang "Tinanggap ng GIS GMP" -…

Ibinigay: MSG (message) table na may maraming mga entry.
CREATETABLEmsg(idINTEGERNOTNULLPRIMARYKEY,descriptionCHAR(50)NOTNULL, date_createDATE);
Gawain:
Kinakailangang i-clear ang talahanayan ng data/
Solusyon: Mayroong ilang mga paraan upang malutas ang problemang ito. Nasa ibaba ang isang paglalarawan at halimbawa ng bawat isa sa kanila.
Ang pinakamadaling paraan ( unang pagpipilian) - pagpapatupad ng operator ng pagtanggal ng tala. Kapag pinaandar mo ito, makikita mo ang resulta (kung gaano karaming mga tala ang tinanggal). Isang madaling gamiting bagay kapag kailangan mong malaman at maunawaan kung ang tamang data ay tinanggal. NGUNIT may mga disadvantages kumpara sa iba pang mga opsyon para sa paglutas ng problema.

DELETE FROMmsg;--Delete lahat ng row sa table --Tinatanggal ang lahat ng mga hilera na may petsa ng paglikha na "2019.02.01" DELETE FROMmsg WHEREdate_create="2019.02.01";

Pangalawang opsyon. Gamit ang DML statement para i-clear ang lahat ng row sa isang table.
TRUNCATETABLEmsg;
Mayroong ilang mga tampok ng paggamit ng operator na ito:
Wala ito sa Firebird, kaya ginagamit namin ang una at pangatlong opsyon Pagkatapos…

Mga kasalukuyang address para sa mga kahilingan sa SMEV 3.0 Ipinaaalala namin sa iyo na, alinsunod sa naunang na-publish na impormasyon sa SMEV 3.0 Technology Portal, kinakailangang gamitin ang kasalukuyang mga address para sa Unified Electronic Service:
ang address ng pinag-isang elektronikong serbisyo ng kapaligiran ng pag-unlad ng SMEV 3.0, na tumutugma sa scheme 1.1 - http://smev3-d.test.gosuslugi.ru:7500/smev/v1.1/ws?wsdl, at ang serbisyo ay magkakaroon din magagamit sa

Ang XML Extensible Markup Language ay isang hanay ng mga panuntunan para sa pag-encode ng mga dokumento sa form na nababasa ng makina. Ang XML ay isang sikat na format para sa pagpapalitan ng data sa Internet. Ang mga site na madalas na nag-a-update ng kanilang nilalaman, tulad ng mga site ng balita o blog, ay kadalasang nagbibigay ng XML feed upang malaman ng mga panlabas na programa ang mga pagbabago sa nilalaman. Ang pagpapadala at pag-parse ng XML data ay isang karaniwang gawain para sa mga application na konektado sa network. Ipinapaliwanag ng tutorial na ito kung paano i-parse ang mga XML na dokumento at gamitin ang data ng mga ito.

Pagpili ng Parser

Pagsusuri ng channel

Ang unang hakbang sa pag-parse ng feed ay ang magpasya kung aling mga field ng data ang interesado ka. Kinukuha ng parser ang ibinigay na mga patlang at binabalewala ang lahat ng iba pa.

Narito ang isang snippet ng channel na i-explore sa halimbawang application. Ang bawat post sa StackOverflow.com ay lumalabas sa isang feed bilang isang entry tag, na naglalaman ng ilang mga subtag:

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

Kinukuha ng sample na application ang data mula sa entry tag at ang pamagat, link, at buod ng mga subtag nito.

Paglikha ng isang halimbawa ng parser

Ang susunod na hakbang ay i-instantiate ang parser at simulan ang proseso ng pag-parse. Sinisimulan ng snippet na ito ang parser upang hindi mahawakan ang mga namespace at gamitin ang ibinigay na InputStream bilang input. Ang proseso ng pag-parse ay nagsisimula sa isang tawag sa nextTag() at tumatawag sa readFeed() na paraan, na kumukuha at nagpoproseso ng data kung saan interesado ang application:

Pampublikong klase StackOverflowXmlParser ( // Hindi kami gumagamit ng mga namespace na pribadong static na panghuling String ns = null; ang pampublikong List parse(InputStream in) ay naghagis ng XmlPullParserException, IOException ( subukan ( XmlPullParser parser = Xml.newPullParser(); parser.setFeature(CMLESSPullParser(); parser.setFeature(XmlSP_PullNAME) , false); parser.setInput(in, null);

Ibawas ang channel

Ginagawa ng readFeed() na pamamaraan ang aktwal na gawain ng pagproseso ng feed. Ang mga elementong minarkahan ng tag na "entry" ay ang panimulang punto para sa recursive na pagproseso ng channel. Kung ang susunod na tag ay hindi isang entry tag, ito ay nilaktawan. Pagkatapos na muling maproseso ang buong "feed", ang readFeed() ay nagbabalik ng Listahan na naglalaman ng mga entry (kabilang ang mga nested data item) na kinukuha mula sa feed. Ang Listahan na ito ay ibinalik ng parser.

Inihagis ng Pribadong Listahan ang readFeed(XmlPullParser parser) ng XmlPullParserException, IOException ( Mga entry sa listahan = bagong ArrayList (); parser.require(XmlPullParser.START_TAG, ns, "feed"); habang (parser.next() != XmlPullParser.END_TAG) ( kung XmlPullParser.END_TAG) (parser.getEventType() != XmlPullParser.START_TAG) ( continue; ) String name = parser.getName(); // Magsisimula sa pamamagitan ng paghahanap sa entry tag kung (name.equals("entry")) ( entries.add( readEntry(parser) ) else ( skip(parser); ) ) ibalik ang mga entry;

XML parsing

Ang mga hakbang sa pag-parse ng XML feed ay ang mga sumusunod:

Ipinapakita ng snippet na ito kung paano pina-parse ng parser ang entry, pamagat, link, at buod.

Pampublikong static na klase Entry ( pampubliko panghuling String pamagat; pampubliko panghuling String link; pampubliko panghuling String buod; pribadong Entry(String title, String summary, String link) ( this.title = title; this.summary = summary; this.link = link ; ) ) // Pinu-parse ang mga nilalaman ng isang entry. Kung makatagpo ito ng pamagat, buod, o link na tag, ibigay ang mga ito // sa kani-kanilang "basahin" na pamamaraan para sa pagproseso. Kung hindi, laktawan ang tag. private Entry readEntry(XmlPullParser parser) throws XmlPullParserException, IOException ( parser.require(XmlPullParser.START_TAG, ns, "entry"); String title = null; String summary = null; String link = null; while (parser.next() ! = XmlPullParser.END_TAG) ( if (parser.getEventType() != XmlPullParser.START_TAG) ( continue; ) String name = parser.getName(); if (name.equals("title")) ( title = readTitle(parser) ; ) else if (name.equals("summary")) ( summary = readSummary(parser); ) else if (name.equals("link")) ( link = readLink(parser); ) else ( skip(parser) ; ) ) ibalik ang bagong Entry(title, summary, link) // Pinoproseso ang mga title tag sa feed. private String readTitle(XmlPullParser parser) throws IOException, XmlPullParserException ( parser.require(XmlPullParser.START_TAG, ns, "title"); String title = readText(parser); parser.require(XmlPullParser.END_TAG", ns, "title"); return title; ) // Pinoproseso ang mga tag ng link sa feed. private String readLink(XmlPullParser parser) throws IOException, XmlPullParserException ( String link = ""; parser.require(XmlPullParser.START_TAG, ns, "link"); String tag = parser.getName(); String relType = parser.getAttributeValue , "rel"); if (tag.equals("link")) ( if (relType.equals("alternate"))( link = parser.getAttributeValue(null, "href"); parser.nextTag(); ) ) parser.require(XmlPullParser.END_TAG, ns, "link"); private String readSummary(XmlPullParser parser) throws IOException, XmlPullParserException ( parser.require(XmlPullParser.START_TAG, ns, "summary"); String summary = readText(parser); parser.require(XmlPullParser.END_TAG, ns); return summary; ) // Para sa pamagat at buod ng mga tag, kinukuha ang mga halaga ng teksto nito. pribadong String readText(XmlPullParser parser) throws IOException, XmlPullParserException ( String result = ""; kung (parser.next() == XmlPullParser.TEXT) ( result = parser.getText(); parser.nextTag(); ) return result; ) ... )

Nilaktawan ang mga bagay na hindi mo kailangan

Sa isa sa mga hakbang sa pag-parse ng XML na inilarawan sa itaas, nilalaktawan ng parser ang mga tag na hindi kami interesado. Nasa ibaba ang parser code para sa skip() method:

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

Narito kung paano ito gumagana:

• Ang pamamaraan ay nagtatapon ng isang pagbubukod kung ang kasalukuyang kaganapan ay hindi START_TAG .
• Kumokonsumo ito ng START_TAG, at lahat ng kaganapan hanggang END_TAG.
• Upang matiyak na hihinto ito sa tamang END_TAG at hindi sa unang tag pagkatapos ng orihinal na START_TAG, sinusubaybayan nito ang lalim ng nesting.

Kaya, kung ang kasalukuyang elemento ay may mga nested na elemento, ang halaga ng lalim ay hindi magiging 0 hanggang sa maproseso ng parser ang lahat ng mga kaganapan sa pagitan ng orihinal na START_TAG at ang katumbas nitong END_TAG . Halimbawa, isaalang-alang kung paano pumasa ang analyzer isang elemento na mayroong 2 nested na elemento, At :

• Sa unang pagpasa sa while loop, ang susunod na tag na makikita ng analyzer pagkatapos ito ay START_TAG para sa
• Sa pangalawang pagpasa sa while loop, ang susunod na tag na nakatagpo ng analyzer ay END_TAG
• Sa ikatlong pagpasa sa while loop, ang susunod na tag na nakatagpo ng analyzer ay START_TAG . Ang lalim na halaga ay tumaas sa 2.
• Sa ikaapat na pagpasa sa while loop, ang susunod na tag na nakatagpo ng analyzer ay END_TAG. Ang depth value ay binabawasan sa 1.
• Sa ikalima at huling pagpasa sa while loop, ang susunod na tag na makakatagpo ng analyzer ay END_TAG. Ang lalim na halaga ay binabawasan sa 0, na nagpapahiwatig na matagumpay na nalaktawan ang elemento.

Pagproseso ng Data ng XML

Ang sample na application ay tumatanggap at nag-parse ng XML feed sa isang AsyncTask. Nagaganap ang pagproseso sa labas ng pangunahing thread ng UI. Kapag kumpleto na ang pagproseso, ina-update ng application ang user interface sa pangunahing aktibidad (NetworkActivity).

Sa snippet sa ibaba, ang paraan ng loadPage() ay gumagawa ng sumusunod:

• Nagsisimula ng string variable na may URL na tumuturo sa isang XML feed.
• Kung pinapayagan ng mga setting ng user at koneksyon sa network, tatawag ng bagong DownloadXmlTask().execute(url) . Lumilikha ito ng bagong DownloadXmlTask ​​​​object (AsyncTask subclass) at isinasagawa ang execute() na pamamaraan nito, na nagda-download at nag-parse ng pipe at nagbabalik ng string na resulta na ipapakita sa UI.

• Ang doInBackground() ay nagpapatupad ng loadXmlFromNetwork() na pamamaraan. Ipinapasa nito ang URL ng channel bilang isang parameter. Ang paraan ng loadXmlFromNetwork() ay tumatanggap at nagpoproseso ng channel. Kapag natapos na ang pagproseso, ibabalik nito ang resultang string.
• Kinukuha ng onPostExecute() ang ibinalik na string at ipinapakita ito sa UI.