Java and XML. XML documents consist of Elements. Each element will contains other elements and will have Attributes. For example:

Transcription

1 Java and XML XML Documents An XML document is a way to represent structured information in a neutral format. The purpose of XML documents is to provide a way to represent data in a vendor and software neutral way and to provide a way to validate the data. XML documents consist of Elements. Each element will contains other elements and will have Attributes. For example: <?xml version="1.0" encoding="utf-8"?> <Students> <Student id="1234"> <FirstName>Joe</FirstName> <LastName>Smith</LastName> <Street>334 North</Street> <City>Fullerton</City> <Units>44</Units> <Student id="5678"> <FirstName>Sara</FirstName> <LastName>Williams</LastName> <Street>787 South</Street> <City>Brea</City> <Units>9</Units> </Students> In this case the root Element is named <Students> which contains a set of <Student> elements, each of which contains a number of smaller elements. The Student elements have an ID attribute. XML is case sensitive. XML Schema A simple XML file can represent structured data but by itself does not have any validation methods. That is, there are no constraints on the data that can be checked. When a block of XML data is sent to a program the validity of the data cannot be checked. This is why another element to XML files are schema. An XML schema is an XML file which contains information about the structure of the main file. An XML file can be sent with a schema and the schema can be used to validate the main file. For example, suppose we modified the Students XML file: <?xml version="1.0" encoding="utf-8"?> <Students xmlns=" xmlns:xsi=" xsi:schemalocation=" studentschema.xsd"> <Student id="1234"> <FirstName>Joe</FirstName> <LastName>Smith</LastName> <Street>334 North</Street> <City>Fullerton</City> <Units>44</Units> <Student id="5678"> <FirstName>Sara</FirstName> <LastName>Williams</LastName>

2 <Street>787 South</Street> <City>Brea</City> <Units>9</Units> </Students> In this case we have added some namespace and schema location information to the root tag. The file named studentschema.xsd would be placed in the same workspace as the XML file and can be used to validate the file. The Schema file would look like: <?xml version="1.0" encoding="utf-8"?> <xs:schema attributeformdefault="unqualified" targetnamespace=" elementformdefault="qualified" xmlns:xs=" <xs:element name="students"> <xs:complextype> <xs:sequence> <xs:element name="student" maxoccurs="unbounded" minoccurs="1"> <xs:complextype> <xs:sequence> <xs:element type="xs:string" name="firstname" /> <xs:element type="xs:string" name="lastname" /> <xs:element type="xs:string" name="street" /> <xs:element type="xs:string" name="city" /> <xs:element type="xs:string" name="state" /> <xs:element type="xs:string" name="zip" /> <xs:element type="xs:int" name="units" /> </xs:sequence> <xs:attribute type="xs:short" name="id" use="required" /> </xs:complextype> </xs:element> </xs:sequence> </xs:complextype> </xs:element> </xs:schema> Notice that the schema file is just another XML file which contains a set of schema information which can be used to validate the original file. Names spaces can refer to online resources that define custom types, but the standards for XSD files normally suffice. In this case, the schema file contains a definition of the Students element as a complextype which contains a sequence of Student elements (each of which is also a complex type). SAX and DOM There are two ways to parse an XML file using the standard libraries. These are by using the SAX parser and using the DOM parser. The main difference is how the data is read and parsed. When parsing an XML element the parsing Java program must read an entire Element at once. That is, a Student element may contains a number of enclosed elements. When the program reaches the end of an element it can then deal with the element. A SAX parser reads an XML file from start to finish and uses callback functions to handle the XML file. The callback functions are startelement() and endelement(). SAX parsers are good for very large XML files. A DOM parser reads the entire XML file into memory and creates an in-memory Model of the xml file. This model consists of viewing the XML file as a series of Nodes. Each Node consists of an Element Node, a Text Node, and other such elements. The XML file is parsed into various collections which can be accessed by the programmer. DOM parsers are good for smaller XML files.

