Использование XML Document Object Model. Получаем данные о постах блога. Концепция DOM - объектная модель документа
Сегодня решил немного продолжить тему работы с XML-RPC в WordPress. Как это обычно со мной бывает, идея родилась в момент чтения случайного блога, вздумалось взглянуть на работу с постами в блоге и, заодно, попробовать написать что-нибудь под свои нужды.
Естественно программу я сегодня не выложу, но некоторые выкладки, листинги и идеи в посте будут присутствовать.
Вкратце работу с XML-RPC я рассматривал в посте “ ” Сегодня попробуем продвинуться дальше в своей работе и использовать несколько взаимосвязанных методов для получения определенной информации из блога.
Конкретизируем цель на сегодня : необходимо получить данные по постам в блоге, используя доступные методы из API WordPress .
Для достижения поставленной цели нам понадобятся следующие модули Delphi: XMLIntf , xmldom , XMLDoc и библиотека synapce или компонент Indy idHTTP (кому как угодно).
1. Тестируем соединение с блогом.
Полагаю, что первое, что следует сделать - это проверить корректность работы с блогом на предмет следующих возможных ошибок:
- В блоге отключена возможность использования XML-RPC
- Пользователь предоставил некорректные данные (url, логин или пароль).
Для проверки возможности работы с XML-RPC в блоге достаточно воспользоваться методом demo.sayHello . Если ответом будет строка “Hello” , значит всё в порядке и можно приступать к следующему шагу проверки. Для выполнения этой проверки нам потребуется выполнить три простенькие задачки:
- сформировать правильный XML-документ
- отправить запрос на сервер и получить ответ
- проанализировать ответ
Формируем XML-документ, который должен выглядеть так:
Для этого воспользуемся интерфейсом IXMLDocument:
[ ... ] var doc: IXMLDocument; //документ Root: IXMLNode; //корневой узел begin inherited Create; doc: = NewXMLDocument() ; //создаем пустой документ Root: = Doc. CreateElement ("methodCall" , "" ) ; //добавляем корневой узел Doc. DocumentElement : = Root; Root. AddChild ("methodName" ) . NodeValue : = "demo.sayHello" ; //добавляем название метода Root. AddChild ("params" ) . AddChild ("param" ) . AddChild ("value" ) . AddChild ("string" ) . NodeValue : = "test" ; //записываем параметры метода [ ... ]
Так как сам по себе XML-документ достаточно простой, то я позволил себе немного “похалявить” и последней строкой кода записал сразу все узлы и значение единственного параметра для нашего метода.
Теперь можно отправить документ на сервер и получить ответ:
[ ... ] with THTTPSend. Create do begin Doc. SaveToStream (Document) ; //записываем документ в тело запроса if HTTPMethod("POST" , aURL) then begin //запрос успешно отправлен и получен ответ end else begin //запрос не удался end ; end ; [ ... ]
Что мне нравится в Synapce
, так это то, что не требуется лишних “телодвижений” в плане заполнения заголовков Content-Length
, Content-Type
и пр. Конечно никто не мешает заполнить все возможные заголовки самому, но можно обойтись и так, как показал я выше - всё на автомате.
Двигаемся дальше - проводим анализ ответа.
Позволю себе напомнить Вам, что удачная отправка запроса на сервер никак не свидетельствует о том, что мы успешно получили доступ к XML-RPC блога. Удачная отправка запроса свидетельствует только о том, что мы отправили запрос и получили ответ, а _что_ находится в ответе ошибка или нет - мы пока не знаем
.
Чтобы пока не забивать голову лишними способами и методами парсинга ответа от сервера, предлагаю в данном случае остановиться на применении простой проверки:
[ ... ] Doc. LoadFromStream (Document, xetUTF_8) ; //записали XML-документ if Doc. DocumentElement . ChildNodes . FindNode ("fault" ) = nil then ShowMessage("XML-RPC работает исправно" ) [ ... ]
В соответствии со спецификацией XML-RPC сообщения об ошибках содержится в узле с названием fault. Следовательно, применительно к нашему случаю достаточно проверить наличие такого узла в ответном XML-документе - если его нет, то значит проверка прошла успешно, был сформирован корректный запрос и XML-RPC работает исправно.
Переходим к следующему шагу - проверке на корректность предоставленных данных пользователем и возможности работы пользователя с XML-RPC блога
.
С XML-RPC блога имеет право работать только администратор, следовательно, необходимо узнать кто пробует получить доступ. Для этого воспользуемся методом wp.getUsersBlogs
. Параметрами метода являются логин и пароль.
Но прежде, чем приступим к отправке запроса и получению ответа, думаю, стоит немного задуматься о будущем и предусмотреть работу с ошибками, формирование документов и т.д.
В предыдущей проверке, можно сказать, было баловство - простейших вариант работы типа:
отправил/получил/тут_же_разобрал/забыл/пошел_дальше.
Так как я планирую развивать модуль по работе с API WordPress и дальше, то есть смысл определиться со следующими моментами в работе:
- Сформировать “скелет” документа
- Записать в документ все необходимые параметры, учитывая типы данных
- Отправить запрос и получить ответ от сервера
- Проанализировать ответ и, если в ответе содержится сообщение об ошибке, то правильно его прочитать
Все эти четыре шага я сделал отдельными методами класса. Под “скелетом” документа я понимаю следующее содержимое:
То есть часть документа, содержащая имя метода и узел params без содержимого. Дальше на останется только правильно заполнить список параметров. Чем мы сейчас и займемся.
Всего в XML-RPC предусмотрено использование шести простых типов данных:
- int и i4 - целые числаinteger)
- double - дробные числа
- string - строки
- base64 - закодированная строка
- dateTime.iso8601 - дата/время
- boolean
Заводим новый тип данных:
TSimpleType = (tsInt, tsI4, tsString, tsDouble, tsDateTime, tsBase64, tsBoolean) ;
С помощью значений этого типа будем определять тэг для значения параметра.
Так как операции создания “скелета” документа и добавления параметров метода разнесены по разным функциям, то создадим ещё один вспомогательный тип данных:
PXMLDocument = ^ IXMLDocument;
Теперь сам метод добавления параметра в документ:
procedure TBlog. SetParam (SimpleType: TSimpleType; Value: string ; Document: PXMLDocument) ; var Root: IXMLNode; begin if Document^ . IsEmptyDoc then Exit; //документ пуст Root: = Document^ . DocumentElement . ChildNodes . FindNode ("params" ) ; if Root= nil then Exit; //узел не найден case SimpleType of tsInt: Root. AddChild ("param" ) . AddChild ("value" ) . AddChild ("int" ) . NodeValue : = Value; tsI4: Root. AddChild ("param" ) . AddChild ("value" ) . AddChild ("i4" ) . NodeValue : = Value; tsString: Root. AddChild ("param" ) . AddChild ("value" ) . AddChild ("string" ) . NodeValue : = Value; tsDouble: Root. AddChild ("param" ) . AddChild ("value" ) . AddChild ("double" ) . NodeValue : = Value; tsDateTime: Root. AddChild ("param" ) . AddChild ("value" ) . AddChild ("dateTime.iso8601" ) . NodeValue : = Value; tsBase64: Root. AddChild ("param" ) . AddChild ("value" ) . AddChild ("base64" ) . NodeValue : = Value; tsBoolean: Root. AddChild ("param" ) . AddChild ("value" ) . AddChild ("boolean" ) . NodeValue : = Value; end ; end ;
Этот метод работает только в случае записи простого типа. При работе со структурами необходимо доработать алгоритм.
Теперь про анализ сообщений об ошибке. Рассмотрим пример того, как выглядит сообщение об ошибке в XML-RPC:
Сообщение об ошибке приходит нам в структуре. Причём, если считать, что теги member нумеруются от нуля, то каждый чётный элемент структуры - это код ошибки, а нечётный - текст ошибки. Следовательно метод обработки сообщений об ошибке может выглядеть так:
function TBlog. ParseErrors (aDocument: PXMLDocument) : TStringList; var i: integer ; List: IDOMNodeList; code: string ; begin List: = aDocument^ . DOMDocument . getElementsByTagName ("member" ) ; Result: = TStringList. Create ; for i: = 0 to List. length - 1 do begin case i mod 2 of 0 : code: = (List. item [ i] . lastChild . firstChild as IDOMNodeEx) . text ; //чётный элемент - читаем код ошибки 1 : //нечётный элемент - читаем текст ошибки и записываем результат Result. Add (code+ " " + (List. item [ i] . lastChild . firstChild as IDOMNodeEx) . text ) ; end ; end ; end ;
Здесь код и текст ошибки записывается в TStringList. Думаю, что при необходимости можно легко сделать, чтобы код и текст читались в разные списки или массивы. Нам пока это не требуется.
Отправку документа мы уже рассматривали, поэтому сразу привожу метод проверки данных на корректность:
function TBlog. CheckUserAccess (const aURL, aUser, aPassword: string ; var Error: string ) : boolean ; var Doc: IXMLDocument; begin Doc: = GetDocument("wp.getUsersBlogs" ) ; //создали "скелет" //добавляем параметры SetParam(tsString, aUser, @ Doc) ; SetParam(tsString, aPassword, @ Doc) ; SendQuery(@ Doc, aURL) ; //отправляем запрос if not Doc. IsEmptyDoc then //если документ записан корректно begin if Doc. DocumentElement . ChildNodes . FindNode ("fault" ) < > nil then //есть сообщение об ошибке begin Result: = false ; Error: = ParseErrors(@ Doc) . Strings [ 0 ] ; end else Result: = true ; end else Result: = false ; end ;
Если пришло сообщение об ошибке, то записываем сообщение в переменную Error. В данном случае структура содержит только одно сообщение об ошибке - поэтому я так легко прописал:
Error: = ParseErrors(@ Doc) . Strings [ 0 ] ;
Итак, две проверки сделаны и мы определили, что XML-RPC включен и работает исправно, а пользователь ввёл корректные данные логина и пароля и может работать с API WordPress. Что дальше? А дальше начинаем основную работу - получаем данные по комментариям в блоге.
2. Получаем данные о постах блога.
Итак, что предоставляет в наше распоряжение WordPress. Сначала сделаем кратки обзор методов из xmlrpc.php.
wp.getPostStatusList - выводит значения для статуса поста. По сути на выходе будем имеет четыре строки: ‘draft’, ‘pending’, ‘private’, ‘publish’.
Пока этот метод нам бесполезен.
blogger.getRecentPosts - эта функция уже из API Blogger, но поддерживается в WordPress. На выходе будем иметь последние посты блога, включая весь контент поста.
Можно использовать метод, НО работа программы будет замедлена так как придётся “тягать” по Сети пост целиком. А если попробуем получить список постов блога целиком, то, видимо придётся ложиться спать, не дождавшись результата. Следовательно - пока оставляем метод в стороне.
metaWeblog.getRecentPosts - аналогично предыдущему методу.
mt.getRecentPostTitles - метод из MovableType API. Судя по названию - то, что нам надо. Смотрим описание метода.
Метод возвращает список, содержащий заголовки постов блога. При этом контент в список не записывается.
Входные параметры:
- String blogid
- String username
- String password
- int numberOfPosts
blogid всегда равен 1 (см. описание в xmlrpc.php)
numberOfPosts - количество постов, которые необходимо вывести в список. Если параметр имеет значение больше, чем количество постов в блоге, то метод возвращает список всех постов.
Осталось узнать, что из себя представляет этот список. А на выходе мы будем иметь массив структур, включающий в себя:
- дату создания элемента
- userid
- postid
- заголовок.
Замечательно. Воспользуемся этим методом, а заодно научимся анализировать сложные структуры ответа.
Про создание запроса, думаю, писать не стоит. Процедура аналогична той, что рассмотрена выше. А на анализе ответа сервера остановимся подробно. Стем как выглядит тип struct (структура) мы познакомились при парсинге ответа, содержащего ошибку авторизации. Посмотрим, что из себя представляет массив.
Массивы не имеют названия и описываются тегом
У нас на выходе из метода mt.getRecentPostTitles
будет содержаться массив структур
, причём одна структура - это информация по одному посту блога. Следовательно, чтение данных по постам блога можно условно разделить на следующие шаги:
- Выделяем из XML-документа все элементы
.
firstChild
.
childNodes
;
//получили все members для 1 value
for
j:
=
0
to
Members.
length
-
1
do
begin
with
Result[
i]
do
case
j of
0
:
dateCreated:
=
(Members[
j]
.
lastChild
.
firstChild
as
IDOMNodeEx)
.
text
;
1
:
user_id:
=
StrToInt
((Members[
j]
.
lastChild
.
firstChild
as
IDOMNodeEx)
.
text
)
;
2
:
id:
=
StrToInt
((Members[
j]
.
lastChild
.
firstChild
as
IDOMNodeEx)
.
text
)
;
3
:
title:
=
(Members[
j]
.
lastChild
.
firstChild
as
IDOMNodeEx)
.
text
;
end
;
end
;
end
;
[
...
]
Соответственно, если получено сообщение об ошибке, то можно воспользоваться рассмотренной ранее функцией.
На сегодня всё. В следующий раз продолжим работу с API и попробуем получить все комментарии из блога.
Несмотря на то, что тема работы с XML в Delphi довольно широко обсуждалась в Интернете, вопросы на эту тему довольно часто возникают на всевозможных форумах.
Я тоже уже писал , но хотел бы вернуться к реальному случаю быстрого разбора XML файла и извлечения данных, который я сегодня проделал на работе. Получение необходимых данных у меня заняло не более 5 минут времени.
Предыстория
. Сегодня понадобилось обработать данные об установленных программах на компьютерах пользователей (да, да, пиратов выявляем:)). Технический отдел предоставил мне такую информацию содраную с ничего не подозревающих пользователей по сети с использованием WMI . Программа, которой они пользовались выдает отчеты в формате XML. Соответственно - мне притащили гору XML файлов с довольно сложной структурой из которых мне необходимо было вытащить только название установленных программных продуктов. Обработка
. Просмотрев пару файлов вручную, понял что так и состариться не долго, и решил написать небольшой конвертер. Запустив Delphi - выбрал в репозитарии объект XML DataBinding и скормил ему один из файлов. Все настройки и параметры я оставил по умолчанию и в результате у меня сформировался модуль с большим количеством классов и интерфейсов для доступа к элементам этого XML файла. Я не стал долго разбираться со структурой классов, сразу же перешел к написанию конвертера. В новом консольном приложении написал довольно простой код:
program XML2TXT;
uses
Forms,
Classes, SysUtils,
SoftwareXML in "SoftwareXML.pas";
procedure CovertXML2Text;
var
softbase: IXMLSTDSoftwareType;
i: integer;
sr: TSearchRec;
CurDir: string;
ExportFile: TStringList;
begin
CurDir:= IncludeTrailingPathDelimiter(ExtractFilePath(Application.ExeName));
if FindFirst(CurDir+"*.xml", faAnyFile, sr) = 0 then
repeat
ExportFile:= TStringList.Create;
softbase:= LoadSTDSoftware(Pchar(CurDir+sr.Name));
for i:= 0 to softbase.InstalledSoftware.source.software.Count - 1 do
ExportFile.Add(softbase.InstalledSoftware.source.software[i].DisplayName);
ExportFile.Sort;
ExportFile.SaveToFile(CurDir + softbase.InstalledSoftware.Source.servername+".txt");
ExportFile.Free;
until FindNext(sr) 0;
end;
begin
Application.Initialize;
CovertXML2Text;
end.
В результате которого у меня образовался по одному текстовичку на каждый компьютер в сетке, содержащий список установленного ПО.
Чувствую что данный код потребует пояснений. Например, зачем я в консольном приложении использовал модуль Forms
и вызывал процедуру Application.Initialize;?
На самом деле все просто - это небольшой хак, позволяющий использовать XML Data Binding в консольном приложении. Потому как в нем упорно отказывался инициализироваться класс для работы с XML. В истинных причинах пока не разбирался - сегодня было важно время, я и так 4 из 5 минут потратил на борьбу с этой ошибкой. :) Думаю позже разобраться с этой проблемой и написать в чем истинная причина.
Странный класс softbase был создан на основе XML файла - так назывался корневой элемент, а softbase.InstalledSoftware.source.software[i].DisplayName - просто навигация по вложенным элементам до нужного и получение его значения.
Вот собственно так выглядит один из самых быстрых способов работы с XML в Delphi.
У многих программистов Delphi, сохранение настроек ассоциируется с использованием INI
файлов в своих программах. Применение данного метода, в более менее серьезных проектах, необходимо избегать, так как это ограничивает в гибкости, что препятствует дальнейшему расширению программы. Стоит сказать, что такой подход достаточно популярен, в силу своей простоты использования и наличия встроенных средств в среду разработки.
Тем не менее, идеальным вариантом для хранения настроек программы являются структурированные XML
файлы. Их преимущество заключается в том, что количество параметров может быть не фиксированным. Чтобы лучше это понять, рассмотрим конкретный пример.
В программе USearch , при клике по записи, появляется контекстное меню , в котором отображается список пунктов. Эти пункты являются командами, которые в свою очередь загружаются из файла настроек. В случае, если бы настройки хранились в INI файле, то программа могла бы сохранять и загружать определенное количество команд, например 10 или 50. Как только потребуется большее значение, придется заново переписывать код и соответственно повторно компилировать его.
Применяя подход с использованием XML
файлов, у нас появится возможность загружать все параметры секции динамически. Ко всему этому, файл конфигурации станет более изящным, без избыточной нумерации параметров. Однако, стандартные средства для работы с XML
в Delphi имеют множество недостатков, поэтому рекомендую использовать стандартную библиотеку MSXML
. Обычно она по-умолчанию входит в состав операционных систем семейства Windows.
Для подключения MSXML
, нам необходимо сформировать файл интерфейса со списком всех функций, импортировав его из COM-сервера. Как импортировать интерфейс написано не мало подробных статей, я же предлагаю вам скачать файл MSXML2_TLB.PAS
уже готовый к использованию. После того, как файл будет скачан, разместите его рядом с вашим проектом, либо закиньте в папку lib среды Delphi. Таким образом, все создаваемые программы смогут использовать модуль MSXML
, достаточно лишь дописать в uses строчку MSXML2_TLB .
Для наглядности, рассмотрим следующий пример применения этой библиотеки:
Procedure LoadData; var XMLDoc: DOMDocument; Root: IXMLDOMElement; begin XMLDoc:= CoDOMDocument.Create; XMLDoc.Load("settins.xml"); Root:= XMLDoc.DocumentElement; ShowMessage(Root.SelectSingleNode("size/width").Text); Root:= nil; XMLDoc:= nil; end;
Сначала создается экземпляр класса DOMDocument , после чего в память загружается содержимое файла settings.xml . Так как по стандарту любой XML
файл должен содержать корневой тэг (в данном случае config
), то нам необходимо его получить, используя функцию DocumentElement
. Затем происходит вывод содержимого между тэгами
Здесь применен метод SelectSingleNode , который в качестве параметра принимает строку
Несмотря на то, что тема работы с XML в Delphi довольно широко обсуждалась в Интернете, вопросы на эту тему довольно часто возникают на всевозможных форумах.
Я тоже уже писал по этому поводу , но хотел бы вернуться к реальному случаю быстрого разбора XML файла и извлечения данных, который я сегодня проделал на работе. Получение необходимых данных у меня заняло не более 5 минут времени.
Предыстория
. Сегодня понадобилось обработать данные об установленных программах на компьютерах пользователей (да, да, пиратов выявляем:)). Технический отдел предоставил мне такую информацию содраную с ничего не подозревающих пользователей по сети с использованием WMI . Программа, которой они пользовались выдает отчеты в формате XML. Соответственно - мне притащили гору XML файлов с довольно сложной структурой из которых мне необходимо было вытащить только название установленных программных продуктов. Обработка
. Просмотрев пару файлов вручную, понял что так и состариться не долго, и решил написать небольшой конвертер. Запустив Delphi - выбрал в репозитарии объект XML DataBinding и скормил ему один из файлов. Все настройки и параметры я оставил по умолчанию и в результате у меня сформировался модуль с большим количеством классов и интерфейсов для доступа к элементам этого XML файла. Я не стал долго разбираться со структурой классов, сразу же перешел к написанию конвертера. В новом консольном приложении написал довольно простой код:
program XML2TXT;
uses
Forms,
Classes, SysUtils,
SoftwareXML in "SoftwareXML.pas";
procedure CovertXML2Text;
var
softbase: IXMLSTDSoftwareType;
i: integer;
sr: TSearchRec;
CurDir: string;
ExportFile: TStringList;
begin
CurDir:= IncludeTrailingPathDelimiter(ExtractFilePath(Application.ExeName));
if FindFirst(CurDir+"*.xml", faAnyFile, sr) = 0 then
repeat
ExportFile:= TStringList.Create;
softbase:= LoadSTDSoftware(Pchar(CurDir+sr.Name));
for i:= 0 to softbase.InstalledSoftware.source.software.Count - 1 do
ExportFile.Add(softbase.InstalledSoftware.source.software[i].DisplayName);
ExportFile.Sort;
ExportFile.SaveToFile(CurDir + softbase.InstalledSoftware.Source.servername+".txt");
ExportFile.Free;
until FindNext(sr) 0;
end;
begin
Application.Initialize;
CovertXML2Text;
end.
В результате которого у меня образовался по одному текстовичку на каждый компьютер в сетке, содержащий список установленного ПО.
Чувствую что данный код потребует пояснений. Например, зачем я в консольном приложении использовал модуль Forms
и вызывал процедуру Application.Initialize;?
На самом деле все просто - это небольшой хак, позволяющий использовать XML Data Binding в консольном приложении. Потому как в нем упорно отказывался инициализироваться класс для работы с XML. В истинных причинах пока не разбирался - сегодня было важно время, я и так 4 из 5 минут потратил на борьбу с этой ошибкой. :) Думаю позже разобраться с этой проблемой и написать в чем истинная причина.
Странный класс softbase был создан на основе XML файла - так назывался корневой элемент, а softbase.InstalledSoftware.source.software[i].DisplayName - просто навигация по вложенным элементам до нужного и получение его значения.
Вот собственно так выглядит один из самых быстрых способов работы с XML в Delphi.
Язык XML все чаще используется для хранения информации, обмена ею между приложениями и Web-узлами. Во многих приложениях этот язык применяется в качестве базового для хранения данных, в других - для экспортирования и импортирования XML-данных. Из этого следует, что разработчикам пора задуматься над тем, как можно использовать XML-данные в собственных приложениях.
В этой статье мы рассмотрим XML Document Object Model (DOM) и ее реализацию фирмой Microsoft - Microsoft XML DOM.
XML DOM - это объектная модель, предоставляющая в распоряжение разработчика объекты для загрузки и обработки XML-файлов. Объектная модель состоит из следующих основных объектов: XMLDOMDocument, XMLDOMNodeList, XMLDOMNode, XMLDOMNamedNodeMap и XMLDOMParseError. Каждый из этих объектов (кроме XMLDOMParseError) содержит свойства и методы, позволяющие получать информацию об объекте, манипулировать значениями и структурой объекта, а также перемещаться по структуре XML-документа.
Рассмотрим основные объекты XML DOM и приведем несколько примеров их использования в Borland Delphi.
Использование XML DOM в Borland Delphi
Для того чтобы использовать Microsoft XML DOM в Delphi-приложениях, необходимо подключить к проекту соответствующую библиотеку типов. Для этого мы выполняем команду Project | Import Type Library и в диалоговой панели Import Type Library выбираем библиотеку Microsoft XML version 2.0 (Version 2.0), которая обычно находится в файле Windows\System\MSXML.DLL
После нажатия кнопки Create Unit будет создан интерфейсный модуль MSXML_TLB, который позволит нам воспользоваться объектами XML DOM: DOMDocument, XMLDocument, XMLHTTPRequest и рядом других, реализованных в библиотеке MSXML.DLL. Ссылка на модуль MSXML_TLB должна быть указана в списке Uses.
Устройство XML DOM
Document Object Model представляет XML-документ в виде древовидной структуры, состоящей из ветвей. Программные интерфейсы XML DOM позволяют приложениям перемещаться по дереву документа и манипулировать его ветвями. Каждая ветвь может иметь специфический тип (DOMNodeType), согласно которому определяются родительская и дочерние ветви. В большинстве XML-документов можно встретить ветви типа element, attribute и text. Атрибуты (attribute) представляют собой особый вид ветви и не являются дочерними ветвями. Для управления атрибутами используются специальные методы, предоставляемые объектами XML DOM.
Помимо реализации рекомендованных World Wide Web Consortium (W3C) интерфейсов, Microsoft XML DOM содержит методы, поддерживающие XSL, XSL Patterns, Namespaces и типы данных. Например, метод SelectNodes позволяет использовать синтаксис шаблонов XSL (XSL Pattern Syntax) для поиска ветвей по определенному контексту, а метод TransformNode поддерживает использование XSL для выполнения трансформаций.
Тестовый XML-документ
В качестве примера XML-документа возьмем каталог музыкальных CD-ROM, который имеет следующую структуру :
Теперь мы готовы приступить к рассмотрению объектной модели XML DOM, знакомство с которой начнем с объекта XMLDOMDocument.
XML-документ - объект XMLDOMDocument
Работа с XML-документом начинается с его загрузки. Для этого мы используем метод Load, который имеет всего один параметр, указывающий URL загружаемого документа. При загрузке файлов с локального диска указывается только полное имя файла (протокол file:/// в данном случае можно опустить). Если XML-документ хранится в виде строки, для загрузки такого документа следует использовать метод LoadXML.
Для управления способом загрузки документа (синхронный или асинхронный) используется свойство Async. По умолчанию это свойство имеет значение True, указывающее на то, что документ загружается асинхронно и управление возвращается приложению еще до полной загрузки документа. В противном случае документ загружается синхронно, и тогда приходится проверять значение свойства ReadyState, чтобы узнать, загрузился документ или нет. Также можно создать обработчик события OnReadyStateChange, который получит управление при изменении значения свойства ReadyState.
Ниже показано, как загрузить XML-документ, используя метод Load:
Uses ... MSXML_TLB ... procedure TForm1.Button1Click(Sender: TObject); var XMLDoc: IXMLDOMDocument; begin XMLDoc:= CoDOMDocument.Create; XMLDoc.Async:= False; XMLDoc.Load(‘C:\DATA\DATA.xml’); // // Здесь располагается код, манипулирующий // XML-документом и его ветвями // XMLDoc:= Nil; end;
После того как документ загружен, мы можем обратиться к его свойствам. Так, свойство NodeName будет содержать значение #document, свойство NodeTypeString - значение document, свойство URL - значение file:///C:/DATA/DATA.xml.
Обработка ошибoк
Особый интерес представляют свойства, связанные с обработкой документа при его загрузке. Так, свойство ParseError возвращает объект XMLDOMParseError, содержащий информацию об ошибке, возникшей в процессе обработки документа.
Чтобы написать обработчик ошибки, можно добавить следующий код:
Var XMLError: IXMLDOMParseError; ... XMLDoc.Load(‘C:\DATA\DATA.xml’); XMLError:= XMLDoc.ParseError; If XMLError.ErrorCode <> 0 Then // // Здесь мы обрабатываем ошибку // Else Memo1.Lines.Add(XMLDoc.XML); ... XMLDoc:= Nil;
Чтобы узнать, какая информация возвращается в случае ошибки, изменим следующий элемент каталога:
убрав закрывающий элемент
Теперь напишем код, возвращающий значения свойств объекта XMLDOMParseError:
XMLError:= XMLDoc.ParseError; If XMLError.ErrorCode <> 0 Then With XMLError, Memo1.Lines do begin Add(‘Файл: ‘ + URL); Add(‘Код: ‘ + IntToStr(ErrorCode)); Add(‘Ошибка: ‘ + Reason); Add(‘Текст: ‘ + SrcText); Add(‘Строка: ‘ + IntToStr(Line)); Add(‘Позиция: ‘ + IntToStr(LinePos)); end Else Memo1.Lines.Add(XMLDoc.XML); End;
и выполним наше приложение. В результате получаем следующую информацию об ошибке .
Как видно из приведенного примера, возвращаемой объектом XMLDOMParseError информации вполне достаточно для того, чтобы локализовать ошибку и понять причину ее возникновения.
Теперь восстановим закрывающий элемент
Доступ к дереву документа
Для доступа к дереву документа можно либо получить корневой элемент и затем перебрать его дочерние ветви, либо найти какую-то специфическую ветвь. В первом случае мы получаем корневой элемент через свойство DocumentElement, которое возвращает объект типа XMLDOMNode. Ниже показано, как воспользоваться свойством DocumentElement для того, чтобы получить содержимое каждого дочернего элемента:
Var Node: IXMLDOMNode; Root: IXMLDOMElement; I: Integer; ... Root:= XMLDoc.DocumentElement; For I:= 0 to Root.ChildNodes.Length-1 do Begin Node:= Root.ChildNodes.Item[I]; Memo1.Lines.Add(Node.Text); End;
Для нашего XML-документа мы получим следующий текст .
Если нас интересует какая-то специфическая ветвь или ветвь уровнем ниже первой дочерней ветви, мы можем воспользоваться либо методом NodeFromID, либо методом GetElementByTagName объекта XMLDOMDocument.
Метод NodeFromID требует указания уникального идентификатора, определенного в XML Schema или Document Type Definition (DTD), и возвращает ветвь с этим идентификатором.
Метод GetElementByTagName требует указания строки со специфическим элементом (тэгом) и возвращает все ветви с данным элементом. Ниже показано, как использовать данный метод для нахождения всех исполнителей в нашем каталоге CD-ROM:
Nodes: IXMLDOMNodeList; Node: IXMLDOMNode; ... Nodes:= XMLDoc.GetElementsByTagName(‘ARTIST’); For I:= 0 to Nodes.Length-1 do Begin Node:= Nodes.Item[I]; Memo1.Lines.Add(Node.Text); End;
Для нашего XML-документа мы получим следующий текст
Отметим, что метод SelectNodes объекта XMLDOMNode обеспечивает более гибкий способ для доступа к ветвям документа. Но об этом чуть ниже.
Ветвь документа - объект XMLDOMNode
Объект XMLDOMNode представляет собой ветвь документа. Мы уже сталкивались с этим объектом, когда получали корневой элемент документа:
Root:= XMLDoc.DocumentElement;
Для получения информации о ветви XML-документа можно использовать свойства объекта XMLDOMNode (табл. 1).
Для доступа к данным, хранимым в ветви, обычно используют либо свойство NodeValue (доступно для атрибутов, текстовых ветвей, комментариев, инструкций по обработке и секций CDATA), либо свойство Text, возвращающее текстовое содержимое ветви, либо свойство NodeTypedValue. Последнее, однако, может использоваться только для ветвей с типизованными элементами.
Перемещение по дереву документа
Объект XMLDOMNode предоставляет множество способов для перемещения по дереву документа. Например, для доступа к родительской ветви используется свойство ParentNode (тип XMLDOMNode), доступ к дочерним ветвям осуществляется через свойства ChildNodes (тип XMLDOMNodeList), FirstChild и LastChild (тип XMLDOMNode) и т.д. Свойство OwnerDocument возвращает объект типа XMLDOMDocument, идентифицирующий сам XML-документ. Перечисленные выше свойства позволяют легко перемещаться по дереву документа.
Теперь переберем все ветви XML-документа:
Root:= XMLDoc.DocumentElement; For I:= 0 to Root.ChildNodes.Length-1 do Begin Node:= Root.ChildNodes.Item[I]; If Node.HasChildNodes Then GetChilds(Node,0); End;
Как уже отмечалось выше, SelectNodes объекта XMLDOMNode обеспечивает более гибкий способ доступа к ветвям документа. Кроме того, существует метод SelectSingleNode, возвращающий только первую ветвь документа. Оба эти метода позволяют задавать XSL-шаблоны для поиска ветвей.
Рассмотрим процесс использования метода SelectNodes для извлечения всех ветвей, у которых есть ветвь CD и подветвь PRICE:
Root:= XMLDoc.DocumentElement; Nodes:= Root.SelectNodes(‘CD/PRICE’);
В коллекцию Nodes будут помещены все подветви PRICE ветви CD. К обсуждению XSL-шаблонов вернемся чуть позже.
Манипуляция дочерними ветвями
Для манипуляции дочерними ветвями мы можем воспользоваться методами объекта XMLDOMNode (табл. 2).
Для того чтобы полностью удалить запись о первом диске, необходимо выполнить следующий код :
Var XMLDoc: IXMLDOMDocument; Root: IXMLDOMNode; Node: IXMLDOMNode; XMLDoc:= CoDOMDocument.Create; XMLDoc.Async:= False; XMLDoc.Load(‘C:\DATA\DATA.xml’); // Получить корневой элемент Root:= XMLDoc.DocumentElement; Node:= Root; // Удалить первую дочернюю ветвь Node.RemoveChild(Node.FirstChild);
Обратите внимание на то, что в данном примере мы удаляем первую дочернюю ветвь. Как удалить первый элемент первой дочерней ветви, показано ниже :
Var XMLDoc: IXMLDOMDocument; Root: IXMLDOMNode; Node: IXMLDOMNode; XMLDoc:= CoDOMDocument.Create; XMLDoc.Async:= False; XMLDoc.Load(‘C:\DATA\DATA.xml’); // Получить корневой элемент Root:= XMLDoc.DocumentElement; // и первую дочернюю ветвь Node:= Root.FirstChild; // Удалить первую дочернюю ветвь Node.RemoveChild(Node.FirstChild);
В приведенном выше примере мы удалили не первую ветвь
Теперь добавим новую ветвь. Ниже приведен код, показывающий, как добавить новую запись о музыкальном CD-ROM :
Var
NewNode: IXMLDOMNode;
Child: IXMLDOMNode;
...
// Создадим новую ветвь -
Приведенный выше код показывает следующую последовательность действий по добавлению новой ветви:
- Создание новой ветви методом CreateNode:
- создание элемента методом CreateNode;
- добавление элемента к ветви методом AppendChild;
- установка значения элемента через свойство Text;
- … повторить для всех элементов.
- Добавление новой ветви к документу методом AppendChild.
Напомним, что метод AppendChild добавляет ветвь в конец дерева. Для того чтобы добавить ветвь в конкретное место дерева, необходимо использовать метод InsertBefore.
Набор ветвей - объект XMLDOMNodeList
Объект XMLNodeList содержит список ветвей, который может быть построен с помощью методов SelectNodes или GetElementsByTagName, а также получен из свойства ChildNodes.
Мы уже рассматривали использование этого объекта в примере, приведенном в разделе «Перемещение по дереву документа». Здесь же мы приведем некоторые теоретические замечания.
Число ветвей в списке может быть получено как значение свойства Length. Ветви имеют индексы от 0 до Length-1, и каждая отдельная ветвь доступна через элемент массива Item с соответствующим индексом.
Перемещение по списку ветвей также может осуществляться с помощью метода NextNode, возвращающего следующую ветвь в списке, или Nil, если текущая ветвь - последняя. Чтобы вернуться к началу списка, следует вызвать метод Reset.
Создание и сохранение документов
Итак, мы рассмотрели, как можно добавлять ветви и элементы в существующие XML-документы. Теперь создадим XML-документ «на лету». Прежде всего напомним, что документ может быть загружен не только из URL, но и из обычной строки. Ниже показано, как создать корневой элемент, который затем может использоваться для динамического построения остальных элементов (что мы уже рассмотрели в разделе «Манипуляция дочерними ветвями»):
Var
XMLDoc: IXMLDOMDocument;
Root: IXMLDOMNode;
Node: IXMLDOMNode;
S: WideString;
...
S:= ‘
После построения XML-документа сохраним его в файле с помощью метода Save. Например:
XMLDoc.Save(‘C:\DATA\NEWCD.XML’);
Помимо сохранения в файле метод Save позволяет сохранять XML-документ в новом объекте XMLDOMDocument. В этом случае происходит полная обработка документа и, как следствие, проверка его структуры и синтаксиса. Ниже показано, как сохранить документ в другом объекте:
Procedure TForm1.Button2Click(Sender: TObject); var XMLDoc2: IXMLDOMDocument; begin XMLDoc2:= CoDOMDocument.Create; XMLDoc.Save(XMLDoc2); Memo2.Lines.Add(XMLDoc2.XML); ... XMLDoc2:= Nil; end;
В заключение отметим, что метод Save также позволяет сохранять XML-документ в другие COM-объекты, поддерживающие интерфейсы IStream, IPersistStream или IPersistStreamInit.
Использование XSL-шаблонов
Обсуждая метод SelectNodes объекта XMLDOMNode, мы упомянули о том, что он обеспечивает более гибкий способ доступа к ветвям документа. Гибкость заключается в том, что в качестве критерия для выбора ветвей можно указать XSL-шаблон. Такие шаблоны предоставляют мощный механизм для поиска информации в XML-документах. Например, для того, чтобы получить список всех названий музыкальных CD-ROM в нашем каталоге, можно выполнить следующий запрос:
Чтобы узнать, диски каких исполнителей выпущены в США, запрос формируется следующим образом:
Nodes:= Root.SelectNodes(‘CD/ARTIST’);
Ниже показано, как найти первый диск в каталоге:
Nodes:= Root.SelectNodes(‘CD/TITLE’);
и последний:
Nodes:= Root.SelectNodes(‘CD/TITLE’);
Чтобы найти диски Боба Дилана, можно выполнить следующий запрос:
Nodes:= Root.SelectNodes(‘CD[$any$ ARTIST= ”Bob Dylan”]/TITLE’);
а чтобы получить список дисков, выпущенных после 1985 года, мы выполняем следующий запрос:
Nodes:= Root.SelectNodes(‘CD/TITLE’);
Более подробное обсуждение синтаксиса XSL требует отдельной публикации. Чтобы заинтриговать читателей и подтолкнуть к дальнейшим исследованиям, приведу всего один небольшой пример возможного использования XSL. Допустим, нам необходимо преобразовать наш каталог в обычную HTML-таблицу. Пользуясь традиционными способами, мы должны перебрать все ветви дерева и для каждого полученного элемента сформировать соответствующие тэги
Используя XSL, мы просто создаем шаблон (или таблицу стилей), в котором указываем, что и как надо преобразовать. Затем накладываем этот шаблон на наш каталог - и готово: перед нами текст XSL-шаблона, преобразующего каталог в таблицу (листинг 2).
Код для наложения XSL-шаблона на наш каталог выглядит так:
Procedure TForm1.Button2Click(Sender: TObject); var XSLDoc: IXMLDOMDocument; begin XSLDoc:= CoDOMDocument.Create; XSLDoc.Load(‘C:\DATA\DATA.xsl’); Memo2.Text:= XMLDoc.TransformNode(XSLDoc); XSLDoc:= Nil; end;
Завершая наше обсуждение XSL, следует сказать, что в настоящее время этот язык активно используется для трансформации между различными XML-документами, а также для форматирования документов.
Заключение
По вполне понятным причинам в одной статье невозможно рассмотреть все объекты Microsoft XML DOM и привести примеры их использования. Здесь мы лишь коснулись основных вопросов использования XML DOM в приложениях. В табл. 3 показаны все объекты, реализованные в Microsoft XML DOM.
КомпьютерПресс 12"2000