Чтение Данных XML в ДОМА

В этом разделе Вы создадите Объектную модель документа, читая в существующем XML-файле.

Отметьте - В Преобразованиях Расширяемого языка таблиц стилей, Вы будете видеть, как выписать ДОМУ как XML-файл. (Вы будете также видеть, как преобразовать существующий файл данных в XML с относительной непринужденностью.)

Создание Программы

Объектная модель документа обеспечивает API, которые позволяют Вам создавать, изменять, удалять, и перестраивать узлы. Прежде, чем Вы попытаетесь создать ДОМА, полезно понять, как структурируется ДОМ. Эта серия примеров сделает внутренности ДОМА видимыми через пример программы под названием DOMEcho, который Вы найдете в каталоге INSTALL_DIR/jaxp-version/samples/dom после того, как Вы установили API JAXP.

Создайте Скелет

Во-первых, создайте простую программу, чтобы считать XML-документ в ДОМА и затем записать это обратно снова.

Запустите с нормальной основной логики для приложения, и проверки, чтобы удостовериться, что параметр был предоставлен на командной строке:

public class DOMEcho {

    static final String outputEncoding = "UTF-8";

    private static void usage() {
        // ...
    }

    public static void main(String[] args) throws Exception {
        String filename = null;
    
        for (int i = 0; i < args.length; i++) {
            if (...) { 
                // ...
            } 
            else {
                filename = args[i];
                if (i != args.length - 1) {
                    usage();
                }
            }
        }

        if (filename == null) {
            usage();
        }
    }
}

Этот код выполняет весь основной набор операции. Весь вывод для DOMEcho использует кодирование UTF-8. Метод usage(), который вызывают, если никакой параметр не определяется просто, говорит Вам, какие параметры DOMEcho ожидает, таким образом, код не покажут здесь. Строка filename также объявляется, который будет именем XML-файла, который будет проанализирован в ДОМА DOMEcho.

Импортируйте Необходимые Классы

В этом разделе все классы индивидуально называют так Вами, которые могут видеть, куда каждый class прибывает из, в случае, если Вы хотите сослаться на документацию API. В файле примера операторы импорта делаются с более короткой формой, такой как javax.xml.parsers.*.

Они - API JAXP, используемые DOMEcho:

package dom;
import javax.xml.parsers.DocumentBuilder; 
import javax.xml.parsers.DocumentBuilderFactory;

Эти классы для исключений, которые могут быть выданы, когда XML-документ анализируется:

import org.xml.sax.ErrorHandler;
import org.xml.sax.SAXException; 
import org.xml.sax.SAXParseException;
import org.xml.sax.helpers.*

Эти классы чтение демонстрационный XML-файл и управляют выводом:

import java.io.File;
import java.io.OutputStreamWriter;
import java.io.Printwriter;

Наконец, импортируйте определения W3C для ДОМА, исключений ДОМА, объектов и узлов:

import org.w3c.dom.Document;
import org.w3c.dom.DocumentType;
import org.w3c.dom.Entity;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;

Обработайте Ошибки

Затем, добавьте логику обработки ошибок. Наиболее важный момент - то, что JAXP-совместимый разработчик документа обязан сообщать об исключениях SAX, когда это испытывает затруднения, анализируя XML-документ. Синтаксический анализатор ДОМА не должен фактически использовать синтаксический анализатор SAX внутренне, но потому что стандарт SAX уже там, имеет смысл использовать это для того, чтобы сообщить об ошибках. В результате код обработки ошибок для приложений ДОМА очень подобен этому для приложений SAX:

private static class MyErrorHandler implements ErrorHandler {
     
    private PrintWriter out;

    MyErrorHandler(PrintWriter out) {
        this.out = out;
    }

    private String getParseExceptionInfo(SAXParseException spe) {
        String systemId = spe.getSystemId();
        if (systemId == null) {
            systemId = "null";
        }

        String info = "URI=" + systemId + " Line=" + spe.getLineNumber() +
                      ": " + spe.getMessage();
        return info;
    }

    public void warning(SAXParseException spe) throws SAXException {
        out.println("Warning: " + getParseExceptionInfo(spe));
    }
        
    public void error(SAXParseException spe) throws SAXException {
        String message = "Error: " + getParseExceptionInfo(spe);
        throw new SAXException(message);
    }

    public void fatalError(SAXParseException spe) throws SAXException {
        String message = "Fatal Error: " + getParseExceptionInfo(spe);
        throw new SAXException(message);
    }
}