3 Using the DOM Parser The DOM Parser requires the following import libraries: import javax.xml.parsers.documentbuilder; import javax.xml.parsers.documentbuilderfactory; import javax.xml.parsers.parserconfigurationexception; import org.w3c.dom.document; import org.w3c.dom.element; import org.w3c.dom.node; import org.w3c.dom.nodelist; import org.xml.sax.saxexception; To use a DOM parser your program must complete the following steps: 1. Create a Document Builder Factory object 2. Use the Document Builder Factory object to create a Document Builder 3. Use the Builder to parse an XML file and return a Document object. Once your program has a Document object you can retrieve elements from the object. When retrieving elements you will retrieve objects called Nodes. A Node can be one of a set of elements in the document. These include Element Nodes, Text Nodes, etc. When you get a node you must determine what type of node it is before working with it. Some of the useful methods in the Document object are: getelementsbytagname( ) which returns a NodeList. This is a list of Nodes which your program can parse through. When you get a Node object you can then call the method getchildnodes() to return a list of all nodes contained in the node. Sample Look at the following sample XML file: <?xml version="1.0" encoding="utf-8"?> <Students> <Student id="1234"> <FirstName>Joe</FirstName> <LastName>Smith</LastName> <Street>334 North</Street> <City>Fullerton</City> <Units>44</Units> <Student id="5678"> <FirstName>Sara</FirstName> <LastName>Williams</LastName> <Street>787 South</Street> <City>Brea</City> <Units>9</Units> </Students>

