XSD is the XML schema definition for defining the XML elements in the XML document. Prior to the XML schemas, DTDs are used which are not XML document and has the limitations. XSD is most popular because of the extensibility and the validations for the XML files. You can set the validation rules for the XML files and the values in the XML documents can be validated using the XSD documents. There are number of tools available in the internet to perform the validation tasks.

There are times when developer wants to generate the XSD from the XML files. In a typical scenario, XSD is written seperately without referring the XML document because XML data can be wrong. In case, if you don’t have the XSD for an XML document and want to generate the XSD for that XML document, there are tools in the internet. This article is not to explain much detail on how to generate the XSD from XML, but to give an idea on where to get the details on the tools and guiding for the resources on the internet.

• How to Convert XML to Xsd Online
• XML-2-XSD
• List of Links

If you are facing any issues on converting the XML files into the XSD, please post it here.

	For an introduction on XPath refer to the <i>W3C Recommendation for
	XPath</i> (http://www.w3.org/TR/xpath). As a brief review,
	expression evaluation in XPath is performed with respect to a <b>context
	node</b>. The most commonly used type of expression in XPath is a <b>location
	path</b> . XPath defines two types of location paths: <b>relative location paths</b>
	and <b>absolute location paths</b>. A relative location path is defined with
	respect to a context node and consists of a sequence of one or more
	location steps separated by "/". A <b>location step</b> consists of an <b>axis</b>, a
	<b>node test</b>, and <b>predicates</b>.

	child::journal[position()=2]

<?xml version="1.0" encoding="UTF-8"?>
<catalog xmlns:journal="http://www.xdk11g.com/xpath"
		title="Oracle Magazine" publisher="Oracle Publishing">
   <journal:journal journal:date="November-December 2008">
	  <journal:article journal:section="ORACLE DEVELOPER">
		 <title>Instant ODP.NET Deployment</title>
		 <author>Mark A. Williams</author>
	  </journal:article>
	  <journal:article journal:section="COMMENT">
		 <title>Application Server Convergence</title>
		 <author>David Baum</author>
	  </journal:article>
   </journal:journal>
   <journal date="March-April 2008">
	  <article section="TECHNOLOGY">
		 <title>Oracle Database 11g Redux</title>
		 <author>Tom Kyte</author>
	  </article>
	  <article section="ORACLE DEVELOPER">
		 <title>Declarative Data Filtering</title>
		 <author>Steve Muench</author>
	  </article>
   </journal>
</catalog>

XPath search

In this section, we shall select nodes from the example XML document, catalog.xml, with the XPath Search tool of JDeveloper 11g. The XPath Search tool consists of an Expression field for specifying an XPath expression. Specify an XPath expression and click on OK to select nodes matching the XPath expression. The XPath Search tool has the provision to search for nodes in a specific namespace. An XML namespace is a collection of element and attribute names that are identified by a URI reference. Namespaces are specified in an XML document using namespace declarations. A namespace declaration is an xmlns-prefixed attribute in an element
that consists of a namespace prefix in the attribute name with the namespace URI as the attribute value.

If you want to select nodes in a specific namespace or nodes from different namespaces, first add the namespace Prefix and URI to the XPath Search tool using the Add button. Subsequently, include namespace prefixes in the XPath expression. The XPath Search tool is shown here:

To navigate catalog.xml with XPath, select catalog.xml in the Application Navigator and select Search|XPath Search.

In the following subsections, we shall select example nodes using absolute location paths and relative location paths. Use a relative location path if the XML document is large and a specific node is required. Also, use a relative path if the node from which subnodes are to be selected and the relative location path are known. Use an absolute location path if the XML document is small, or if the relative location path is not known. The objective is to use minimum XPath navigation. Use the minimum number nodes to navigate in order to select the required node.

Selecting nodes with absolute location paths

Nex t, we shall demonstrate with various examples of selecting nodes using XPath. As an example, select all the title elements in catalog.xml. Specify the XPath expression for selecting the title elements in the Expression field of the Apply an XPath Expression on catalog.xml window. The XPath expression to select all title elements is /catalog/journal/article/title. Click on the OK button to select the title elements.

The title elements get selected. Title elements from the journal:article elements in the journal namespace do not get selected because a namespace has not been applied to the XPath expression.

As an other example, select the title element in the first article element using the XPath expression /catalog/journal/article[1]/title. We are not using namespaces yet. The XPath expression is specified in the Expression field.

The title of the first article element gets selected as shown in the JDeveloper output:

Attribu te nodes may also be selected with XPath. Attributes are selected by using the ”@” prefix. As an example, select the section attribute in the first article element in the journal element. The XPath expression for selecting the section attribute is
/catalog/journal/article[1]/@section and is specified in the Expression field. Click on the OK button to select the section attribute.

The attr ibute section gets outputted in JDeveloper.

Selecting nodes with relative location paths

In the pr evious examples, an absolute location is used to select nodes. Next, we shall demonstrate selecting an element with a relative location path. As an example, select the title of the first article element in the journal element. The relative location path for selecting the title element is child::catalog/journal/article[position()=1]/ title. Specifying the axis as child and node test as catalog selects all the child nodes of the catalog node and is equivalent to an absolute location path that starts with /catalog. If the child nodes of the journal node were required to be selected, specify the node test as journal. Specify the XPath expression in the Expression
field and click on the OK button.

The title of the first article element in the journal element gets selected as shown here:

Selecting namespace nodes

XPath Searc h also has the provision to select elements and attributes in a namespace.To illustrate, select all the title elements in the journal element (that is, in the journal namespace) using the XPath expression /catalog/journal:journal/journal:
article/title. First, add the namespaces of the elements and attributes to be selected in the Namespaces text area. Prefix and URI of namespaces are added with the Add button. Specify the prefix in the Prefix column, and the URI in the URI column. Multiple namespace mappings may be added. XPath expressions that select namespace nodes are similar to no-namespace expressions, except that the namespace prefixes are included in the expressions. Elements in the default namespace, which does not have a namespace prefix, are also considered to be in a namespace. Click on the OK button to select the nodes with XPath.

The title elements in the journal element (in the journal namespace) get selected and outputted in JDeveloper.

Attributes in a namespace may also be selected with XPath Search. As an example, select the section attributes in the journal namespace. Specify the XPath expression to select the section attributes in the Expression field and click on the OK button.

Section attributes in the journal namespace get selected.

Selecting nodes with XPath API

In the previous section, XML document nodes were selected automatically with the XPath Search tool in JDeveloper. In this section, we shall select nodes with the XPath API in the XPathParser class. JDeveloper XPath searches with the XPath Search tool are for the convenience of the developer as they find nodes faster than when looking through the XML file. The XPath searches, using the XPath API, actually let your application find nodes via XPath.

The XMLDocument class has select methods to select nodes with an XPath expression. A single node may be selected or a NodeList of nodes may be selected. Nodes declared in a namespace may also be selected. First, we need to import the oracle.xml.parser.v2 package that has the XMLDocument class and the parser class DOMParser, from which an XMLDocument may be obtained.

	import oracle.xml.parser.v2.*;

Creating the DOM parser

Next, we need t o parse an XML document and create a DOM structure for the XML document before being able to select nodes with XPath. Therefore, create a DOMParser using:

	DOMParser domParser=new DOMParser();

The DOMParser class, which extends the XMLParser class, has overloaded the parse methods to parse an XML document from different input sources. An XML document may be parsed from InputSource, InputStream, Reader, String, or URL. In the example application XPathParser.java, we shall parse an example document from a FileReader.

Create a FileReader object from a File object and parse it with the parse(Reader) method as shown in the following listing:

	domParser.parse(new FileReader(xmlDocument));

Variable xmlDocument is the File representation of the XML document catalog.xml. The class that provides XPath functionality is XMLDocument. Obtain an XMLDocument object from the DOMParser object with the getDocument() method.

	XMLDocument document=domParser.getDocument();

Method selectS ingleNode(String)

The XMLDocument class method selectSingleNode(String) selects a single node specified by an XPath expression. If more than one nodes match the XPath expression, the first node that matches the XPath expression gets selected. As an example, select the title of the first article node with section attribute value ORACLE DEVELOPER. The title element is selected with the selectSingleNode(String) method as shown here:

	XMLNode titleNode=(XMLNode)document.selectSingleNode("/catalog/
	journal/article[@section='ORACLE DEVELOPER']/title");

The title element value may be selected by first selecting the text node in the title element node using the getFirstChild() method and subsequently selecting the text node value using the getNodeValue() method, as shown in the following listing:

	String title=titleNode.getFirstChild().getNodeValue();

As another example of the selectSingleNode(String) method, select the author of the article with the title Oracle Database 11g Redux, as shown here:

	XMLNode authorNode=(XMLNode)document.selectSingleNode("/catalog/
	journal/article[title= Oracle Database 11g Redux']/author");

The author element text value is outputted by first selecting the text node within the author element node using the getFirstChild() method and subsequently selecting the text node value using the getNodeValue() method, as shown here:

	String author=authorNode.getFirstChild().getNodeValue();

The XMLDocument class selectSingleNode(String) may also be used to select an attribute node. As an example, select the section attribute of the second article in the journal of date March-April 2008:

	XMLNode sectionNode=(XMLNode)document.selectSingleNode("/catalog/
	journal[@date=March-April 2008]/article[2]/@section");

The section node value may be selected with the getNodeValue() method:

	String section=sectionNode.getNodeValue();

Method selectNodes(String)

The XMLDocument class method selectNodes(String XPathExpression) selects all the nodes specified by an XPath expression. As an example, select all the title elements for the journal of date March-April 2008, as shown in the following listing:

	NodeList nodeList=document.selectNodes("/catalog/journal[@date='March-
	April 2008']/article/title");

The method selectNodes(String) returns a NodeList that may be iterated over to output title elements:

	for(int i=0; i<nodeList.getLength(); i++){
	   titleNode=(XMLElement)nodeList.item(i);
	   title=titleNode.getFirstChild().getNodeValue();
	   System.out.println(title);
	}

The method selectNodes(String) may also be used to select attribute nodes. For example, select all the section attributes for the articles in the journal of date March-April 2008:

	NodeList
	nodeList=document.selectNodes("/catalog/journal[@date='March- April
	2008]/article/@section");

The NodeList of section nodes may be iterated over to output section node values as shown in the following listing:

	for(int i=0; i<nodeList.getLength(); i++){
	   XMLNode sectionNode=(XMLNode)nodeList.item(i);
	   String section=sectionNode.getNodeValue();
	   System.out.println(section+" ");
	}

Method selectSingleNode(String,NSResolver)

The XMLDocument class method selectSingleNode(String XSLPattern, NSResolver resolver) selects a single node specified by an XPath expression. NSResolver is used to resolve any namespace prefixes that may occur in the XPath expression.

To select nodes in a namespace, create a class (for example, CustomNSResolver) that implements the NSResolver interface. In the implementation class, implement the NSResolver method resolveNamespacePrefix(String prefix) as shown in the following listing:

	class CustomNSResolver implements NSResolver{
	   public java.lang.String resolveNamespacePrefix(java.lang.String
	   prefix){
	      if(prefix.equals("journal")){
		 return new String("http://www.xdk11g.com/xpath");
	      }
	   }
	}

The resolveNamespacePrefix method accepts a prefix and returns a URI.Create an NSResolver object. Set the namespace prefix to resolve using the resolveNamespacePrefix method:

	CustomNSResolver resolver=new CustomNSResolver();
	resolver.resolveNamespacePrefix("journal");

In the example XML document, catalog.xml, one of the journal elements is in the journal namespace. As an example, select the section attribute in the journal namespace in the first article element (in journal namespace) in the journal element (in journal namespace). The section attribute value will be outputted with the getNodeValue() method, as shown in the following listing:

	XMLNode sectionNode= (XMLNode)document.selectSingleNode("/catalog/
	journal:journal/journal:article/@journal:section", resolver);
	section=sectionNode.getNodeValue();

As a contrast b etween the selectSingleNode method that takes an NSResolver and the selectSingleNode method that doesn’t, the method that doesn’t take an NSResolver does not select nodes in a namespace. On the other hand, the one thatdoes selects nodes in a namespace. If the method that does not take an NSResolver is invoked with an XPath expression containing namespace nodes, the following error is generated:

	XSLException Namespace prefix 'journal' used but not declared.

Method selectNodes(String,NSResolver)

The XMLDocument class method selectNodes(String XPathExpression, NSResolver resolver) selects all the namespace nodes resolved by an NSResolver that are specified in an XPath expression. NSResolver is used to resolve any prefixes that may occur in the XPath expression. For example, select all the title elements in journal (in journal namespace) of date (in journal namespace) November-December 2008, as shown in the following listing:

	NodeList nodeList=document.selectNodes("/catalog/journal:journal[@
	journal:date='November-December 2008']/journal:article/title",
	resolver );

The namespace prefix journal in the XPath expression is resolved with an NSResolver object. The NodeList returned by the selectNodes(String, NSResolver) method may be iterated over to output the title elements.

	for(int i=0; i<nodeList.getLength(); i++){
	   titleNode=(XMLElement)nodeList.item(i);
	   title=titleNode.getFirstChild().getNodeValue();
	   System.out.println(title);
	}

Running the Java application

The Java progra m XPathParser.java is used to select nodes from the XML document catalog.xml. The Java application is listed with additional explanations about the application as follows:

1. First, we import the required packages from XDK 11g.

   	import oracle.xml.parser.v2.*;
   	import java.io.*;
   	import org.xml.sax.SAXException;
   	import org.w3c.dom.*;
   

2. Next, we add the XPathParser Java class declaration.

   	public class XPathParser{
   

3. We define the parseDocument method to parse an XML document with the DOMParser.

	public void parseDocument(File xmlDocument){
	   try{

• Next, we create a DOMParser object and parse the XML document.

  	DOMParser domParser=new DOMParser();
  	domParser.parse(new FileReader(xmlDocument));
  	XMLDocument document=domParser.getDocument();
  

• We specify the NSResolver object to resolve namespaces.

  	CustomResolver resolver=new CustomResolver();
  	resolver.resolveNamespacePrefix("journal");
  

• Next, we select nodes using the selectSingleNode(String) method.

  	XMLNodetitleNode=(XMLNode)document.selectSingleNode
  	("/catalog/journal/article[@section=' ORACLE DEVELOPER']/title");
  	String title=titleNode.getFirstChild().getNodeValue();
  	System.out.println("Title of first Article in ORACLE DEVELOPER
  	Section (with nodes not in any namespace) is "+ title);
  	XMLNode authorNode=(XMLNode)document.selectSingleNode("/catalog/
  	journal/article[title= Oracle Database 11g Redux']/author");
  	String author=authorNode.getFirstChild().getNodeValue();
  	   System.out.println("Author of Title Oracle Database 11g Redux
  	   is "+ author);
  	   XMLNode sectionNode=(XMLNode)document.selectSingleNode
  	   ("/catalog/journal[@date=March-April 2008']/article[2]
  	   /@section");
  	String section=sectionNode.getNodeValue();
  	System.out. println("Section of 2nd Article in Journal of date
  	March-April 2008 is "+ section);
  

• We select nodes using the selectNodes(String) method.

  	NodeList nodeList = document.selectNodes("/catalog/journal[@date=
  	'March-April 2008']/article/title");
  	System.out.println("Article Titles published in journal of March-
  	April 2008 are: ");
  	for(int i=0; i<nodeList.getLength(); i++){
  	   titleNode=(XMLElement)nodeList.item(i);
  	   title=titleNode.getFirstChild().getNodeValue();
  	   System.out.println(title);
  	}
  	nodeList=document.selectNodes("/catalog/journal[@date='March-April
  	2008']/article/@section");
  	System.out.println("Articles in journal of March-April 2008 were
  	published in Sections: ");
  	for(int i=0; i<nodeList.getLength(); i++){
  	   sectionNode=(XMLNode)nodeList.item(i);
  	   section=sectionNode.getNodeValue();
  	   System.out.println(section+" ");
  	}
  

• Next, we select nodes using the selectSingleNode(String,NSResolver) method.

  	sectionNode=(XMLNode)document.selectSingleNode("/catalog/journal:
  	journal/journal:article/@journal:section", resolver);
  	section=sectionNode.getNodeValue();
  	System.out.println("Section of first article in first journal
  	(nodes being in journal namespace) is "+section+" ");
  	System.out.println("Titles for articles in journal of date
  	November-December 2008 (journal, article, and date nodes being in
  	journal namespace) are ");
  

• We also select nodes using the selectNodes(String,NSResolver) method.

  	nodeList=document.selectNodes("/catalog/journal:journal[@journal:
  	date= 'November-December 2008']/journal:article/title",
  	resolver );
  	for(int i=0; i<nodeList.getLength(); i++){
  	   titleNode=(XMLElement)nodeList.item(i);
  	   title=titleNode.getFirstChild().getNodeValue();
  	   System.out.println(title);
  	   }
  	   }catch(IOException e){
  	      System.err.println("IOException"+e.getMessage());
  	   }
  	   catch(XMLDOMException e){
  	      System.err.println("XMLDOMException"+e.getMessage());
  	   }
  	   catch(XMLParseException e)
  	      {System.err.println("XMLParseException"+e.getMessage());
  	   }
  	   catch(XSLException e){
  	      System.err.println("XSLException"+e.getMessage());
  	   }
  	   catch(SAXException e){
  	      System.err.println("SAXException"+e.getMessage());
  	   }
  	}
  

• We add the Java class that extends the NSResolver class.

  	class CustomResolver implements NSResolver{
  	public java.lang.String
  	resolveNamespacePrefix(java.lang.String prefix){
  	if(prefix.equals("journal")){
  	   return new "http://www.xdk11g.com/xpath";
  	}else
  	   return null;
  	   }
  	}
  

• Finally, we define the main method in which we create an instance of the

  	XPathParser class and invoke the parseDocument method.
  	   public static void main(String[] argv){
  	      XPathParser parser=new XPathParser();
  	      parser.parseDocument(new File("catalog.xml"));
  	   }
  	}
  

To run the XPathParser.java application in JDeveloper, right-click on the XPathParser.java node in the Application Navigator, and select Run. The output from the XPathParser.java application is shown in the following illustration:

Summary

In this chapter you learned about XPath support in JDeveloper 11g. JDeveloper provides an XPath Search GUI tool to select nodes from an XML document using XPath. We selected nodes using absolute location paths and relative location paths, and also selected namespace nodes. We discussed the XDK’s XMLDocument class select methods to select elements and attributes in an XML document with XPath. The select methods may be used to select single nodes or collections of nodes. The select methods may also be used to select nodes in a namespace. In the next chapter, you will learn about XSLT(Extensible Stylesheet Language Transformation) support in JDeveloper.

1
2
3
4
5
6

<employee grade="senior">
	<id>745821</id>
	<empName>Tim</empName>
	<salary>35000</salary>
	<domain>Insurance</domain>
</employee>

1
2
3
4
5
6
7
8
9
10

<xs:element name="employee">
    <xs:complexType>
      <xs:sequence>
	<xs:element name="id" type="xs:string"/>
	<xs:element name="empName" type="xs:string"/>
	<xs:element name="salary" type="xs:string"/>
	<xs:element name="domain" type="xs:string"/>
      </xs:sequence>
    </xs:complexType>
</xs:element>

1

<employee empId="157117" />

1
2
3
4
5

<xs:element name="employee">
  <xs:complexType>
    <xs:attribute name="empId" type="xs:positiveInteger"/>
  </xs:complexType>
</xs:element>

1

<domain>BFS</domain>

1
2
3
4
5
6
7

<xs:element name="domain">
  <xs:complexType>
    <xs:simpleContent>
      <xs:extension base="xs:string" />
    </xs:simpleContent>
  </xs:complexType>
</xs:element>

1
2
3
4
5

<employeeInfo>
The employee <id>134567</id>
belongs to <domain>BFS</domain>
and his salary is <salary>56430</salary>
</employeeInfo>

1
2
3
4
5
6
7
8
9

<xs:element name="employeeInfo">
  <xs:complexType mixed="true">
    <xs:sequence>
      <xs:element name="id" type="xs:positiveInteger"/>
      <xs:element name="domain" type="xs:string"/>
      <xs:element name="salary" type="xs:positiveInteger"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

1
2
3
4
5
6
7
8
9
10

<xs:element name="employee">
  <xs:complexType>
    <xs:all>
      <xs:element name="empId" type="xs:string"/>
      <xs:element name="name" type="xs:string"/>
      <xs:element name="salary" type="xs:integer"/>
      <xs:element name="domain" type="xs:string"/>
    </xs:all>
  </xs:complexType>
</xs:element>

1
2
3
4
5
6
7
8

<xs:element name="employee">
  <xs:complexType>
    <xs:choice>
      <xs:element name="manager" type="manager"/>
      <xs:element name="member" type="member"/>
    </xs:choice>
  </xs:complexType>
</xs:element>

1
2
3
4
5
6
7
8
9
10

<xs:element name="employee">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="empId" type="xs:string"/>
      <xs:element name="name" type="xs:string"/>
      <xs:element name="salary" type="xs:integer"/>
      <xs:element name="domain" type="xs:string"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

1
2
3
4
5
6
7
8
9
10
11

<xs:element name="employee">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="empId" type="xs:string"/>
      <xs:element name="name" type="xs:string"/>
      <xs:element name="salary" type="xs:integer"/>
      <xs:element name="domain" type="xs:string"/>
      <xs:element name="project" type="xs:string" maxOccurs="10"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

1
2
3
4
5
6
7
8
9
10
11

<xs:element name="employee">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="empId" type="xs:string"/>
      <xs:element name="name" type="xs:string"/>
      <xs:element name="salary" type="xs:integer"/>
      <xs:element name="domain" type="xs:string"/>
      <xs:element name="project" type="xs:string" maxOccurs="10" minOccurs="0"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

1
2
3
4
5
6

<xs:group name="projectGroup">
  <xs:sequence>
    <xs:element name="projectname" type="xs:string"/>
    <xs:element name="technology" type="xs:string"/>
  </xs:sequence>
</xs:group>

1
2
3
4
5
6
7
8
9
10
11

<xs:element name="employee">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="empId" type="xs:string"/>
      <xs:element name="name" type="xs:string"/>
      <xs:element name="salary" type="xs:integer"/>
      <xs:element name="domain" type="xs:string"/>
      <xs:group ref="projectGroup"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

1
2
3
4
5
6
7

<xs:attributeGroup name="empAttrGroup">
    <xs:attribute name="designation" type="xs:string"/>
</xs:attributeGroup>
 
<xs:complexType name="employee">
    <xs:attributeGroup ref="empAttrGroup"/>
</xs:complexType>

1
2
3
4
5
6
7
8
9
10
11

<xs:element name="employee">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="empId" type="xs:positiveinteger"/>
      <xs:element name="name" type="xs:string"/>
      <xs:element name="salary" type="xs:positiveinteger"/>
      <xs:element name="domain" type="xs:string"/>
      <xs:any minOccurs="0"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

1
2
3
4
5
6
7
8

<xs:element name="project">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="projectName" type="xs:string" />
      <xs:element name="technologyUsed" type="xs:string" />
    </xs:sequence>
  </xs:complexType>
</xs:element>

1
2
3
4
5
6
7
8
9
10

<employee>
	<empId>143233</empId>
	<name>John</name>
	<salary>34500</salary>
	<domain>Insurance</domain>
	<project>
		<projectName>ISD</projectName>
		<technologyUsed>.NET</technologyUsed>
	</project>
</employee>

1
2
3
4
5
6
7
8
9
10

	<table border="1">
	<tr>
		<td>XML Schema</td>
		<td><xs:element name="name" type="xs:string"/></td>
	</tr>
	<tr>
		<td>XML</td>
		<td><name>John</name></td>
	</tr>
	</table>

1
2
3
4
5
6
7
8
9
10
11

<table border="1">
<tr>
	<td>XML Schema</td>
	<td><xs:element name="joiningDate" type="xs:date"/>
</td>
</tr>
<tr>
	<td>XML</td>
	<td><joiningDate>2007-03-27</joiningDate></td>
</tr>
</table>

• XML Schema Elements
• XForms
• Creating XSLT documents
• How to use XLink and XPointer?
• How to Query XML using XPath

1
2
3
4
5

<?xml version="1.0"?>
<bookstore xmlns:xlink="http://www.w3.org/1999/xlink">
	<book xlink:type="simple" xlink:href="http://www.lordoftherings.com">Lord of the rings</homepage>
	<book xlink:type="simple" xlink:href="http://www.harryporter.com">Harry Porter</homepage>
</homepages>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

<?xml version="1.0" encoding="ISO-8859-1"?>
<employees>
	<employee id="17452" vertical="banking">
		<id>17452</id>
		<name>Jason</name>
		<experience>2</experience>
		<salary>35000</salary>
	</employee>
 
	<employee id="14782" vertical="insurance">
		<id>14782</id>
		<name>Jim</name>
		<experience>3</experience>
		<salary>45000</salary>
	</employee>
 
	<employee id="12563" vertical="telecom">
		<id>12563</id>
		<name>Charles</name>
		<experience>4</experience>
		<salary>55000</salary>
	</employee>
</employees>

1
2
3
4
5
6
7
8
9

<?xml version="1.0" encoding="ISO-8859-1"?>
<myemployees xmlns:xlink="http://www.w3.org/1999/xlink">
	<myemployee xlink:type="simple"
		xlink:href="employees.xml#14782">
		<description xlink:type="simple"
			Jim is the employee of the year
		</description>
	</myemployee>
</myemployees>

• How to Query XML using XPath?
• How to read xml file and inject bean reference using Spring Framework?
• XML Tips
• XML Articles
]]> http://www.javabeat.net/2009/03/how-to-use-xlink-and-xpointer/feed/ 0 http://www.javabeat.net/2009/03/how-to-query-xml-using-xpath/ http://www.javabeat.net/2009/03/how-to-query-xml-using-xpath/#comments Thu, 12 Mar 2009 00:29:34 +0000 Mohamed Sanaulla http://www.javabeat.net/examples/?p=309 Connect to us ( @twitter | @facebook )

How to Query XML using XPath Introduction XML Documents are nothing until some kind of Components called Parsers parses the Documents to extract the meaningful data. Some of the most popular DOM parsers are the Simple API for XML (SAX) and Document Object Model (DOM). Both these parsers have their own advantages and disadvantages in parsing [...]

]]> Connect to us ( @twitter | @facebook )

How to Query XML using XPath

Introduction

XML Documents are nothing until some kind of Components called Parsers parses the Documents to extract the meaningful data. Some of the most popular DOM parsers are the Simple API for XML (SAX) and Document Object Model (DOM). Both these parsers have their own advantages and disadvantages in parsing the XML Documents. XPath is a simple Query Language for querying data from a XML Document and it is a standard specification from the W3C Group.

• XQuery by Oreilly Publications.

XPath – A Query Language for XML

Let us see how XPath can be used to query the various pieces of data in a XML Document. Consider a following simple XML file (employees.xml)

<employees>
  <employee id = "001">
    <name>Johny</name>
  </employee>
  <employee id = "002">
    <name>Williams</name>
  </employee>
</employees>

The above XML file represents a collection of Employee instances as represented by the employee tag. A set of employees shares a common root tag employees. It is wise to mention that in XML terms a tag, element or a node all means the same. A XML Document is nothing but a collection of properly organised tags. A XML Document can contain a mixture of several of the commonly-used tags which either represent an element or the value/text stored by the element. Each element can also have certain attributes. For example, in the above employees.xml, the employees, employee, name represent the elements, the values “Williams“, “Johny” represent the text. Also note that the element/tag- employee has an “id” attribute associated with it.

XPath uses simple expressions to query or select a portion of information from a XML Document. For instance, if we want to get the name of the first employee, then we can frame an expression like this:

/employees/employee[1]/name

The above expression can be intepreted like this, Starting from the root of the XML Document, (which is represented by “/“) traverse until the employees element is found, then deep traverse to find the first employee element represented by employee[1], then retrive the value of the name element. As seen, the XML Document is hierarchically traversed to retrieve the information. The forward slash represents the root of the document, and multiple elements having the same name can be accessed using array based index notation. The index starts with 0, 1, … and so on. If we want to select an attribute then “@” symbol has to be prefixed along with the attribute name. For example, if we wish to query for the id value for the second employee, then the following XPath expression will just do that,

/employees/employee[2]/@id

Java and XPath

Easy to use, Java XPath API is available for accessing the XML data. The XPath API is available in the standard JDK distribution in the javax.xml.xpath package. All we have to do is to utilize the XPathFactory, XPath and XPathExpression classes and interfaces to do the task.
XPathFactory class follows the standard Factory Pattern to create XPath objects. XPath objects provides an environment to compile expressions which is encapsulated by XPathExpression. Then the compiled XPathExpression can be executed to get the desired results. Following is the code snippet,

XPathFactory xPathFactory = XPathFactory.newInstance();
// To get an instance of the XPathFactory object itself.
XPath xPath = xPathFactory.newXPath();
// Create an instance of XPath from the factory class.
String expression = "SomeXPathExpression";
XPathExpression xPathExpression = xPath.compile(expression);
// Compile the expression to get a XPathExpression object.
Object result = xPathExpression.evaluate(xmlDocument);
// Evaluate the expression against the XML Document to get the result.

Sample Application:

Following section provides a sample application to demonstrate the usage of XPath in Java Applications. The sample application tries to select the value of an element, the value of an attribute, the value of a element-set (which is an element containing multiple elements) by compiling and executing different expressions.

projects.xml

Here is a XML file called ‘projects.xml’ which contains the structured information for various projects. The project element has an attribute called id and various nested elements like name, start-date and end-date. The structure of the XML File is given below:

<xml version="1.0" encoding="UTF-8>
<projects>
  <project id = "BP001">
    <name>Banking Project</name>
    <start-date>Jan 10 1999</start-date>
    <end-date>Jan 10 2003</end-date>
  </project>
  <project id = "TP001">
    <name>Telecommunication Project</name>
    <start-date>March 20, 1999</start-date>
    <end-date>July 30, 2004</end-date>
  </project>
  <project id = "PP001">
    <name>Portal Project</name>
    <start-date>Dec 10 1999</start-date>
    <end-date>March 10 2006</end-date>
  </project>
</projects>

XPathReader.java

Now, let write a simple Java Application which acts as a reader in reading the various pieces of information from the XML Document. Following is the Java source that does the job of parsing the XML Document:

import java.io.IOException;
import javax.xml.XMLConstants;
import javax.xml.namespace.QName;
import javax.xml.parsers.*;
import javax.xml.xpath.*;
import org.w3c.dom.Document;
import org.xml.sax.SAXException;

public class XPathReader {

  private String xmlFile;
  private Document xmlDocument;
  private XPath xPath;

  public XPathReader(String xmlFile) {
    this.xmlFile = xmlFile;
    initObjects();
  }

  private void initObjects(){
      try {
        xmlDocument = DocumentBuilderFactory.
        newInstance().newDocumentBuilder().
        parse(xmlFile);
        xPath =  XPathFactory.newInstance().
        newXPath();
      } catch (IOException ex) {
        ex.printStackTrace();
      } catch (SAXException ex) {
        ex.printStackTrace();
      } catch (ParserConfigurationException ex) {
        ex.printStackTrace();
      }
  }

  public Object read(String expression, QName returnType){
    try {
      XPathExpression xPathExpression =
      xPath.compile(expression);
      return xPathExpression.evaluate
      (xmlDocument, returnType);
    } catch (XPathExpressionException ex) {
      ex.printStackTrace();
      return null;
    }
  }
}

The constructor of this class is passed a XML File from which the information has to be read. The method initObjects() is called immediately, and it is used to initialize the XML Document and the XPath objects. A Document representation of the XML File is created by calling the DocumentBuilder.parse() method Then, a new XPath object is created by calling the XPathFactory.newXPath() method.

Client Applications can then call XPathReader.read() method by passing the expression to be evaluated and the return type of the expression. The return type of the expression is a QName which in XML terms, stands for Qualified Name. The standard XPath data-types are String, Number, Boolean, Node, NodeSet etc., which are represented as constants in XPathConstants namely XPathConstants.STRING, XPathConstants.NUMBER, XPathConstants.BOOLEAN, XPathConstants.NODE and XPathConstants.NODESET. Hence, the return type after evaluating an expression should be any of the above mentioned data-types. Within the read() method, an expression is compiled using the XPath.compile() method which returns a XPathExpression and the compiled expression can be evaluated using XPathExpression.evaluate() method.

XPathReaderTest.java

package com.javabeat.tips.xpath;
import javax.xml.xpath.XPathConstants;
import org.w3c.dom.*;
public class XPathReaderTest {

  public XPathReaderTest() {
  }

  public static void main(String[] args){

      XPathReader reader = new XPathReader("
      src\com\javabeat\tips\xpath\projects.xml");

      // To get a xml attribute.
      String expression = "/projects/project[1]/@id";
      System.out.println(reader.read(expression,
      XPathConstants.STRING) + "n");

      // To get a child element's value.'
      expression = "/projects/project[2]/name";
      System.out.println(reader.read(expression,
      XPathConstants.STRING) + "n");

      // To get an entire node
      expression = "/projects/project[3]";
      NodeList thirdProject = (NodeList)reader.read(expression,
      XPathConstants.NODESET);
      traverse(thirdProject);
    }

  private static void traverse(NodeList rootNode){
    for(int index = 0; index < rootNode.getLength(); index ++){
      Node aNode = rootNode.item(index);
      if (aNode.getNodeType() == Node.ELEMENT_NODE){
        NodeList childNodes = aNode.getChildNodes();
        if (childNodes.getLength() > 0){
          System.out.println("Node Name-->" +
          aNode.getNodeName() +
          " , Node Value-->" +
          aNode.getTextContent());
        }
        traverse(aNode.getChildNodes());
      }
    }
  }
}

This test application uses the XPathReader class by creating its instance and then calls the XPathReader.read() method by passing different expressions and return types. As we see, the third expression tries to retrieve an entire node-set by passing the return type as XPathConstants.NODESET. Since a node-set contains a collection of nodes which in turn can contain some other nodes, a Recursive Traversal is made on the node-set to get the name and the value of the node by calling the Node.getNodeName() and Node.getTextContent() methods. The following would be the expected output for the above sample client application.

]]> http://www.javabeat.net/2009/03/how-to-query-xml-using-xpath/feed/ 2 http://www.javabeat.net/2009/03/xquery-syntax/ http://www.javabeat.net/2009/03/xquery-syntax/#comments Thu, 05 Mar 2009 04:40:54 +0000 JavaBeat http://www.javabeat.net/examples/?p=495 Connect to us ( @twitter | @facebook )

XQuery is a concept very similar to SQL. As sql is used to query database tables we can use XQuery to query XML data. Xquery can be used to query XML documents, data which is in XML syntax and databases. Using XQuery we can find XML elements. This can be very useful in situations when [...]

]]> Connect to us ( @twitter | @facebook )

XQuery is a concept very similar to SQL. As sql is used to query database tables we can use XQuery to query XML data. Xquery can be used to query XML documents, data which is in XML syntax and databases. Using XQuery we can find XML elements. This can be very useful in situations when we need to search relevant information in large XML documents or XML data. Using XQuery we can exactly extract informatiuon what we are really looking for. XQuery is a W3C standards.

We will be using the following document to understand the basic of XQuery:

File Name : employees.xml

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

<?xml version="1.0" encoding="ISO-8859-1"?> <employees> <employee vertical="banking"> <id>17452</id> <name>Jason</name> <experience>2</experience> <salary>35000</salary> </employee>   <employee vertical="insurance"> <id>14782</id> <name>Jim</name> <experience>3</experience> <salary>45000</salary> </employee>   <employee vertical="telecom"> <id>12563</id> <name>Charles</name> <experience>4</experience> <salary>55000</salary> </employee> </employees>

Selecting nodes in XQuery

Functions

XQuery uses the doc function to open a XML document.
E.g : doc(“employees.xml”)

Path Expressions

XQuery uses path expressions to traverse a XML document.

E.g: doc(“employees.xml”)/employees/employee/name

The above XQuery produces the following output :

1 2 3

<name>Jason</name> <name>Jim</name> <name>Charles</name>

Predicates

Predicates are used in XQuery to filter data from a XML document.

E.g: doc(“employees.xml”)/employees/employee[salary>45000]

The above XQuery produces the following output :

1 2 3 4 5 6

<employee vertical="telecom"> <id>12563</id> <name>Charles</name> <experience>4</experience> <salary>55000</salary> </employee>

FLWOR

FLWOR can be expanded to “For, Let, Where, Order by, Return”. Consider this example :

1 2 3 4

for $x in doc("employees.xml")/employees/employee where $x/salary>35000 order by $x/name return $x/name

Output

1 2	<name>Jim</name> <name>Charles</name>

Explanation

In the above example :

• The for clause selects all employee elements under employees element into the variable $x
• The where clause selects only those employees whose salary is greater than 35000
• The order by clause determines the sort order based on a named columm
• The return clause determines what value should be returned. Here the name of employees is returned

If-Else construct in XQuery

It is possible to write the IF-Else construct in XQuery using the following syntax:

1 2 3 4

for $x in doc("employees.xml")/employees/employee return if($x/salary gt 35000) then <senior>{data($x/name)}</senior> else <junior>{data($x/name)}</junior>

[Note : The function data is used to extract the value of a node]

Output

1 2 3

<junior>Jason</junior> <senior>Jim</senior> <senior>Charles</senior>

XQuery Comparisons

We can do comparison in XQuery by using two set of operators :

• 1) General comparision operators: =, !=, <, , >=
• 2) Value comparision operators: eq, ne, lt, le, gt, ge

The difference between these two is that the General Operators works for multiple set of values while Value comparision works for a single value

]]> http://www.javabeat.net/2009/03/xquery-syntax/feed/ 0 http://www.javabeat.net/2008/12/what-is-rss-and-atom/ http://www.javabeat.net/2008/12/what-is-rss-and-atom/#comments Fri, 19 Dec 2008 15:18:48 +0000 krishnas http://www.javabeat.net/?p=2234 Connect to us ( @twitter | @facebook )

About this book RSS and Atom are the most widely used of many content syndication formats that have developed over the last few years to address the need to distribute and receive streams of content from websites and applications. Sites syndicate content for a broad variety of reasons, from replacing email as a medium for [...]

]]> Connect to us ( @twitter | @facebook )

About this book

RSS and Atom are the most widely used of many content syndication formats that have developed over the last few years to address the need to distribute and receive streams of content from websites and applications. Sites syndicate content for a broad variety of reasons, from replacing email as a medium for outbound contact to updating satellite sites. Each format has

]]> http://www.javabeat.net/2008/12/what-is-rss-and-atom/feed/ 0 http://www.javabeat.net/2008/07/writing-simple-ant-build-script/ http://www.javabeat.net/2008/07/writing-simple-ant-build-script/#comments Thu, 24 Jul 2008 10:54:33 +0000 JavaBeat http://www.javabeat.net/examples/?p=188 Connect to us ( @twitter | @facebook )

Apache Ant Example This article explains how to write a very basic ANT build script. This does not explain indepth knowledge on building your project using ANT script. But, this writeup will be more useful for the beginners who haben’t writen any ANT script before. Before start writing the script, lets look into how to [...]

]]> Connect to us ( @twitter | @facebook )