Как можно видеть, обработчик ошибок class DomEcho генерирует свой вывод, используя экземпляры PrintWriter.

Инстанцируйте Фабрики

Затем, добавьте следующий код к методу main(), чтобы получить экземпляр фабрики, которая может дать нам разработчика документа.

public static void main(String[] args) throws Exception {
    DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();

    // ...
}

Получите Синтаксический анализатор и Проанализируйте Файл

Теперь, добавьте следующий код к main(), чтобы получить экземпляр разработчика, и использовать это, чтобы проанализировать указанный файл.

DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder(); 
Document doc = db.parse(new File(filename));

Проанализированный файл обеспечивается переменной filename, которая была объявлена в начале метода main(), который передают к DOMEcho как параметр, когда программа выполняется.

Конфигурирование Фабрики

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

public static void main(String[] args) throws Exception {

    String filename = null;
    boolean dtdValidate = false;
    boolean xsdValidate = false;
    String schemaSource = null;
        
    for (int i = 0; i < args.length; i++) {
        if (args[i].equals("-dtd"))  { 
            dtdValidate = true;
        } 
        else if (args[i].equals("-xsd")) {
            xsdValidate = true;
        } 
        else if (args[i].equals("-xsdss")) {
            if (i == args.length - 1) {
                usage();
            }
            xsdValidate = true;
            schemaSource = args[++i];
        }
        else {
            filename = args[i];
            if (i != args.length - 1) {
                usage();
            }
        }
    }

    if (filename == null) {
        usage();
    }

    DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();

    dbf.setNamespaceAware(true);
    dbf.setValidating(dtdValidate || xsdValidate);

    // ...

    DocumentBuilder db = dbf.newDocumentBuilder();
    Document doc = db.parse(new File(filename));
}

Как можно видеть, параметры командной строки устанавливаются так, чтобы можно было сообщить DOMEcho, чтобы выполнить проверку допустимости или против DTD или против XML-схемы, и фабрика конфигурируется, чтобы быть знающим пространством имен и выполнить, какой бы ни тип проверки допустимости пользователь определяет.

Отметьте - JAXP-совместимые синтаксические анализаторы не обязаны поддерживать все комбинации тех опций, даже при том, что ссылочный синтаксический анализатор делает. Если Вы определяете недопустимую комбинацию опций, фабрика генерирует ParserConfigurationException, когда Вы пытаетесь получить экземпляр синтаксического анализатора.

Больше информации о том, как использовать пространства имен и проверку допустимости, предоставляется в Проверке допустимости с XML-схемой, в который код, который отсутствует в вышеупомянутом извлечении, будет описан.

Обработка Ошибок Проверки допустимости

Ответ значения по умолчанию на ошибку проверки допустимости, как диктующийся стандартом SAX, ничего не должен сделать. Стандарт JAXP требует исключений SAX выдачи, таким образом, Вы используете точно те же самые механизмы обработки ошибок, как Вы используете для приложения SAX. В частности Вы используете метод setErrorHandler class DocumentBuilder, чтобы предоставить это объект, который реализует SAX интерфейс ErrorHandler.

Отметьте - у DocumentBuilder также есть метод setEntityResolver, который можно использовать.

Следующий код конфигурирует разработчика документа, чтобы использовать обработчик ошибок, определенный в, Обрабатывают Ошибки.

DocumentBuilder db = dbf.newDocumentBuilder();
OutputStreamWriter errorWriter = new OutputStreamWriter(System.err,
                                         outputEncoding);
db.setErrorHandler(new MyErrorHandler (new PrintWriter(errorWriter, true)));
Document doc = db.parse(new File(filename));

Код, который Вы видели до сих пор, устанавливал разработчика документа, и конфигурировал это, чтобы выполнить проверку допустимости по запросу. Обработка ошибок также на месте. Однако, DOMEcho ничего еще не делает. В следующем разделе Вы будете видеть, как вывести на экран структуру ДОМА и начать исследовать ее. Например, Вы будете видеть то, на что ссылки на сущность и разделы CDATA похожи в ДОМЕ. И возможно что наиболее важно, Вы будете видеть, как текстовые узлы (которые содержат фактические данные) находятся под узлами элемента в ДОМЕ.

Отображение ДОМА Ноудса

