Chapter 24 XML. CHAPTER GOALS Understanding XML elements and attributes Understanding the concept of...

Chapter 24

XML

CHAPTER GOALS

• Understanding XML elements and attributes

• Understanding the concept of an XML parser

• Being able to read and write XML documents

• Being able to design Document Type Definitions for XML documents

XML

• Stands for Extensible Markup Language

• Lets you encode complex data in a form that the recipient can parse easily

• Is independent from any programming language

XML Encoding of Coin Data

<coin> <value>0.5</value> <name>half dollar</name>

</coin>

Advantages of XML

• XML files are readable by both computers and humans

• XML formatted data is resilient to change

o It is easy to add new data elements

o Old programs can process the old information in the new data format

Differences Between XML and HTML

• Both are descendants of SGML (Standard Generalized Markup Language)

• XML is a simplified version of SGML

• XML is very strict but HTML (as used today) is not

• XML tells what the data means; HTML tells how to display data

Differences Between XML and HTML

• XML tags are case-sensitive o <LI> is different from <li>

• Every XML start tag must have a matching end tag

• If a tag has no end-tag, it must end in /> o <img src="hamster.jpeg"/>

• XML attribute values must be enclosed in quotes o <img src="hamster.jpeg" width="400" height="300"/>

Structure of an XML Document • An XML data set is called a document

• The document starts with a header

<?xml version 1.0?>

• The data are contained in a root element <?xml version 1.0?> <purse>

more data </purse>

• The document contains elements and text

Structure of an XML Document • An XML element has one of two forms

<elementTag optional attributes> contents </elementTag> or <elementTag optional attributes/>

• The contents can be elements or text or both

• An example of an element with both elements and text (mixed content):

<p>Use XML for <strong>robust</strong> data formats.</p>

• Avoid mixed content for data descriptions

Structure of an XML Document • An element can have attributes

• The a element in HTML has an href attribute

<a href="http://java.sun.com"> ... </a>

• An attribute has a name (such as href) and a value

• The attribute value is enclosed in either single or double quotes

• Attribute is intended to provide information about the content

<value currency="USD">0.5</value> or

<value currency="EUR">0.5</value>

• An element can have multiple attributes

Parsing XML Documents

• A parser is a program that o Reads a document o Checks whether it is syntactically cornet o Takes some action as it processes the document

• There are two kinds of XML parsers o SAX (Simple Access to XML) o DOM ( Document Object Model)

Parsing XML Documents • SAX parser

o Event-driven o It calls a method you provide to process each construct it encounters o More efficient for handling large XML documents

• DOM parser o Builds a tree that represents the document o When the parser is done, you can analyze the tree o Easier to use for most applications

JAXP • Stands for Java API for XML Processing

• Provides a standard mechanism for DOM parsers to read and create documents

• Part of Java1.4 and above

• Earlier versions need to download additional libraries

Parsing XML Documents • Document interface describes the tree structure of an XML document

• A DocumentBuilder can generate an object of a class that implements Document interface

• Get a DocumentBuilder by calling the static newInstance method of the DocumentBuilderFactory class

• Call newDocumentBuilder method of the factory to get a DocumentBuilder DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); DocumentBuilder builder = factory.newDocumentBuilder();

Parsing XML Documents • To read a document from a file String fileName = . . . ; File f = new File(filename);

Document doc = builder.parse(f);

• To read a document from a URL on the Internet String urlName = . . . ; URL u = new URL(urlName); Document doc = builder.parse(u);

• To read from an input stream InputStream in = . . . ; Document doc = builder.parse(in);


• You can inspect or modify the document

• The document tree consists of nodes

• Two node type are Element and Text

• Element and Text are subinterfaces of the Node interface

An XML Document <?xml version="1.0"?><items> <item> <product> <description>Ink Jet Refill Kit</description> <price>29.95</price> </product> <quantity>8</quantity> </item> <item> <product> <description>4-port Mini Hub</description> <price>19.95</price> </product> <quantity>4</quantity> </item></items>

Tree View of XML Document

Parsing XML Documents • Start inspection of the tree by getting the root element Element root = doc.getDocumentElement();

• To get the child elements of an element o Use the GetChildNodes method of the Element interface o The nodes are stored in an object of a class that implements the NodeList interface

• Use a NodeList to visit the child nodes of an element o getLength method gives the number of elements o item method gets an item in the node list

