xmldatasource XML Data Source Sample Shows how the built-in XPath-based data source could be used for reporting out of XML data. How to fill a report using data from an XML file. 0.6.0 Sanda Zaharia shertage@users.sourceforge.net XML Data Sources

XML documents can be used as report data sources based on appropriate JRDataSource implementations. JasperReports features a built-in XML data source implementation (JRXmlDataSource) that relies on DOM and uses XPath expressions to select data from the XML document.
To instantiate an XML data source, the following inputs are required:
  • An XML document. The parsed document, its location, or its source is provided as an argument to the data source constructor.
  • An XPath expression to select the node set that corresponds to the data source record list. The expression is passed to the data source as a constructor argument. The default XPath expression selects the document node itself. The XPath expression is executed when the data source is instantiated; each item in the resulting node set will generate a record in the data source.
  • An XPath expression to select the field value for every field in the data set, when iterating through records. The field’s XPath expression is provided by the field description (<fieldDescription> element in JRXML).
One interesting particularity of XML data sources is that they can be used to create sub–data sources to be used for subreports or subdatasets, using different XPath expressions to select the appropriate nodes. There are two ways to accomplish this:
  • A sub–data source can be created for a new document that uses the current node as a root node.
  • The same document can be reused for a new sub–data source, which would specify a different XPath expression for the main node set.
XML data sources are created by interpreting XPath expressions and selecting nodes and values from the XML document based on these expressions. Processing XPath expressions relies on a generic service interface called JRXPathExecuter. The XPath executer implementation used by XML data sources can be configured with a JasperReports property named net.sf.jasperreports.xpath.executer.factory. This property gives the name of an XPath executer factory class, which has to implement the JRXPathExecuterFactory.
The XML data source provides localization support for both number and date/time values rendered as text in the wrapped XML document. In order to get the appropriate localization one have to set the following information in the JRXmlDataSource object:
  • the Number pattern - see the setNumberPattern(java.lang.String) method;
  • the Date pattern - see the setDatePattern(java.lang.String) method;
  • the Locale property - see the setLocale(java.util.Locale) method;
  • the time zone - see the setTimeZone(java.util.TimeZone) method.
Patterns should be non-localized and in accordance with the java.text.DecimalFormat and java.text.SimpleDateFormat pattern syntax. If specific patterns are not supplied, the defaults for these two format classes apply.

Before running the sample, please consult the next section regarding the XPath query executer. How to fill reports using embedded XPath queries. 1.2.0 Sanda Zaharia shertage@users.sourceforge.net The XPath Query Executer

XPath (the XML Path language) is an expression language with specific syntax used to navigate through nodes in an XML document and retrieve their information, based on a tree representation of XML documents. When using XML data sources, one can specify an XPath expression that produces the list of nodes/records as the report query:

  <queryString language="xPath"><![CDATA[/Northwind/Orders[CustomerID='ALFKI']]]></queryString>

This query returns a list containing only Orders elements with CustomerID set to ALFKI.

In the case of the XPath language the query executer factory (see the JRXPathQueryExecuterFactory class) registers a parameter named XML_DATA_DOCUMENT of type org.w3c.dom.Document. The XPath query executer (see the JRXPathQueryExecuter class) runs the XPath query against this document and stores the result in an in-memory JRXmlDataSource object. For more information about XML data sources please consult the XML Data Sources above section.

Being an expression language itself, XPath supports parameters. Parameters will be processed and replaced by their java.lang.String values. When creating the JRXmlDataSource instance, the query executer also provides the four additional parameters containing localization settings required by the data source:
  • XML_LOCALE
  • XML_NUMBER_PATTERN
  • XML_DATE_PATTERN
  • XML_TIME_ZONE
In the next section you can see how these additional parameters are set in the fill() method of the /src/XmlDataSourceApp.java class.

For more information about the XPath syntax and queries, one can consult the official documentation: http://www.w3.org/TR/xpath20.

XML Data Source Example

