Расширяемый язык разметки XML представляет собой набор правил для кодирования документов в машиночитаемой форме. XML является популярным форматом для обмена данными в Интернете. Сайты, которые часто обновляют свой контент, например, новостные сайты или блоги, часто предоставляют XML канал, чтобы внешние программы были в курсе изменений контента. Отправка и разбор XML-данных является общей задачей для приложений с сетевым подключением. Этот урок объясняет, как выполнить разбор XML документов и использовать их данные.
Выбор синтаксического анализатора
Анализ канала
Первым шагом в разборе канала является решение о том, в какие полях данные вы заинтересованы. Анализатор извлекает заданные поля и игнорирует все остальное.
Вот фрагмент канала, который будет разбираться в примере приложения. Каждый пост на StackOverflow.com появляется в канале, как entry тег, который содержит несколько вложенных тегов:
I have an Application that requires a data file...
Пример приложения извлекает данные из entry тега и его вложенных тегов title , link , и summary .
Создание экземпляра синтаксического анализатора
Следующим шагом является создание экземпляра синтаксического анализатора и запуск процесса разбора. В этом фрагменте анализатор инициализируется так, чтобы не обрабатывать пространства имен, а также использовать предоставленный InputStream в качестве входных данных. Процесс разбора запускается с помощью вызова nextTag() и вызывает readFeed() метод, который извлекает и обрабатывает данные, в которых заинтересовано приложение:
Public class StackOverflowXmlParser { // We don"t use namespaces private static final String ns = null; public List parse(InputStream in) throws XmlPullParserException, IOException { try { XmlPullParser parser = Xml.newPullParser(); parser.setFeature(XmlPullParser.FEATURE_PROCESS_NAMESPACES, false); parser.setInput(in, null); parser.nextTag(); return readFeed(parser); } finally { in.close(); } } ... }
Вычитать канал
readFeed() метод делает фактическую работу по обработке канала. Элементы, помеченные тэгом "entry", являются отправной точкой для рекурсивной обработки канала. Если следующий тег не entry тег, он пропускается. После того, как вся "лента" была рекурсивно обработана, readFeed() возвращает List содержащий записи (в том числе вложенные элементы данных), которые извлекаются из канала. Этот List затем возвращается анализатором.
Private List readFeed(XmlPullParser parser) throws XmlPullParserException, IOException { List entries = new ArrayList (); parser.require(XmlPullParser.START_TAG, ns, "feed"); while (parser.next() != XmlPullParser.END_TAG) { if (parser.getEventType() != XmlPullParser.START_TAG) { continue; } String name = parser.getName(); // Starts by looking for the entry tag if (name.equals("entry")) { entries.add(readEntry(parser)); } else { skip(parser); } } return entries; }
Разбор XML
Шаги для разбора XML канала следующие:
Этот фрагмент показывает, как анализатор анализирует entry, title, link, и summary.
Public static class Entry { public final String title; public final String link; public final String summary; private Entry(String title, String summary, String link) { this.title = title; this.summary = summary; this.link = link; } } // Parses the contents of an entry. If it encounters a title, summary, or link tag, hands them off // to their respective "read" methods for processing. Otherwise, skips the 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); } } return new Entry(title, summary, link); } // Processes title tags in the 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; } // Processes link tags in the 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(null, "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; } // Processes summary tags in the feed. 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, "summary"); return summary; } // For the tags title and summary, extracts their text values. private String readText(XmlPullParser parser) throws IOException, XmlPullParserException { String result = ""; if (parser.next() == XmlPullParser.TEXT) { result = parser.getText(); parser.nextTag(); } return result; } ... }
Пропуск элементов, который вам не нужны
Одним из шагов XML разбора описанном выше, синтаксический анализатор пропускает теги, в которых мы не заинтересованы. Ниже представлен код синтаксического анализатора skip() метода:
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; } } }
Вот как это работает:
- Метод генерирует исключение, если текущее событие не START_TAG .
- Он потребляет START_TAG , и все события, вплоть до END_TAG .
- Чтобы убедиться, что он останавливается на правильном END_TAG , а не на первом встречном теге после оригинального START_TAG , он отслеживает глубину вложенности.
Таким образом, если текущий элемент имеет вложенные элементы, значение depth не будет равно 0 пока анализатор не обработает все события между оригинальным START_TAG и его соответствующим END_TAG . Например, рассмотрим как анализатор пропускает
- В первый проход по while циклу, следующий тег, который анализатор встречает после
это START_TAG для - Во второй проход по while циклу, следующий тег, который встречает анализатор, это END_TAG
- В третий проход по while циклу, следующий тег, который встречает анализатор, это START_TAG
. Значение depth увеличивается до 2. - В четвертый проход по while циклу, следующий тег, который встречает анализатор, это END_TAG . Значение depth уменьшается до 1.
- На пятый и последний проход по while циклу, следующий тег, который встречает анализатор, это END_TAG . Значение depth уменьшается до 0, что указывает на то, что
элемент был успешно пропущен.
Обработка XML данных
Пример приложения получает и анализирует XML канал в AsyncTask . Обработка выполняется вне основного потока пользовательского интерфейса. Когда обработка завершена, приложение обновляет пользовательский интерфейс в основной деятельности(NetworkActivity).
Во фрагменте представленном ниже, loadPage() метод делает следующее:
- Инициализирует строковую переменную значением URL, указывающим на XML канал.
- Если настройки пользователя и подключение к сети позволяют, вызывает new DownloadXmlTask().execute(url) . Это создает новый DownloadXmlTask объект(AsyncTask подкласс) и выполняет его execute() метод, который загружает и анализирует канал и возвращает строковый результат, который будет отображаться в пользовательском интерфейсе.
- doInBackground() выполняет метод loadXmlFromNetwork() . Он передает URL канала в качестве параметра. Метод loadXmlFromNetwork() получает и обрабатывает канал. Когда он заканчивает обработку, он передает обратно результирующую строку.
- onPostExecute() принимает возвращенную строку и отображает её в пользовательском интерфейсе.
Ниже приведен метод loadXmlFromNetwork() , который вызывается из DownloadXmlTask . Он делает следующее:
- Создает экземпляр StackOverflowXmlParser . Он также создает переменные для List Entry объектов(entries), и title , url , и summary , для хранения значений, извлеченных из XML канала, для этих полей.
- Вызывает downloadUrl() , который загружает канал и возвращает его как InputStream .
- Использует StackOverflowXmlParser для разбора InputStream . StackOverflowXmlParser заполняет List entries данными из канала.
- Обрабатывает entries List , и объединяет в себе данные канала с HTML разметкой.
- Возвращает HTML строку, отображаемую в пользовательском интерфейсе главной деятельности, AsyncTask в методе onPostExecute() .
" + getResources().getString(R.string.page_title) + "
"); htmlString.append("" + getResources().getString(R.string.updated) + " " + formatter.format(rightNow.getTime()) + ""); try { stream = downloadUrl(urlString); entries = stackOverflowXmlParser.parse(stream); // Makes sure that the InputStream is closed after the app is // finished using it. } finally { if (stream != null) { stream.close(); } } // StackOverflowXmlParser returns a List (called "entries") of Entry objects. // Each Entry object represents a single post in the XML feed. // This section processes the entries list to combine each entry with HTML markup. // Each entry is displayed in the UI as a link that optionally includes // a text summary. for (Entry entry: entries) { htmlString.append("" + entry.title + "
"); // If the user set the preference to include summary text, // adds it to the display. if (pref) { htmlString.append(entry.summary); } } return htmlString.toString(); } // Given a string representation of a URL, sets up a connection and gets // an input stream. private InputStream downloadUrl(String urlString) throws IOException { URL url = new URL(urlString); HttpURLConnection conn = (HttpURLConnection) url.openConnection(); conn.setReadTimeout(10000 /* milliseconds */); conn.setConnectTimeout(15000 /* milliseconds */); conn.setRequestMethod("GET"); conn.setDoInput(true); // Starts the query conn.connect(); return conn.getInputStream(); }Сейчас мы с вами изучим работу с XML. XML - это формат для обмена данными между сайтами. Он очень похож на HTML, только в XML разрешены свои теги и атрибуты.
Зачем нужен XML при парсинге? Иногда бывает так, что сайт, который вам нужно спарсить, имеет API, с помощью которого можно получить желаемое, особо не напрягаясь. Поэтому сразу совет - перед тем, как парсить сайт, проверьте, нету ли у него API.
Что такое API? Это набор функций, с помощью которых вы можете слать запрос этому сайту и получать нужный ответ. Вот этот ответ чаще всего приходит в формате XML. Поэтому давайте приступим к его изучению.
Работа с XML в PHP
Пусть у вас есть XML. Он может быть в строке, либо хранится в файле или отдаваться по запросу к определенному URL.
Пусть XML хранится в строке. В этом случае из этой строки нужно создать объект с помощью new SimpleXMLElement :
$str = "
Сейчас у нас в переменной $xml хранится объект с разобранным XML. Обращаясь к свойствам этого объекта можно получать доступ с содержимому тегов XML. Как именно - разберем чуть ниже.
Если же XML хранится в файле или отдается по обращению к URL (что чаще всего и бывает), то следует использовать функцию simplexml_load_file , которая делает тот же объект $xml :
$xml = simplexml_load_file(путь к файлу или урл);
Приемы работы
В примерах ниже наш XML хранится в файле или по URL.
Пусть дан следующий XML:
Давайте получим имя, возраст и зарплату работника:
$xml = simplexml_load_file(путь к файлу или урл); echo $xml->name; //выведет "Коля" echo $xml->age; //выведет 25 echo $xml->salary; //выведет 1000
Как вы видите, у объекта $xml есть свойства, соответствующие тегам.
Вы может обратили внимание, что тег
$xml = simplexml_load_file(путь к файлу или урл); echo $xml->name; //выведет "Коля" echo $xml->age; //выведет 25 echo $xml->salary; //выведет 1000
Корневой тег в XML может быть только один, так же, как и тег в обычном HTML.
Давайте чуть модифицируем наш XML:
В этом случае у нас получится цепочка обращений:
$xml = simplexml_load_file(путь к файлу или урл); echo $xml->worker->name; //выведет "Коля" echo $xml->worker->age; //выведет 25 echo $xml->worker->salary; //выведет 1000
Работа с атрибутами
Пусть некоторые данные хранятся в атрибутах:
$xml = simplexml_load_file(путь к файлу или урл); echo $xml->worker["name"]; //выведет "Коля" echo $xml->worker["age"]; //выведет 25 echo $xml->worker["salary"]; //выведет 1000 echo $xml->worker; //выведет "Номер 1"
Теги с дефисами
В XML разрешены теги (и атрибуты) с дефисом. В этом случае обращение к таким тегам происходит так:
$xml = simplexml_load_file(путь к файлу или урл); echo $xml->worker->{first-name}; //выведет "Коля" echo $xml->worker->{last-name}; //выведет "Иванов"
Перебор циклом
Пусть теперь у нас не один работник, а несколько. В этом случае мы можем перебрать наш объект с помощью цикла foreach:
$xml = simplexml_load_file(путь к файлу или урл); foreach ($xml as $worker) { echo $worker->name; //выведет "Коля", "Вася", "Петя" }
Из объекта в нормальный массив
Если вам неудобно работать с объектом, вы можете преобразовать его в нормальный массив PHP с помощью следующего хитрого приема:
$xml = simplexml_load_file(путь к файлу или урл); var_dump(json_decode(json_encode($xml), true));
Больше информации
Парсинг на основе sitemap.xml
Зачастую на сайте есть файл sitemap.xml. В этом файле хранятся ссылки на все страницы сайта для удобства индексации их поисковыми системами (индексация - это по сути и есть парсинг сайта яндексом и гуглом).
В общем-то нас мало должно волновать, зачем нужен этот файл, главное, что если он есть - можно не лазить по страницам сайта какими-либо хитрыми методами, а просто воспользоваться этим файлом.
Как проверить наличие этого файла: пусть мы парсим сайт site.ru, тогда обратитесь в браузере к site.ru/sitemap.xml - если что-то увидите, значит он там есть, а если не увидите - то увы.
Если sitemap есть - то в нем содежатся ссылки на все страницы сайта в формате XML. Спокойно забираете этот XML, парсите его, отделяете ссылки на нужные вам страницы любым удобным вам способом (например, анализом URL, который был описан в методе паука).
В итоге вы получаете список ссылок для парсинга, остается только зайти на них и спарсить нужным вам контент.
Подробнее об устройстве sitemap.xml читайте в википедии .
Что вам делать дальше:
Приступайте к решению задач по следующей ссылке: задачи к уроку .
Когда все решите - переходите к изучению новой темы.
1 этап. Прохождение тестирования(взаимодействие с тестовым контуром ГИС ГМП)
#Адрес сервиса ГИС ГМП тестовый:
gisgmp.wsdlLocation=http://213.59.255.182:7777/gateway/services/SID0003663?wsdl
gisgmp.wsdlLocation.endPoint=http://213.59.255.182:7777/gateway/services/SID0003663
Этот адрес прописывается в настройках СП.Дополнительно требуется прописать в файле настроек логгирования, указав значение
После выгрузки требуется проверить статус действием "Запрос статуса обработки". После чего ЭД Сведение о платеже переходит на статус "Принят ГИС ГМП" -…
Дано:
Таблица MSG (сообщения) с большим количеством записей.
CREATETABLEmsg(idINTEGERNOTNULLPRIMARYKEY,descriptionCHAR(50)NOTNULL,
date_createDATE);
Задача:
Необходимо очистить таблицу от данных/
Решение:
Для решения данной задачи есть несколько способов. Ниже описание и пример каждого из них.
Самый простой способ (первый вариант
) - выполнение оператора удаления записи. При его выполнении вы будете видеть результат (сколько записей удалено). Удобная штука когда необходимо точно знать и понимать правильные ли данные удалены. НО имеет недостатки перед другими вариантами решения поставленной задачи.
DELETE FROMmsg;--Удалит все строки в таблице--Удалит все строки у которых дата создания "2019.02.01" DELETE FROMmsg WHEREdate_create="2019.02.01";
Второй вариант
. Использование оператораDML для очистки всех строк в таблице.
TRUNCATETABLEmsg;
При этом несколько особенностей использования данного оператора:
Его нет в Firebird, поэтому пользуемся первым и третьим вариантом.После выпо…
Актуальные адреса для обращений к ЕСМЭВ 3.0
Напоминаем, что в соответствии с ранее опубликованной информацией на Технологическом портале СМЭВ 3.0 необходимо использовать актуальные адреса размещения Единого электронного сервиса:
адрес единого электронного сервиса среды разработки СМЭВ 3.0, соответствующий схеме 1.1 - http://smev3-d.test.gosuslugi.ru:7500/smev/v1.1/ws?wsdl , при этом сервис будет также доступен по адресу
публикация данной статьи разрешена только со ссылкой на сайт автора статьи
В этой статье я покажу пример, как разобрать большой XML файл. Если на вашем сервере (хостинге) не запрещено увеличение времени работы скрипта, то можно разбирать XML файл весом хоть гигабайты, сам лично разбирал только файлы от озона весом 450 мегабайт.
При разборе больших XML файлов возникает две проблемы:
1. Не хватает памяти.
2. Не хватает выделенного времени для работы скрипта.
Вторую проблему с временем решить можно, если сервером это не запрещено.
А вот проблему с памятью решить сложно, даже если речь идет о своем сервере, то ворочать файлы по 500 мегабайт не очень просто а уж на хостинге и на VDS увеличить память просто не получится.
В PHP существует несколько встроенных вариантов обработки XML - SimpleXML, DOM, SAX.
Все эти варианты подробно описаны во многих статьях с примерами, но все примеры демонстрируют работу с полным XML документом.
Вот один из примеров, получаем объект из XML файла
Теперь можно обрабатывать этот объект, НО...
Как видно, весь XML файл считывается в память, затем все разбирается в объект.
То есть все данные попадают в память и если выделенной памяти мало, то скрипт останавливается.
Для обработки больших файлов такой вариант не подходит, нужно читать файл построчно и обрабатывать эти данные по очереди.
При этом проверка на валидность осуществляется так же по мере обработки данных, поэтому нужно иметь возможность для отката, например удалить все внесенные в базу данные в случае не валидного XML файла, либо осуществить два прохода по файлу, сначала читать на валидность, затем читать для обработки данных.
Вот теоретический пример разбора большого XML файла.
Этот скрипт читает по одному символу из файла, собирает эти данные в блоки и отправляет в разборщик XML.
Такой подход полностью решает проблему с памятью и не вызывает нагрузки, но усугубляет проблему со временем. Как попытаться решить проблему со временем, читайте ниже.
Function
webi_xml
($file
)
{
########
### функция работы с данными
{
print
$data
;
}
############################################
{
print
$name
;
print_r
($attrs
);
}
## функция закрывающих тегов
function
endElement
($parser
,
$name
)
{
print
$name
;
}
############################################
($xml_parser , "data" );
// открываем файл
$fp
=
fopen
($file
,
"r"
);
$perviy_vxod = 1 ; $data = "" ;
{
$simvol = fgetc ($fp ); $data .= $simvol ;
if($simvol
!=
">"
) { continue;}
echo
"
break;
}
$data
=
""
;
}
fclose
($fp
);
Webi_xml ("1.xml" );
?>
В этом примере я все сложил в одну функцию webi_xml()
и в самом низу видно ее вызов.
Сам скрипт состоит из трех основных функций:
1. Функция которая ловит открытие тега startElement()
2. Функция которая ловит закрытие тега endElement()
3. И функция получения данных data()
.
Предположим что содержимое файла 1.xml некий рецепт
<
title
>
Простой хлеб
<
ingredient amount
=
"3"
unit
=
"стакан"
>
Мука
<
ingredient amount
=
"0.25"
unit
=
"грамм"
>
Дрожжи
<
ingredient amount
=
"1.5"
unit
=
"стакан"
>
Тёплая вода
<
ingredient amount
=
"1"
unit
=
"чайная ложка"
>
Соль
<
instructions
>
<
step
>
Смешать все ингредиенты и тщательно замесить
.
<
step
>
Закрыть тканью и оставить на один час в тёплом помещении
.
<
step
>
Замесить ещё раз
,
положить на противень и поставить в духовку
.
<
step
>
Посетить сайт сайт
Начинаем все с вызова общей функции webi_xml
("1.xml"
);
Дальше в этой функции стартует разборщик и все имена тегов переводим в верхний регистр, чтобы все теги имели одинаковый регистр.
$xml_parser
=
xml_parser_create
();
xml_parser_set_option
($xml_parser
,
XML_OPTION_CASE_FOLDING
,
true
);
Теперь указываем какие функции будут работать для отлова открытия тега, закрытия и обработки данных
xml_set_element_handler
($xml_parser
,
"startElement"
,
"endElement"
);
xml_set_character_data_handler
($xml_parser
,
"data"
);
Дальше идет открытие указанного файла, перебор файла по одному символу и каждый символ добавляется в строковую переменную пока не будет найден символ >
.
Если это самое первое обращение к файлу, то попутно будет удалено все что будет лишним в начале файла, все что стоит до , именно с такого тега должен начинаться XML.
В первый раз строковая переменная соберет в себе строку
И отправит ее в разборщик
xml_parse
($xml_parser
,
$data
,
feof
($fp
))
;
После обработки данных строковая переменная сбрасыватеся и снова начинается сбор данных в строку и во второй раз сформируется строка
В третий
Обратите внимание, что строковая переменная всегда формируется по законченному тегу >
и не обязательно посылать разбощику открытый и закрытый тег с данными например
Данному обработчику важно получить целый не разбитый тег, хоть один открытый, а в следущий шаг закрытый тег, или сразу получить 1000 строк файла, не важно, главное чтобы тег не разрывался, например
le>Простой хлеб
Так отправить данные обработчику нельзя, так как тег разорвался.
Вы можете придумать свою методику посылания данных в обработчик, например собирать по 1 мегабайту данных и отправлять в обработчик для повышения скорости, только следите чтобы теги всегда завершались, а данные можно разрывать
Таким образом частями, как вы пожелаете можно отправить большой файл в обработчик.
Теперь рассмотрим каким образом эти данные обрабатываются и как их получить.
Начинаем с функции открывающих тегов startElement
($parser
,
$name
,
$attrs
)
Предположим, что обработка дошла до строки
<
ingredient amount
=
"3"
unit
=
"стакан"
>
Мука
Тогда внутри функции переменная $name
будет равна ingredient
то есть название открытого тега (до закрытия тега дело еще не дошло).
Так же в данном случае будет доступен массив атрибутов этого тега $attrs
, в котором будут данные amount
=
"3"
и unit
=
"стакан"
.
После этого пошла обработка данных открытого тега функцией data
($parser
,
$data
)
В переменной $data
будет все, что находится между открывающим и закрывающим тегом, в нашем случае это текст Мука
И завершается обработка нашей строки функцией endElement
($parser
,
$name
)
Это название закрытого тега, в нашем случае $name
будет равна ingredient
А после этого опять пошло все по кругу.
Приведенный пример лишь демонстрирует принцип обработки XML, но для реального применения его нужно доработать.
Обычно, разбирать большой XML приходится для занесения данных в базу и для правильной обработки данных нужно знать к какому открытому тегу относятся данные, какой уровень вложения тега и какие теги открыты по иерархии выше. Обладая такой информацией можно без проблем правильно обработать файл.
Для этого нужно ввести несколько глобальных переменных, которые будут собирать информацию об открытых тегах, вложенности и данные.
Привожу пример, который можно использовать
Function
webi_xml
($file
)
{
global
$webi_depth
;
// счетчик, для отслеживания глубины вложенности
$webi_depth
=
0
;
global
$webi_tag_open
;
// будет содержать массив открытых в данный момент тегов
$webi_tag_open
= array();
global
$webi_data_temp
;
// этот массив будет содержать данные одного тега
####################################################
### функция работы с данными
function
data
($parser
,
$data
)
{
global
$webi_depth
;
global
$webi_tag_open
;
global
$webi_data_temp
;
// добавляем данные в массив с указанием вложенности и открытого в данный момент тега
$webi_data_temp
[
$webi_depth
][
$webi_tag_open
[
$webi_depth
]][
"data"
].=
$data
;
}
############################################
####################################################
### функция открывающих тегов
function
startElement
($parser
,
$name
,
$attrs
)
{
global
$webi_depth
;
global
$webi_tag_open
;
global
$webi_data_temp
;
// если уровень вложенности уже не нулевой, значит один тег уже открыт
// и данные из него уже в массиве, можно их обработать
if ($webi_depth
)
{
"
;
print
"
"
;
print_r
($webi_tag_open
);
// массив открытых тегов
print
"
" ;
// после обработки данных удаляем их для освобождения памяти
unset($GLOBALS
[
"webi_data_temp"
][
$webi_depth
]);
}
// теперь пошло открытие следующего тега и дальше обработка его произойдет на следующем шаге
$webi_depth
++;
// увеличиваем вложенность
$webi_tag_open
[
$webi_depth
]=
$name
;
// добавляем открытый тег в массив информаци
$webi_data_temp
[
$webi_depth
][
$name
][
"attrs"
]=
$attrs
;
// теперь добавляем атрибуты тега
}
###############################################
#################################################
## функция закрывающих тегов
function
endElement
($parser
,
$name
) {
global
$webi_depth
;
global
$webi_tag_open
;
global
$webi_data_temp
;
// здесь начинается обработка данных, например добаление в базу, сохранение в файл и т.д.
// $webi_tag_open содержит цепочку открытых тегов по уровню вложенности
// например $webi_tag_open[$webi_depth] содержит название открытого тега чья информация сейчас обрабатывается
// $webi_depth уровень вложенности тега
// $webi_data_temp[$webi_depth][$webi_tag_open[$webi_depth]]["attrs"] массив атрибутов тега
// $webi_data_temp[$webi_depth][$webi_tag_open[$webi_depth]]["data"] данные тега
Print
"данные "
.
$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"
]);
// после обработки данных удаляем массив с данными целиком, так как произошло закрытие тега
unset($GLOBALS
[
"webi_tag_open"
][
$webi_depth
]);
// удаляем информацию об этом открытом теге... так как он закрылся
$webi_depth
--;
// уменьшаем вложенность
}
############################################
$xml_parser
=
xml_parser_create
();
xml_parser_set_option
($xml_parser
,
XML_OPTION_CASE_FOLDING
,
true
);
// указываем какие функции будут работать при открытии и закрытии тегов
xml_set_element_handler
($xml_parser
,
"startElement"
,
"endElement"
);
// указываем функцию для работы с данными
xml_set_character_data_handler
($xml_parser
,
"data"
);
// открываем файл
$fp
=
fopen
($file
,
"r"
);
$perviy_vxod
=
1
;
// флаг для проверки первого входа в файл
$data
=
""
;
// сюда собираем частями данные из файла и отправляем в разборщик xml
// цикл пока не найден конец файла
while (!
feof
($fp
) and
$fp
)
{
$simvol
=
fgetc
($fp
);
// читаем один символ из файла
$data
.=
$simvol
;
// добавляем этот символ к данным для отправки
// если символ не завершающий тег, то вернемся к началу цикла и добавим еще один символ к данным, и так до тех пор, пока не будет найден закрывающий тег
if($simvol
!=
">"
) { continue;}
// если закрывающий тег был найден, теперь отправим эти собранные данные в обработку
// проверяем, если это первый вход в файл, то удалим все, что находится до тега // так как иногда может встретиться мусор до начала XML (корявые редакторы, либо файл получен скриптом с другого сервера)
if($perviy_vxod
) {
$data
=
strstr
($data
,
"
// теперь кидаем данные в разборщик xml
if (!
xml_parse
($xml_parser
,
$data
,
feof
($fp
))) {
// здесь можно обработать и получить ошибки на валидность...
// как только встретится ошибка, разбор прекращается
echo
"
XML Error: "
.
xml_error_string
(xml_get_error_code
($xml_parser
));
echo
" at line "
.
xml_get_current_line_number
($xml_parser
);
break;
}
// после разбора скидываем собранные данные для следующего шага цикла.
$data
=
""
;
}
fclose
($fp
);
xml_parser_free
($xml_parser
);
// удаление глобальных переменных
unset($GLOBALS
[
"webi_depth"
]);
unset($GLOBALS
[
"webi_tag_open"
]);
unset($GLOBALS
[
"webi_data_temp"
]);
Webi_xml ("1.xml" );
?>
Весь пример сопроводил комментариями, теперь тестируйте и экспериментируйте.
Обратите внимание, в функции работы с данными в массив данные не просто вставляются, а именно добавляются с помощью ".="
так как данные могут поступать не в целом виде и если сделать просто присвоение, то время от времени вы будете получать данные кусками.
Ну вот и все, теперь при обработке файла любого размера памяти хватит, а вот время работы скрипта увеличить можно несколькими способами.
В начало скрипта вставьте функцию
set_time_limit
(6000
);
или
ini_set
("max_execution_time"
,
"6000"
);
Либо добавьте в файл.htaccess текст
php_value max_execution_time 6000
Данные примеры увеличат время работы скрипта до 6000 секунд.
Увеличить время подобным образом можно только в выключенном безопасном режиме.
Если у вас есть доступ к редактированию php.ini можете увеличить время с помощью
max_execution_time = 6000
Например на хостинге мастерхост на момент написания статьи увеличение времени скрипта запрещено, не смотря на выключенный безопасный режим, но если вы профи, вы можете сделать свою сборку php на мастерхосте, но об этом не в этой статье.