Читаем XML файл на Java с помощью JDOM Parser

JDOM – это максимально упрощенная open source Java-библиотека для создания, парсинга, изменения и сериализации XML-документов. В отличие от других подобных DOM APIs, JDOM ориентированна на язык Java, а не на спецификации XML, что очень упрощает код и облегчает его интуитивное понимание. При этом JDOM не является “велосипедом” и не содержит в себе свой собственный парсер, а использует уже существующие наработки – стандартные пакеты javax.xml и org.xml.sax. Если вам понадобилось работать с XML, то обратите сначала внимание именно на эту библиотеку, скорее всего вам она понравится.

Краткое описание модели библиотеки JDOM

Так же, как и сам XML, JDOM APIs являются древовидными. Для представления XML в библиотеке, главным образом, используются классы Document, Element и Attribute.

Документ XML в JDOM представляет из себя дерево, корнем которого является объект класса Document. Экземпляр Document является контейнером для всех остальных элементов и обязательно содержит один корневой элемент (экземпляр Element). Главной характеристикой объекта Element является его содержание (Content) и список атрибутов (Attribute). Класс Content является родительским для классов Element, Comment и Text (а так же для некоторых других), поэтому экземпляры перечисленных классов могут быть содержимым объекта Element. Объект Element есть ничто иное как XML-тег, у которого обязательно должно быть имя и могут быть атрибуты. Классы Comment и Text соответственно представляют комментарий и текст внутри тега. Экземпляры Attribute, Comment и Text не могут содержать внутри себя никаких элементов и по сути являются объектами, которые содержат только текстовые значения. Значение экземпляра Attribute может быть получено по имени в отличие от Comment и Text, у которых имени нет.

Для того что бы все стало совсем понятно, приведу схему документа, который ниже будет создан и прочитан с помощью JDOM.

Представленный документ является списком глав подразделений компании. Документ для простоты содержит всего два руководителя ( ). У каждого элемента есть атрибут id, а в качестве содержания – комментарий, кратко описывающий руководителя и элементы и , которые в свою очередь содержат текст, представляющий имя руководителя и название подразделения соответственно.

Теперь посмотрим, как будет выглядеть сам XML.

Для того чтобы создать XML-документ в общем случае необходимо выполнить следующие этапы:

Создать экземпляр Document
Создать корневой Element и добавить его в экземпляр Document
Создать и заполнить, начиная с корневого элемента, необходимое дерево с помощью экземпляров Element, Attribute, Comment и т.д.
Если необходимо, вывести (например в файл) созданный документ как поток байт с помощью класса XMLOutputter.

Пример метода, который создаёт описанное выше XML-дерево и выводит его на стандартный вывод, а так же в файл Heads.xml.

Из комментариев весь код должен быть понятен, но все же сделаю пару пояснений.

Метод addContent() после выполнения возвращает ссылку на тот же объект из которого он был вызван, благодаря чему можно создавать целую цепочку вызовов addContent(), заполняя содержание всех элементов очень небольшим объемом кода. Однако, не стоит этим сильно увлекаться, что бы код оставался понятным.

Форматом вывода можно управлять с помощью класса org.jdom.output.Format. Например, можно установить отступ, символ новой строки, кодировку вывода, указать как следует выводить пустые элементы ( или ), установить автоматическое удаление лишних пробельных символов и т.д..

Работа с существующим XML-файлом состоит из следующих этапов:

Создание экземпляра класса org.jdom.input.SAXBuilder, который умеет строить JDOM-дерево из файлов, потоков, URL и т.д.
Вызов метода build() экземпляра SAXBuilder с указанием файла или другого источника.
Навигация по дереву и манипулирование элементами, если это необходимо.

С первыми двумя пунктами все предельно ясно, а вот навигация по дереву может осуществляться множеством способов.