Apache Ant Example

This article explains how to write a very basic ANT build script. This does not explain indepth knowledge on building your project using ANT script. But, this writeup will be more useful for the beginners who haben’t writen any ANT script before. Before start writing the script, lets look into how to install the ANT in your machine.

Install Apache Ant

Download the Apache Ant from the link : Download Apache Ant

• Unzip the files into your machine.
• Set your system path variable to ANT’s bin directory. For example d:/projects/ant/bin”
• Set the ANT_HOME in your system variables. ANT_HOME should point to your Ant installation directory. For example “d:/projects/ant”.
• Set JAVA_HOME in your system environment variables.
• Copy tools.jar file into the “JRE/lib” folder.

To test the setup open your command prompt and type as “ant”. You will see a message saying

1 2	Buildfile: build.xml does not exist! Build failed

Set up is done. Let’s look into our first simple example program using ANT script.

This example program shows how to create the JAR file after building all the java files.

1	<project name="sampleProject" basedir="." default="jar">

In the above code “sampleProject” is the project name for this prticular build. We are setting base directory as the current directory by just giving .(dot). We are telling the script to start from “jar” target name. The default attribute is used for setting the starting point for the ANT script.

We call a seperate task as target. We can define as many number of targets inside a build file. If we closely look into the build file, we have many number of targets based its operations. So, our build starts with “jar” target.

Target has depends attribute to indicate, that particular task can be executed only after the certain number of dependencies. In our case, before building the jar file, we have to compile the files. So, jar target calls compile target. That has some dependencies that is executed. Once the build is successful, test.jar will be created in the same directory.

build.xml

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

<?xml version="1.0"?> <project name="sampleProject" basedir="." default="jar"> <property name="src" value="ant-source"/> <property name="output" value="bin"/>   <target name="compile" depends="create"> <javac destdir="bin"> <src path="${src}"/> <classpath refid="java"/> </javac> </target>   <target name="jar" depends="compile"> <jar destfile="test.jar"> <fileset dir="bin"/> </jar> </target>     <target name="clean"> <delete dir="${output}"/> </target>   <target name="create" depends="clean"> <mkdir dir="${output}"/> </target>   <path id="java"> <fileset dir="D:JarsHibernate"> <include name="*.jar"/> </fileset> </path> </project>

]]> http://www.javabeat.net/2008/07/writing-simple-ant-build-script/feed/ 4