• Code to get a child node NodeList nodes = root.getChildNodes(); int i = . . . ; //a value between o and getlength() - 1 Node child = nodes.item(i);

• The XML parser keeps all white spaces if you don't use a DTD o You can include a test to ignore the white space


• Get an element name with the getTagName Element priceElement = . . . ;

String name = priceElement.getTagName();

• To find the value of the currency attribute String attributeValue = priceElement.getAttribute("currency")

• You can also iterate through all attributes o Use a NamedNodeMap o Each attribute is stored in a Node

Parsing XML Documents • Some elements have children that contain text

• Document builder creates nodes of type Text

• If you don't use mixed content elements o Any element containing text has a single Text child node o Use getFirstChild method to get it o Use getData method to read the text

• To determine the price stored in the price element Element priceNode = . . . ; Text priceData = (Text)priceNode.getFirstChild(); String priceString = priceNode.getData(); double price = Double.parseDouble(priceString);

File ItemListParser.java 001: import java.io.File;

002: import java.io.IOException;

003: import java.util.ArrayList;

004: import javax.xml.parsers.DocumentBuilder;

005: import javax.xml.parsers.DocumentBuilderFactory;

006: import javax.xml.parsers.ParserConfigurationException;

007: import org.w3c.dom.Attr;

008: import org.w3c.dom.Document;

009: import org.w3c.dom.Element;

010: import org.w3c.dom.NamedNodeMap;

011: import org.w3c.dom.Node;

012: import org.w3c.dom.NodeList;

013: import org.w3c.dom.Text;

014: import org.xml.sax.SAXException;

015:

016: /**

017: An XML parser for item lists

018: */

019: public class ItemListParser

020: {

021: /**

022: Constructs a parser that can parse item lists

023: */

024: public ItemListParser()

025: throws ParserConfigurationException

026: {

027: DocumentBuilderFactory factory

028: = DocumentBuilderFactory.newInstance();

029: builder = factory.newDocumentBuilder();

030: }

031:

032: /**

033: Parses an XML file containing an item list

034: @param fileName the name of the file

035: @return an array list containing all items in the XML file

036: */

037: public ArrayList parse(String fileName)

038: throws SAXException, IOException

039: {

040: File f = new File(fileName);

041: Document doc = builder.parse(f);

042:

043: // get the <items> root element

044:

045: Element root = doc.getDocumentElement();

046: return getItems(root);

047: }

048:

049: /**

050: Obtains an array list of items from a DOM element

051: @param e an <items> element

052: @return an array list of all <item> children of e

053: */

054: private static ArrayList getItems(Element e)

055: {

056: ArrayList items = new ArrayList();

057:

058: // get the <item> children

059:

060: NodeList children = e.getChildNodes();

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

062: {

063: Node childNode = children.item(i);

064: if (childNode instanceof Element)

065: {

066: Element childElement = (Element)childNode;

067: if (childElement.getTagName().equals("item"))

068: {

069: Item c = getItem(childElement);

070: items.add(c);

071: }

072: }

073: }

074: return items;

075: }

076:

077: /**

078: Obtains an item from a DOM element

079: @param e an <item> element

080: @return the item described by the given element

081: */

082: private static Item getItem(Element e)

083: {


085: Product p = null;

086: int quantity = 0;

087: for (int j = 0; j < children.getLength(); j++)

088: {

089: Node childNode = children.item(j);


091: {


093: String tagName = childElement.getTagName();

094: if (tagName.equals("product"))

095: p = getProduct(childElement);

096: else if (tagName.equals("quantity"))

097: {

098: Text textNode = (Text)childElement.getFirstChild();

099: String data = textNode.getData();

100: quantity = Integer.parseInt(data);

101: }

102: }

103: }

104: return new Item(p, quantity);

105: }

106:

107: /**

108: Obtains a product from a DOM element

109: @param e a <product> element

110: @return the product described by the given element

111: */

112: private static Product getProduct(Element e)

113: {


115: String name = "";

116: double price = 0;

117: for (int j = 0; j < children.getLength(); j++)

118: {

119: Node childNode = children.item(j);


121: {


123: String tagName = childElement.getTagName();

124: Text textNode = (Text)childElement.getFirstChild();

125:

126: String data = textNode.getData();

127: if (tagName.equals("description"))

128: name = data;

129: else if (tagName.equals("price"))

130: price = Double.parseDouble(data);

131: }

132: }

133: return new Product(name, price);

134: }

135:

136: private DocumentBuilder builder;

137: }

