1. Parsing XML into programming languages
JAXP, DOM, SAX, JDOM/DOM4J, Xerces, Xalan, JAXB

2. Parsing XML
Goal: read XML files into data structures in programming languages
Possible strategies
Parse by hand with some reusable libraries
Parse into generic tree structure
Parse as sequence of events
Automagically parse to language-specific objects

3. Parsing by-hand Advantages Disadvantages Complete control
Good if simple needs – build off of regex package
Disadvantages
Must write the initial code yourself, even if it becomes generalized
Pretty tedious and error prone.
Gets very hard when using schema or DTD to validate

4. Parsing into generic tree structure
Advantages
Industry-wide, language neutral standard exists called DOM (Document Object Model)
Learning DOM for one language makes it easy to learn for any other
As of JAXP 1.2, support for Schema
Have to write much less code to get XML to something you want to manipulate in your program
Disadvantages
Non-intuitive API, doesn’t take full advantage of Java
Still quite a bit of work

5. What is JAXP? JAXP: Java API for XML Processing
In the Java language, the definition of these standard API’s (together with XSLT API) comprise a set of interfaces known as JAXP
Java also provides standard implementations together with vendor pluggability layer
Some of these come standard with J2SDK, others are only availdable with Web Services Developers Pack
We will study these shortly

6. Another alternative
JDOM: Native Java published API for representing XML as tree
Like DOM but much more Java-specific, object oriented
However, not supported by other languages
Also, no support for schema
Dom4j another alternative

7. JAXB JAXB: Java API for XML Bindings
Defines an API for automagically representing XML schema as collections of Java classes.
Most convenient for application programming
Will cover next class

8. DOM

9. About DOM Stands for Document Object Model
A World Wide Web Consortium (w3c) standard
Standard constantly adding new features – Level 3 Core just released this month
Well cover most of the basics. There’s always more, and it’s always changing.

10. DOM abstraction layer in Java -- architecture
Emphasis is on allowing vendors to supply their own DOM
Implementation without requiring change to source code
Returns specific parser
implementation
org.w3d.dom.Document

11. Sample Code DocumentBuilderFactor factory =
A factory instance
is the parser implementation.
Can be changed with runtime
System property. Jdk has default.
Xerces much better.
DocumentBuilderFactor factory =
DocumentBuilderFactory.newInstance();
/* set some factory options here */
DocumentBuilder builder =
factory.newDocumentBuilder();
Document doc = builder.parse(xmlFile);
From the factory one obtains
an instance of the parser
xmlFile can be an java.io.File,
an inputstream, etc.
javax.xml.parsers.DocumentBuilderFactory
javax.xml.parsers.DocumentBuilder
org.w3c.dom.Document
For reference. Notice that the
Document class comes from the
w3c-specified bindings.

12. Validation
Note that by default the parser will not validate against a schema or DTD
As of JAXP1.2, java provides a default parse than can handle most schema features
See next slide for details on how to setup

13. Important: Schema validation
String JAXP_SCHEMA_LANGUAGE =    
 "
String W3C_XML_SCHEMA =     
"
Next, you need to configure DocumentBuilderFactory to generate a
namespace-aware, validating parser that uses XML Schema:
… DocumentBuilderFactory factory =     DocumentBuilderFactory.newInstance()
 factory.setNamespaceAware(true);  
 factory.setValidating(true);
try {  
 factory.setAttribute(JAXP_SCHEMA_LANGUAGE, W3C_XML_SCHEMA); }