Чтобы создать или управлять ДОМОМ, это помогает иметь ясное представление о том, как узлы в ДОМЕ структурируются. Этот раздел учебного руководства представляет внутреннюю структуру ДОМА, так, чтобы можно было видеть то, что это содержит. Пример DOMEcho делает это, повторяя узлы ДОМА, и затем распечатывая их экранный, с соответствующим добавлением отступа, чтобы сделать иерархию узла очевидной. Спецификация этих типов узла может быть сочтена в ДОМЕ Левеле 2 Базовыми Спецификациями под спецификацией для Node.  Таблица 3-1 ниже адаптируется от той спецификации.

 Табличные 3-1 Типы Узла

Информация в этой таблице чрезвычайно полезна; Вы будете нуждаться в этом, работая с ДОМОМ, потому что все эти типы смешиваются в дереве ДОМА.

Получение информации о Типе Узла

Информация о типе элемента узла ДОМА получается, вызывая различные методы org.w3c.dom.Node class. Атрибуты узла представленным DOMEcho отражаются следующим кодом.

private void printlnCommon(Node n) {
    out.print(" nodeName=\"" + n.getNodeName() + "\"");

    String val = n.getNamespaceURI();
    if (val != null) {
        out.print(" uri=\"" + val + "\"");
    }

    val = n.getPrefix();

    if (val != null) {
        out.print(" pre=\"" + val + "\"");
    }

    val = n.getLocalName();
    if (val != null) {
        out.print(" local=\"" + val + "\"");
    }

    val = n.getNodeValue();
    if (val != null) {
        out.print(" nodeValue=");
        if (val.trim().equals("")) {
            // Whitespace
            out.print("[WS]");
        }
        else {
            out.print("\"" + n.getNodeValue() + "\"");
        }
    }
    out.println();
}

У каждого узла ДОМА есть, по крайней мере, тип, имя, и значение, которое могло бы или не могло бы быть пустым. В примере выше, интерфейс Node getNamespaceURI(), getPrefix(), getLocalName(), и методы getNodeValue() возвращают и печатают URI пространства имен отраженного узла, префикс пространства имен, локальное полностью определенное имя и значение. Отметьте, что метод trim() вызывают на значении, возвращенном getNodeValue(), чтобы установить, является ли значение узла пустым пробелом, и напечатайте сообщение соответственно.

Для полного списка методов Node и различной информации они возвращают, видят документацию API для Node.

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

private void outputIndentation() {
    for (int i = 0; i < indent; i++) {
        out.print(basicIndent);
    }
}

basicIndent, постоянный, чтобы определить основную единицу добавления отступа, используемого, когда DOMEcho выводит на экран иерархию дерева узла, определяется, добавляя следующие выделенные строки к конструктору DOMEcho class.

public class DOMEcho {
    static final String outputEncoding = "UTF-8";

    private PrintWriter out;
    private int indent = 0;
    private final String basicIndent = " ";

    DOMEcho(PrintWriter out) {
        this.out = out;
    }
}

Как имел место с обработчиком ошибок, определенным в, Обрабатывают Ошибки, программа DOMEcho создаст свой вывод как экземпляры PrintWriter.

Лексические Средства управления

Лексической информацией является информация, Вы должны восстановить исходный синтаксис XML-документа. Сохранение лексической информации важно в редактировании приложений, где Вы хотите сохранить документ, который является точным отражением исходно-полного комментариев, ссылок на сущность, и любых разделов CDATA, которые это, возможно, включало в начало.

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

Следующие методы DocumentBuilderFactory дают Вам контроль над лексической информацией, которую Вы видите в ДОМЕ.

setCoalescing()

Преобразовать узлы CDATA в узлы Text и добавить к смежному узлу Text (если любой).

setExpandEntityReferences()

Развернуть узлы ссылки на сущность.

setIgnoringComments()

Проигнорировать комментарии.

setIgnoringElementContentWhitespace()

Проигнорировать пробел, который не является значительной частью контента элемента.

Значения по умолчанию для всех этих свойств являются ложью, которая сохраняет всю лексическую информацию, необходимую, чтобы восстановить входящий документ в его исходной форме. Установка их к истине позволяет Вам создавать самого простого ДОМА так, чтобы приложение могло сосредоточиться на семантическом контенте данных, не имея необходимость волноваться о лексических деталях синтаксиса.  Таблица 3-2 суммирует эффекты настроек.

 Таблица 3-2 Лексические Настройки Управления

Реализацию этих методов в основном методе примера DomEcho показывают ниже.

// ...

dbf.setIgnoringComments(ignoreComments);
dbf.setIgnoringElementContentWhitespace(ignoreWhitespace);
dbf.setCoalescing(putCDATAIntoText);
dbf.setExpandEntityReferences(!createEntityRefs);