File ItemListParserTest.java01: import java.util.ArrayList;

02:

03: /**

04: This program parses an XML file containing an item list.

05: It prints out the items that are described in the XML file.

06: */

07: public class ItemListParserTest

08: {

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

10: {

11: ItemListParser parser = new ItemListParser();

12: ArrayList items = parser.parse("items.xml");

13: for (int i = 0; i < items.size(); i++)

14: {

15: Item anItem = (Item)items.get(i);

16: System.out.println(anItem.format());

17: }

18: }

19: }

Creating XML Documents • We can build a Document object in a Java program

and then save it as an XML document

• We need a DocumentBuilder object to create a new, empty document DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); DocumentBuilder builder = factory.newDocumentBuilder(); Document doc = builder.newDocument(); //empty document

• The Document class has methods to create elements and text nodes

Creating XML Documents • To create an element use createElement method and

pass it a tag

Element itemElement = doc.createElement("item");

• To create a text node, use createTextNode and pass it a string

Text quantityText= doc.createTextNode("8");

• Use setAttribute method to add an attribute to the tag priceElement.setAttribute("currency", "USD");

Creating XML Documents • To construct the tree structure of a document

o start with the root

o add children with appendChild

• To build an XML tree that describes an item

// create elementsElement itemElement = doc.createElement("item");Element productElement = doc.createElement("product");Element descriptionElement = doc.createElement("description");Element priceElement = doc.createElement("price");Element quantityElement = doc.createElement("quantity");Text descriptionText = doc.createTextNode("Ink Jet Refill Kit");Text priceText = doct.createTextNode("29.95");Text quantityText = doc.createTextNode("8");

// add elements to the documentdoc.appendChild(itemElement);itemElement.appendChild(productElement);itemElement.appendChild(quantityElement);productElement.appendChild(descriptionElement);productElement.appendChild(priceElement);descriptionElement.appendChild(descriptionText);priceElement.appendChild(priceText);quantityElement.appendChild(quantityText);

Creating XML Documents • Use a Transformer to write an XML document to a stream

• Create a transformer Transformer t =

TransformerFactory.newInstance().newTransformer();

• Create a DOMSource from your document

• Create a StreamResult from your output stream

• Call the transform method of your transformer t.transform(new DOMSource(doc),

new StreamResult(System.out));

File ItemListBuilder.java 001: import java.util.ArrayList;







008:

009: /**

010: Builds a DOM document for an array list of items.

011: */

012: public class ItemListBuilder

013: {

014: /**

015: Constructs an item list builder.

016: */

017: public ItemListBuilder()


019: {




023: }

024:

025: /**

026: Builds a DOM document for an array list of items.

027: @param items the items

028: @return a DOM document describing the items

029: */

030: public Document build(ArrayList items)

031: {

032: doc = builder.newDocument();

033: Element root = createItemList(items);

034: doc.appendChild(root);

035: return doc;

036: }

037:

038: /**

039: Builds a DOM element for an array list of items.

040: @param items the items

041: @return a DOM element describing the items

042: */

043: private Element createItemList(ArrayList items)

044: {

045: Element itemsElement = doc.createElement("items");


047: {


049: Element itemElement = createItem(anItem);

050: itemsElement.appendChild(itemElement);

051: }

052: return itemsElement;

053: }

054:

055: /**

056: Builds a DOM element for an item.

057: @param anItem the item

058: @return a DOM element describing the item

059: */

060: private Element createItem(Item anItem)

061: {

062: Element itemElement = doc.createElement("item");

063: Element productElement

064: = createProduct(anItem.getProduct());

065: Text quantityText = doc.createTextNode(

066: "" + anItem.getQuantity());

067: Element quantityElement = doc.createElement("quantity");

068: quantityElement.appendChild(quantityText);

069:

070: itemElement.appendChild(productElement);

071: itemElement.appendChild(quantityElement);

072: return itemElement;

073: }

074:

075: /**

076: Builds a DOM element for a product.

077: @param p the product

078: @return a DOM element describing the product

079: */

080: private Element createProduct(Product p)

081: {

082: Text descriptionText

083: = doc.createTextNode(p.getDescription());

084: Text priceText = doc.createTextNode("" + p.getPrice());

085:

086: Element descriptionElement

087: = doc.createElement("description");

088: Element priceElement = doc.createElement("price");

089:

090: descriptionElement.appendChild(descriptionText);

091: priceElement.appendChild(priceText);

092:

093: Element productElement = doc.createElement("product");

094:

095: productElement.appendChild(descriptionElement);

096: productElement.appendChild(priceElement);

097:

098: return productElement;

099: }

100:


102: private Document doc;

103: }