catch (IllegalArgumentException x) {  
 // Happens if the parser does not support JAXP 1.2   ... }

14. Associating document with schema
An xml file can be associated with a schema in two ways
Directly in xml file in regular way
Programmatically from java
Latter is done as:
factory.setAttribute(JAXP_SCHEMA_SOURCE,    new File(schemaSource));

15. A few notes Factory allows ease of switching parser implementations
Java provides simple DOM implementation, but much better to use vendor-supplied when doing serious work
Xerces, part of apache project, is installed on cluster as Eclipse plugin. We’ll use next week.
Note that some properties are not supported by all parser implementations.

16. Document object
Once a Document object is obtained, rich API to manipulate.
First call is usually
Element root = doc.getDocumentElement();
This gets the root element of the Document as an instance of the Element class
Note that Element subclasses Node and has methods getType(), getName(), and getValue(), and getChildNodes()

17. Types of Nodes
Note that there are many types of Nodes (ie subclasses of Node:
Attr, CDATASection, Comment, Document, DocumentFragment, DocumentType, Element, Entity, EntityReference, Notation, ProcessingInstruction, Text
Each of these has a special and non-obvious associated type, value, and name.
Standards are language-neutral and are specified on chart on following slide
Important: keep this chart nearby when using DOM

18. Node nodeValue() Attributes nodeType() 2 4 8 9 11 10 1 6 5 7 3
nodeName()
nodeValue()
Attributes
nodeType()
Attr
Attr name
Value of attribute
null 2
CDATASection
#cdata-section
CDATA cotnent 4
Comment
#comment
Comment content 8
Document
#document
Null 9
DocumentFragment
#document-fragment 11
DocumentType
Doc type name 10
Element
Tag name
NamedNodeMap 1
Entity
Entity name 6
EntityReference
Name entitry referenced 5
Notation
Notation name
ProcessingInstruction
target
Entire string 7
Text
#text
Actual text 3

19. Transforming XML

20. The JAXP Transformation Packages
JAXP Transformation APIs:
javax.xml.transform
This package defines the factory class you use to get a Transformer object. You then configure the transformer with input (Source) and output (Result) objects, and invoke its transform() method to make the transformation happen. The source and result objects are created using classes from one of the other three packages.
javax.xml.transform.dom
Defines the DOMSource and DOMResult classes that let you use a DOM as an input to or output from a transformation.
javax.xml.transform.sax
Defines the SAXSource and SAXResult classes that let you use a SAX event generator as input to a transformation, or deliver SAX events as output to a SAX event processor.
javax.xml.transform.stream
Defines the StreamSource and StreamResult classes that let you use an I/O stream as an input to or output from a transformation.

21. Transformer Architecture

22. Writing DOM to XML public class WriteDOM{
public static void main(String[] argv) throws Exception{
File f = new File(argv[0]);
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document document = builder.parse(f);
TransformerFactory tFactory =
TransformerFactory.newInstance();
Transformer transformer = tFactory.newTransformer();
DOMSource source = new DOMSource(document);
StreamResult result = new StreamResult(System.out);
transformer.transform(source, result); }

23. Creating a DOM from scratch
Sometimes you may want to create a DOM tree directly in memory. This is done with:
DocumentBuilderFactory factory =  DocumentBuilderFactory.newInstance();         
DocumentBuilder builder =         factory.newDocumentBuilder();       
 document = builder.newDocument();

24. Manipulating Nodes
Once the root node is obtained, typical tree methods exist to manipulate other elements:
boolean node.hasChildNodes()
NodeList node.getChildNodes()
Node node.getNextSibling()
Node node.getParentNode()
String node.getValue();
String node.getName();
String node.getText();
void setNodeValue(String nodeValue);
Node insertBefore(Node new, Node ref);

25. Simple API for XML Processing
SAX
Simple API for XML Processing

26. About SAX SAX in Java is hosted on source forge
SAX is not a w3c standard
Originated purely in Java
Other languages have chosen to implement in their own ways based on this prototype

27. SAX vs. … Please don’t compared unrelated things:
SAX is an alternative to DOM, but realize that DOM is often built on top of SAX
SAX and DOM do not compete with JAXP
They do both compete with JAXB implementations

28. How a SAX parser works
SAX parser scans an xml stream on the fly and responds to certain parsing events as it encounters them.
This is very different than digesting an entire XML document into memory.
Much faster, requires less memory.
However, need to reparse if you need to revisit data.

29. Obtaining a SAX parser Important classes
javax.xml.parsers.SAXParserFactory;
javax.xml.parsers.SAXParser;
javax.xml.parsers.ParserConfigurationException;
//get the parser
SAXParserFactory factory = SAXParserFactory.newInstance();
SAXParser saxParser = factory.newSAXParser();
//parse the document
saxParser.parse( new File(argv[0]), handler);

30. DefaultHandler
Note that an event handler has to be passed to the SAX parser.
This must implement the interface
org.xml.sax.ContentHandler;
Easier to extend the adapter
org.xml.sax.helpers.DefaultHandler

31. Overriding Handler methods
Most important methods to override
void startDocument()
Called once when document parsing begins
void endDocument()
Called once when parsing ends
void startElement(...)
Called each time an element begin tag is encountered
void endElement(...)
Called each time an element end tag is encountered
void characters(...)
Called randomly between startElement and endElement calls to accumulated character data

32. startElement
public void startElement(
String namespaceURI, //if namespace assoc
String sName, //nonqualified name
String qName, //qualified name
Attributes attrs) //list of attributes
Attribute info is obtained by querying Attributes objects.

33. Characters public void characters(
char buf[], //buffer of chars accumulated
int offset, //begin element of chars
int len) //number of chars
Note, characters may be called more than once between begin tag / end tag
Also, mixed-content elements require careful handling

34. Entity references
Recall that entity references are special character sequences for referring to characters that have special meaning in XML syntax
‘<‘ is &lt
‘>’ is &gt
In SAX these are automatically converted and passed to the characters stream unless they are part of a CDATA section

35. Choosing a Parser Choosing your Parser Implementation
If no other factory class is specified, the default SAXParserFactory class is used. To use a different manufacturer's parser, you can change the value of the environment variable that points to it. You can do that from the command line, like this:
java -Djavax.xml.parsers.SAXParserFactory=yourFactoryHere ...
The factory name you specify must be a fully qualified class name (all package prefixes included). For more information, see the documentation in the newInstance() method of the SAXParserFactory class.

36. Validating SAX Parsers
String JAXP_SCHEMA_LANGUAGE =    
 "
String W3C_XML_SCHEMA =     
"
Next, you need to configure DocumentBuilderFactory to generate a
namespace-aware, validating parser that uses XML Schema:
… SaxParserFactory factory =     SaxParserFactory.newInstance()
 factory.setNamespaceAware(true);  
 factory.setValidating(true);
try {  
 factory.setAttribute(JAXP_SCHEMA_LANGUAGE, W3C_XML_SCHEMA); }
catch (IllegalArgumentException x) {  
 // Happens if the parser does not support JAXP 1.2   ... }

37. Transforming arbitrary data structures using SAX and Transformer

38. Goal
Now that we know SAX and a little about Transformations, there are some cool things we can do.
One immediate thing is to create xml files from plain text files using the help of a faux SAX parser
Turns out to be more robust than doing by hand

39. Transformers
Recall that transformers easily let us go between any source and result by arbitrary wirings of
StreamSource / StreamResult
SAXSource / SAXResult
DOMSource / DOMResult
We used this to write a DOM tree to an XML file
Now we will use a SAXSource together with a StreamResult to convert our text file

40. Strategy
We construct our own SAXParser – ie a class that implements the XMLReader interface
This class must have a parse method (among others)
We use parse to read our input file and fire the appropriate SAX events.

41. What? What are we really doing here?
We’re having the SAXParser pretend as though it has encountered certain SAX XML events when it reads the text file.
Exactly where we pretend these things occur is where the appropriate XML will get written by the transformer

42. Main snippet public static void main (String argv []){
StudentReader parser = new StudentReader();
TransformerFactory tFactory =
TransformerFactory.newInstance();
Transformer transformer = tFactory.newTransformer();
FileReader fr = new FileReader(“students.txt”);
BufferedReader br = new BufferedReader(fr);
InputSource inputSource = new InputSource(fr);
SAXSource source = new SAXSource(parser, inputSource);
StreamResult result = new StreamResult(System.out);
transformer.transform(source, result); }
Create SAX “parser”
create transformer
Use text File as
Transformer source
Use text as result

43. XMLReader implementation
To have a valid SAXSource we need a class that implements
XMLReader interface
public void parse(InputSource input)
public void setContentHandler(ContentHandler handler)
public ContentHandler getContentHandler() .
Shown are the important methods for a simple app