// ...

Логические переменные, которыми ignoreComments, ignoreWhitespace, putCDATAIntoText, и createEntityRefs объявляются в начале основного кода метода, и они устанавливаются параметрами командной строки, когда DomEcho выполняется.

public static void main(String[] args) throws Exception {
    // ...

    boolean ignoreWhitespace = false;
    boolean ignoreComments = false;
    boolean putCDATAIntoText = false;
    boolean createEntityRefs = false;

    for (int i = 0; i < args.length; i++) {
        if (...) {  // Validation arguments here
           // ... 
        } 
        else if (args[i].equals("-ws")) {
            ignoreWhitespace = true;
        } 
        else if (args[i].startsWith("-co")) {
            ignoreComments = true;
        }
        else if (args[i].startsWith("-cd")) {
            putCDATAIntoText = true;
        } 
        else if (args[i].startsWith("-e")) {
            createEntityRefs = true;

            // ...
        } 
        else {
            filename = args[i];

            // Must be last arg
            if (i != args.length - 1) {
                usage();
            }
        }
    }

    // ...
}

Печать Узлов ДОМА Три

Приложение DomEcho позволяет Вам видеть структуру ДОМА, и демонстрирует, какие узлы составляют ДОМА и как они располагаются. Обычно, огромное большинство узлов в дереве ДОМА будет узлы Text и Element.

Отметьте - текстовые узлы существуют под узлами элемента в ДОМЕ, и данные всегда хранятся в текстовых узлах. Возможно, наиболее распространенная ошибка в ДОМЕ, обрабатывающем, состоит в том, чтобы переместиться к узлу элемента и ожидать, что это будет содержать данные, которые хранятся в том элементе. Не так! Даже у самого простого узла элемента есть текстовый узел под этим, которое содержит данные.

Код, чтобы распечатать узлы дерева ДОМА с соответствующим добавлением отступа показывают ниже.

private void echo(Node n) {
    outputIndentation();
    int type = n.getNodeType();

    switch (type) {
        case Node.ATTRIBUTE_NODE:
            out.print("ATTR:");
            printlnCommon(n);
            break;

        case Node.CDATA_SECTION_NODE:
            out.print("CDATA:");
            printlnCommon(n);
            break;

        case Node.COMMENT_NODE:
            out.print("COMM:");
            printlnCommon(n);
            break;

        case Node.DOCUMENT_FRAGMENT_NODE:
            out.print("DOC_FRAG:");
            printlnCommon(n);
            break;

        case Node.DOCUMENT_NODE:
            out.print("DOC:");
            printlnCommon(n);
            break;

        case Node.DOCUMENT_TYPE_NODE:
            out.print("DOC_TYPE:");
            printlnCommon(n);
            NamedNodeMap nodeMap = ((DocumentType)n).getEntities();
            indent += 2;
            for (int i = 0; i < nodeMap.getLength(); i++) {
                Entity entity = (Entity)nodeMap.item(i);
                echo(entity);
            }
            indent -= 2;
            break;

        case Node.ELEMENT_NODE:
            out.print("ELEM:");
            printlnCommon(n);

            NamedNodeMap atts = n.getAttributes();
            indent += 2;
            for (int i = 0; i < atts.getLength(); i++) {
                Node att = atts.item(i);
                echo(att);
            }
            indent -= 2;
            break;

        case Node.ENTITY_NODE:
            out.print("ENT:");
            printlnCommon(n);
            break;

        case Node.ENTITY_REFERENCE_NODE:
            out.print("ENT_REF:");
            printlnCommon(n);
            break;

        case Node.NOTATION_NODE:
            out.print("NOTATION:");
            printlnCommon(n);
            break;

        case Node.PROCESSING_INSTRUCTION_NODE:
            out.print("PROC_INST:");
            printlnCommon(n);
            break;

        case Node.TEXT_NODE:
            out.print("TEXT:");
            printlnCommon(n);
            break;

        default:
            out.print("UNSUPPORTED NODE: " + type);
            printlnCommon(n);
            break;
    }

    indent++;
    for (Node child = n.getFirstChild(); child != null;
         child = child.getNextSibling()) {
        echo(child);
    }
    indent--;
}

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

Атрибуты узла не включаются как дочерние элементы в иерархии ДОМА. Они вместо этого получаются через метод getAttributes интерфейса Node.