Для того, чтобы пробежаться по всем элементам дерева (экземпляры Element), можно воспользоваться методом getChildren(), что бы получить список List всех дочерних экземпляров корневого Element, а затем для каждого дочернего элемента так же вызвать getChildren() и т.д.

Пример использования getChildren()

Можно поступить по-другому – использовать методы getContent() и getDescendants(), передавая им фильтры для того что бы ограничить выборку.

Метод getContent() возвращает список List вложенных элементов, причем поиск осуществляется только на глубине 1 уровня. Таким образом, с помощью getContent() можно получить дочерние элементы объекта у которого вызывается данный метод, но нельзя получить дочерние элементы его дочерних элементов.

Метод getDescendants() возвращает Iterator по всем найденным элементам, но в отличие от getContent() поиск ведется на всех уровнях вложенности элементов.

Как я уже сказал, для ограничения выборки дочерних элементов в обоих методах можно использовать фильтры. Фильтры это классы, которые реализуют интерфейс org.jdom.filter.Filter. В библиотеке JDOM есть два готовых класса фильтра, реализующих этот интерфейс: org.jdom.filter.ContentFilter и org.jdom.filter.ElementFilter. Используя фильтр ElementFilter, можно осуществлять поиск объектов Element ограничивая его именем элемента и/или пространством имен (Namespace), а с помощью ContentFilter можно ограничивать поиск определенным “видом” элемента, например, получить все комментарии и текст, которые содержит элемент или только текст и в таком духе. В тоже время интерфейс Filter очень прост и требует реализации лишь одного метода matches(java.lang.Object obj), который возвращает true в случае если элемент obj соответствует заданным параметрам фильтра, поэтому довольно легко можно создавать свои изощеренные фильтры.

Теперь приведу пример метода, который парсит созданный ранее XML-файл.
После выполнения метода на консоль будет выведено следующее:

Изменение дерева осуществляется с помощью различных методов вроде removeChild(), removeChildren(), removeContent(), addContent(), setContent(), removeAttribute(), setAttribute(), setName(), setText() и т.д. и т.п., думаю что это и так понятно.

Читать еще: Как посмотреть какая оперативная память на компьютере?

Более подробную информацию о JDOM можно найти на официальном сайте, а так же в главах 14 и 15 свободно доступной книги о работе с XML на Java (всё на английском).

Java json parser — пример работы парсера

В этом посте мы разберем подробный пример парсера Java JSON. JSON(JavaScript Object Notation) — это простой текстовый формат, который облегчает чтение и запись. Это широко используемый формат обмена данными, поскольку его анализ и генерация просты в использовании.

В языке Java есть несколько способов обработки JSON. В этом примере мы собираемся использовать общий набор инструментов — JSON.simple — и узнаем, как анализировать каждый тип файла.

Установка среды

Перед началом написания кода программы, мы должны установить подходящую среду для компилятора, чтобы распознавать классы JSON. Если необходимо построить проект с помощью Maven, нужно добавить следующую запись в pom.xml:

Иначе необходимо добавить версию json-simple-1.1.1.jar в CLASSPATH.

Пример парсинга JSON

Разберем, как мы можем проанализировать и произвести чтение файла json, для этого нужно создать наш собственный файл, он будет называться jsonTestFile.json. Он имеет следующую структуру:

Теперь необходимо создать файл Java в проекте с именем JsonParseTest и вставить следующий код.

Объясним данный код. После создания экземпляра JSONParser мы создаем объект JSONObject.

Он содержит коллекцию пар ключ-значение, из которых мы можем получить каждое значение. Чтобы распарсить объекты, вызывается метод get() экземпляра JSONObject, определяющий указанный ключ в качестве аргумента.

Важно применить подходящий метод. Для типов массивов в файле json используется JSONArray, который представляет упорядоченную последовательность значений. В программном коде итератор должен использоваться для получения каждого значения массива json.

Структура в файле предполагает создание нового объекта JSONObject для получения значений.

Полученный результат парсинга приведен ниже.

