.
в–Ў Рлементы Рё имеют РїРѕ РѕРґРЅРѕР№ текстовой строке.
в–Ў Рлемент содержит РѕРґРЅРѕ целое число.
□ У открывающего тега есть один необязательный атрибут type, принимающий одно из трех значений: город, поселок или деревня. Значение по умолчанию — город.
□ Необязательный элемент содержит ни одного, один или несколько элементов и .
в–Ў Рлементы Рё содержат РїРѕ РѕРґРЅРѕР№ строке, состоящей только РёР· цифр.
Рто словесное описание, называемое схемой документа XML, формализуется несколькими способами. Наиболее распространены РґРІР° СЃРїРѕСЃРѕР±Р°: можно сделать описание DTD, пришедшее РІ XML РёР· SGML, или описать схему РЅР° языке XSD (XML Schema Definition Language).
Описание DTD
Описание DTD нашей адресной книжки записано в листинге 28.3.
Листинг 28.3. Описание DTD документа XML
first CDATA #IMPLIED second CDATA #IMPLIED surname CDATA #REQUIRED>
type (город | поселок | деревня) "город">
Как видите, описание DTD почти очевидно. Оно повторяет приведенное ранее словесное описание. Первое слово element означает, что элемент может содержать тело с вложенными элементами. Вложенные элементы перечисляются в круглых скобках. Порядок перечисления вложенных элементов в скобках должен соответствовать порядку их появления в документе. Слово empty в третьей строке листинга 28.3 означает пустой элемент.
Слово attlist начинает описание списка атрибутов элемента. Для каждого атрибута указывается имя, тип и обязательность присутствия атрибута. Типов атрибута всего девять, но чаще всего употребляется тип cdata (Character DATA), означающий произвольную строку символов Unicode, или перечисляются значения типа. Так сделано в описании атрибута type тега , принимающего одно из трех значений: город, поселок или деревня. В кавычках показано значение по умолчанию — город.
Обязательность указания атрибута отмечается одним из трех слов:
□ #required — атрибут обязателен;
□ #implied — атрибут необязателен;
□ #fixed — значение атрибута фиксировано, оно задается в DTD.
Первым словом могут быть, кроме слов element или attlist, слова any, mixed или entity. Слова any и mixed означают, что элемент может содержать и простые данные и/или вложенные элементы. Слово entity служит для обозначения или адреса данных, приведенного в описании DTD, так называемой сущности.
После имени элемента в скобках записываются вложенные элементы или тип данных, содержащихся в теле элемента. Тип pcdata (Parsed Character DATA) означает строку символов Unicode, которую надо интерпретировать. Тип cdata — строку символов Unicode, которую не следует интерпретировать.
Звездочка, записанная после имени элемента, означает "нуль или более вхождений" элемента, после которого она стоит, а плюс — "одно или более вхождений". Вопросительный знак означает "нуль или один раз". Если эти символы относятся ко всем вложенным элементам, то их можно указать после круглой скобки, закрывающей список вложенных элементов.
Описание DTD можно занести в отдельный файл, например ntb.dtd, указав его имя во второй части пролога, как показано во второй строке листингов 28.1 и 28.2. Можно включить описание во вторую часть пролога XML-файла, заключив его в квадратные скобки:
После того как создано описание DTD нашей реализации XML и написан документ, размеченный тегами этой реализации, следует проверить правильность их написания. Для этого есть специальные программы — проверяющие анализаторы (validating parsers). Все фирмы, разрабатывающие средства для работы с XML, выпускают бесплатные или коммерческие проверяющие анализаторы.
Проверяющий анализатор корпорации Sun Microsystems содержится в пакете классов JAXP (Java API for XML Processing), входящем в состав Java SE. Кроме того, этот пакет можно загрузить отдельно с адреса .
Корпорация Microsoft поставляет проверяющий анализатор MSXML (Microsoft XML Parser), доступный по адресу .
Есть еще множество проверяющих анализаторов, но лидером среди них является, пожалуй, Apache Xerces2, входящий во многие средства обработки документов XML, выпускаемые другими фирмами. Он свободно доступен по адресу xerces2-j/.
Ограниченные средства DTD РЅРµ позволяют полностью описать структуру документа XML. Р’ частности, описание DTD РЅРµ указывает точное количество повторений вложенных элементов, РѕРЅРѕ РЅРµ задает точный тип тела элемента. Например, РІ листинге 28.3 РёР· описания DTD РЅРµ РІРёРґРЅРѕ, что РІ элементе содержится дата рождения. Рти недостатки DTD привели Рє появлению РґСЂСѓРіРёС… схем описания документов XML. Наиболее развитое описание дает язык XSD. РњС‹ будем называть описание РЅР° этом языке просто схемойXML (XML Schema).
Посмотрим, как создаются схемы XML, но сначала познакомимся еще с одним понятием XML — пространством имен.
Пространства имен XML
Поскольку в разных языках разметок — реализациях XML — могут встретиться одни и те же имена тегов и их атрибутов, имеющие совершенно разный смысл, а в документе XML их часто приходится смешивать, анализатору надо дать возможность их как-то различать. В языке Java мы имена полей класса уточняем именем класса, а имена классов уточняем указанием пакета, что позволяет назвать поле просто именем a, применяя при необходимости полное имя, что-нибудь вроде com.mydomain.myhost.mypack.MyClass.a. При этом рекомендуется пакет для уникальности называть доменным именем сайта разработчика, записывая его справа налево.
Р’ языке XML принята подобная схема: локальное РёРјСЏ уточняется идентификатором. Рдентификатор должен быть уникальным РІРѕ всем Рнтернете, поэтому РёРј должна быть строка символов, имеющая форму адреса URI. Адрес может соответствовать или РЅРµ соответствовать какому-то реальному сайту Рнтернета, это РЅРµ важно. Важно, чтобы РѕРЅ РЅРµ повторялся РІ Рнтернете, можно записать, например, строку 2008/ntbml. Р’СЃРµ имена СЃ РѕРґРЅРёРј Рё тем же идентификатором образуют РѕРґРЅРѕ пространство имен (namespace).
Поскольку идентификатор пространства имен получается весьма длинным, было бы очень неудобно всегда записывать его перед локальным именем. В языке Java для сокращения записи имен мы используем оператор import. В XML принят другой подход.
В каждом документе идентификатор пространства имен связывается с некоторым коротким префиксом, отделяемым от локального имени двоеточием. Префикс определяется атрибутом xmlns следующим образом:
Как видите, префикс ntb только что определен, но его уже можно использовать в имени
ntb:notebook.
После такого описания имена тегов и атрибутов, которые мы хотим отнести к пространству имен , снабжаются префиксом ntb, например:
Горeлово
РРјСЏ вместе СЃ префиксом, например ntb:city, называется расширенным или уточненным именем (Qualified Name, QName).
Хотя идентификатор пространства имен записывается РІ форме адреса URI, такого как , анализатор документа XML Рё РґСЂСѓРіРёРµ программы, использующие документ, РЅРµ Р±СѓРґСѓС‚ обращаться РїРѕ этому адресу. Там даже может РЅРµ быть никакой Web-странички вообще. Просто идентификатор пространства имен должен быть уникальным РІРѕ всем Рнтернете, Рё разработчики рекомендации РїРѕ применению пространства имен, которую можно посмотреть РїРѕ адресу , справедливо решили, что будет СѓРґРѕР±РЅРѕ использовать для него DNS-РёРјСЏ сайта, РЅР° котором размещено определение пространства имен. Смотрите РЅР° URI просто как РЅР° строку символов, идентифицирующую пространство имен. Обычно указывается URL фирмы, создавшей данную реализацию XML, или РёРјСЏ файла СЃ описанием схемы XML.
Поскольку идентификатор — это строка символов, то и сравниваются они как строки, с учетом регистра символов. Например, идентификатор будет считаться XML-анализатором, отличным от идентификатора 2008/ntbml, введенного нами ранее, и будет определять другое пространство имен.
По правилам SGML и XML двоеточие может применяться в именах как обычный символ, поэтому имя с префиксом — это просто фокус, анализатор рассматривает его как обычное имя. Отсюда следует, что в описании DTD нельзя опускать префиксы имен. Некоторым анализаторам надо специально указать необходимость учета пространства имен. Например, при работе с анализатором Xerces следует применить метод
setNamespaceAware(true).
Атрибут xmlns, определяющий префикс имен, может появиться в любом элементе XML, а не только в корневом элементе. Определенный им префикс можно применять в том элементе, в котором записан атрибут xmlns, и во всех вложенных в него элементах. Больше того, в одном элементе можно определить несколько пространств имен:
xmlns:bk = "">
Появление имени тега без префикса в документе, использующем пространство имен, означает, что имя принадлежит пространству имен по умолчанию (default namespace). Например, язык XHTML допускает применение тегов HTML и XML в одном документе. Допустим, мы определили тег с именем title. Чтобы анализатор не принял его за один из тегов HTML, поступаем следующим образом:
xmlns:ntb = "">
MoH 6H6mHOTeKa
Созданиe Java Web Services
В этом примере пространством имен по умолчанию становится пространство имен XHTML, имеющее общеизвестный идентификатор , и теги, относящиеся к этому пространству имен, записываются без префикса.
Атрибуты никогда не входят в пространство имен по умолчанию. Если имя атрибута записано без префикса, то это означает, что атрибут не относится ни к одному пространству имен.
Префикс имени не относится к идентификатору пространства имен и может быть разным в разных документах. Например, в каком-нибудь другом документе мы можем написать корневой элемент
и записывать элементы с префиксом nb:
Более того, можно связать несколько префиксов с одним и тем же идентификатором пространства имен даже в одном документе, но это может привести к путанице, поэтому применяется редко.
Теперь, после того как мы ввели понятие пространства имен, можно обратиться к схеме XML.
Схема XML
В мае 2001 года консорциум W3C рекомендовал описывать структуру документов XML на языке описания схем XSD (XML Schema Definition Language). На этом языке составляются схемы XML (XML Schema), описывающие элементы документов XML.
Схема XML сама записывается как документ XML. Его элементы называют компонентами (components), чтобы отличить их от элементов описываемого документа XML. Корневой компонент схемы носит имя . Компоненты схемы описывают элементы XML и определяют различные типы элементов. Рекомендация схемы XML, которую можно найти по ссылкам, записанным по адресу , перечисляет 13 типов компонентов, но наиболее важны компоненты, определяющие простые и сложные типы элементов, сами элементы и их атрибуты.
Язык XSD различает простые и сложные элементы XML. Простыми (simple) элементами описываемого документа XML считаются элементы, не содержащие атрибутов и
вложенных элементов. Соответственно, сложные (complex) элементы содержат атрибуты и/или вложенные элементы. Схема XML описывает простые типы — типы простых элементов, и сложные типы — типы сложных элементов.
Язык описания схем содержит много встроенных простых типов. Они перечислены в следующем разделе.
Встроенные простые типы XSD
Встроенные типы языка описания схем XSD позволяют записывать двоичные и десятичные целые числа, вещественные числа, дату и время, строки символов, логические значения, адреса URI. Рассмотрим их по порядку.
Вещественные числа
Вещественные числа в языке XSD разделены на три типа: decimal, float и double.
РўРёРї decimal составляют вещественные числа, записанные СЃ фиксированной точкой: 123.45, -0.1234567689345 Рё С‚. Рґ. Фактически хранятся РґРІР° целых числа: мантисса Рё РїРѕСЂСЏРґРѕРє. Спецификация языка XSD РЅРµ ограничивает количество цифр РІ мантиссе, РЅРѕ требует, чтобы можно было записать РЅРµ менее 18 цифр. Ртот тип легко реализуется классом java.math.BigDecimal, описанным РІ главе 4.
Типы float и double соответствуют стандарту IEEE754-85 и одноименным типам Java. Они записываются с фиксированной или с плавающей десятичной точкой.
Целые числа
РћСЃРЅРѕРІРЅРѕР№ целый тип integer понимается как подтип типа decimal, содержащий числа СЃ нулевым РїРѕСЂСЏРґРєРѕРј. Рто целые числа СЃ любым количеством десятичных цифр: -34567, 123456789012345 Рё С‚. Рґ. Данный тип легко реализуется классом java.math.BigInteger, описанным РІ главе 4.
Типы long, int, short и byte полностью соответствуют одноименным типам Java. Они понимаются как подтипы типа integer, типы более коротких чисел считаются подтипами более длинных чисел: тип byte — это подтип типа short, оба они подтипы типа int и т. д.
Типы nonPositiveInteger и negativeInteger — подтипы типа integer — составлены из неположительных и отрицательных чисел соответственно с любым количеством цифр.
Типы nonNegativeInteger и positiveInteger — подтипы типа integer — составлены из неотрицательных и положительных чисел соответственно с любым количеством цифр.
У типа nonNegativeInteger есть подтипы беззнаковых целых чисел unsignedLong, unsignedInt, unsignedShort и unsignedByte.
Строки символов
Основной символьный тип string описывает произвольную строку символов Unicode. Его можно реализовать классом java.lang.String.
Тип normalizedString — подтип типа string — это строки, не содержащие символы перевода строки '\n', возврата каретки '\r' и символы горизонтальной табуляции '\t'.
В строках типа token — подтипа типа normalizedString — нет, кроме того, начальных и завершающих пробелов и нет нескольких подряд идущих пробелов.
В типе token выделены три подтипа. Подтип language определен для записи названия языка согласно RFC 1766, например: ru, en, de, fr. Подтип nmtoken используется только в атрибутах для записи их перечисляемых значений. Подтип name составляют имена XML — последовательности букв, цифр, дефисов, точек, двоеточий, знаков подчеркивания, начинающиеся с буквы (кроме зарезервированной последовательности букв X, x, м, m, l, l в любом сочетании регистров) или знака подчеркивания. Двоеточие в значениях типа name используется для выделения префикса пространства имен.
РР· типа name выделен подтип NCName (Non-Colonized Name) имен, РЅРµ содержащих двоеточия, РІ котором, РІ СЃРІРѕСЋ очередь, определены три подтипа: id, entity, idref, описывающие идентификаторы XML, сущности Рё перекрестные ссылки.
Дата и время
Тип duration описывает промежуток времени, например запись P1Y2M3DT10H30M45S означает один год (1y), два месяца (2м), три дня (3d), десять часов (10h), тридцать минут (30м) и сорок пять секунд (45s). Запись может быть сокращенной, например P120M означает 120 месяцев, а T120M — 120 минут.
Тип dateTime содержит дату и время в формате CCYY-MM-DDThh:mm:ss, например 2008 — 04 — 25Т09:30: 05. Остальные типы выделяют какую-либо часть даты или времени.
Тип time содержит время в обычном формате hh:mm:ss.
Тип date содержит дату в формате ccyy-mm-dd.
Тип gYearMonth выделяет год и месяц в формате CCYY-MM.
Тип gMonthDay содержит месяц и день месяца в формате -mm-dd.
Тип gYear означает год в формате CCYY, тип gMonth- месяц в формате -mm-, тип gDay —
день месяца в формате -dd.
Двоичные типы
Двоичные целые числа записываются либо в шестнадцатеричной форме без всяких дополнительных символов: 0B2F, 356C0A и т. д., это тип hexBinary, либо в кодировке Base64,
это тип base64Binary.
Прочие встроенные простые типы
Еще три встроенных простых типа описывают значения, часто используемые в документах XML.
Адреса URI относятся к типу anyURI.
Расширенное имя тега или атрибута (qualified name), т. е. имя вместе с префиксом, отделенным от имени двоеточием,-это тип QName.
Рлемент notation описания DTD выделен как отдельный простой тип схемы XML. Его используют для записи математических, химических Рё РґСЂСѓРіРёС… символов, РЅРѕС‚, азбуки Брайля Рё прочих обозначений.
Определение простых типов
В схемах XML с помощью встроенных типов можно тремя способами определить новые типы простых элементов. Они вводятся как сужение (restriction) встроенного или ранее определенного простого типа, список (list) или объединение (union) простых типов.
Простой тип определяется компонентом схемы , имеющим вид:
Определение TMna
Сужение
Сужение простого типа определяется компонентом , в котором атрибут base указывает сужаемый простой тип, а в теле задаются ограничения, выделяющие определяемый простой тип. Например, почтовый индекс zip можно задать как шесть арабских цифр следующим образом:
Можно дать другое определение простого типа zip как целого положительного числа, находящегося в диапазоне от 100 000 до 999 999:
Теги , и другие теги, задающие ограничения, называются фасетками (facets). Вот их список:
□ — наибольшее значение, оно уже не входит в определяемый тип;
□ — наибольшее значение определяемого типа;
□ — наименьшее значение, уже не входящее в определяемый тип;
□ — наименьшее значение определяемого типа;
□ — общее количество цифр в определяемом числовом типе — сужении типа decimal;
□ — количество цифр в дробной части числа;
□ — длина значений определяемого типа;
□ — наибольшая длина значений определяемого типа;
□ — наименьшая длина значений определяемого типа;
□ — одно из перечисляемых значений;
□ — регулярное выражение [8];
□ — применяется при сужении типа string и определяет способ преобразования пробельных символов '\n', '\r', '\t'. Атрибут value этого тега принимает одно из трех значений:
• preserve — не убирать пробельные символы;
• replace — заменить пробельные символы пробелами;
• collapse — после замены пробельных символов пробелами убрать начальные и конечные пробелы, а из нескольких подряд идущих пробелов оставить только один.
В тегах-фасетках можно записывать следующие атрибуты, называемые базисными фасетками (fundamental facets):
□ ordered — задает упорядоченность определяемого типа, принимает одно из трех значений:
• false — тип неупорядочен;
• partial — тип частично упорядочен;
• total — тип полностью упорядочен;
□ bounded — задает ограниченность или неограниченность типа значениями true или
false;
□ cardinality — задает конечность или бесконечность типа значениями finite или
countably infinite;
□ numeric — показывает, числовой этот тип или нет, значениями true или false.
Как видно из приведенных ранее и далее примеров, в одном сужении может быть несколько ограничений-фасеток. При этом фасетки и задают независимые друг от друга ограничения, их можно мысленно объединить союзом "или". Остальные фасетки задают общие, совместно накладываемые ограничения, их можно мысленно объединить союзом "и".
РЎРїРёСЃРѕРє
Простой тип-список — это тип элементов, в теле которых записывается, через пробел, несколько значений одного и того же простого типа. Например, в документе XML может встретиться такой элемент, содержащий список целых чисел:
21 34 55 46
Список определяется компонентом , в котором атрибутом itemType указывается тип элементов определяемого списка. Тип элементов списка можно указать и в теле элемента . Например, показанный ранее элемент документа XML можно определить в схеме так:
а использованный при его определении тип listOfInteger задать как список не более чем из пяти целых чисел следующим образом:
При определении списка можно применять фасетки , , , , . В приведенном примере список — тело элемента — не может содержать более пяти чисел.
Объединение
Простой тип-объединение определяется компонентом , в котором атрибутом memberTypes можно указать имена объединяемых типов. Например:
Другой способ — записать в теле компонента определения простых типов, входящих в объединение. Например:
После этого атрибут size можно использовать, например, так:
Простой TeKCT
Описание элементов и их атрибутов
Рлементы, которые Р±СѓРґСѓС‚ применяться РІ документе XML, описываются РІ схеме компонентом :
minOccurs="наименьшее число появлений элемента в документе" maxOccurs="наибольшее число появлений" />
Значение РїРѕ умолчанию необязательных атрибутов minOccurs Рё maxOccurs равно 1. Рто означает, что если эти атрибуты отсутствуют, то элемент должен появиться РІ документе XML СЂРѕРІРЅРѕ РѕРґРёРЅ раз. Определение типа элемента можно вынести РІ тело элемента
:
Определение типа элемента
Описание атрибута элемента тоже несложно:
use="обязательность атрибута" default="значение по умолчанию" />
Необязательный атрибут use принимает три значения:
□ optional — описываемый атрибут необязателен (это значение по умолчанию);
□ required — описываемый атрибут обязателен;
в–Ў prohibited — описываемый атрибут неприменим. Рто значение полезно РїСЂРё определении подтипа, чтобы отменить некоторые атрибуты базового типа.
Если описываемый атрибут необязателен, то атрибутом default можно задать его значение по умолчанию.
Определение типа атрибута — а это должен быть простой тип — можно вынести в тело элемента :
Тип атрибута
Определение сложных типов
Напомним, что тип элемента называется сложным, если в элемент вложены другие элементы и/или в открывающем теге элемента есть атрибуты.
Сложный тип определяется компонентом , имеющим вид:
Определение типа
Необязательный атрибут name задает имя типа, а в теле компонента описываются элементы, входящие в сложный тип, и/или атрибуты открывающего тега.
Определение сложного типа можно разделить на определение типа пустого элемента, элемента с простым телом и элемента, содержащего вложенные элементы. Рассмотрим эти определения подробнее.
Определение типа пустого элемента
Проще всего определяется тип пустого элемента — элемента, не имеющего тела, а содержащего только атрибуты в открывающем теге. Таков, например, элемент из листинга 28.2. Каждый атрибут описывается одним компонентом , например:
После этого определения можно в схеме описать элемент типа imageType:
а в документе XML использовать это описание:
Определение типа элемента с простым телом
Немного сложнее описание элемента, содержащего тело простого типа Рё атрибуты РІ открывающем теге. Ртот тип отличается РѕС‚ простого типа только наличием атрибутов Рё определяется компонентом . Р’ теле данного компонента должен быть либо компонент , либо компонент , атрибутом base задающий тип (простой) тела описываемого элемента.
В компоненте описываются атрибуты открывающего тега описываемого элемента. Все вместе выглядит так, как в следующем примере:
type="xsd:nonNegativeInteger" />
Рту конструкцию можно описать словами так: "Определяется тип calcResultType элемента, тело которого содержит значения встроенного простого типа xsd:decimal. Простой тип расширяется тем, что Рє нему добавляются атрибуты unit Рё precision".
Если в схеме описать элемент этого типа следующим образом:
то в документе XML можно написать
123.25
В компоненте кроме атрибутов описывается простой тип тела элемента и/или фасетки, ограничивающие тип, заданный атрибутом base. Например:
type="xsd:nonNegativeInteger" />
Определение типа вложенных элементов
Если значениями определяемого сложного типа будут элементы, содержащие вложенные элементы, как, например, элементы
, листинга 28.2, то перед перечислением описания вложенных элементов надо выбрать модель РіСЂСѓРїРїС‹ (model group) вложенных элементов. Дело РІ том, что вложенные элементы, составляющие определяемый тип, РјРѕРіСѓС‚ появляться или РІ определенном РїРѕСЂСЏРґРєРµ, или РІ произвольном РїРѕСЂСЏРґРєРµ, РєСЂРѕРјРµ того, можно выбирать только РѕРґРёРЅ РёР· перечисленных элементов. Рта возможность Рё называется моделью РіСЂСѓРїРїС‹ элементов. РћРЅР° определяется РѕРґРЅРёРј РёР· трех компонентов: , или .
Компонент применяется в том случае, когда перечисляемые элементы должны записываться в документе в конкретном порядке. Пусть, например, мы описываем книгу. Сначала определяем тип:
Потом описываем элемент:
Рлементы , , <pages> Рё <publisher> должны входить РІ элемент <book> именно РІ таком РїРѕСЂСЏРґРєРµ. Р’ документе XML надо писать: </p>
<p class="paragraph">
<book> </p>
<p class="paragraph">
<author>H. Рльф, Р•. neTpoB</author> </p>
<p class="paragraph">
^^^>Золотой тeлeнок
Художeствeнная литература
Если же вместо компонента записать компонент , то элементы
, , <pages> и <publisher> можно перечислять в любом порядке. </p>
<p class="paragraph">
Компонент <choice> применяется РІ том случае, РєРѕРіРґР° надо выбрать РѕРґРёРЅ РёР· нескольких элементов. Например, РїСЂРё описании журнала вместо издательства, описываемого элементом <publisher>, следует записать название журнала. Рто можно определить так: </p>
<p class="paragraph">
<xsd:complexType name="bookType"> </p>
<p class="paragraph">
<xsd:sequence maxOccurs="unbounded"> </p>
<p class="paragraph">
<xsd:element name="author" type="xsd:normalizedString" minOccurs="0" /> </p>
<p class="paragraph">
<xsd:element name="title" type="xsd:normalizedString" /> </p>
<p class="paragraph">
<xsd:element name="pages" type="xsd:positiveInteger" minOccurs="0" /> </p>
<p class="paragraph">
<xsd:choice> </p>
<p class="paragraph">
<xsd:element name="publisher" type="xsd:normalizedString" minOccurs="0" /> </p>
<p class="paragraph">
<xsd:element name="magazine" type="xsd:normalizedString" minOccurs="0" /> </p>
<p class="paragraph">
</xsd:choice> </p>
<p class="paragraph">
</xsd:sequence> </p>
<p class="paragraph">
</xsd:complexType> </p>
<p class="paragraph">
Как видно из приведенного примера, компонент <choice> можно вложить в компонент <sequence>. Можно, наоборот, вложить компонент <sequence> в компонент <choice>. Такие вложения допустимо проделывать сколько угодно раз. Кроме того, каждая группа в этих моделях может появиться сколько угодно раз, т. е. в компоненте <choice> тоже разрешено записать атрибут maxOccurs="unbounded". </p>
<p class="paragraph">
Модель группы <all> отличается в этом от моделей <sequence> и <choice>. В компоненте <all> не допускается применение компонентов <sequence> и <choice>. Обратно, в компонентах <sequence> и <choice> нельзя применять компонент <all>. Каждый элемент, входящий в группу модели <all>, может появиться не более одного раза, т. е. атрибут maxOccurs этого элемента может равняться только единице. </p>
<p class="paragraph">
Определение типа со сложным телом
</p>
<p class="paragraph">
При определении сложного типа можно воспользоваться уже определенным, базовым, сложным типом, расширив его дополнительными элементами или, наоборот, удалив из него некоторые элементы. Для этого надо применить компонент <complexContent>. В этом компоненте, так же как и в компоненте <simpleContent>, записывается либо компонент <extension>, если нужно расширить базовый тип, либо компонент <restriction>, если необходимо сузить базовый тип. Базовый тип указывается атрибутом base, так же как и при записи компонента <simpleContent>, но теперь это должен быть сложный, а не простой тип! </p>
<p class="paragraph">
Расширим, например, определенный ранее тип bookType, добавив год издания — элемент <year>: </p>
<p class="paragraph">
<xsd:complexType name="newBookType"> </p>
<p class="paragraph">
<xsd:complexContent> </p>
<p class="paragraph">
<xsd:extension base="bookType"> </p>
<p class="paragraph">
<xsd:sequence> </p>
<p class="paragraph">
<xsd:element name="year" type="xsd:gYear"> </p>
<p class="paragraph">
</xsd:sequence> </p>
<p class="paragraph">
</xsd:extension> </p>
<p class="paragraph">
</xsd:complexContent> </p>
<p class="paragraph">
</xsd:complexType> </p>
<p class="paragraph">
При сужении базового типа компонентом <restriction> надо перечислить те элементы, которые останутся после сужения. Например, оставим в типе newbookType только автора и название книги из типа bookType: </p>
<p class="paragraph">
<xsd:complexType name="newBookType"> </p>
<p class="paragraph">
<xsd:complexContent> </p>
<p class="paragraph">
<xsd:restriction base="bookType"> </p>
<p class="paragraph">
<xsd:sequence> </p>
<p class="paragraph">
<xsd:element name="author" type="xsd:normalizedString" minOccurs="0" /> </p>
<p class="paragraph">
<xsd:element name="title" type="xsd:normalizedString" /> </p>
<p class="paragraph">
</xsd:sequence> </p>
<p class="paragraph">
</xsd:restriction> </p>
<p class="paragraph">
</xsd:complexContent> </p>
<p class="paragraph">
</xsd:complexType> </p>
<p class="paragraph">
Рто описание выглядит странно. Почему надо заново описывать РІСЃРµ элементы, остающиеся после сужения? РќРµ проще ли определить новый тип? </p>
<p class="paragraph">
Дело в том, что в язык XSD внесены элементы объектно-ориентированного программирования, которых мы не будем касаться. Расширенный и суженный типы связаны со своим базовым типом отношением наследования, и к ним можно применить операцию подстановки. У всех типов языка XSD есть общий предок базовый тип anyType. От </p>
<p class="paragraph">
него наследуются РІСЃРµ сложные типы. Рто РїРѕРґРѕР±РЅРѕ тому, как Сѓ всех классов Java есть общий предок — класс Object, Р° РІСЃРµ массивы наследуются РѕС‚ него. РћС‚ базового типа anyType наследуется Рё тип anySimpleType — общий предок всех простых типов. </p>
<p class="paragraph">
Таким образом, сложные типы определяются как сужение типа anyType. Если строго подходить к определению сложного типа, то определение типа bookType, сделанное в начале предыдущего раздела, надо записать так: </p>
<p class="paragraph">
<xsd:complexType name="bookType"> </p>
<p class="paragraph">
<xsd:complexContent> </p>
<p class="paragraph">
<xsd:restriction base="xsd:anyType"> </p>
<p class="paragraph">
<xsd:sequence maxOccurs="unbounded"> </p>
<p class="paragraph">
<xsd:element name="author" type="xsd:normalizedString" minOccurs="0" /> </p>
<p class="paragraph">
<xsd:element name="title" type="xsd:normalizedString" /> </p>
<p class="paragraph">
<xsd:element name="pages" type="xsd:positiveInteger" minOccurs="0" /> </p>
<p class="paragraph">
<xsd:element name="publisher" type="xsd:normalizedString" minOccurs="0" /> </p>
<p class="paragraph">
</xsd:sequence> </p>
<p class="paragraph">
</xsd:restriction> </p>
<p class="paragraph">
</xsd:complexContent> </p>
<p class="paragraph">
</xsd:complexType> </p>
<p class="paragraph">
Рекомендация языка XSD позволяет сократить эту запись, что РјС‹ Рё сделали РІ предыдущем разделе. Рто РїРѕРґРѕР±РЅРѕ тому, как РІ Java РјС‹ опускаем слова "extends Object" РІ заголовке описания класса. </p>
<p class="paragraph">
Закончим на этом описание языка XSD и перейдем к примерам. </p>
<p>
Пример: схема адресной книги
</p> <p class="paragraph">
В листинге 28.4 записана схема документа, приведенного в листинге 28.2. </p>
<p class="paragraph">
Листинг 28.4. Схема документа XML
</p>
<p class="paragraph">
<?xml version="1.0"?> </p>
<p class="paragraph">
<xsd:schema xmlns:xsd="" </p>
<p class="paragraph">
xmlns:ntb="" targetNamespace=""> </p>
<p class="paragraph">
<xsd:element name="notebook" type="ntb:notebookType" /> </p>
<p class="paragraph">
<xsd:complexType name="notebookType"> </p>
<p class="paragraph">
<xsd:element name="person" type="ntb:personType" </p>
<p class="paragraph">
minOccurs="0" maxOccurs="unbounded" /> </p>
<p class="paragraph">
<xsd:complexType name="personType"> </p>
<p class="paragraph">
<xsd:sequence> </p>
<p class="paragraph">
<xsd:element name="name"> </p>
<p class="paragraph">
<xsd:complexType> </p>
<p class="paragraph">
<xsd:attribute name="first" type="xsd:string" use="optional" /> </p>
<p class="paragraph">
<xsd:attribute name="second" type="xsd:string" use="optional" /> <xsd:attribute name="surname" type="xsd:string" use="required" /> </xsd:complexType> </p>
<p class="paragraph">
</xsd:element> </p>
<p class="paragraph">
<xsd:element name="birthday" type="ntb:ruDate" minOccurs="0" /> </p>
<p class="paragraph">
<xsd:element name="address" type="ntb:addressType" minOccurs="0" maxOccurs="unbounded" /> </p>
<p class="paragraph">
<xsd:element name="phone-list" type="ntb:phone-listType" minOccurs="0" /> </p>
<p class="paragraph">
</xsd:sequence> </p>
<p class="paragraph">
</xsd:complexType> </p>
<p class="paragraph">
<xsd:complexType name="addressType" > </p>
<p class="paragraph">
<xsd:sequence> </p>
<p class="paragraph">
<xsd:element name="street" type="xsd:string" /> </p>
<p class="paragraph">
<xsd:element name="city" type="ntb:cityType" /> </p>
<p class="paragraph">
<xsd:element name="zip" type="xsd:positiveInteger" /> </p>
<p class="paragraph">
</xsd:sequence> </p>
<p class="paragraph">
</xsd:complexType> </p>
<p class="paragraph">
<xsd:complexType name='cityType'> </p>
<p class="paragraph">
<xsd:simpleContent> </p>
<p class="paragraph">
<xsd:extension base=,xsd:string' > </p>
<p class="paragraph">
<xsd:attribute name='type' type='ntb:placeType' default=’город’ /> </xsd:extension> </p>
<p class="paragraph">
</xsd:simpleContent> </p>
<p class="paragraph">
</xsd:complexType> </p>
<p class="paragraph">
<xsd:simpleType name="placeType"> </p>
<p class="paragraph">
<xsd:restriction base = "xsd:string"> </p>
<p class="paragraph">
<xsd:enumeration СѓР°1РёРµ="РіРѕСЂРѕРґ" /> </p>
<p class="paragraph">
<xsd:enumeration уа1ие="поселок" /> </p>
<p class="paragraph">
<xsd:enumeration value^^epeBHH" /> </p>
<p class="paragraph">
</xsd:restriction> </p>
<p class="paragraph">
</xsd:simpleType> </p>
<p class="paragraph">
<xsd:complexType name="phone-listType"> </p>
<p class="paragraph">
<xsd:element name="work-phone" type="xsd:string" </p>
<p class="paragraph">
minOccurs="0" maxOccurs="unbounded" /> </p>
<p class="paragraph">
<xsd:element name="home-phone" type="xsd:string" </p>
<p class="paragraph">
minOccurs="0" maxOccurs="unbounded" /> </p>
<p class="paragraph">
</xsd:complexType> <xsd:simpleType name="ruDate"> </p>
<p class="paragraph">
<xsd:restriction base="xsd:string"> </p>
<p class="paragraph">
<xsd:pattern value="[0-9] {2}. [0-9]{2}.[0-9] {4}" /> </xsd:restriction> </p>
<p class="paragraph">
</xsd:simpleType> </p>
<p class="paragraph">
</xsd:schema> </p>
<p class="paragraph">
Листинг 28.4, как обычный документ XML, начинается СЃ пролога, показывающего версию XML Рё определяющего стандартное пространство имен схемы XML СЃ идентификатором . Ртому идентификатору дан префикс xsd. Конечно, префикс может быть РґСЂСѓРіРёРј, часто пишут префикс xs. </p>
<p class="paragraph">
Еще РЅРµ встречавшийся нам атрибут targetNamespace определяет идентификатор пространства имен, РІ которое попадут определяемые РІ этом документе имена типов, элементов Рё атрибутов, так называемое целевое пространство имен (target namespace). Ртот идентификатор сразу же связывается СЃ префиксом ntb, который тут же используется для уточнения только что определенных имен РІ ссылках РЅР° РЅРёС…. </p>
<p class="paragraph">
Р’СЃРµ описание схемы нашей адресной книжки заключено РІ РѕРґРЅРѕР№ третьей строке, РІ которой указано, что адресная РєРЅРёРіР° состоит РёР· РѕРґРЅРѕРіРѕ элемента СЃ именем notebook, имеющего сложный тип notebookType. Ртот элемент должен появиться РІ документе СЂРѕРІРЅРѕ РѕРґРёРЅ раз. Остаток листинга 28.4 посвящен описанию типа этого элемента Рё РґСЂСѓРіРёС… типов. </p>
<p class="paragraph">
Описание сложного типа notebookType несложно (простите за каламбур). Оно занимает три строки листинга, не считая открывающего и закрывающего тега, и просто говорит о том, что данный тип составляют несколько элементов person типа personType. </p>
<p class="paragraph">
Описание типа personType немногим сложнее. Оно говорит, что этот тип составляют четыре элемента: name, birthday, address и phone-list. Для элемента name сразу же указаны необязательные атрибуты first и second простого типа string, определенного в пространстве имен xsd. Тип обязательного атрибута surname тоже string. </p>
<p class="paragraph">
Далее в листинге 28.4 определяются оставшиеся типы: addressType, phone-listType и ruDate. Необходимость определения простого типа ruDate возникает потому, что встроенный в схему XML тип date предписывает задавать дату в виде 2004-10-22, а в России принят формат 22.10.2004. Тип ruDate определяется как сужение (restriction) типа string с помощью шаблона. Шаблон (pattern) для записи даты в виде дц.мм.гггг задается регулярным выражением. </p>
<p>
Безымянные типы
</p> <p class="paragraph">
Р’СЃРµ описанные РІ листинге 28.4 типы используются только РѕРґРёРЅ раз. Поэтому необязательно давать типу РёРјСЏ. Схема XML, как говорилось ранее, позволяет определять безымянные типы. Такое определение дается внутри описания элемента. Рменно так РІ листинге 28.4 описаны атрибуты элемента name. Р’ листинге 28.5 показано упрощенное описание схемы адресной РєРЅРёРіРё. </p>
<p class="paragraph">
Листинг 28.5. Схема документа XML с безымянными типами
</p>
<p class="paragraph">
<?xml version=,1.0,?> </p>
<p class="paragraph">
<xsd:schema xmlns:xsd=’ </p>
<p class="paragraph">
targetNamespace='> </p>
<p class="paragraph">
<xsd:element name='notebook'> </p>
<p class="paragraph">
<xsd:complexType> </p>
<p class="paragraph">
<xsd:sequence> </p>
<p class="paragraph">
<xsd:element name=iperson’ maxOccurs=iunbounded’> </p>
<p class="paragraph">
<xsd:complexType> </p>
<p class="paragraph">
<xsd:sequence> </p>
<p class="paragraph">
<xsd:element name=’name’> </p>
<p class="paragraph">
<xsd:complexType> </p>
<p class="paragraph">
<xsd:attribute name=,first' type=’xsd:string’ use=’optional’ /> <xsd:attribute name='second' type=’xsd:string’ use=’optional’ /> <xsd:attribute name='surnamel type=’xsd:string’ use=’required’ /> </xsd:complexType> </p>
<p class="paragraph">
</xsd:element> </p>
<p class="paragraph">
<xsd:element name=’birthday’> </p>
<p class="paragraph">
<xsd:simpleType> </p>
<p class="paragraph">
<xsd:restriction base=’xsd:string’> </p>
<p class="paragraph">
<xsd:pattern value=’[0-9]{2}.[0-9]{2}.[0-9]{4}’ /> </xsd:restriction> </p>
<p class="paragraph">
</xsd:simpleType> </p>
<p class="paragraph">
</xsd:element> </p>
<p class="paragraph">
<xsd:element name=’address’ maxOccurs=’unbounded’> </p>
<p class="paragraph">
<xsd:complexType> </p>
<p class="paragraph">
<xsd:sequence> </p>
<p class="paragraph">
<xsd:element name=’street’ type=’xsd:string’ /> </p>
<p class="paragraph">
<xsd:element name=’cityi> </p>
<p class="paragraph">
<xsd:complexType> </p>
<p class="paragraph">
<xsd:simpleContent> </p>
<p class="paragraph">
<xsd:extension base=’xsd:string’> </p>
<p class="paragraph">
<xsd:attribute name=’type’ type=’xsd:string’ </p>
<p class="paragraph">
use=’optional’ default=’gorod’ /> </p>
<p class="paragraph">
</xsd:extension> </p>
<p class="paragraph">
</xsd:simpleContent> </p>
<p class="paragraph">
</xsd:complexType> </p>
<p class="paragraph">
</xsd:element> </p>
<p class="paragraph">
<xsd:element name=’zip’ type=’xsd:positiveIntegeri /> </p>
<p class="paragraph">
</xsd:sequence> </p>
<p class="paragraph">
</xsd:complexType> </p>
<p class="paragraph">
</xsd:element> </p>
<p class="paragraph">
<xsd:element name=’phone-list’> </p>
<p class="paragraph">
<xsd:complexType> </p>
<p class="paragraph">
<xsd:sequence> </p>
<p class="paragraph">
<xsd:element name=’work-phone’ type=’xsd:string’ </p>
<p class="paragraph">
minOccurs=’0’ maxOccurs=’unbounded’ /> </p>
<p class="paragraph">
<xsd:element name=’home-phone’ type=’xsd:string’ </p>
<p class="paragraph">
minOccurs=’0’ maxOccurs=’unbounded’ /> </p>
<p class="paragraph">
</xsd:sequence> </p>
<p class="paragraph">
</xsd:complexType> </p>
<p class="paragraph">
</xsd:element> </p>
<p class="paragraph">
</xsd:sequence> </p>
<p class="paragraph">
</xsd:complexType> </p>
<p class="paragraph">
</xsd:element> </p>
<p class="paragraph">
</xsd:sequence> </p>
<p class="paragraph">
</xsd:complexType> </p>
<p class="paragraph">
</xsd:element> </p>
<p class="paragraph">
</xsd:schema> </p>
<p class="paragraph">
Еще одно упрощение можно сделать, используя пространство имен по умолчанию. Посмотрим, какие пространства имен применяются в схемах XML. </p>
<p>
Пространства имен языка XSD
</p> <p class="paragraph">
Рмена элементов Рё атрибутов, используемые РїСЂРё записи схем, определены РІ пространстве имен СЃ идентификатором . Префикс имен, относящихся Рє этому пространству, часто называют xs или xsd, как РІ листингах 28.4 Рё 28.5. Каждый анализатор "знает" это пространство имен Рё "понимает" имена РёР· этого пространства. </p>
<p class="paragraph">
Можно сделать это пространство имен пространством по умолчанию, но тогда надо обязательно определить префикс идентификатора целевого пространства имен для определяемых в схеме типов и элементов. </p>
<p class="paragraph">
Р’ листинге 28.6 для упрощения записи стандартное пространство имен схемы XML СЃ идентификатором сделано пространством имен РїРѕ умолчанию. Рмена, относящиеся Рє целевому пространству имен, снабжены префиксом ntb, чтобы РѕРЅРё РЅРµ попали РІ пространство имен РїРѕ умолчанию. </p>
<p>
Листинг 28.6. Схема документа XML с целевым пространством имен
</p> <p class="paragraph">
<?xml version=’1.0’?> </p>
<p class="paragraph">
<schema xmlns=’ </p>
<p class="paragraph">
targetNamespace=’ xmlns:ntb=’> </p>
<p class="paragraph">
<element name=’notebook’> </p>
<p class="paragraph">
<complexType> </p>
<p class="paragraph">
<sequence> </p>
<p class="paragraph">
<element name=’person’ maxOccurs=’unbounded’> <complexType> </p>
<p class="paragraph">
<sequence> </p>
<p class="paragraph">
<element name=’name’> </p>
<p class="paragraph">
<complexType> </p>
<p class="paragraph">
<attribute name=’first’ type=’string’ use=’optional’ /> </p>
<p class="paragraph">
<attribute name=’second’ type=’string’ use=’optional’ /> </p>
<p class="paragraph">
<attribute name=’surname’ type=’string’ use=’required’ /> </p>
<p class="paragraph">
</complexType> </p>
<p class="paragraph">
</element> </p>
<p class="paragraph">
<element name=’birthdayi> </p>
<p class="paragraph">
<simpleType> </p>
<p class="paragraph">
<restriction base=istringi> </p>
<p class="paragraph">
<pattern value=i[0-9]{2}.[0-9]{2}.[0-9]{4}i /> </p>
<p class="paragraph">
</restriction> </p>
<p class="paragraph">
</simpleType> </p>
<p class="paragraph">
</element> </p>
<p class="paragraph">
<element name=iaddressi maxOccurs=iunboundedi> </p>
<p class="paragraph">
<complexType> </p>
<p class="paragraph">
<sequence> </p>
<p class="paragraph">
<element name=istreet type=istringi /> </p>
<p class="paragraph">
<element name=icityi type=istringi /> </p>
<p class="paragraph">
<element name=izipi type=ipositiveIntegeri /> </p>
<p class="paragraph">
</sequence> </p>
<p class="paragraph">
</complexType> </p>
<p class="paragraph">
</element> </p>
<p class="paragraph">
<element name=iphone-lisf> </p>
<p class="paragraph">
<complexType> </p>
<p class="paragraph">
<sequence> </p>
<p class="paragraph">
<element name=iwork-phonei type=istringi </p>
<p class="paragraph">
minOccurs=i0i maxOccurs=iunboundedi/> </p>
<p class="paragraph">
<element name=ihome-phonei type=istringi </p>
<p class="paragraph">
minOccurs=i0i maxOccurs=iunboundedi/> </p>
<p class="paragraph">
</sequence> </p>
<p class="paragraph">
</complexType> </p>
<p class="paragraph">
</element> </p>
<p class="paragraph">
</sequence> </p>
<p class="paragraph">
</complexType> </p>
<p class="paragraph">
</element> </p>
<p class="paragraph">
</sequence> </p>
<p class="paragraph">
</complexType> </p>
<p class="paragraph">
</element> </p>
<p class="paragraph">
</schema> </p>
<p>Поскольку в листинге 28.6 пространством имен по умолчанию сделано пространство </p> <p class="paragraph">
, префикс xsd не нужен. </p>
<p>Следует заметить, что РІ целевое пространство имен попадают только глобальные имена, чьи описания непосредственно вложены РІ элемент <schema>. Рто естественно, потому что лишь глобальными именами можно воспользоваться далее РІ этой или РґСЂСѓРіРѕР№ схеме. Р’ листинге 28.6 только РѕРґРЅРѕ глобальное РёРјСЏ — <notebook>. Вложенные имена name, address Рё РґСЂСѓРіРёРµ всего-навсего ассоциированы СЃ глобальными именами. </p> <p class="paragraph">
Р’ схемах Рё документах XML часто применяется еще РѕРґРЅРѕ стандартное пространство имен. Рекомендация языка XSD определяет несколько атрибутов: type, nil, schemaLocation, noNamespaceSchemaLocation, которые применяются РЅРµ только РІ схемах, РЅРѕ Рё непосредственно РІ описываемых этими схемами документах XML, называемых экземплярами схем (XML schema instance). Рмена этих атрибутов относятся Рє пространству имен . Данному пространству имен чаще всего приписывают префикс xsi, например: </p>
<p class="paragraph">
<xsd:schema xmlns:xsd="" </p>
<p class="paragraph">
xmlns:xsi=""> </p>
<p>
Включение файлов схемы в другую схему
</p> <p class="paragraph">
В создаваемую схему можно включить файлы, содержащие другие схемы. Для этого есть два элемента схемы: <include> и <import>. Например: </p>
<p class="paragraph">
<xsd:include xsi:schemaLocation="names.xsd" /> </p>
<p class="paragraph">
Включаемый файл задается атрибутом xsi:schemaLocation. Р’ примере РѕРЅ использован для того, чтобы включить РІ создаваемую схему содержимое файла names.xsd. Файл должен содержать схему СЃ описаниями Рё определениями РёР· того же пространства имен, что Рё РІ создаваемой схеме, или без пространства имен, С‚. Рµ. РІ нем РЅРµ использован атрибут targetNamespace. Рто СѓРґРѕР±РЅРѕ, если РјС‹ хотим добавить Рє создаваемой схеме определения схемы names.xsd или просто хотим разбить большую схему РЅР° РґРІР° файла. Можно представить себе результат включения так, как будто содержимое файла names.xsd просто записано РЅР° месте элемента <include>. </p>
<p class="paragraph">
Перед включением файла можно изменить некоторые определения, приведенные в нем. Для этого используется элемент <redefine>, например: </p>
<p class="paragraph">
<xsd:redefine schemaLocation="names.xsd"> </p>
<p class="paragraph">
<xsd:simpleType name="nameType"> </p>
<p class="paragraph">
<xsd:restriction base="xsd:string"> </p>
<p class="paragraph">
<xsd:maxLength value="40"/> </p>
<p class="paragraph">
</xsd:restriction> </p>
<p class="paragraph">
</xsd:simpleType> </p>
<p class="paragraph">
</xsd:redefine> </p>
<p class="paragraph">
Если же включаемый файл содержит имена из другого пространства имен, то надо воспользоваться элементом схемы <import>. Например, пусть файл A.xsd начинается со следующих определений: </p>
<p class="paragraph">
<?xml version="1.0"?> </p>
<p class="paragraph">
<xsd:schema xmlns:xsd="" targetNamespace=""> </p>
<p class="paragraph">
а файл B.xsd начинается с определений </p>
<p class="paragraph">
<?xml version="1.0"?> </p>
<p class="paragraph">
<xsd:schema xmlns:xsd="" targetNamespace=""> </p>
<p class="paragraph">
РњС‹ решили включить эти файлы РІ новый файл C.xsd. Рто делается так: </p>
<p class="paragraph">
<?xml version="1.0"?> </p>
<p class="paragraph">
<xsd:schema xmlns:xsd="" targetNamespace="" xmlns:pr1="" xmlns:pr2=""> </p>
<p class="paragraph">
<xsd:import namespace="" xsi:schemaLocation="A.xsd" /> </p>
<p class="paragraph">
<xsd:import namespace="" xsi:schemaLocation="B.xsd" /> </p>
<p class="paragraph">
После этого в файле C.xsd можно использовать имена, определенные в файлах A.xsd и B.xsd, снабжая их префиксами pr1 и pr2 соответственно. </p>
<p class="paragraph">
Рлементы <include> Рё <import> следует располагать перед всеми определениями схемы. </p>
<p class="paragraph">
Значение атрибута xsi:schemaLocation — строка URI, поэтому файл СЃ включаемой схемой может располагаться РІ любом месте Рнтернета. </p>
<p>
Связь документа XML со своей схемой
</p> <p class="paragraph">
Программе-анализатору, проверяющей соответствие документа XML его схеме, надо как-то указать файлы (РѕРґРёРЅ или несколько), содержащие схему документа. Рто можно сделать разными способами. Р’Рѕ-первых, можно подать необходимые файлы РЅР° РІС…РѕРґ анализатора. Так делает, например, проверяющий анализатор XSV (XML Schema Validator) — ftp://ftp.cogsci.ed.ac.uk/pub/XSV/: </p>
<p class="paragraph">
$ xsv ntb.xml ntb1.xsd ntb2.xsd </p>
<p class="paragraph">
Во-вторых, можно задать файлы со схемой как свойство анализатора, устанавливаемое методом setProperty(), или значение переменной окружения анализатора. Так делает, например, проверяющий анализатор Xerces. </p>
<p class="paragraph">
Рти СЃРїРѕСЃРѕР±С‹ СѓРґРѕР±РЅС‹, РєРѕРіРґР° документ РІ разных случаях нужно связать СЃ различными схемами. Если же схема документа фиксирована, то ее удобнее указать РїСЂСЏРјРѕ РІ документе XML. Рто делается РѕРґРЅРёРј РёР· РґРІСѓС… СЃРїРѕСЃРѕР±РѕРІ. </p>
<p class="paragraph">
□ Если элементы документа не принадлежат никакому пространству имен и записаны без префикса, то в корневом элементе документа записывается атрибут noNamespaceSchemaLocation, указывающий расположение файла со схемой в фор -ме URI: </p>
<p class="paragraph">
<notebook xmlns:xsi="" xsi:noNamespaceSchemaLocation="ntb.xsd"> </p>
<p class="paragraph">
В этом случае в схеме не должно быть целевого пространства имен, т. е. не следует использовать атрибут targetNamespace. </p>
<p class="paragraph">
□ Если же элементы документа относятся к некоторому пространству имен, то применяется атрибут schemaLocation, в котором через пробел парами перечисляются пространства имен и расположение файла со схемой, описывающей это пространство имен. Продолжая пример предыдущего раздела, можно написать: </p>
<p class="paragraph">
<notebook xmlns="" </p>
<p class="paragraph">
xmlns:xsi="" xsi:schemaLocation= </p>
<p class="paragraph">
" A.xsd B.xsd" xmlns:pr1="" xmlns:pr2=""> </p>
<p class="paragraph">
После этого в документе можно использовать имена, определенные в схемах A.xsd и B.xsd, снабжая их префиксами pr1 и pr2 соответственно. </p>
<p>
Другие языки описания схем
</p> <p class="paragraph">
Даже РёР· приведенного ранее краткого описания языка XSD РІРёРґРЅРѕ, что РѕРЅ получился весьма сложным Рё запутанным. Есть уже несколько РєРЅРёРі, полностью посвященных этому языку. РС… объем ничуть РЅРµ меньше объема этой РєРЅРёРіРё. </p>
<p class="paragraph">
Существуют и другие, более простые языки описания схемы документа XML. Наибольшее распространение получили следующие языки: </p>
<p class="paragraph">
□ Schematron — ; </p>
<p class="paragraph">
□ RELAX NG (Regular Language Description for XML, New Generation), этот язык возник как слияние языков Relax и TREX — relax-ng/; </p>
<p class="paragraph">
□ Relax — ; </p>
<p class="paragraph">
□ TREX (Tree Regular Expressions for XML) — ; </p>
<p class="paragraph">
□ DDML (Document Definition Markup Language), известный еще как XSchema — . </p>
<p class="paragraph">
Менее распространены языки DCD (Document Content Description), SOX (One's Schema for Object-Oriented XML), XDR (XML-Data Reduced). </p>
<p class="paragraph">
Все перечисленные языки позволяют более или менее полно описывать схему документа. Возможно, они вытеснят язык XSD, возможно, будут существовать совместно. </p>
<p class="paragraph">
Рнструкции РїРѕ обработке
</p>
<p class="paragraph">
Упомянем еще РѕРґРЅСѓ конструкцию языка XML — инструкции РїРѕ обработке (processing instructions). РћРЅР° позволяет передать анализатору или РґСЂСѓРіРѕР№ программе-обработчику документа дополнительные сведения для обработки. Рнструкция РїРѕ обработке выглядит так: </p>
<p class="paragraph">
<? сведения для анализатора ?> </p>
<p class="paragraph">
Первая часть пролога документа XML — первая строка XML-файла — это как раз инструкция по обработке. Она передает анализатору документа версию языка XML и кодировку символов, которыми записан документ. </p>
<p class="paragraph">
Первая часть работы закончена. Документы XML и их схемы написаны. Теперь надо подумать о том, каким образом они будут отображаться на экране дисплея, на листе бумаги, на экране сотового телефона, т. е. нужно подумать о визуализации документа XML. </p>
<p class="paragraph">
Прежде всего, документ следует разобрать, проанализировать (parse) его структуру. </p>
<p class="paragraph">
Анализ документа XML
</p>
<p class="paragraph">
На первом этапе разбора проводится лексический анализ (lexical parsing) документа XML. Документ разбивается на отдельные неделимые элементы (tokens), которыми являются теги, служебные слова, разделители, текстовые константы. Проводится проверка полученных элементов и их связей между собой. Лексический анализ выполняют специальные программы — сканеры (scanners). Простейшие сканеры — это классы java.util.StringTokenizer и java.io.StreamTokenizer из стандартной поставки Java SE JDK, которые мы рассматривали в предыдущих главах. </p>
<p class="paragraph">
Затем осуществляется грамматический анализ (grammar parsing). При этом анализируется логическая структура документа, составляются выражения, выражения объединяются в блоки, блоки — в модули, которыми могут являться абзацы, параграфы, пункты, главы. Грамматический анализ проводят программы-анализаторы, так называемые парсеры (parsers). </p>
<p class="paragraph">
Создание сканеров и парсеров — любимое развлечение программистов. За недолгую историю XML написаны десятки, если не сотни XML-парсеров. Многие из них написаны на языке Java. Все парсеры можно разделить на три группы. </p>
<p class="paragraph">
В первую группу входят парсеры, проводящие анализ, основываясь на структуре дерева, отражающего вложенность элементов документа (tree-based parsing). Дерево документа строится в оперативной памяти перед просмотром. Такие парсеры проще реализовать, но создание дерева требует большого объема оперативной памяти, ведь размер документов XML не ограничен. Необходимость частого просмотра узлов дерева замедляет работу парсера. </p>
<p class="paragraph">
Р’Рѕ вторую РіСЂСѓРїРїСѓ РІС…РѕРґСЏС‚ парсеры, проводящие анализ, основываясь РЅР° событиях (event-based parsing). Рти парсеры просматривают документ РѕРґРёРЅ раз, отмечая события просмотра. Событием считается появление очередного элемента XML: открывающего или закрывающего тега, текста, содержащегося РІ теле элемента. РџСЂРё возникновении события вызывается соответствующий метод его обработки: startElement(), endElement (), characters () Рё С‚. Рґ. Такие парсеры сложнее РІ реализации, зато РѕРЅРё РЅРµ строят дерево РІ оперативной памяти Рё РјРѕРіСѓС‚ анализировать РЅРµ весь документ, Р° его отдельные элементы вместе СЃ вложенными РІ РЅРёС… элементами. Фактическим стандартом здесь стал СЃРІРѕР±РѕРґРЅРѕ распространяемый набор классов Рё интерфейсов SAX (Simple API for XML), созданный Давидом Меггинсоном (David Megginson). РћСЃРЅРѕРІРЅРѕР№ сайт данного проекта — . Сейчас применяется второе поколение этого набора, называемое SAX2. Набор SAX2 РІС…РѕРґРёС‚ РІРѕ РјРЅРѕРіРёРµ парсеры, например Xerces2. </p>
<p class="paragraph">
Третью группу образуют потоковые парсеры (stream parsers), которые так же, как и парсеры второй группы, просматривают документ, переходя от элемента к элементу. При каждом переходе парсер предоставляет программе методы getName ( ), getText ( ), </p>
<p class="paragraph">
getAttributeName (), getAttributeValue() и т. д., позволяющие обработать текущий элемент. </p>
<p class="paragraph">
В стандартную поставку Java и Standard Edition и Enterprise Edition входит набор интерфейсов и классов для создания парсеров и преобразования документов XML, называемый JAXP (Java API for XML Processing). С помощью одной из частей этого набора, называемой DOM API (Document Object Model API), можно создавать парсеры первого типа, формирующие дерево объектов. С помощью второй части набора JAXP, называемой SAX API, можно создавать SAX-парсеры. Третья часть JAXP, предназначенная для создания потоковых парсеров, называется StAX (Streaming API for XML). </p>
<p class="paragraph">
Анализ документов XML с помощью SAX2
</p>
<p class="paragraph">
Рнтерфейсы Рё классы SAX2 собраны РІ пакеты org.xml.sax, org.xml.sax.ext, </p>
<p class="paragraph">
org.xml.sax.helpers, javax.xml.parsers. Рассмотрим их подробнее. </p>
<p class="paragraph">
Основу SAX2 составляет интерфейс org.xml.sax.ContentHandler, описывающий методы обработки событий: начала документа, появления открывающего тега, появление тела элемента, появление закрывающего тега, окончание документа. При возникновении такого события SAX2 обращается к методу-обработчику события, передавая ему аргументы, содержащие информацию о событии. Дело разработчика — реализовать эти методы, обеспечив правильный анализ документа. </p>
<p class="paragraph">
В начале обработки документа вызывается метод </p>
<p class="paragraph">
public void startDocument(); </p>
<p class="paragraph">
В нем можно задать начальные действия по обработке документа. </p>
<p class="paragraph">
При появлении символа "<", начинающего открывающий тег, вызывается метод </p>
<p class="paragraph">
public void startElement(String uri, String name, </p>
<p class="paragraph">
String qname, Attributes attrs); </p>
<p class="paragraph">
В метод передаются три имени, два из которых связаны с пространством имен: идентификатор пространства имен uri, локальное имя тега без префикса name и расширенное имя с префиксом qname, а также атрибуты открывающего тега элемента attrs, если они есть. Если пространство имен не определено, то значения первого и второго аргументов равны null. Если нет атрибутов, то передается ссылка на пустой объект attrs. </p>
<p class="paragraph">
При появлении символов "</", начинающих закрывающий тег, вызывается метод </p>
<p class="paragraph">
public void endElement(String uri, String name, String qname); </p>
<p class="paragraph">
При появлении строки символов вызывается метод </p>
<p class="paragraph">
public void characters(char[] ch, int start, int length); </p>
<p class="paragraph">
В него передается массив символов ch, индекс начала строки символов start в этом массиве и количество символов length. </p>
<p class="paragraph">
При появлении в тексте документа инструкции по обработке вызывается метод </p>
<p class="paragraph">
public void processingInstruction(String target, String data); </p>
<p class="paragraph">
В метод передается имя программы-обработчика target и дополнительные сведения </p>
<p class="paragraph">
data. </p>
<p class="paragraph">
При появлении пробельных символов, которые должны быть пропущены, вызывается метод </p>
<p class="paragraph">
public void ignorableWhitespace(char[] ch, int start, int length); </p>
<p class="paragraph">
В него передается массив ch идущих подряд пробельных символов, индекс начала символов в массиве start и количество символов length. </p>
<p class="paragraph">
Рнтерфейс org.xml.sax.ContentHandler реализован классом org.xml.sax.helpers.DefaultHandler. Р’ нем сделана пустая реализация всех методов. Разработчику остается реализовать только те методы, которые ему нужны. </p>
<p class="paragraph">
Применим методы SAX2 для обработки нашей адресной книжки. Запись документа РЅР° языке XML СѓРґРѕР±РЅР° для выявления структуры документа, РЅРѕ неудобна для работы СЃ документом РІ объектно-ориентированной среде. Поэтому чаще всего содержимое документа XML представляется РІ РІРёРґРµ РѕРґРЅРѕРіРѕ или нескольких объектов, называемых объектами данных JDO (Java Data Objects). Рта операция называется связыванием данных (data binding) СЃ объектами JDO. </p>
<p class="paragraph">
Свяжем содержимое нашей адресной книжки с объектами Java. Для этого сначала опишем классы Java (листинги 28.7 и 28.8), которые представят содержимое адресной книги. </p>
<p>
Листинг 28.7. Класс, описывающий адрес
</p> <p class="paragraph">
public class Address{ </p>
<p class="paragraph">
private String street, city, zip, type = "РіРѕСЂРѕРґ"; public Address(){} </p>
<p class="paragraph">
public String getStreet(){ return street; } </p>
<p class="paragraph">
public void setStreet(String street){ this.street = street; } </p>
<p class="paragraph">
public String getCity(){ return city; } </p>
<p class="paragraph">
public void setCity(String city){ this.city = city; } </p>
<p class="paragraph">
public String getZip(){ return zip; } </p>
<p class="paragraph">
public void setZip(String zip){ this.zip = zip; } </p>
<p class="paragraph">
public String getType(){ return type; } </p>
<p class="paragraph">
public void setType(String type){ this.type = type; } </p>
<p class="paragraph">
public String toString(){ </p>
<p class="paragraph">
return "Address: " + street + " " + city + " " + zip; </p>
<p class="paragraph">
} </p>
<p>
Листинг 28.8. Класс, описывающий запись адресной книжки
</p> <p class="paragraph">
public class Person{ </p>
<p class="paragraph">
private String firstName, secondName, surname, birthday; private Vector<Address> address; private Vector<Integer> workPhone; private Vector<Integer> homePhone; </p>
<p class="paragraph">
public Person(){} </p>
<p class="paragraph">
public Person(String firstName, String secondName, String surname){ this.firstName = firstName; this.secondName = secondName; this.surname = surname; </p>
<p class="paragraph">
} </p>
<p class="paragraph">
public String getFirstName(){ return firstName; } public void setFirstName(String firstName){ this.firstName = firstName; </p>
<p class="paragraph">
} </p>
<p class="paragraph">
public String getSecondName(){ return secondName; } public void setSecondName(String secondName){ this.secondName = secondName; </p>
<p class="paragraph">
} </p>
<p class="paragraph">
public String getSurname(){ return surname; } public void setSurname(String surname){ this.surname = surname; </p>
<p class="paragraph">
} </p>
<p class="paragraph">
public String getBirthday(){ return birthday; } public void setBirthday(String birthday){ this.birthday = birthday; </p>
<p class="paragraph">
} </p>
<p class="paragraph">
public void addAddress(Address addr){ </p>
<p class="paragraph">
if (address == null) address = new Vector(); address.add(addr); </p>
<p class="paragraph">
} </p>
<p class="paragraph">
public Vector<Address> getAddress(){ return address; } </p>
<p class="paragraph">
public void removeAddress(Address addr){ if (address != null) address.remove(addr); </p>
<p class="paragraph">
} </p>
<p class="paragraph">
public void addWorkPhone(String phone){ </p>
<p class="paragraph">
if (workPhone == null) workPhone = new Vector(); workPhone.add(new Integer(phone)); </p>
<p class="paragraph">
} </p>
<p class="paragraph">
public Vector<Integer> getWorkPhone(){ return workPhone; } </p>
<p class="paragraph">
public void removeWorkPhone(String phone){ </p>
<p class="paragraph">
if (workPhone != null) workPhone.remove(new Integer(phone)); </p>
<p class="paragraph">
} </p>
<p class="paragraph">
public void addHomePhone(String phone){ </p>
<p class="paragraph">
if (homePhone == null) homePhone = new Vector(); homePhone.add(new Integer(phone)); </p>
<p class="paragraph">
} </p>
<p class="paragraph">
public Vector<Integer> getHomePhone(){ return homePhone; } </p>
<p class="paragraph">
public void removeHomePhone(String phone){ </p>
<p class="paragraph">
if (homePhone != null) homePhone.remove(new Integer(phone)); </p>
<p class="paragraph">
} </p>
<p class="paragraph">
public String toString(){ </p>
<p class="paragraph">
return "Person: " + surname; </p>
<p class="paragraph">
} </p>
<p class="paragraph">
} </p>
<p class="paragraph">
После определения классов Java, в экземпляры которых будет занесено содержимое адресной книжки, напишем программу, читающую адресную книжку и связывающую ее с объектами Java. </p>
<p class="paragraph">
В листинге 28.9 приведен пример класса-обработчика NotebookHandler для адресной книжки, описанной в листинге 28.2. Методы класса NotebookHandler анализируют содержимое адресной книжки и помещают его в вектор, составленный из объектов класса Person, описанного в листинге 28.8. </p>
<p>
Листинг 28.9. Кпасс-обработник документа XML средствами SAX2
</p> <p class="paragraph">
import org.xml.sax.*; import org.xml.sax.helpers.*; import javax.xml.parsers.*; import java.util.*; import java.io.*; </p>
<p class="paragraph">
public class NotebookHandler extends DefaultHandler{ </p>
<p class="paragraph">
static final String JAX P_SCHEMA_LAN GUAGE = </p>
<p class="paragraph">
" ava.sun.com/xml/j axp/properties/schemaLanguage"; </p>
<p class="paragraph">
static final String W3C XML SCHEMA = ""; </p>
<p class="paragraph">
private Person person; private Address address; </p>
<p class="paragraph">
private static Vector<Person> pers = new Vector<>(); boolean inBirthday, inStreet, inCity, inZip, inWorkPhone, inHomePhone; </p>
<p class="paragraph">
public void startElement(String uri, String name, </p>
<p class="paragraph">
String qname, Attributes attrs) </p>
<p class="paragraph">
throws SAXException{ switch (qname){ case "name": </p>
<p class="paragraph">
person = new Person(attrs.getValue("first"), </p>
<p class="paragraph">
attrs.getValue("second"), attrs.getValue("surname")); </p>
<p class="paragraph">
break; </p>
<p class="paragraph">
case "birthday": </p>
<p class="paragraph">
inBirthday = true; break; case "address": </p>
<p class="paragraph">
address = new Address(); break; case "street": </p>
<p class="paragraph">
inStreet = true; break; case "city": </p>
<p class="paragraph">
inCity = true; </p>
<p class="paragraph">
if (attrs != null) address.setType(attrs.getValue("type")); break; case "zip": </p>
<p class="paragraph">
inZip = true; break; case "work-phone": </p>
<p class="paragraph">
inWorkPhone = true; break; case "home-phone": </p>
<p class="paragraph">
inHomePhone = true; </p>
<p class="paragraph">
} </p>
<p class="paragraph">
public void characters(char[] buf, int offset, int len) throws SAXException{ </p>
<p class="paragraph">
String s = new String(buf, offset, len); </p>
<p class="paragraph">
if (inBirthday){ </p>
<p class="paragraph">
person.setBirthday(s); inBirthday = false; </p>
<p class="paragraph">
}else if (inStreet){ </p>
<p class="paragraph">
address.setStreet(s); inStreet = false; </p>
<p class="paragraph">
}else if (inCity){ </p>
<p class="paragraph">
address.setCity(s); inCity = false; </p>
<p class="paragraph">
}else if (inZip){ </p>
<p class="paragraph">
address.setZip(s); inZip = false; </p>
<p class="paragraph">
}else if (inWorkPhone){ person.addWorkPhone(s); inWorkPhone = false; </p>
<p class="paragraph">
}else if (inHomePhone){ person.addHomePhone(s); inHomePhone = false; </p>
<p class="paragraph">
} </p>
<p class="paragraph">
} </p>
<p class="paragraph">
public void endElement(String uri, String name, String qname) throws SAXException{ </p>
<p class="paragraph">
if (qname.equals("address")){ person.addAddress(address); address = null; </p>
<p class="paragraph">
}else if (qname.equals("person")){ pers.add(person); person = null; </p>
<p class="paragraph">
} </p>
<p class="paragraph">
} </p>
<p class="paragraph">
public static void main(String[] args){ </p>
<p class="paragraph">
if (args.length < 1){ </p>
<p class="paragraph">
System.err.println("Usage: java NotebookHandler ntb.xml"); </p>
<p class="paragraph">
System.exit(1); </p>
<p class="paragraph">
} </p>
<p class="paragraph">
try{ </p>
<p class="paragraph">
NotebookHandler handler = new NotebookHandler(); </p>
<p class="paragraph">
SAXParserFactory fact = SAXParserFactory.newInstance(); </p>
<p class="paragraph">
fact.setNamespaceAware(true); fact.setValidating(true); </p>
<p class="paragraph">
SAXParser saxParser = fact.newSAXParser(); </p>
<p class="paragraph">
saxParser.setProperty(JAXP_SCHEMA_LANGUAGE, W3C_XML_SCHEMA); </p>
<p class="paragraph">
File f = new File(args[0]); </p>
<p class="paragraph">
saxParser.parse(f, handler); </p>
<p class="paragraph">
for (int k = 0; k < pers.size(); k++) </p>
<p class="paragraph">
System.out.println((pers.get(k)).getSurname()); </p>
<p class="paragraph">
}catch(SAXNotRecognizedException x){ </p>
<p class="paragraph">
System.err.println("HeH3BecTHoe свойство: " + </p>
<p class="paragraph">
JAXP_SCHEMA_LANGUAGE) ; </p>
<p class="paragraph">
System.exit(1); </p>
<p class="paragraph">
}catch(Exception ex){ </p>
<p class="paragraph">
System.err.println(ex); </p>
<p class="paragraph">
} </p>
<p class="paragraph">
} </p>
<p class="paragraph">
public void warning(SAXParseException ex){ System.err.println("Warning: " + ex); System.err.println("line = " + ex.getLineNumber() + </p>
<p class="paragraph">
" col = " + ex.getColumnNumber()); </p>
<p class="paragraph">
} </p>
<p class="paragraph">
public void error(SAXParseException ex){ System.err.println("Error: " + ex); </p>
<p class="paragraph">
System.err.println("line " col </p>
<p class="paragraph">
+ ex.getLineNumber() + </p>
<p class="paragraph">
+ ex.getColumnNumber()); </p>
<p class="paragraph">
} </p>
<p class="paragraph">
public void fatalError(SAXParseException ex){ System.err.println("Fatal error: " + ex); System.err.println("line = " + ex.getLineNumber() + </p>
<p class="paragraph">
" col = " + ex.getColumnNumber()); </p>
<p class="paragraph">
} </p>
<p class="paragraph">
} </p>
<p class="paragraph">
После того как класс-обработчик написан, проанализировать документ очень легко. Стандартные действия приведены в методе main () программы листинга 28.9. </p>
<p class="paragraph">
Поскольку реализация парсера сильно зависит от его программного окружения, SAX-парсер — объект класса SAXParser — создается не конструктором, а фабричным методом newSAXParser(). </p>
<p class="paragraph">
Объект-фабрика, в свою очередь, формируется методом newinstance (). Далее можно методом </p>
<p class="paragraph">
void setFeature(String name, boolean value); </p>
<p class="paragraph">
установить свойства парсеров, создаваемых этой фабрикой. Например, после </p>
<p class="paragraph">
fact.setFeature("", true); </p>
<p class="paragraph">
парсеры, создаваемые фабрикой fact, будут учитывать префиксы имен тегов и атрибутов. </p>
<p class="paragraph">
Список таких свойств можно посмотреть в документации Java API в описании пакета org.xml.sax или на сайте проекта SAX . Следует учитывать, что не все парсеры полностью выполняют эти свойства. </p>
<p class="paragraph">
Если к объекту-фабрике применить метод </p>
<p class="paragraph">
void setValidating(true); </p>
<p class="paragraph">
как это сделано в листинге 28.9, то она будет производить парсеры, проверяющие структуру документа. Если применить метод </p>
<p class="paragraph">
void setNamespaceAware(true); </p>
<p class="paragraph">
то объект-фабрика будет производить парсеры, учитывающие пространства имен. </p>
<p class="paragraph">
После того как объект-парсер создан, остается только применить метод parse (), передав ему имя анализируемого файла и экземпляр класса-обработчика событий. </p>
<p class="paragraph">
В классе javax.xml.parsers.SAXParser есть десяток методов parse(). Кроме метода parse (File, DefaultHandler), использованного в листинге 28.9, существуют еще методы, позволяющие извлечь документ из входного потока класса InputStream, объекта класса InputSource, адреса URI или из специально созданного источника класса InputSource. </p>
<p class="paragraph">
Методом setProperty() можно задать различные свойства парсера. Р’ листинге 28.9 этот метод использован для того, чтобы парсер проверял правильность документа СЃ помощью схемы XSD. Если парсер выполняет проверки, С‚. Рµ. применен метод setValidating(true), то имеет смысл сделать развернутые сообщения РѕР± ошибках. Рто предусмотрено интерфейсом ErrorHandler. РћРЅ различает предупреждения, ошибки Рё фатальные ошибки Рё описывает три метода, которые автоматически выполняются РїСЂРё появлении ошибки соответствующего РІРёРґР°: </p>
<p class="paragraph">
public void warning(SAXParserException ex); public void error(SAXParserException ex); public void fatalError(SAXParserException ex); </p>
<p class="paragraph">
Класс DefaultHandler делает пустую реализацию этого интерфейса. РџСЂРё расширении данного класса можно сделать реализацию РѕРґРЅРѕРіРѕ или всех методов интерфейса ErrorHandler. Пример такой реализации приведен РІ листинге 28.9. Класс SAXParserException хранит номер строки Рё столбца проверяемого документа, РІ котором замечена ошибка. РС… можно получить методами getLineNumber( ) Рё getColumnNumber ( ), как сделано РІ листинге 28.9. </p>
<p class="paragraph">
Анализ документов XML с помощью StAX
</p>
<p class="paragraph">
Рнтерфейсы Рё классы StAX собраны РІ пакеты javax.xml.stream, javax.xml.stream.events, javax.xml. stream.util, РЅРѕ РЅР° практике достаточно применения только нескольких интерфейсов Рё классов. </p>
<p class="paragraph">
Основные методы разбора документа описаны в интерфейсе XMLStreamReader. Разбор заключается в том, что парсер просматривает документ, переходя от элемента к элементу и от одной части элемента к другой методом next (). Метод next () возвращает одну из целочисленных констант, описанных в интерфейсе XMLStreamConstants, показывающих тип той части документа, в которой находится парсер: start_document, start_element, END_ELEMENT, CHARACTERS и т. д. В зависимости от этого типа интерфейс XMLStreamReader предоставляет те или иные методы обработки документа. Так, если парсер находится в открывающем теге элемента, start_element, то мы можем получить короткое имя элемента методом getLocalName ( ), число атрибутов методом getAttributeCount(), имя и значение k-го атрибута методами getAttributeName(k) и getAttributeValue(k). Если парсер находится в теле элемента, characters, можно получить содержимое тела методом </p>
<p class="paragraph">
getText(). </p>
<p class="paragraph">
Программа следующего листинга 28.10 выполняет средствами StAX ту же работу, что и программа, записанная в листинге 28.9. </p>
<p>
Листинг 28.10. Класс-обработчик документа XML средствами StAX
</p> <p class="paragraph">
import javax.xml.stream.*; import java.util.*; import j ava.io.*; </p>
<p class="paragraph">
public class NotebookHandlerStAX implements XMLStreamConstants{ private Person person; private Address address; </p>
<p class="paragraph">
private static Vector<Person> pers = new Vector<>(); boolean inBirthday, inStreet, inCity, inZip, </p>
<p class="paragraph">
inWorkPhone, inHomePhone; </p>
<p class="paragraph">
private void processElement(XMLStreamReader element) throws XMLStreamException{ switch (element.getLocalName()){ case "name": person = new Person(element.getAttributeValue(0), element.getAttributeValue(1), element.getAttributeValue(2)); break; case "birthday": inBirthday = true; break; case "address": address = new Address(); break; case "street": inStreet = true; break; case "city": inCity = true; break; case "zip": inZip = true; break; case "work-phone": inWorkPhone = true; break; case "home-phone": inHomePhone = true; break; </p>
<p class="paragraph">
} </p>
<p class="paragraph">
} </p>
<p class="paragraph">
private void processText(String text){ if (inBirthday){ </p>
<p class="paragraph">
person.setBirthday(text); inBirthday = false; </p>
<p class="paragraph">
}else if (inStreet){ </p>
<p class="paragraph">
address.setStreet(text) ; inStreet = false; </p>
<p class="paragraph">
}else if (inCity) { </p>
<p class="paragraph">
address.setCity(text); inCity = false; </p>
<p class="paragraph">
}else if (inZip){ </p>
<p class="paragraph">
address.setZip(text); inZip = false; </p>
<p class="paragraph">
}else if (inWorkPhone){ person.addWorkPhone(text); inWorkPhone = false; </p>
<p class="paragraph">
}else if (inHomePhone){ person.addHomePhone(text); inHomePhone = false; </p>
<p class="paragraph">
} </p>
<p class="paragraph">
} </p>
<p class="paragraph">
private void finishElement(String name){ switch (name){ </p>
<p class="paragraph">
case "address": person.addAddre s s(addre ss); </p>
<p class="paragraph">
address = null; break; case "person": pers.add(person); person = null; break; </p>
<p class="paragraph">
} </p>
<p class="paragraph">
} </p>
<p class="paragraph">
public static void main(String[] args){ if (args.length < 1){ </p>
<p class="paragraph">
System.err.println("Usage: java NotebookHandlerStAX ntb.xml"); </p>
<p class="paragraph">
System.exit(1); </p>
<p class="paragraph">
} </p>
<p class="paragraph">
NotebookHandlerStAX handler = new NotebookHandlerStAX(); try{ </p>
<p class="paragraph">
FileInputStream inStream = new FileInputStream(args[0]); </p>
<p class="paragraph">
XMLStreamReader xmlReader = </p>
<p class="paragraph">
XMLInputFactory.newInstance(). createXMLStreamReader(inStream) ; int event; </p>
<p class="paragraph">
while (xmlReader.hasNext()) { event = xmlReader.next(); switch (event){ </p>
<p class="paragraph">
case START_ELEMENT: handler.processElement(xmlReader); break; case CHARACTERS: handler.processText(xmlReader.getText()); break; case END_ELEMENT: handler.finishElement(xmlReader.getLocalName()); </p>
<p class="paragraph">
} </p>
<p class="paragraph">
} </p>
<p class="paragraph">
xmlReader.close() ; </p>
<p class="paragraph">
}catch(Exception ex){ ex.printStackTrace() ; </p>
<p class="paragraph">
} </p>
<p class="paragraph">
} </p>
<p class="paragraph">
} </p>
<p class="paragraph">
Связывание данных XML с объектами Java
</p>
<p class="paragraph">
В приведенном примере мы сами создали классы Address и Person, представляющие документ XML. Поскольку структура документа XML четко определена, можно разработать стандартные правила связывания данных XML с объектами Java и создать программные средства для их реализации. </p>
<p class="paragraph">
Корпорация Sun Microsystems разработала пакет интерфейсов и классов JAXB (Java Architecture for XML Binding), облегчающих связывание данных. Он входит в стандартную поставку Java SE, а также может быть скопирован с сайта http:// jaxb.dev.java.net/. Для работы с пакетом JAXB анализируемый документ XML обязательно должен быть снабжен описанием на языке XSD. </p>
<p class="paragraph">
В состав пакета JAXB входит компилятор xj c (XML-Java Compiler). Он просматривает схему XSD и строит по нему объекты Java в оперативной памяти, а также создает исходные файлы объектов Java. Например, после выполнения команды </p>
<p class="paragraph">
$ xjc -roots notebook ntb.xsd -d sources </p>
<p class="paragraph">
в которой ntb.xsd — файл листинга 28.4 — в каталоге sources (по умолчанию в текущем каталоге) будут созданы файлы Addressjava, Namejava, Notebookjava, Personjava, PhoneListjava с описаниями объектов Java. </p>
<p class="paragraph">
Флаг -roots показывает один или несколько корневых элементов, разделенных запятыми. </p>
<p class="paragraph">
Созданные компилятором xjc исходные файлы обычным образом, с помощью компилятора j avac, компилируются в классы Java. </p>
<p class="paragraph">
Получив объекты данных, можно перенести РІ РЅРёС… содержимое документа XML методом unmarshal (), который создает дерево объектов, или, наоборот, записать объекты Java РІ документы XML методом marshal (). Рти методы уже записаны РІ созданный компилятором xj c класс корневого элемента, РІ примере это класс Notebook. </p>
<p class="paragraph">
Объекты данных JDO
</p>
<p class="paragraph">
Задачу связывания данных естественно обобщить — связывать объекты Java не только с документами XML, но и с текстовыми файлами, реляционными или объектными базами данных, другими хранилищами данных. </p>
<p class="paragraph">
Корпорация Sun Microsystems опубликовала спецификацию JDO, сейчас уже версии 3.0, и разработала интерфейсы для работы с JDO. Спецификация JDO рассматривает более широкую задачу связывания данных, полученных не только из документа XML, но и из любого источника данных, называемого информационной системой предприятия (Enterprise Information System, EIS). Спецификация описывает два набора классов и интерфейсов: </p>
<p class="paragraph">
□ JDO SPI (JDO Service Provider Interface) — вспомогательные классы и интерфейсы, которые следует реализовать в сервере приложений для обращения к источнику данных, создания объектов, обеспечения их сохранности, выполнения транзакций, проверки прав доступа к объектам; эти классы и интерфейсы составляют пакет </p>
<p class="paragraph">
javax.jdo.spi; </p>
<p class="paragraph">
□ JDO API (JDO Application Programming Interface) — интерфейсы, предоставляемые пользователю для доступа к объектам, управления транзакциями, создания и удаления объектов; эти интерфейсы собраны в пакет javax.jdo. </p>
<p class="paragraph">
Есть много коммерческих и свободно распространяемых реализаций интерфейсов JDO. </p>
<p class="paragraph">
Сообщество Apache Software Foundition назвало СЃРІРѕСЋ реализацию Apache JDO. Рту разработку можно посмотреть РїРѕ адресу . </p>
<p class="paragraph">
Фирма DataNucleus, , выпускает продукт Access Platform, бывший JPOX. </p>
<p class="paragraph">
Компания SolarMetric, , выпускает свою реализацию спецификации JDO под названием Kodo JDO. Ее можно встроить в серверы приложений WebLogic, WebSphere, JBoss. </p>
<p class="paragraph">
Некоторые фирмы разработали свои варианты JDO, более или менее соответствующие спецификации. Наиболее известна свободно распространяемая разработка, названная Castor. Ее можно посмотреть по адресу . </p>
<p class="paragraph">
С помощью Castor можно предельно упростить связывание данных. Например, создание объекта Java из простого документа XML, если отвлечься от проверок и обработки исключительных ситуаций, выполняется одним действием: </p>
<p class="paragraph">
Person person = (Person)Unmarshaller.unmarshal( </p>
<p class="paragraph">
Person.class, new FileReader("person.xml")); </p>
<p class="paragraph">
Обратно, сохранение объекта Java в виде документа XML в самом простом случае выглядит так: </p>
<p class="paragraph">
Marshaller.marshall(person, new FileWriter("person.xml")); </p>
<p class="paragraph">
В более сложных случаях надо написать файл XML, аналогичный схеме XSD, с указаниями по связыванию данных (mapping file). </p>
<p class="paragraph">
Анализ документов XML с помощью DOM API
</p>
<p class="paragraph">
Как РІРёРґРЅРѕ РёР· предыдущих разделов, SAX-парсер читает документ только РѕРґРёРЅ раз, отмечая появляющиеся РїРѕ С…РѕРґСѓ чтения открывающие теги, содержимое элементов Рё закрывающие теги. Ртого достаточно для связывания данных, РЅРѕ неудобно для редактирования документа. </p>
<p class="paragraph">
Консорциум W3C разработал спецификации Рё набор интерфейсов DOM (Document Object Model), которые можно посмотреть РЅР° сайте этого проекта DOM/. Методами этих интерфейсов документ XML можно загрузить РІ оперативную память РІ РІРёРґРµ дерева объектов. Рто позволяет РЅРµ только анализировать документ анализаторами, основанными РЅР° структуре дерева, РЅРѕ Рё менять дерево, добавляя или удаляя объекты РёР· дерева. РљСЂРѕРјРµ того, можно обращаться непосредственно Рє каждому объекту РІ дереве Рё РЅРµ только читать, РЅРѕ Рё изменять информацию, хранящуюся РІ нем. РќРѕ РІСЃРµ это требует большого объема оперативной памяти для загрузки большого дерева. </p>
<p class="paragraph">
Корпорация Sun Microsystems реализовала интерфейсы DOM в пакетах javax.xml. parsers и org.w3c.dom, входящих в состав пакета JAXP. Воспользоваться этой реализацией очень легко: </p>
<p class="paragraph">
DocumentBuilderFactory fact = </p>
<p class="paragraph">
DocumentBuilderFactory.newInstance(); </p>
<p class="paragraph">
DocumentBuilder builder = fact.newDocumentBuilder(); </p>
<p class="paragraph">
Document doc = builder.parse("ntb.xml"); </p>
<p class="paragraph">
Метод parse () строит дерево объектов и возвращает ссылку на него в виде объекта типа Document. В классе DocumentBuilder есть несколько методов parse ( ), позволяющих загрузить файл с адреса URL, из входного потока, как объект класса File или из источника класса InputSource. </p>
<p class="paragraph">
Рнтерфейс Document, расширяющий интерфейс Node, описывает дерево объектов документа РІ целом. Рнтерфейс Node — РѕСЃРЅРѕРІРЅРѕР№ интерфейс РІ описании структуры дерева — описывает узел дерева. РЈ него есть еще РѕРґРёРЅ наследник — интерфейс Element, описывающий лист дерева, соответствующий элементу документа XML. Как РІРёРґРЅРѕ РёР· структуры наследования этих интерфейсов, Рё само дерево, Рё его лист считаются узлами дерева. Каждый атрибут элемента дерева описывается интерфейсом Attr. Еще несколько интерфейсов — CDATASection, Comment, Text, Entity, EntityReference, ProcessingInstruction, Notation — описывают разные типы элементов XML. </p>
<p class="paragraph">
На рис. 28.2 показано начало дерева объектов, построенного по документу, приведенному в листинге 28.2. Обратите внимание на то, что текст, находящийся в теле элемента, хранится в отдельном узле дерева — потомке узла элемента. Для каждого атрибута открывающего тега тоже создается отдельный узел. </p>
<div style="width:100%;text-align:center;">
<table>
<tr>
<td colspan="1" rowspan="1"></td>
<td colspan="1" rowspan="1">
Рис. 28.2. Дерево объектов документа XML
</td>
</tr>
</table>
</div>
<p>
Рнтерфейс Node
</p> <p class="paragraph">
Рнтерфейс Node описывает тип узла РѕРґРЅРѕР№ РёР· следующих констант: </p>
<p class="paragraph">
□ attribute_node — узел типа Attr, содержит атрибут элемента; </p>
<p class="paragraph">
□ CDATA_SECTION_NODE узел типа CDADASection, содержит данные типа CDATA; </p>
<p class="paragraph">
□ comment_node — узел типа Comment, содержит комментарий; </p>
<p class="paragraph">
□ DOCUMENT_FRAGMENT_NODE в узле типа DocumentFragment находится фрагмент документа; </p>
<p class="paragraph">
□ DOCUMENT_NODE корневой узел типа Document; </p>
<p class="paragraph">
□ DOCUMENT_TYPE_NODE узел типа Document; </p>
<p class="paragraph">
□ ELEMENT_NODE узел является листом дерева типа Element; </p>
<p class="paragraph">
□ entity_node — в узле типа Entity хранится сущность entity; </p>
<p class="paragraph">
□ ENTITY_REFERENCE_NODE в узле типа EntityReference хранится ссылка на сущность; </p>
<p class="paragraph">
□ NOTATION_NODE-в узле хранится нотация типа Notation; </p>
<p class="paragraph">
□ PROCESSING_INSTRUCTION_NODE- узел типа ProcessingInstruction, содержит инструкцию </p>
<p class="paragraph">
по обработке; </p>
<p class="paragraph">
□ TEXT_NODE в узле типа Text хранится текст. </p>
<p class="paragraph">
Методы интерфейса Node описывают действия с узлом дерева: </p>
<p class="paragraph">
□ public short getNodeType ( ) — возвращает тип узла; </p>
<p class="paragraph">
□ public String getNodeName() — возвращает имя узла; </p>
<p class="paragraph">
□ public string getNodeValue() — возвращает значение, хранящееся в узле; </p>
<p class="paragraph">
□ public boolean hasAttributes ( ) - выполняет проверку существования атрибутов у </p>
<p class="paragraph">
элемента XML, хранящегося в узле в виде объекта типа NamedNodeMap, если это узел типа Element; </p>
<p class="paragraph">
□ public NamedNodeMap getAttributes() — возвращает атрибуты; метод возвращает null, если у элемента нет атрибутов; </p>
<p class="paragraph">
□ public boolean hasChildNodes ( ) -проверяет, есть ли у данного узла узлы-потомки; </p>
<p class="paragraph">
□ public NodeList getChildNodes() - возвращает список узлов-потомков в виде объекта </p>
<p class="paragraph">
типа NodeList; </p>
<p class="paragraph">
□ public Node getFirstchild() — возвращает первый узел в списке узлов-потомков; </p>
<p class="paragraph">
□ public Node getLastchild() — возвращает последний узел в списке узлов-потомков; </p>
<p class="paragraph">
□ public Node getParentNode() — возвращает родительский узел; </p>
<p class="paragraph">
□ public Node getPreviousSibling( ) - возвращает предыдущий узел, имеющий того же </p>
<p class="paragraph">
предка, что и данный узел; </p>
<p class="paragraph">
□ public Node getNextsibling() — возвращает следующий узел, имеющий того же предка, что и данный узел; </p>
<p class="paragraph">
□ public Document getOwnerDocument() — возвращает ссылку на весь документ. Следующие методы позволяют изменить дерево объектов: </p>
<p class="paragraph">
□ public Node appendChild(Node newChild) — добавляет новый узел-потомок newChild; </p>
<p class="paragraph">
□ public Node insertBefore(Node newChild, Node refChild) — вставляет новый узел-потомок newChild перед существующим потомком refChild; </p>
<p class="paragraph">
□ public Node replaceChild(Node newChild, Node oldChild) — заменяет один узел-потомок oldChild новым узлом newChild; </p>
<p class="paragraph">
□ public Node removeChild(Node child) — удаляет узел-потомок. </p>
<p>
Рнтерфейс Document
</p> <p class="paragraph">
Рнтерфейс Document добавляет Рє методам своего предка Node методы работы СЃ документом РІ целом: </p>
<p class="paragraph">
□ public DocumentType getDocType() — возвращает общие сведения о документе в виде объекта типа DocumentType; </p>
<p class="paragraph">
□ getName(), getEntitied(), getNotations() и другие методы интерфейса DocumentType возвращают конкретные сведения о документе; </p>
<p class="paragraph">
□ public Element getDocumentElement() — возвращает корневой элемент дерева объектов; </p>
<p class="paragraph">
в–Ў public NodeList getElementsByTagName(String name); </p>
<p class="paragraph">
public NodeList getElementsByTagNameNS(String uri, String qname); public Element getElementById(String id) </p>
<p class="paragraph">
возвращают все элементы с указанным именем tag без префикса или с префиксом, а также элемент, определяемый значением атрибута с именем ID. </p>
<p class="paragraph">
Несколько методов позволяют изменить структуру и содержимое дерева объектов: </p>
<p class="paragraph">
□ public Element createElement(String name) — создает новый пустой элемент по его имени; </p>
<p class="paragraph">
□ public Element createElementNS(String uri, String name) — создает новый пустой элемент по имени с префиксом; </p>
<p class="paragraph">
□ public CDATASection createCDATASection(String name) — создает узел типа CDATA SECTION </p>
<p class="paragraph">
node; </p>
<p class="paragraph">
□ public EntityReference createEntityReference(String name) — создает узел типа ENTITY </p>
<p class="paragraph">
reference_node; </p>
<p class="paragraph">
□ public ProcessingInstruction createProcessingInstruction(String name) — создает узел </p>
<p class="paragraph">
типа processing_instruction_node; </p>
<p class="paragraph">
□ public TextNode createTextNode(String name) — создает узел типа TEXT_NODE; </p>
<p class="paragraph">
□ public Attr createAttribute (String name) — создает узел-атрибут с именем name; </p>
<p class="paragraph">
□ public Attr createAttributeNS(String uri, String name) — аналогично; </p>
<p class="paragraph">
□ public Comment createComment(String comment) — создает узел-комментарий; </p>
<p class="paragraph">
□ public DocumentFragment createDocumentFragment() — создает пустой документ — фрагмент данного документа с целью его дальнейшего заполнения; </p>
<p class="paragraph">
в–Ў public Node importNode(Node importedNode, boolean deep) — вставляет созданный узел, Р° значит, Рё РІСЃРµ его поддерево, РІ дерево документа. Ртим методом можно соединить РґРІР° дерева объектов. Если второй аргумент равен true, то рекурсивно вставляется РІСЃРµ поддерево. </p>
<p>
Рнтерфейс Element
</p> <p class="paragraph">
Рнтерфейс Element добавляет Рє методам своего предка Node методы работы СЃ атрибутами открывающего тега элемента XML Рё методы, позволяющие обратиться Рє вложенным элементам. Только РѕРґРёРЅ метод </p>
<p class="paragraph">
public String getTagName(); </p>
<p class="paragraph">
дает сведения о самом элементе, а именно имя элемента. </p>
<p class="paragraph">
Прежде чем получить значение атрибута с именем name, надо проверить его наличие методами </p>
<p class="paragraph">
public boolean hasAttribute(String name); </p>
<p class="paragraph">
public boolean hasAttributeNS(String uri, String name); </p>
<p class="paragraph">
Второй из этих методов учитывает пространство имен с именем uri, записанным в виде строки URI; имя name должно быть полным, с префиксом. </p>
<p class="paragraph">
Получить атрибут в виде объекта типа Attr или его значение в виде строки по имени name с учетом префикса или без него можно методами </p>
<p class="paragraph">
public Attr getAttributeNode(String name); </p>
<p class="paragraph">
public Attr getAttributeNodeNS(String uri, String name); </p>
<p class="paragraph">
public String getAttribute(String name); </p>
<p class="paragraph">
public String getAttributeNS(String uri, String name); </p>
<p>Удалить атрибут можно методами </p> <p class="paragraph">
public Attr removeAttributeNode(Attr name); </p>
<p class="paragraph">
public void removeAttribute(String name); </p>
<p class="paragraph">
public void removeAttributeNS(String uri, String name); </p>
<p>Установить значение атрибута можно методами </p> <p class="paragraph">
public void setAttribute(String name, String value); </p>
<p class="paragraph">
public void setAttributeNS(String uri, String name, String value); </p>
<p>Добавить атрибут в качестве потомка можно методами </p> <p class="paragraph">
public Attr setAttributeNode(String name); </p>
<p class="paragraph">
public Attr setAttributeNodeNS(Attr name); </p>
<p>Два метода позволяют получить список узлов-потомков: </p> <p class="paragraph">
public NodeList getElrmentsByTagName(String name); </p>
<p class="paragraph">
public NodeList getElrmentsByTagNameNS(String uri, String name); </p>
<p>Ртак, методы перечисленных интерфейсов позволяют перемещаться РїРѕ дереву, менять структуру дерева, просматривать информацию, хранящуюся РІ узлах Рё листьях дерева, Рё изменять ее. </p><p>Приведем пример работы СЃ деревом объектов, построенным РїРѕ документу XML. Добавим РІ адресную книжку листинга 28.2 новый рабочий или домашний телефон РЎРёРґРѕСЂРѕРІРѕР№. Рто действие записано РІ листинге 28.11. </p><p>
Листинг 28.11. Анализ адресной книжки с помощью DOM API
</p> <p class="paragraph">
import org.w3c.dom.*; import javax.xml.parsers.*; import org.xml.sax.*; </p>
<p class="paragraph">
class ErrHand implements ErrorHandler{ </p>
<p class="paragraph">
public void warning(SAXParseException ex){ System.err.println("Warning: " + ex); System.err.println("line = " + ex.getLineNumber() + </p>
<p class="paragraph">
" col = " + ex.getColumnNumber()); </p>
<p class="paragraph">
} </p>
<p class="paragraph">
public void error(SAXParseException ex){ System.err.println("Error: " + ex); System.err.println("line = " + ex.getLineNumber() + </p>
<p class="paragraph">
" col = " + ex.getColumnNumber()); </p>
<p class="paragraph">
} </p>
<p class="paragraph">
public void fatalError(SAXParseException ex){ System.err.println("Fatal error: " + ex); System.err.println("line = " + ex.getLineNumber() + </p>
<p class="paragraph">
" col = " + ex.getColumnNumber()); </p>
<p class="paragraph">
} </p>
<p class="paragraph">
public class TreeProcessDOM{ </p>
<p class="paragraph">
static final String JAXP_SCHEMA_MNGUAGE = </p>
<p class="paragraph">
" ava.sun.com/xml/j axp/properties/schemaLanguage"; </p>
<p class="paragraph">
static final String W3C XML SCHEMA = </p>
<p class="paragraph">
""; </p>
<p class="paragraph">
public static void main(String[] args) throws Exception{ if (args.length != 3){ </p>
<p class="paragraph">
System.err.println("Usage: java TreeProcessDOM " + "<file-name>.xml {workjhome} <phone>"); </p>
<p class="paragraph">
System.exit(-1); </p>
<p class="paragraph">
} </p>
<p class="paragraph">
DocumentBuilderFactory fact = DocumentBuilderFactory.newInstance(); fact.setNamespaceAware(true); fact.setValidating(true) ; </p>
<p class="paragraph">
try{ </p>
<p class="paragraph">
fact. setAttribute ( JAXP_SCHEMA_LANGUAGE, W3C_XML_SCHEMA) ; }catch(IllegalArgumentException x){ </p>
<p class="paragraph">
System.err.println("HeH3BecTHoe свойство: " + </p>
<p class="paragraph">
JAXP_SCHEMA_LANGUAGE) ; </p>
<p class="paragraph">
System.exit(-1); </p>
<p class="paragraph">
} </p>
<p class="paragraph">
DocumentBuilder builder = fact.newDocumentBuilder(); builder.setErrorHandler(new ErrHand()); </p>
<p class="paragraph">
Document doc = builder.parse(args[0]); </p>
<p class="paragraph">
NodeList list = doc.getElementsByTagName("notebook"); int n = list.getLength(); if (n == 0){ </p>
<p class="paragraph">
System.err.println("Документ пуст."); </p>
<p class="paragraph">
System.exit(-1); </p>
<p class="paragraph">
} </p>
<p class="paragraph">
Node thisNode = null; </p>
<p class="paragraph">
for (int k = 0; k < n; k++){ thisNode = list.item(k); </p>
<p class="paragraph">
String elemName = null; </p>
<p class="paragraph">
if (thisNode.getFirstChild() instanceof Element){ </p>
<p class="paragraph">
elemName = (thisNode.getFirstChild()).getNodeName(); if (elemName.equals("name")){ </p>
<p class="paragraph">
if (!thisNode.hasAttributes()){ </p>
<p class="paragraph">
System.err.println("ATpH5yTbi отсутствуют " + elemName); </p>
<p class="paragraph">
System.exit(1); </p>
<p class="paragraph">
} </p>
<p class="paragraph">
NamedNodeMap attrs = thisNode.getAttributes(); </p>
<p class="paragraph">
Node attr = attrs.getNamedItem("surname"); if (attr instanceof Attr) </p>
<p class="paragraph">
if (((Attr)attr).getValue().equals("РЎРёРґРѕСЂРѕРІР°")) break; </p>
<p class="paragraph">
} </p>
<p class="paragraph">
} </p>
<p class="paragraph">
} </p>
<p class="paragraph">
NodeList topics = ((Element)thisNode) </p>
<p class="paragraph">
.getElementsByTagName("phone-list"); </p>
<p class="paragraph">
Node newNode; </p>
<p class="paragraph">
if (args[1].equals("work")) </p>
<p class="paragraph">
newNode = doc.createElement("work-phone"); else newNode = doc.createElement("home-phone"); </p>
<p class="paragraph">
Text textNode = doc.createTextNode(args[2]); </p>
<p class="paragraph">
newNode.appendChild(textNode); </p>
<p class="paragraph">
thisNode.appendChild(newNode); </p>
<p class="paragraph">
} </p>
<p class="paragraph">
} </p>
<p class="paragraph">
Дерево объектов можно вывести РЅР° экран дисплея, например, как объект класса JTree — РѕРґРЅРѕРіРѕ РёР· компонентов графической библиотеки Swing. Рменно так сделано РЅР° СЂРёСЃ. 28.2. Для вывода применена программа DomEcho РёР· электронного учебника "Web Services Tutorial". Рсходный текст программы слишком велик, чтобы приводить его здесь, РЅРѕ его можно посмотреть РїРѕ адресу tutorial.html. Р’ состав парсера Xerces РІ качестве примера анализа документа РІ раздел samples/ui/ РІС…РѕРґРёС‚ программа TreeView, которая тоже показывает дерево объектов РІ РІРёРґРµ дерева JTree библиотеки Swing. </p>
<p>
Другие DOM-парсеры
</p> <p class="paragraph">
Модель дерева объектов DOM была первоначально разработана РіСЂСѓРїРїРѕР№ OMG (Object Management Group) РІ рамках языка IDL (Interface Definition Language) без учета особенностей Java. Только потом РѕРЅР° была переведена РЅР° Java консорциумом W3C РІ РІРёРґРµ интерфейсов Рё классов, составивших пакет org.w3c.dom. Ртим объясняется, РІ частности, широкое применение РІ DOM API интерфейсов Рё фабричных методов вместо классов Рё конструкторов. </p>
<p class="paragraph">
Данное неудобство привело к появлению других разработок. </p>
<p class="paragraph">
Участники общественного проекта JDOM РЅРµ стали реализовать модель DOM, Р° разработали СЃРІРѕСЋ модель дерева объектов, получившую название JDOM. РћРЅРё выпускают одноименный СЃРІРѕР±РѕРґРЅРѕ распространяемый программный РїСЂРѕРґСѓРєС‚, СЃ которым можно ознакомиться РЅР° сайте проекта . Ртот РїСЂРѕРґСѓРєС‚ широко используется для обработки документов XML средствами Java. </p>
<p class="paragraph">
Участники другого общественного проекта — dom4j — приняли модель W3C DOM, но упростили и упорядочили DOM API. С их одноименным продуктом dom4j можно ознакомиться на сайте . </p>
<p class="paragraph">
Преобразование дерева объектов в XML
</p>
<p class="paragraph">
Ртак, дерево объектов DOM построено надлежащим образом. Теперь надо его преобразовать РІ документ XML, страничку HTML, документ PDF или объект РґСЂСѓРіРѕРіРѕ типа. Средства для выполнения такого преобразования составляют третью часть набора JAXP — пакеты javax.xml.transform, javax.xml.transform.dom, javax.xml.transform.sax, javax.xml. transform. stream, которые представляют СЃРѕР±РѕР№ реализацию языка описания таблиц стилей для преобразований XSLT (XML Stylesheet Language for Transformations) средствами Java. </p>
<p class="paragraph">
Язык XSLT разработан консорциумом W3 как одна из трех частей, составляющих язык записи таблиц стилей XSL (XML Stylesheet Language). Все материалы по XSL можно посмотреть на сайте проекта по адресу . </p>
<p class="paragraph">
Рнтерфейсы Рё классы, входящие РІ пакеты javax.xml.transform.*, управляют процессором XSLT, РІ качестве которого выбран процессор Xalan, разработанный РІ рамках проекта Apache Software Foundation, . </p>
<p class="paragraph">
Рсходный объект преобразования должен иметь тип Source. Рнтерфейс Source определяет всего РґРІР° метода доступа Рє идентификатору объекта: </p>
<p class="paragraph">
public String getSystemId(); public void setSystemId(String id); </p>
<p class="paragraph">
У интерфейса Source есть три реализации. Класс DOMSource подготавливает к преобразованию дерево объектов DOM, класс SAXSource подготавливает SAX-объект, а класс StreamSource — простой поток данных. В конструкторы этих классов заносится ссылка на исходный объект — для конструктора класса DOMSource это узел дерева, для конструктора класса SAXSource-имя файла, для конструктора класса StreamSource — входной </p>
<p class="paragraph">
поток. Методы перечисленных классов позволяют задать дополнительные свойства исходных объектов преобразования. </p>
<p class="paragraph">
Результат преобразования описывается интерфейсом Result. Он тоже определяет точно такие же методы доступа к идентификатору объекта-результата, как и интерфейс Source. У него тоже есть три реализации- классы DOMResult, SAXResult и StreamResult. В конст </p>
<p class="paragraph">
рукторы этих классов заносится ссылка на выходной объект. В первом случае это узел дерева, во втором — объект типа ContentHandler, в третьем — файл, в который будет занесен результат преобразования, или выходной поток. </p>
<p class="paragraph">
Само преобразование выполняется объектом класса Transformer. Вот стандартная схема преобразования дерева объектов DOM в документ XML, записываемый в файл. </p>
<p class="paragraph">
TransformerFactory transFactory = TransformerFactory.newInstance(); </p>
<p class="paragraph">
Transformer transformer = transFactory.newTransformer(); </p>
<p class="paragraph">
DOMSource source = new DOMSource(document); </p>
<p class="paragraph">
File newXMLFile = new File("ntb1.xml"); </p>
<p class="paragraph">
FileOutputStream fos = new FileOutputStream(newXMLFile); </p>
<p class="paragraph">
StreamResult result = new StreamResult(fos); transformer.transform(source, result); </p>
<p class="paragraph">
Вначале методом newInstance() создается экземпляр transFactory фабрики объектов-преобразователей. Методом </p>
<p class="paragraph">
public void setAttrbute(String name, String value); </p>
<p class="paragraph">
класса TransformerFactory можно установить некоторые атрибуты этого экземпляра. Рмена Рё значения атрибутов зависят РѕС‚ реализации фабрики. </p>
<p class="paragraph">
С помощью фабрики преобразователей создается объект-преобразователь класса Transformer. При формировании этого объекта в него можно занести объект, содержащий правила преобразования, например таблицу стилей XSL. </p>
<p class="paragraph">
В созданный объект класса Transformer методом </p>
<p class="paragraph">
public void setParameter(String name, String value); </p>
<p class="paragraph">
можно занести параметры преобразования, а методами </p>
<p class="paragraph">
public void setOutputProperties(Properties out); public void setOutputProperty(String name, String value); </p>
<p class="paragraph">
легко определить свойства преобразованного объекта. Рмена свойств name задаются константами, которые собраны РІ специально определенный класс OutputKeys, содержащий только эти константы. Р’РѕС‚ РёС… СЃРїРёСЃРѕРє: </p>
<p class="paragraph">
□ cdata_sect I on_e lements — список имен секций cdata через пробел; </p>
<p class="paragraph">
□ doctype_public — открытый идентификатор public преобразованного документа; </p>
<p class="paragraph">
□ doctype_system — системный идентификатор system преобразованного документа; </p>
<p class="paragraph">
□ encoding — кодировка символов преобразованного документа, значение атрибута encoding объявления XML; </p>
<p class="paragraph">
□ indent — делать ли отступы в тексте преобразованного документа. Значения этого свойства "yes" или "no"; </p>
<p class="paragraph">
□ media_type — MIME-тип содержимого преобразованного документа; </p>
<p class="paragraph">
□ METHOD — метод вывода, одно из значений: "xml", "html" или "text"; </p>
<p class="paragraph">
□ omit_xml_declaration — не включать объявление XML. Значения "yes" или "no"; </p>
<p class="paragraph">
□ STANDALONE- отдельный или вложенный документ, значение атрибута standalone </p>
<p class="paragraph">
объявления XML. Значения "yes" или "no"; </p>
<p class="paragraph">
□ version — номер версии XML для атрибута version объявления XML. </p>
<p class="paragraph">
Например, можно задать кодировку символов преобразованного документа следующим методом: </p>
<p class="paragraph">
transformer.setOutputProperty(OutputKeys.ENCODING, "Windows-1251"); </p>
<p class="paragraph">
Затем в приведенном примере по дереву объектов document типа Node создается объект класса DOMSource — упаковка дерева объектов для последующего преобразования. Тип аргумента конструктора этого класса — Node, откуда видно, что можно преобразовать не все дерево, а какое-либо его поддерево, записав в конструкторе класса DOMSource корневой узел поддерева. </p>
<p class="paragraph">
Наконец, определяется результирующий объект result, связанный с файлом newCourses.xml, и осуществляется преобразование методом transform(). </p>
<p class="paragraph">
Более сложные преобразования выполняются с помощью таблицы стилей XSL. </p>
<p class="paragraph">
Таблицы стилей XSL
</p>
<p class="paragraph">
В документах HTML часто применяются таблицы стилей CSS (Cascading Style Sheet), задающие общие правила оформления документов HTML: цвет, шрифт, заголовки. Выполнение этих правил придает документам единый стиль оформления. </p>
<p class="paragraph">
Для документов XML, в которых вообще не определяются правила визуализации, идея применить таблицы стилей оказалась весьма плодотворной. Таблицы стилей для документов XML записываются на специально сделанной реализации языка XML, названной XSL (XML Stylesheet Language). Все теги документов XSL относятся к пространству имен с идентификатором . Обычно они записываются с префиксом xsl. Если принят этот префикс, то корневой элемент таблицы стилей XSL будет называться <xsl: stylesheet>. </p>
<p class="paragraph">
Простейшая таблица стилей выглядит так, как записано в листинге 28.12. </p>
<p>
Листинг 28.12. Простейшая таблица стилей XSL
</p> <p class="paragraph">
<?xml version="1.0" encoding="UTF-8"?> </p>
<p class="paragraph">
<xsl:stylesheet version="1.0" </p>
<p class="paragraph">
xmlns:xsl=""> <xsl:output method="text" encoding="CP866"/> </p>
<p class="paragraph">
</xsl:stylesheet> </p>
<p class="paragraph">
Здесь только определяется префикс пространства имен xsl и правила вывода, а именно выводится "плоский" текст, на что показывает значение text (другие значения — html и xml), в кодировке CP866. Такая кодировка выбрана для вывода кириллицы на консоль MS Windows. Объект класса Transformer, руководствуясь таблицей стилей листинга 28.12, просто выводит тела элементов так, как они записаны в документе XML, т. е. просто удаляет теги вместе с атрибутами, оставляя их содержимое. </p>
<p class="paragraph">
Рту таблицу стилей записываем РІ файл, например, simple.xsl. Ссылку РЅР° таблицу стилей можно поместить РІ документ XML как РѕРґРЅСѓ РёР· инструкций РїРѕ обработке: </p>
<p class="paragraph">
<?xml version="1.0" encoding="Windows-1251"?> </p>
<p class="paragraph">
<?xml-stylesheet type="text/xsl" href="simple.xsl"?> </p>
<p class="paragraph">
<notebook> </p>
<p class="paragraph">
<!— Продолжение адресной книжки —> </p>
<p class="paragraph">
После этого XML-парсер, если он, кроме того, является XSLT -процессором, выполнит преобразование, заданное в файле simple.xsl. </p>
<p class="paragraph">
Другой путь — использовать таблицу стилей при создании объекта-преобразователя, например, так, как записано в листинге 28.13. </p>
<p>
Листинг 28.13. Консольная программа преобразования документа XML
</p> <p class="paragraph">
import java.io.*; </p>
<p class="paragraph">
import javax.xml.transform.*; </p>
<p class="paragraph">
import j avax.xml.transform.stream.*; </p>
<p class="paragraph">
public class SimpleTransform{ </p>
<p class="paragraph">
public static void main(String[] args) throws TransformerException{ if (args.length != 2){ </p>
<p class="paragraph">
System.out.println("Usage: " + </p>
<p class="paragraph">
"java SimpleTransform xmlFileName xsltFileName"); System.exit(1); </p>
<p class="paragraph">
} </p>
<p class="paragraph">
File xmlFile = new File(args[0]); </p>
<p class="paragraph">
File xsltFile = new File(args[1]); </p>
<p class="paragraph">
Source xmlSource = new StreamSource(xmlFile); </p>
<p class="paragraph">
Source xsltSource = new StreamSource(xsltFile); </p>
<p class="paragraph">
Result result = new StreamResult(System.out); </p>
<p class="paragraph">
TransformerFactory transFact = TransformerFactory.newInstance(); </p>
<p class="paragraph">
Transformer trans = transFact.newTransformer(xsltSource); trans.transform(xmlSource, result); </p>
<p class="paragraph">
} </p>
<p class="paragraph">
} </p>
<p>После компиляции набираем в командной строке </p> <p class="paragraph">
java SimpleTransform ntb.xml simple.xsl </p>
<p>и получаем на экране дисплея содержимое тегов документа ntb.xml. </p><p>В более сложных случаях просто изменяем таблицу стилей. Например, если мы хотим получить содержимое документа на консоли, то таблицу стилей для объекта-преобразователя класса Transformer надо записать так, как показано в листинге 28.14. </p><p>
Листинг 28.14. Таблица стилей для показа адресной книжки
</p> <p class="paragraph">
<?xml version="1.0" encoding="UTF-8"?> </p>
<p class="paragraph">
<xsl:stylesheet version="1.0" </p>
<p class="paragraph">
xmlns:xsl=""> </p>
<p class="paragraph">
<xsl:output method="text" encoding="CP866" /> </p>
<p class="paragraph">
<xsl:template match="person"> </p>
<p class="paragraph">
<xsl:apply-templates /> </p>
<p class="paragraph">
</xsl:template> </p>
<p class="paragraph">
<xsl:template match="name"> </p>
<p class="paragraph">
<xsl:value-of select="@first" /> <xsl:text> </xsl:text> <xsl:value-of select="@second" /> <xsl:text> </xsl:text> </p>
<p class="paragraph">
<xsl:value-of select="@surname" /> </p>
<p class="paragraph">
</xsl:template> </p>
<p class="paragraph">
<xsl:template match="address"> </p>
<p class="paragraph">
<xsl:value-of select="street" /> <xsl:text> </xsl:text> <xsl:value-of select="city" /> <xsl:text> </xsl:text> <xsl:value-of select="zip" /> </p>
<p class="paragraph">
</xsl:template> </p>
<p class="paragraph">
<xsl:template match="phone-list"> </p>
<p class="paragraph">
<xsl:value-of select="work-phone" /> <xsl:text>
</xsl:text> <xsl:value-of select="home-phone" /> <xsl:text>
</xsl:text> </xsl:template> </p>
<p class="paragraph">
</xsl:stylesheet> </p>
<p class="paragraph">
Мы не будем в данной книге заниматься языком XSL — одно его описание будет толще всей этой книги. На русский язык переведена "библия" XSLT [20]. Ее автор Майкл Кэй (Michael H. Kay) создал и свободно распространяет популярный XSLT -процессор Saxon, . </p>
<p class="paragraph">
Преобразование документа XML в HTML
</p>
<p class="paragraph">
С помощью языка XSL и методов класса Transformer можно легко преобразовать документ XML в документ HTML. Достаточно написать соответствующую таблицу стилей. В листинге 28.15 показано, как это можно сделать для адресной книжки листинга 28.2. </p>
<p>Листинг 28.15. Таблица стилей для преобразования XML в HTML </p> <p class="paragraph">
<?xml version="1.0" encoding="Windows-1251"?> </p>
<p class="paragraph">
<xsl:stylesheet version="1.0" </p>
<p class="paragraph">
xmlns:xsl=""> </p>
<p class="paragraph">
<xsl:output method="html" encoding="Windows-1251"/> </p>
<p class="paragraph">
<xsl:template match="/"> </p>
<p class="paragraph">
<html><head><title>ADpecHaH книжка Фамилии, адреса и телефоны