Интерфейс DocType является расширением w3c.org.dom.Node. Это определяет метод getEntities, который Вы используете, чтобы получить узлы Entity - узлы, которые определяют объекты. Как узлы Attribute, узлы Entity не появляются как дочерние элементы узлов ДОМА.

Операции узла

Этот раздел бросает беглый взгляд на некоторые из операций, Вы могли бы хотеть примениться к ДОМУ.

• Создание узлов

• Пересечение узлов

• Поиск узлов

• Получение контента узла

• Создание атрибутов

• Удаление и изменение узлов

• Вставка узлов

Создание Узлов

Можно создать узлы различных типов, используя методы интерфейса Document. Например, createElement, createComment, createCDATAsection, createTextNode, и так далее. Полный список методов для того, чтобы создать различные узлы обеспечивается в документации API для org.w3c.dom.Document.

Пересечение Узлов

Интерфейс org.w3c.dom.Node определяет много методов, которые можно использовать, чтобы пересечь узлы, включая getFirstChild, getLastChild, getNextSibling, getPreviousSibling, и getParentNode. Те операции достаточны, чтобы добраться отовсюду в дереве к любому другому расположению в дереве.

Поиск Узлов

Когда Вы ищете узел с определенным именем, есть немного больше, чтобы принять во внимание. Хотя заманчиво получить первый дочерний элемент и осмотреть это, чтобы видеть, является ли это правильным, поиск должен учесть факт, что первый дочерний элемент в подсписке мог быть комментарием или инструкцией обработки. Если данные XML не были проверены, это мог бы даже быть текстовый узел, содержащий игнорируемый пробел.

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

/**
 * Find the named subnode in a node's sublist.
 * <ul>
 * <li>Ignores comments and processing instructions.
 * <li>Ignores TEXT nodes (likely to exist and contain
 *         ignorable whitespace, if not validating.
 * <li>Ignores CDATA nodes and EntityRef nodes.
 * <li>Examines element nodes to find one with
 *        the specified name.
 * </ul>
 * @param name  the tag name for the element to find
 * @param node  the element node to start searching from
 * @return the Node found
 */
public Node findSubNode(String name, Node node) {
    if (node.getNodeType() != Node.ELEMENT_NODE) {
        System.err.println("Error: Search node not of element type");
        System.exit(22);
    }

    if (! node.hasChildNodes()) return null;

    NodeList list = node.getChildNodes();
    for (int i=0; i < list.getLength(); i++) {
        Node subnode = list.item(i);
        if (subnode.getNodeType() == Node.ELEMENT_NODE) {
           if (subnode.getNodeName().equals(name)) 
               return subnode;
        }
    }
    return null;
}

Для более глубокого объяснения этого кода см. Увеличение Сложности в том, Когда Использовать ДОМА. Отметьте, также, что можно использовать API, описанные в Лексических Средствах управления, чтобы изменить вид ДОМА конструкции синтаксического анализатора. Хорошая вещь об этом коде, тем не менее, состоит в том, что он будет работать на почти любого ДОМА.

Получение Контента Узла

Когда Вы хотите получить текст, который содержит узел, Вы снова должны просмотреть список дочерних узлов, игнорируя записи, которые не представляют интереса и накопления текста, который Вы находите в узлах TEXT, узлах CDATA, и узлах EntityRef. Вот пример вида подпрограммы, которую можно использовать для того процесса.

/**
  * Return the text that a node contains. This routine:
  * <ul>
  * <li>Ignores comments and processing instructions.
  * <li>Concatenates TEXT nodes, CDATA nodes, and the results of
  *     recursively processing EntityRef nodes.
  * <li>Ignores any element nodes in the sublist.
  *     (Other possible options are to recurse into element 
  *      sublists or throw an exception.)
  * </ul>
  * @param    node  a  DOM node
  * @return   a String representing its contents
  */
public String getText(Node node) {
    StringBuffer result = new StringBuffer();
    if (! node.hasChildNodes()) return "";

    NodeList list = node.getChildNodes();
    for (int i=0; i < list.getLength(); i++) {
        Node subnode = list.item(i);
        if (subnode.getNodeType() == Node.TEXT_NODE) {
            result.append(subnode.getNodeValue());
        }
        else if (subnode.getNodeType() == Node.CDATA_SECTION_NODE) {
            result.append(subnode.getNodeValue());
        }
        else if (subnode.getNodeType() == Node.ENTITY_REFERENCE_NODE) {
            // Recurse into the subtree for text
            // (and ignore comments)
            result.append(getText(subnode));
        }
    }

    return result.toString();
}

