读后笔记 -- Java核心技术（第11版卷 II） Chapter3 XML

3.1 XML Introduction

An XML document is made up of elements.

An element can have attributes (key/value pairs) and child nodes.
Child nodes can be elements or text.

XML is widely used for structured documents, configration files, communication protocols, data interchange, and so on.

3.3 Parsing an XML Doucment

1. Three parser methods:

1.1 DOM (Document Object Model) -- produces a tree structure
1.2 SAX (Smiple API for XML) -- notify you whenever it encounters another feature (such as the start or end of an element)
1.3 "pull parser" (StAX) -- where you program a loop that gets each feature

2. If not a huge data set, it's simplest to use the DOM. Here is how:

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

DocumentBuilder builder = factory.newDocumentBuilder();

// usage 1): parse a file

File f = ...;

Document doc = builder.parse(f);

// usage 2): parse a URL

URL u = ...;

Document doc = builder.parse(u);

// usage 3): parse an inputStream

InputStream in = ...

Doucment doc = builder.parse(in);

3. Analyzing the DOM

3.1 To analyze the DOM tree, start with the root element:

Element elem = doc.getDocumentElement();

3.2 When you have any element, you care about three pieces of information:

1) Tag name
2) Attributes
3) Children

3.2.1 Get the tag name by calling: elem.getTagName()

3.2.2 This Code walks throught all attributes:

NamedNodeMap attributes = element.getAttributes();

for (int i = 0; i < attributes.getLength(); i++) {

    Node attribute = attributes.item(i);

    String name = attribute.getNodeName();

    String value = attribute.getNodeValue();

    ...

}

3.2.3 For Children:

NodeList children = root.getChildNodes();

for (int i = 0; i < children.getLength(); i++) {

    Node child = children.item(i);

    ...

}

4. Node Types

4.1 Most applications need to process Element and Text nodes, unless your XML document has a DTD or schema, the DOM includes all whitespace as Text nodes:

4.2 Can filter text out like this:

Node chld = children.item(i);

if (child instanceof Element) {

    Element childElement = (Element) child;

    ...

}

4.3 To get the text child from an element (such as <font> element above), call:

Text textNode = (Text) element.getFirstChild();

String text = textNode.getData();

3.4 Validation

1. Many XML documents have speicifc rules about vaild elements and attributes.

2. Java API supports two mechanism for describing these rules:

Document type definitions (DTD)
XML Schema

3. When a parser validates a document, it checks that the document conforms to the rules.

4. To turn on DTD validation, call

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

factory.setValidating(true);

factory.setIgnoringElementContentWhitespace(true);

then, xml using with DTD

<?xml version="1.0"?>

<!DOCTYPE config SYSTEM "config.dtd">

<config>

    <entry id="background">

        <construct class="java.awt.Color">

            <int>55</int>

            <int>200</int>

            <int>100</int>

        </construct>

    </entry>

    <entry id="currency">

        <factory class="java.util.Currency">

            <string>USD</string>

        </factory>

    </entry>

</config>

5. For XML Schema, use following code. Unfortunately, the parser doesn't discard whitespace.

factory.setNamespaceAware(true);

final String JAXP_SCHEMA_LANGUAGE = "http://java.sun.com/xml/jaxp/properties/schemaLanguage";

final String W3C_XML_SCHEMA = "http://www.w3.org/2001/XMLSchema";

factory.setAttribute(JAXP_SCHEMA_LANGUAGE, W3C_XML_SCHEMA);

xml using with XML Schema

<?xml version="1.0"?>

<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xsi:noNamespaceSchemaLocation="config.xsd">

    <entry id="background">

        <construct class="java.awt.Color">

            <int>55</int>

            <int>200</int>

            <int>100</int>

        </construct>

    </entry>

    <entry id="currency">

        <factory class="java.util.Currency">

            <string>USD</string>

        </factory>

    </entry>

</config>

3.5 XPath

1. It can be tedious to analyze the DOM tree by visiting descends. => XPath is a standard way of locating node sets. For example, /html/body/table describes all tables in an XHTML document.

2. To use XPath, you need a factory, then call the evaluate method to get a string result:

// to create a factory

XPathFactory xpFactory = XPathFactory.newInstance();

path = xpFactory.newXPath();

// call evaluate

String title = path.evaluate("/html/head/title", doc);

3. To get a result as a node list, node, or number, call

// node list

NodeList nodes = (NodeList) path.evaluate("/html/body/table", doc, XPathConstants.NODESET);

// node

Node node = (Node) path.evaluate("/html/body/table", doc, XPathConstants.NODE);

// number

int count = ((Number) path.evaluate("count("html/body/table")", doc, XPathConstants.NUMBER)).intValue();

4. You don't have to start a search at the top of the document:

result = path.evaluate(expression, node);

3.6 Namespaces

1. With namespaces, XMLdocuments can use elements from two grammers. This follwing document contains XHTML and SVG:

// Note the xmlns:prefix in the root node

<html xmls="http://www.w3.org/1999/xhtml"

    xmlns:svg="http://www.w3.org/2000/svg">

// document as below: An unprefixed element (body) is XML, and the SVG elements have an svg prefix

<body>

    <svg:svg width="100" height="100">

        <svg:circle cx="50" cy="50" r="40" stroke="green" stroke-width="4"/>

    </svg:svg>

</body>

2. To turn on namespace processing in Java, call

factory.setNameSpaceAware(true);

3. Now, getNodeName yields the qualified name such as svg:circle in our example.

4. There are methods to get the namesapce URI and the unprefixed tag name:

Node.getNamespaceURI()   // Gets the name space URI, http://www.w3.org/2000/svg

Node.getLocalName()    // Gets the unprefixed name, such as circle

3.7 Streaming parser

3.7.1 SAX Parser

1. Streaming parsers are useful for parsing huge documents.

2. Instead of building a tree structure (DOM, section 3.3, -2), the SAX parser reports events. You supply a handler with methods:

startElement and endElement
characters
startDocument and endDocument

3. In the callback methods, you get the element name and attributes, or the text content.

4. Start the parsing process like this:

SAXParserFactory factory = SAXParserFactory.newInstance();

SAXParser saxParser = factory.newSAXParser();

saxParser.parse(source, handler);

3.7.2 StAX Parser

1. The StAX parser is a "pull parser". Instead of installing an event handler, you iterate through the events:

InputStream in = ...;

XMLInputFactory factory = XMLInputFactory.newInstance();

XMLStreamReader parser = factory.createXMLStreamReader(in);

while (parser.hasNext()) {

    int eventType = parser.Next();

    ...

}

2. Then branch on the event type (START_ELEMENT, END_ELEMENT, CHARACTERS, START_DOCUMENT, END_DOCUMENT, and so on).

3.1 Element -- Analyze an element like this:

String name = parser.getName();    // the local name; call getQName if you need namespace data

int attrCount = parser.getAttributeCount();

for (int i = 0; i < attrCount; i++) {

    Process parser.getAttributeLocalName(i) and parser.getAttributeValue(i)

}

　You can also look up an attribute by name:

String value = parser.getAttributeValue(null, attributeName);

3.2 CHARACTERS, call parser.getText() returns the text

3.8 Building XML Document

1. Building a DOM tree in 1.1 -1.3

1.1 Don't write XML with print statements, you can build a DOM tree with follwing codes:

Document doc = builder.newDoucment();

Element rootElement = doc.createElement(rootName);

Element childElement = doc.createElement(childName);

Text textNode = doc.createTextNode(textContents);

1.2 Set attributes like this:

rootElement.setAttribute(name, value);

1.3 Attach the chldren to the parents:

doc.appendChild(rootElement);

rootElement.appendChild(childElement);

childElement.appendChild(textNode);

Then writing Documents 1.4-1.6

1.4 There is no easy way to write a DOM tree. The easiest approach is with LSSerializer interface. You get an instance with this magic incantation:

DOMImplementation impl = doc.getImplementation();

DOMImplementationLS implLS = (DOMImplementationLS) impl.getFeature("LS", "3.0");

LSSerializer ser = implLS.createLSSerializer();

1.5 If you want sapces and line breaks, set this flag:

ser.getDomConfig().setParameter("format-pretty-print", true);

1.6 You can also save the document to a file:

LSOutput out = implLS.createLSOutput();

out.setEncoding("UTF-8");

out.setByteStream(Files.newOutputStream(path));

ser.write(doc, out);

Or you can turn the document into a string:

String str = ser.writeToString(doc);

2. (Easier) Writing an XML Document with StAX

2.1 Wasteful to build a DOM tree just to write a document. The StAX API lets you write an XML document directly.

2.2 Construct an XMLStreamWriter from an OutputStream instance:

XMLOutputFactory factory = XMLOutputFactory.newInstance();

XMLStreamWriter writer = factory.createXMLStreamWriter(out);

2.3 To produce the XML header, call:

writer.writeStartDocument();

2.4 Then start the first element:

writer.writeStartElement(name);

2.5 Add attributes by calling:

writer.writeAttribute(name, value);

2.6 Now you can add child elements by calling writeStartElement again, or write characters with:

writer.writeCharacters(text);

2.7 Call writeEndElement to end an element and writeEndDocument at the end of the document.

2.8 You can write a self-closing tag (such as <img .../>) with the writeEmptyElement method.

2.9 When you are all done, close the XMLStreamWriter -- it isn't auto-closable.