1. Tomcat Java and XML

2. Announcements  Final homework assigned Wednesday  Two week deadline  Will cover servlets + JAXP

3. Tomcat Configuration 1. Download the software. Go to http://jakarta.apache.org/builds/jakarta-tomcat- 4.0/release/ and download and unpack the zip file for the latest version (4.1.12 as of last revision of this page). Download the software. http://jakarta.apache.org/builds/jakarta-tomcat- 4.0/release/ 2. Enable the ROOT context. Edit install_dir/conf/server.xml and uncomment this line:. Not necessary in Tomcat 4.0.3 and earlier. Enable the ROOT context.

4. Tomcat Configuration 3. Enable the invoker servlet. Go to install_dir/conf/web.xml and uncomment the servlet-mapping element that maps the invoker servlet to /servlet/*. Not necessary prior to Tomcat 4.1.12.Enable the invoker servlet. 4. Change the port to 80. Edit install_dir/conf/server.xml and change the port attribute of the Connector element from 8080 to 80.Change the port to 80.

5. Tomcat Configuration 5. Turn on servlet reloading. Edit install_dir/conf/server.xml and add a DefaultContext subelement to the main Service element and supply true for the reloadable attribute.Turn on servlet reloading. 6. Set the JAVA_HOME variable. Set it to refer to the base JDK directory, not the bin subdirectory.Set the JAVA_HOME variable.

6. Servlet example  Goal: Create StudentSort program with web-enable interface?  Ideas?

7. Outline  What is XML?  JAXP –SAX API –DOM API –XSLT API  JAX-RPC  JAXM  JAXR

8. Java and XML

9. XML Basics  Think of XML as a language-neutral text- based way of representing simple objects.  For example, in C: struct Auto{ char* make, char* model, int quantity, double price };

10. XML Basics, cont  In Java: class Auto{ public String make; public String model; public int quantity; public double price }  Note that C and Java Auto objects are not human- readable, can not be interchanged between languages and platforms (in C case).

11. XML version of Auto  XML is a formalism for describing simple structures in a language neutral way: <!DOCTYPE Auto [ ]>

12. XML version of Auto <!DOCTYPE Auto [ ]>

13. Making Auto objects  In C struct Auto a; a.make = “Ford”; a.model = “Pinto; etc....  In Java Auto a = new Auto(); a.make = “Ford”; etc....

14. Making auto objects, cont.  XML is not a programming language!  We make a car object in an xml file: Ford Pinto 100 1200.50  Think of this as like a serialized java object.

15. XML vs. DTD  Note that there are two parts to what we did –Defining the “structure” layout –Defining an “instance” of the structure  The first is done with a Document Type Descriptor (DTD)  The second is the XML part  Both can go in the same file, or an XML file can refer to an external DTD file  We will look at the syntax of each

16. Aspects of XML syntax  It is illegal to omit closing tags  XML tags are case-sensitive  XML elements must be properly nested  XML elements must have a root element  XML preserves whitespaces  XML comments:

17. DTD syntax  Can be declared either before XML or in separate file as:  Note: DTD’s are not required, but they are strongly recommended for: –ensuring correctness of XML document –standardizing industry-wide layouts

18. Building blocks of XML  From DTD point of view, XML files are composed of: –Elements –Tags –Attributes –Entities –PCDATA –DATA

19. Elements  Elements are the fields of the structure, so to speak: –The elements of auto are make, model, price, quantity  Tags are the things that surround (mark-up) elements (...)  Attributes provide extra information about elements –  Entities –characters that are parsed by XML parser. Things like &lt, &gt, &amp, etc.

20. DTD elements, cont.  PCDATA –Parsed character data. –Text found between the start tag and the end tag of an XML element. –Text that will be parsed by a parser. Tags inside the text will be treated as markup and entities will be expanded.  CDATA –Character data. –Text that will NOT be parsed by a parser. Tags inside the text will NOT be treated as markup and entities will not be expanded.

21. Examples  Study the three simple course examples: –cars.xml –employees.xml –computers.xml  Run the validating parser listed on the course webpage to verify that the xml document is well-formed  See dtd and xml tutorials listed on course website for more cool stuff.

22. What can we do with this?  So, we have an XML document.  We think of this as a text-based, language neutral serialized object.  But what can we do with it?  How does it relate to html?  Why is it useful?

23. Displaying XML  Notice that XML documents have no display information  Opening with a browser will show the raw source nicely colored  Display information can be associated with an XML file by using one of two technologies: –CSS (Cascading Style Sheets) Simple, quick –XSL (Extensible Stylesheet Language) made up of XSLT, XPATH, and XSL Formatting Objects Far slicker, more general, and complicated

24. Displaying XML  We will not study how to display XML in this course  Please see CSS and XSL tutorials listed on course website  Main point is that data is decoupled from display.  Display can be plugged in separately, but data can still be accessed.  Compare computers.html and computers.xml  What is the advantage of computers.xml?

25. Java and XML  To this point the only special thing about XML is that data and presentation were decoupled, unlike HTML.  The next key feature is language support –Language-neutral standards exists for parsing XML documents! –This means that XML documents are great ways of sharing data between programs, sending messages, etc.

26. Parsing XML in Java  Two distinct traditional models: –DOM (Document Object Model) –SAX(Simplified API for XML Parsing)  Both are language-neutral standards with bindings specified for Java  These are defined as part of JAXP (Java API for XML Processing)  JDK contains DOM and SAX parser implementations

27. DOM  DOM represents and XML document in java memory as a tree.  DOM is both read-write  Getting a DOM parser in Java: import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); DocumentBuilder builder = factory.newDocumentBuilder();

28. Parsing XML to DOM  Once an instance of the parser is obtained: org.w3c.dom. Document document = builder.parse(xmlFile);  Once a Document object is obtained: org.w3c.dom.Node = document.getDocumentElement(); gets the root Node of the document

29. 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);

30. What are Nodes?  Ok, but what information is placed in Nodes? See http://java.sun.com/j2se/1.4.1/docs/api/org.w3c.dom.Node.html  Note that the DOM parser parses everthing – white space, tags, comments, etc.  There are several ways to skip over info that doesn’t interest you –use e.g. (if node.getType == Node.TEXT_NODE) –use DocumentBuilderFactory methods to configure parser with comment parsing, etc. turned off.

31. Node Example  A good practice exercise is to do a depth- first traversal of a Document printing only the element informtion with level- dependent indentation.  I recommend doing this by yourself and then looking at my solution on the web site.  See ScanTree.java

32. SAX parser  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, can not use to change XML.  Need to reparse if you need to revisit data.

33. 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);

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

35. Overriding Handler methods  Most typical methods to override void startDocument() void endDocument() void startElement(...) void endElement(...) void characters(...)  See examples on course website

36. Writing XML from DOM import javax.xml.transform.Source; import javax.xml.transform.Transformer; import javax.xml.transform.TransformerFactory; import javax.xml.transform.Result; import javax.xml.transform.dom.DOMSource; import javax.xml.transform.stream.StreamResult; import org.w3c.dom.Document; import java.io.File; public class WriteXML{ public static void write(Document doc, String filename) throws Exception { /* Prepare the DOM document for writing */ Source source = new DOMSource(doc); Result result = new StreamResult(new File(filename))); /* Write the DOM document to the file */ Transformer xformer = TransformerFactory.newInstance().newTransformer(); xformer.transform(source, result);}}

37. Using JAXP to simplify file input  Goal: read xml-based file into lottery servlet program.

38. Using JAXP for messaging  Goal: build a socket program that exchanges xml-based messages