In our example data records are stored as node elements in the data/northwind.xml file.
The <Northwind/> root element contains two children types: <Customers/> and <Orders/>. Below is an example of a <Customers/> entity, completely characterized by the following elements: 

    ALFKI
    Alfreds Futterkiste
    Maria Anders
    Sales Representative
    
Obere Str. 57

    Berlin
    12209
    Germany
    030-0074321
    030-0076545
  
]]>
And below is an example of an <Orders/> entity: 

    10643
    ALFKI
    6
    1997-08-25
    1997-09-22
    1997-09-02
    1
    29.46
    Alfreds Futterkiste
    Obere Str. 57
    Berlin
    12209
    Germany
  
]]>
One can see that an <Orders> element has a <CustomerID> property which points to the <CustomerID> element in the <Customers> node, just like a foreign key in a relational database. One can identify a one-to-many relationship between <Customers> and <Orders>.
In order to navigate through elements in the Northwind.xml document, an XPath query executer implementation should be specified using the net.sf.jasperreports.xpath.executer.factory property. In our case it is set in the src/jasperreports.properties file:

net.sf.jasperreports.xpath.executer.factory=net.sf.jasperreports.engine.util.xml.JaxenXPathExecuterFactory

Two JRXmlDataSource objects are necessary to store the two element types. One of them will be populated with Customers records. In this case record field names are given by the property names in the <Customers/> node:
  • CustomerID
  • CompanyName
  • ContactName
  • Sales Representative
  • ContactTitle
  • Address
  • City
  • PostalCode
  • Country
  • Phone
  • Fax
The other JRXmlDataSource object will be populated with Orders records. For this record type, field names are:
  • OrderID
  • CustomerID
  • EmployeeID
  • OrderDate
  • RequiredDate
  • ShippedDate
  • ShipVia
  • Freight
  • ShipName
  • ShipAddress
  • ShipCity
  • ShipPostalCode
  • ShipCountry
As we'll see later, not all fields above are required by the generated report.

There are two JRXML files in the reports directory. The CustomersReport.jrxml is the main report template. The OrdersReport.jrxml is used for generate subreports for the main report. The main report iterates through available customers in the XML data source, and prints for each of them the Customer ID, the Company Name and the own list of ship orders. The orders list exposes only the Order ID, Order Date, Ship City and Freight fields. For each customer are calculated the orders count and the total freight.
In the CustomersReport.jrxml template the query language and XPath query expression are declared in the <queryString/> expression:

  <queryString language="xPath"><![CDATA[/Northwind/Customers]]></queryString>

The fields required for each Customer in the main report are: 

    CustomerID
  
  
    CompanyName
  
]]>
The OrdersReport subreport is called when the orders list has to be completed for each customers: 

    
    
      $P{XML_DATA_DOCUMENT}
    
    
      $P{XML_DATE_PATTERN}
    
    
      $P{XML_NUMBER_PATTERN}
    
    
      $P{XML_LOCALE}
    
    
      $P{XML_TIME_ZONE}
    
    
      $F{CustomerID}
    
    "OrdersReport.jasper"
  
]]>
The Number pattern, Date pattern, Locale and time zone parameters above are necessary for data formatting. The CustomerID parameter is required in order to filter data in the subreport.

The <queryString/> expression in the reports/OrdersReport.jrxml template is:

  <queryString language="xPath"><![CDATA[/Northwind/Orders[CustomerID='$P{CustomerID}']]]></queryString>

Only Orders with the given CustomerID are taken into account.
The only fields required from an Orders record are: 

	OrderID
  
  
	OrderDate
  
  
	ShipCity
  
  
	Freight
  
]]>
In the src/XmlDataSourceApp.java all necessary information is prepared to be sent at fill time: the parsed Northwind document, data formatting parameters and the CustomersReport compiled report:
Running the Sample

Running the sample requires the Apache Ant library. Make sure that ant is already installed on your system (version 1.5 or later).
In a command prompt/terminal window set the current folder to demo/samples/xmldatasource within the JasperReports source project and run the > ant test view command.
It will generate all supported document types containing the sample report in the demo/samples/xmldatasource/build/reports directory.
Then the report will open in the JasperReports internal viewer.