4 Note the structure of this file. It contains a root element named <Students> which contains one or more elements named <Student>. Each of the <Student> elements contains a list of Elements. Also, the <Student> element has an attribute id. In order to read and parse this XML file we must: 1. Create a Document object that represents the file. 2. Retrieve a list of all <Student> elements. 3. Retrieve the id attribute from each element. 4. Get the list of child nodes from each <Student> element. 5. Read through these child nodes and retrieve the element name and the element values. The following Java program performs these tasks: import java.io.file; import java.io.ioexception; import java.util.arraylist; import javax.xml.parsers.documentbuilder; import javax.xml.parsers.documentbuilderfactory; import javax.xml.parsers.parserconfigurationexception; import org.w3c.dom.document; import org.w3c.dom.element; import org.w3c.dom.node; import org.w3c.dom.nodelist; import org.xml.sax.saxexception; public class MainClassDOM { public static void main(string[] args) { // TODO Auto-generated method stub Document doc = getdocument("students.xml"); ArrayList<Student> studentlist = getstudents(doc); printstudents(studentlist); public static void printstudents(arraylist<student> studentlist) { for (Student temp : studentlist) { System.out.printf("Student data is %s, %s, %s, %s, %s, %s %d\n", temp.getfirstname(), temp.getlastname(), temp.getstreet(), temp.getcity(), temp.getstate(), temp.getzip(), temp.getunits()); public static Document getdocument(string filename) { try { DocumentBuilderFactory dfact = DocumentBuilderFactory.newInstance(); DocumentBuilder builder = dfact.newdocumentbuilder(); File fn = new File(filename); return builder.parse(fn); catch (ParserConfigurationException e) { catch (SAXException e) { catch (IOException e) {

5 return null; public static ArrayList<Student> getstudents(document doc) { // create a student array list ArrayList<Student> studentlist = new ArrayList<Student>(); // read through the xml file and retrieve Nodes NodeList nlist = doc.getelementsbytagname("student"); for (int i = 0; i < nlist.getlength(); i++) { Node n = nlist.item(i); // get ID Element element = (Element)n; String id = element.getattribute("id"); // create a student object Student st = new Student(id); // get child nodes NodeList slist = n.getchildnodes(); for (int j = 0; j < slist.getlength(); j++) { Node selement = slist.item(j); if (selement.getnodetype() == Node.ELEMENT_NODE) { String textval = selement.gettextcontent(); if (selement.getnodename().equals("firstname")) st.setfirstname(textval); if (selement.getnodename().equals("lastname")) st.setlastname(textval); if (selement.getnodename().equals("street")) st.setstreet(textval); if (selement.getnodename().equals("city")) st.setcity(textval); if (selement.getnodename().equals("state")) st.setstate(textval); if (selement.getnodename().equals("zip")) st.setzip(textval); if( selement.getnodename().equals("units")) st.setunits(textval); studentlist.add(st); return studentlist; This Java program creates Student objects and stores them in an ArrayList. The Student class looks like: public class Student { private String id; private String firstname; private String lastname; private String street; private String city; private String state; private String zip; private int units;

6 public int getunits() { return units; public void setunits(int units) { this.units = units; public void setunits(string units) { try { this.units = Integer.valueOf(units); catch (NumberFormatException e) { this.units = 0; public Student(String idval){id=idval; public String getcity() { return city; public void setcity(string city) { this.city = city; public String getfirstname() { return firstname; public void setfirstname(string firstname) { this.firstname = firstname; public String getlastname() { return lastname; public void setlastname(string lastname) { this.lastname = lastname; public String getstreet() { return street; public void setstreet(string street) { this.street = street; public String getstate() { return state; public void setstate(string state) { this.state = state; public String getzip() { return zip; public void setzip(string zip) { this.zip = zip; public String getid() { return id; In the main() method of our program the following three things are done: public static void main(string[] args) { // TODO Auto-generated method stub Document doc = getdocument("students.xml"); ArrayList<Student> studentlist = getstudents(doc); printstudents(studentlist);

7 A document object is created by the getdocument() method. An ArrayList of students is created by the getstudents() method, and the entire list of students is printed with the printstudents() method. The getdocument() method is passed the name of the XML file and it is fairly simple: public static Document getdocument(string filename) { try { DocumentBuilderFactory dfact = DocumentBuilderFactory.newInstance(); DocumentBuilder builder = dfact.newdocumentbuilder(); File fn = new File(filename); return builder.parse(fn); catch (ParserConfigurationException e) { catch (SAXException e) { catch (IOException e) { return null; A document object is created after the dfact object is created from the DocumentBuilderFactory, which is then used to create the builder object which is then used to parse the xml file and return a Document object. The second method creates an array of students and then reads through the XML document for each element: public static ArrayList<Student> getstudents(document doc) { // create a student array list ArrayList<Student> studentlist = new ArrayList<Student>(); // read through the xml file and retrieve Nodes NodeList nlist = doc.getelementsbytagname("student"); for (int i = 0; i < nlist.getlength(); i++) { Node n = nlist.item(i); // get ID Element element = (Element)n; String id = element.getattribute("id"); // create a student object Student st = new Student(id); // get child nodes NodeList slist = n.getchildnodes(); for (int j = 0; j < slist.getlength(); j++) { Node selement = slist.item(j); if (selement.getnodetype() == Node.ELEMENT_NODE) { String textval = selement.gettextcontent(); if (selement.getnodename().equals("firstname")) st.setfirstname(textval); if (selement.getnodename().equals("lastname")) st.setlastname(textval); if (selement.getnodename().equals("street")) st.setstreet(textval); if (selement.getnodename().equals("city")) st.setcity(textval); if (selement.getnodename().equals("state")) st.setstate(textval);

8 if (selement.getnodename().equals("zip")) st.setzip(textval); if( selement.getnodename().equals("units")) st.setunits(textval); studentlist.add(st); return studentlist; First, a list of <Student> elements is retrieved with: NodeList nlist = doc.getelementsbytagname("student"); This returns a list of Nodes in the nlist object. Next, each item in this list is retrieved in a loop with: for (int i = 0; i < nlist.getlength(); i++) { Node n = nlist.item(i); // get ID Element element = (Element)n; String id = element.getattribute("id"); Notice how the length of the nodelist is retrieved withi getlength() and how the node object is retrieved with nlist.item(i). The Node object is then recast into an Element object because you must work with elements in order to get Attributes. Element element = (Element)n; String id = element.getattribute("id"); Once we have retrieved the ID attribute value we can create a student object (since the id value is the constructor). // create a student object Student st = new Student(id); At this point we have a <Student> node which contains all the elements for the student. Each of these is also a node which we want to use to retrieve the node value. This is done with: // get child nodes NodeList slist = n.getchildnodes(); for (int j = 0; j < slist.getlength(); j++) { Node selement = slist.item(j); Notice that the n refers to one of the <Student> nodes previously retrieved. The getchildnodes() method can be called on a particular node and, if the node has any child elements, they will be returned. We next want to make sure that what we are retrieving as a child node is actually an element. This is important because there are a number of other nodes and we only want to get Element nodes. if (selement.getnodetype() == Node.ELEMENT_NODE) { String textval = selement.gettextcontent();

9 In this example, if the retrieved node is an Element Node we retrieve the text Content (the values inside the XML element). We then read the element name and place the data into the student object. After figuring out which element we have retrieved we assign the newly created student to the ArrayList: studentlist.add(st);