File ItemListBuilderTest.java01: import java.util.ArrayList;


03: import javax.xml.transform.Transformer;

04: import javax.xml.transform.TransformerFactory;

05: import javax.xml.transform.dom.DOMSource;

06: import javax.xml.transform.stream.StreamResult;

07:

08: /**

09: This program tests the item list builder. It prints the

10: XML file corresponding to a DOM document containing a list

11: of items.

12: */

13: public class ItemListBuilderTest

14: {


16: {


18: items.add(new Item(new Product("Toaster", 29.95), 3));

19: items.add(new Item(new Product("Hair dryer", 24.95), 1));

20:

21: ItemListBuilder builder = new ItemListBuilder();

22: Document doc = builder.build(items);

23: Transformer t = TransformerFactory

24: .newInstance().newTransformer();

25: t.transform(new DOMSource(doc),

26: new StreamResult(System.out));

27: }

28: }

Document Type Definitions • A DTD is a set of rules for correctly formed documents of a particular type

o Describes the legal attributes for each element type

o Describes the legal child elements for each element type

• Legal child elements are described with an ELEMENT rule

<!ELEMENT items (item*)>

• The items element (the root in this case) can have 0 or more item elements

• Definition of an item node

<!ELEMENT item (product, quantity)>

• Children of the item node must be a product node followed by a quantity

node

Document Type Definitions • Definition of product node

<! ELEMENT product (description, price)>

• The other nodes

