读后笔记 -- 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.