Для более глубокого объяснения этого кода см. Увеличение Сложности в том, Когда Использовать ДОМА. Снова, можно упростить этот код при использовании API, описанных в Лексических Средствах управления, чтобы изменить вид ДОМА конструкции синтаксического анализатора. Но хорошая вещь об этом коде состоит в том, что он будет работать на почти любого ДОМА.

Создание Атрибутов

Интерфейс org.w3c.dom.Element, который расширяет Узел, определяет работу setAttribute, которая добавляет атрибут к тому узлу. (Лучшим именем с точки зрения платформы Java был бы addAttribute. Атрибут не является свойством class, и новый объект создается.) Можно также использовать работу createAttribute Document, чтобы создать экземпляр Attribute и затем использовать метод setAttributeNode, чтобы добавить это.

Удаление и Изменение Узлов

Чтобы удалить узел, Вы используете метод removeChild его родительского Узла. Чтобы изменить это, можно использовать или работу replaceChild родительского узла или работу setNodeValue узла.

Вставка Узлов

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

Выполнение Выборки DOMEcho

Чтобы выполнить выборку DOMEcho, следуйте за шагами ниже.

1. Переместитесь к каталогу samples.% cd install-dir/jaxp-1_4_2-release-date/samples.
2. Скомпилируйте пример class.% javac dom/*
3. Выполните программу DOMEcho на XML-файле.

   Выберите один из XML-файлов в каталоге data и выполните программу DOMEcho на этом. Здесь, мы хотели выполнять программу на файле personal-schema.xml.

   % java dom/DOMEcho data/personal-schema.xml

   XML-файл personal-schema.xml содержит файлы персонала для небольшой компании. Когда Вы выполняете программу DOMEcho на этом, следует видеть следующий вывод.

   DOC: nodeName="#document"
    ELEM: nodeName="personnel" 
          local="personnel"
    TEXT: nodeName="#text" 
          nodeValue=[WS]
    ELEM: nodeName="person" 
          local="person"
    ATTR: nodeName="id" 
          local="id" 
          nodeValue="Big.Boss"
    TEXT: nodeName="#text" 
          nodeValue=[WS]
    ELEM: nodeName="name" 
          local="name"
    ELEM: nodeName="family" 
          local="family"
    TEXT: nodeName="#text" 
          nodeValue="Boss"
    TEXT: nodeName="#text" 
          nodeValue=[WS]
    ELEM: nodeName="given" 
          local="given"
    TEXT: nodeName="#text" 
          nodeValue="Big"
    TEXT: nodeName="#text" 
          nodeValue=[WS]
    ELEM: nodeName="email" 
          local="email"
    TEXT: nodeName="#text" 
          nodeValue="chief@foo.example.com"
    TEXT: nodeName="#text" 
          nodeValue=[WS]
    ELEM: nodeName="link" 
          local="link"
    ATTR: nodeName="subordinates" 
          local="subordinates" 
          nodeValue="one.worker two.worker 
                     three.worker four.worker
                     five.worker"
    TEXT: nodeName="#text" 
          nodeValue=[WS]
    TEXT: nodeName="#text" 
          nodeValue=[WS]
    ELEM: nodeName="person" 
          local="person"
    ATTR: nodeName="id" 
          local="id" 
          nodeValue="one.worker"
    TEXT: nodeName="#text" 
          nodeValue=[WS]
    ELEM: nodeName="name" 
          local="name"
    ELEM: nodeName="family" 
          local="family"
    TEXT: nodeName="#text" 
          nodeValue="Worker"
    TEXT: nodeName="#text" 
          nodeValue=[WS]
    ELEM: nodeName="given" 
          local="given"
    TEXT: nodeName="#text" 
          nodeValue="One"
    TEXT: nodeName="#text" 
          nodeValue=[WS]
    ELEM: nodeName="email" 
          local="email"
    TEXT: nodeName="#text" 
          nodeValue="one@foo.example.com"
    TEXT: nodeName="#text" 
          nodeValue=[WS]
    ELEM: nodeName="link" 
          local="link"
    ATTR: nodeName="manager" 
          local="manager" 
          nodeValue="Big.Boss"
    TEXT: nodeName="#text"
          nodeValue=[WS]
   
   [...]
   
   

   Как можно видеть, DOMEcho распечатывает все узлы для различных элементов в документе с корректным добавлением отступа, чтобы показать иерархию узла.