<!ELEMENT quantity (#PCDATA)><!ELEMENT description (#PCDATA)><!ELEMENT price (#PCDATA)>

• #PCDATA stands for parsable character data which is just text

o Can contain any characters

o Special characters have to be encoded when they occur in character data

Encodings for Special Characters

DTD for Item List

<!ELEMENT items (item)*>

<!ELEMENT item (product, quantity)>

<!ELEMENT product (description, price)>

<!ELEMENT quantity (#PCDATA)>

<!ELEMENT description (#PCDATA)>

<!ELEMENT price (#PCDATA)>

Regular Expressions for Element Content

Document Type Definitions

• A DTD gives you control over the allowed attributes of an element <!ATTLIST Element Attribute Type Default>

• Type can be any sequence of character data specified as CDATA

• Type can also specify a finite number of choices <!ATTLIST price currency (USD | EUR | JPY ) #REQUIRED >

Common Attribute Types

Attribute Defaults

Document Type Definitions

• #IMPLIED keyword means you can supply an attribute or not.

<!ATTLIST price currency CDATA #IMPLIED >

• If you omit the attribute, the application processing the XML data implicitly assumes some default value

• You can specify a default to be used if the attribute is not specified

<!ATTLIST price currency CDATA "USD" >

Parsing with Document Type Definitions

• Specify a DTD with every XML document

• Instruct the parser to check that the document follows the rules of the DTD

• Then the parser can be more intelligent about parsing

• If the parser knows that the children of an element are elements, it can suppress white spaces


• An XML document can reference a DTD in one of two ways

• The document may contain the DTD

• The document may refer to a DTD stored elsewhere

• A DTD is introduced with a DOCTYPE declaration


• If the document contains the DTD, the declaration looks like this: <!DOCTYPE rootElement [ rules ]>

• Example <?xml version="1.0"?><!DOCTYPE items [<!ELEMENT items (item*)><!ELEMENT item (product, quantity)><!ELEMENT product (description, price)><!ELEMENT quantity (#PCDATA)><!ELEMENT description (#PCDATA)><!ELEMENT price (#PCDATA)>]>

<items> <item> <product> <description>Ink Jet Refill Kit</description> <price>29.95</price> </product> <quantity>8</quantity> </item> <item> <product> <description>4-port Mini Hub</description> <price>19.95</price> </product> <quantity>4</quantity> </item></items>


• If the DTD is stored outside the document, use the SYSTEM keyword inside the DOCTYPE declaration

• This indicates that the system must locate the DTD

• The location of the DTD follows the SYSTEM keyword

• A DOCTYPE declaration can point to a local file <!DOCTYPE items SYSTEM "items.dtd" >

• A DOCTYPE declaration can point to a URL <!DOCTYPE items SYSTEM "http://www.mycompany.com/dtds/items.dtd">


• When your XML document has a DTD, use validation when parsing

• Then the parser will check that all child elements and attributes conformto the ELEMENT and ATTRIBUTE rules in the DTD

• The parser throws an exception if the document is invalid

• Use the setValidating method of the DocumentBuilderFactorybefore calling newDocumentBuilder method

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

factory.setValidating(true); DocumentBuilder builder = factory.newDocumentBuilder(); Document doc = builder.parse(. . .);


• If the parser validates the document with a DTD, you can avoid validity checks in your code

• You can tell the parser to ignore white space in non-text elements factory.setValidating(true); factory.setIgnoringElementContentWhitespace(true);

• If the parser has access to a DTD, it can fill in defaults for attributes

File ItemListParser.java 001: import java.io.File;

002: import java.io.IOException;

003: import java.util.ArrayList;




007: import org.w3c.dom.Attr;



010: import org.w3c.dom.NamedNodeMap;

011: import org.w3c.dom.Node;

012: import org.w3c.dom.NodeList;


014: import org.xml.sax.SAXException;

015:

016: /**

017: An XML parser for item lists

018: */

019: public class ItemListParser

020: {

021: /**

022: Constructs a parser that can parse item lists

023: */

024: public ItemListParser()


026: {



029: factory.setValidating(true);

030: factory.setIgnoringElementContentWhitespace(true);


032: }

033:

034: /**

035: Parses an XML file containing an item list

036: @param fileName the name of the file

037: @return an array list containing all items in the XML file

038: */

039: public ArrayList parse(String fileName)

040: throws SAXException, IOException

041: {

042: File f = new File(fileName);

043: Document doc = builder.parse(f);

044:

045: // get the <items> root element

046:

047: Element root = doc.getDocumentElement();

048: return getItems(root);

049: }

050:

051: /**

052: Obtains an array list of items from a DOM element

053: @param e an <items> element

054: @return an array list of all <item> children of e

055: */

056: private static ArrayList getItems(Element e)

057: {


059:

060: // get the <item> children

061:


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

064: {

065: Element childElement = (Element)children.item(i);

066: Item c = getItem(childElement);

067: items.add(c);

068: }

069: return items;

070: }

071:

072: /**

073: Obtains an item from a DOM element

074: @param e an <item> element

075: @return the item described by the given element

076: */

077: private static Item getItem(Element e)

078: {


080:

081: Product p = getProduct((Element)children.item(0));

082:

083: Element quantityElement = (Element)children.item(1);

084: Text quantityText

085: = (Text)quantityElement.getFirstChild();

086: int quantity = Integer.parseInt(quantityText.getData());

087:

088: return new Item(p, quantity);

089: }

090:

091: /**

092: Obtains a product from a DOM element

093: @param e a <product> element

094: @return the product described by the given element

095: */

096: private static Product getProduct(Element e)

097: {


099:

100: Element descriptionElement = (Element)children.item(1);

101: Text descriptionText

102: = (Text)descriptionElement.getFirstChild();

103: String description = descriptionText.getData();

104:

105: Element priceElement = (Element)children.item(1);

106: Text priceText

107: = (Text)priceElement.getFirstChild();

108: double price = Double.parseDouble(priceText.getData());

109:

110: return new Product(description, price);

111: }

112:


114: }

File ItemListParserTest.java01: import java.util.ArrayList;

02:

03: /**

04: This program parses an XML file containing an item list.

05: The XML file should reference the items.dtd

06: */

07: public class ItemListParserTest

08: {


10: {

11: ItemListParser parser = new ItemListParser();

12: ArrayList items = parser.parse("items.xml");


14: {


16: System.out.println(anItem.format());

17: }

18: }

19: }

Chapter 24 XML. CHAPTER GOALS Understanding XML elements and attributes Understanding the concept of...

Documents

Transcript of Chapter 24 XML. CHAPTER GOALS Understanding XML elements and attributes Understanding the concept of...