Метод с использованием JsonPATH

Два приведенных выше примера требуют полной десериализации JSON в объект Java перед получением значения. Другой альтернативой является использование JsonPATH, который похож на XPath для JSON и позволяет обходить объекты JSON.

Вам нужно добавить JsonPATH, которую можно получить из репозитория maven.(https://mvnrepository.com/artifact/com.jayway.jsonpath/json-path)

Средняя оценка / 5. Количество голосов:

Спасибо, помогите другим – напишите комментарий, добавьте информации к статье.

Или поделись статьей

Видим, что вы не нашли ответ на свой вопрос.

Упрощение XML-программирования при помощи JDOM

Этот API с открытым кодом облегчает манипулирование XML-документом для разработчиков Java

Как разработчик, вы, возможно, слышали о правиле 80-20, известном в других кругах как закон Парето: процесс или методология будет приспособлен для 80 процентов всех возможных ситуаций, а остальные 20 придется обрабатывать по-разному, от случая к случаю. Вывод для разработки программного обеспечения – что разработчикам должно быть очень легко выполнить 80 процентов из того, что им нужно сделать при помощи данной технологии. Конечно, программные продукты и стандарты не всегда развиваются в соответствии с правилом 80-20. Раздробленная сфера инструментов Java XML, в частности, иллюстрирует исключение из этого правила. Мир программирования Java полон разных APIs – некоторые из них доморощенные, некоторые пришли на рынок от ведущих корпораций – которые обеспечивают изощренные решения для определенных задач XML. Как бы в соответствии с универсальностью XML, для каждой новой задачи есть новая технология. Но как их склеить, и как вы собираетесь найти правильный инструмент для 80 процентов вещей, которые вы должны делать снова и снова – на основе манипулирования деревом XML с интуитивным отображением на язык Java? JDOM – это XML API, построенные именно для решения этого вопроса.

Итак, мы здесь: Java и XML

Во многих отношениях язык Java стал языком программирования для XML. Благодаря значительной работе Apache Software Foundation и IBM alphaWorks, сейчас есть полная цепочка инструментов для создания, манипулирования, преобразования и разбора XML-документов. Но хотя множество Java-разработчиков используют XML ежедневно, Sun задерживает индустриальное внедрение XML в платформу Java. Поскольку платформа Java 2 прекрасно развивалась до того, как XML обозначил себя как ключевая технология для всего, от интеграции бизнеса с бизнесом и до наполнения Web-сайтов, фирма Sun использовала процесс JSR в качестве дедушки существующих XML API, которые получили широкое применение. Наиболее значительным на сегодня добавлением было введение JAXP, Java API for XML Parsing, который включает в себя три пакета:

org.w3c.dom, Java-реализация рекомендации W3C для стандартной программной Объектной Модели Документа для XML
org.xml.sax, Simple API for XML для разбора, управляемого событиями
javax.xml.parsers, фабричная реализация, которая позволяет разработчикам приложений конфигурировать и получать определенную реализацию парсера

Хотя введение этих пакетов является хорошей вещью для Java-разработчиков, они только представляют формальный поклон существующим стандартам API, а не большой скачок вперед в обеспечении элегантной интероперабельности Java-XML. Чего недостает в базовой платформе Java, так это интуитивного интерфейса для манипулирования XML-документами как Java-объектами.

Появляется JDOM. Дитя двух известных Java-разработчиков и авторов, Брэта Маклафлина и Джейсона Хантэра, JDOM был введен в действие как проект с открытым кодом по лицензии, подобной Apache, в начале 2000 года. Он рос, включая в себя вклады, и учитывая обратную связь и исправления ошибок от широкого круга Java-разработчиков и стремясь построить полное решение на платформе Java для обращения, манипулирования и вывода XML-данных из кода Java.

Для чего годится JDOM

JDOM может использоваться как альтернатива пакету org.w3c.dom для программного манипулирования XML-документами. Это не обязательная замена, фактически JDOM и DOM могут счастливо сосуществовать. Кроме того, JDOM не занимается разбором исходного текста XML, хотя он обеспечивает классы-оболочки, которые берут на себя большую часть работы по конфигурированию и выполнению реализации парсера. JDOM использует сильные стороны существующих API, чтобы построить, как сказано на домашней странице проекта, “лучшую мышеловку”.

Читать еще: Тест USB-кабелей для аудио: аудиофилия или аудиопаранойя? Подключение передней панели к материнской плате: схема Usb audio разъем.

Чтобы понять, зачем нужен альтернативный API, рассмотрим ограничения проекта W3C DOM:

Независимость от языка. DOM не была разработана, имея в виду язык Java. Хотя этот подход сохраняет очень похожий API для разных языков, он также делает этот API более громоздким для программистов, которые используют стиль языка Java. Например, хотя язык Java имеет встроенный в язык класс String, спецификация DOM определяет собственный класс Text.
Строгая иерархия. API DOM следует непосредственно самой спецификации XML. В XML все является узлами, так что вы находите в DOM интерфейс на базе узлов, где почти все строится на методах, которые возвращают Node. Это элегантно с точки зрения полиморфизма, но, как объяснялось выше, трудно и громоздко работать с этим в языке Java, где явное схождение от Node к типам листьев приводит к громоздкому и плохо понимаемому коду.
Управляемый интерфейсом. DOM API состоит только из интерфейсов (единственным, вполне достаточным исключением является класс Exception). В сферу интересов W3C не входит обеспечение реализаций, только определение интерфейсов, что имеет смысл. Но это также означает, что использующий API Java-программист при создании объектов XML в некоторой степени ущемлен, так как стандарты W3C затрудняют использование классов родовых фабрик и подобных гибких, но менее непосредственных шаблонов. Для определенных вариантов использования, когда XML-документы строятся только парсером и никогда – прикладным кодом, это не имеет значения. Но когда использование XML становится более широким, не все проблемы продолжают оставаться управляемыми только парсером, и разработчики приложений нуждаются в удобном способе конструировать объекты XML программно.

Для программистов эти ограничения означают тяжелый (и в смысле использования памяти, и в смысле размера интерфейса) и громоздкий API, который может быть трудно изучить и использовать. Напротив, JDOM сформулирован как легкий API, прежде всего ориентированный на Java. Он отвечает перечисленным выше требования, следуя основным принципам DOM, но имеет свои особенности:

JDOM специализирован для платформы Java. API использует, где возможно, встроенную в Java поддержку String, так что текстовые значения всегда доступны как String. Он также использует классы коллекций платформы Java 2, такие как List и Iterator, обеспечивая богатую среду для работы программистов, хорошо знакомых с языком Java.
Нет иерархий. В JDOM элемент XML является экземпляром класса Element, атрибут XML является экземпляром класса Attribute, а сам XML-документ является экземпляром класса Document. Поскольку все они представляют разные концепции в XML, они всегда представляются собственными типами, а не как аморфные “узлы”.
Управляемый классом. Поскольку объекты JDOM являются непосредственными экземплярами таких классов, как Document, Element и Attribute, создание их настолько легко, насколько легко использование оператора new языка Java. Это также означает, что нет необходимости в интерфейсе фабрики для конфигурирования – JDOM готов к использованию прямо из jar.

Построение документов JDOM и манипулирование ими

JDOM использует стандартные шаблоны кодирования Java. Где возможно, он использует оператор Java new вместо сложных шаблонов фабрик, делая манипулирование объектами легким даже для начинающего. Например, давайте посмотрим, как вы можете построить простой XML-документ с нуля, используя JDOM. Структура, которую мы собираемся построить, показана в Листинге 1. (Выгрузите полный код примера из Ресурсов).

Листинг 1. Простой XML-документ для построения

Замечание: Мы будем строить документ-пример, подробнее в Листингах 2 – 7 далее.

Для начала давайте создадим корневой элемент и добавим его в документ:

Листинг 2. Создание документа

Этот шаг создает новый элемент org.jdom.Element и делает его корневым элементом org.jdom.Document myDocument. (Если вы используете код примера, из Ресурсов, убедитесь, что импортирован org.jdom.* .) Поскольку XML-документ должен всегда иметь единственный корневой элемент, Document принимает в своем конструкторе Element.

Далее мы добавляем атрибут vin:

Листинг 3. Добавление атрибута

Добавление элементов также весьма очевидно. Вот мы добавляем элемент make:

Листинг 4. Элементы и подэлементы

Поскольку метод addContent класса Element возвращает Element, мы можем также написать это так:

Листинг 5. Добавление элемента в краткой форме

Оба эти оператора выполняют одно и то же. Некоторые могут сказать, что первый пример более читабельный, но другим покажется более читабельным конструирование многих элементов за раз. Чтобы завершить конструирование документа:

Листинг 6. Добавление остальных элементов

Вы заметите, чтоб для элемента license мы не только добавляем содержимое элемента, но также и добавляем к нему атрибут, определяющий штат, в котором лицензия выдана. Это возможно потому, что методы addContent класса Element всегда возвращают сам Element, а не имеют декларацию void.

Добавление комментария или других стандартных типов XML проделывается тем же способом:

Листинг 7. Добавление комментария

Манипулирование документов выполняется в том же стиле. Например, чтобы получить ссылку на элемент year, мы используем метод getChild класса Element:

Листинг 8. Обращение к дочерним элементам

Этот оператор будет возвращать первый дочерний Element с именем элемента year. Если элемента year нет, вызов вернет null. Заметьте, что нам не нужно преобразовывать возвращаемое значение во что-то вроде интерфейса DOM Node – потомки Element’ов – просто Element’ы. Таким же образом мы можем удалить из документа элемент year:

Читать еще: Как восстановить доступ к Facebook Messenger и сохранить историю на Android или Windows компьютере

Листинг 9. Удаление дочерних элементов

Этот вызов удалит только элемент year; остальная часть документа останется неизмененной.

Итак, мы рассмотрели, как документы могут создаваться и как ими манипулировать. Для вывода нашего окончательного документа на консоль мы можем использовать класс JDOM XMLOutputter:

Листинг 10. Настройка JDOM на текст XML

XMLOutputter имеет несколько опций форматирования. Здесь мы задали, что мы хотим, чтобы дочерние элементы отступали на два пробела от родительских элементов, и что мы хотим иметь переводы строки между элементами. XMLOutputter может выводить либо во Writer, либо в OutputStream. Чтобы выводить в файл, мы можем просто изменить строку вывода на:

Листинг 11. Использование FileWriter для вывода XML

Хорошо играет с другими: Взаимодействие с существующими инструментами XML

Одним из интересных свойств JDOM является его интероперабельность с другими API. Используя JDOM, вы можете выводить документ не только в Stream или в Reader, но также и в поток событий SAX или в DOM Document. Эта гибкость позволяет JDOM использоваться в гетерогенной среде или добавляться в систему, уже применяющую другие методы для обработки XML. Как мы увидим в следующем примере, она также позволяет JDOM использовать другие инструменты XML, которые даже не распознают структуры данных JDOM.

Другое использование JDOM состоит в возможности читать и манипулировать уже существующими XML-данными. Чтение правильно форматированного XML-файла выполняется при помощи одного из классов в org.jdom.input. В данном примере мы применяем SAXBuilder:

Листинг 12. Разбор XML-файла при помощи SAXBuilder

Вы можете манипулировать документом, построенным таким способом, так же, как было показано выше, в Листингах 2 – 7.

Другое практическое приложение JDOM комбинирует его с продуктом Xalan от Apache (см Ресурсы). Используя вышеприведенный пример с автомобилем, мы сконструируем Web-страницу для онлайнового продавца автомобилей, представляющую подробности об определенном автомобиле. Сначала предположим, что документ, построенный нами выше, представляет информацию об автомобиле, которую мы хотим представить пользователю. Далее мы скомбинируем этот Document JDOM с таблицей стилей XSL и выведем отформатированные в HTML результаты в OutputStream сервлета для отображения в браузере пользователя.

В данном случае таблица стилей XSL, которую мы собираемся использовать, называется car.xsl:

Листинг 13. XSL для трансформации записи об автомобиле в HTML

Теперь мы настроим org.jdom.Document на Document DOM и скормим его Xalan, вместе с файлом, который представляет наш XSL, и OutputStream, который мы получили от нашего гипотетического сервера приложений, который используется сервлетом (Листинг 14).

Листинг 14. Создание HTML-документа при помощи JDOM и Xalan

В данном примере вывод происходит через HTTPResponse OutputStream Java-сервлета. Однако, поток может так же легко быть и файловым потоком, как в предыдущем примере с XMLOutputter. Мы использовали DOMOutputter при генерации источника XML для Xalan. Однако, мы могли генерировать тот же вход, используя XMLOutputter для вывода XML-документа как String, а затем превратить его в StreamSource. Отметим гибкость: JDOM может выводить свои структуры как String, как поток событий SAX или как Document DOM. Это позволяет JDOM иметь интерфейс с инструментами, которые могут принимать на входе любую из этих моделей. (Если вам нужна дополнительная функциональность, проверьте пакет contrib на Web-сайте JDOM, где вы найдете большую библиотеку утилит JDOM, которые обеспечивают такие инструменты, как построитель JDBC на основе ResultSet, реализацию XPATH и т.п.)

Всего в нескольких строках кода JDOM обеспечивает большое разнообразие функциональности. Мы можем разбирать и программно создавать XML-документы, манипулировать этими документами и использовать их для выработки Web-страниц, управляемых XML.

Sun и JDOM: Что в имени?

Официальный релиз JDOM, 1.0, может совместиться с его продолжающимся оцениванием в Java Community Process. Представленный в JCP как JSR-102, JDOM был одобрен для возможного включения в ядро платформы Java с таким комментарием от Sun: “JDOM выглядит значительно более легким в использовании, чем прежние API, так что мы надеемся, что он будет полезным дополнением к платформе.” В соответствии с JSR, в релизе 1.пакеты JDOM могут измениться с “org.jdom” на “javax.xml.tree”.

JDOM растет: Взгляд в будущее

Когда это пишется, проект JDOM реализован в версии Beta 6. Даже в бета-состоянии JDOM обеспечивает стабильную реализацию для многих реальных приложений. Хотя многие из API уже надежны, продолжается работа во многих областях, которая потенциально повлияет на существующие интерфейсы. Следовательно, никакие проекты-разработки, предпринятые в настоящее время, не должны избегать JDOM из боязни ошибочной реализации, но должны рассматривать возможность того, что определенные сигнатуры методов или специфическая семантика все еще могут измениться до финального релиза и потенциальной адаптации в ядро Java API.

На ближайшее время список того, что нужно сделать для JDOM фокусируется на стабилизации API и оценке аспектов производительности частей реализации. Другие пункты находятся в работе, но это может помешать некоторым разработчикам приложений включать поддержку сущностей DTD и других более редких конструкций. Дорога дальше предусматривает включение в ядро поддержку XPATH, языка маршрутов XML непосредственно в приложения, как XSLT, и более прямую интеграцию с источниками данных XML.

Итак, в заключение, лучше ли JDOM, чем существующие API XML? Если вы думаете на Java, ответ, возможно, да. JDOM не означает отставки вашему любимому парсеру или XML-базе данных, но его принципы проектирования направлены на ускорение обучения Java-разработчиков или их ориентирование в мире XML.

голоса

Рейтинг статьи