Developer: Java
   DOWNLOAD
 Oracle XML Publisher
 Oracle Database 10g
 Oracle JDeveloper 10g
 Sample Code
   TAGS
jdeveloper, reporting, All

Integrating Oracle XML Publisher with Oracle JDeveloper 10g


by Deepak Vohra

Published November 2006

Oracle XML Publisher, Oracle's XSL-FO-based reporting tool, is available as a GUI as well as a set of core API components. The following core APIs may be integrated with Oracle JDeveloper 10.1.3 to generate PDF, Excel, HTML, or RTF reports:

  • PDF Form Processing Engine API. Merges a PDF template with XML data to generate a PDF document. RTF Processor. Converts an RTF template to an Extensible Style Language-Formatting Objects (XSL-FO) file, which may then be used as an input to an FO Processor Engine.
  • FO Processor Engine. Merges an XML file (data source file) and an XSLT file (template) to generate PDF, Excel, HTML, and RTF reports.
  • XSL-FO Utility. Generates an XSL-FO file from an XML file and an XSLT file, or from a set of XML and XSLT files. PDF Document Merger. Combines PDF documents and adds page numbering.
  • PDF Book Binder Processor. Merges a set of PDF documents into a single document with chapters, sections, subsections, and a table of contents.
  • Document Processor Engine. Batch-processes the above APIs with a single XML document that specifies templates, datasources, and outputs.

In this article, you’ll learn how to use the FO Processor Engine, the XSL-FO Utility, and the PDF Document Merger. You’ll also get an overview of the Data Engine API, which generates an XML document from a database. The API uses an XML template to specify the SQL queries to the database as well as the structure of the generated XML document.

Some of the Oracle XML Publisher APIs require RTF and PDF templates as inputs. To create an RTF template you’ll need Oracle XML Publisher Desktop, an add-in to Microsoft Word. To create a PDF template, simply define a layout in a Word document and then convert it to PDF with Adobe Acrobat Distiller. Although this article doesn’t discuss the APIs that need RTF and PDF templates, generating reports with them is similar to the procedure used for the Oracle XML Publisher APIs.

Installing Oracle XML Publisher

  • Download Oracle XML Publisher Enterprise 5.6.2 for Microsoft Windows, and extract the zip file XMLP562_WIN.zip to a directory.
  • In Oracle JDeveloper 10.1.3, select File>New to open the New Gallery Wizard.
  • Create a new application by selecting General>Application, and then click the OK button.
  • In the Create Application frame, specify an application name (for example, XMLPublisher), and click OK.
  • In the Create Project frame, specify a project name (for example, XMLPublisher), and click OK. An application and a project will be added to the Applications Navigator.
  • Next, add a Java class to the project by selecting General>Java Class in the New Gallery frame.
  • In the Create Java Class frame, specify a class name (for example, XMLPublisher), and a package name (for example, ‘xmlpublisher’), and click the OK button. A Java class will be added to the Oracle XML Publisher project.
  • In this article, you’ll create a PDF report from an XML document. So, add an XML document to the project by selecting General>XML>XML Document in New Gallery frame.

You’ll add other XML and XSLT documents to the project in the following sections. Figure 1 shows the directory structure of the Oracle XML Publisher project:

Figure 1
Figure 1: Oracle XML Publisher project directory structure.
  • Next, add the Oracle XML Publisher API’s Jar files to the Oracle XML Publisher project by selecting Tools>Project Properties.
  • In the Project Properties frame, select Libraries.
  • Add Jar files with the Add Jar/Directory button. The Oracle XML Publisher Jar files are in the <XMLP562_WIN>\manual\lib directory;  <XMLP562_WIN> is the directory where the Oracle XML Publisher zip file is installed.
  • Use the Add Library button to add the Oracle JDBC library, which you’ll need to establish a JDBC connection with Oracle Database. Click OK.

Figure 2 shows the Jar files/libraries in the Oracle XML Publisher project:

Figure 2
Figure 2: Oracle XML Publisher project libraries.

Download and install Oracle Database 10g, and create a database instance including the sample schemas. Then, create an example database table in the OE schema with the SQL script as shown below.

CREATE TABLE OE.Catalog(CatalogId VARCHAR(25) PRIMARY KEY, 
Journal VARCHAR(25), Publisher VARCHAR(25),
Edition VARCHAR(25), Title Varchar(45), Author Varchar(25));

INSERT INTO OE.Catalog VALUES('catalog1', 'Oracle Magazine', 'Oracle Publishing', 
'March-April 2006', 'Commanding ASM', 'Arup Nanda');

INSERT INTO OE.Catalog VALUES('catalog2', 'Oracle Magazine', 'Oracle Publishing', 
'May-June 2006', 'Tuning Your View Objects', 'Steve Muench');

INSERT INTO OE.Catalog VALUES('catalog3', 'Oracle Magazine', 'Oracle Publishing', 
'May-June 2006', 'Managing Oracle Portal', 'Aradhana Puri');

FO Processor Engine

The FO Processor Engine API is used to generate a PDF, Excel, HTML or RTF report from an XML file and an XSLT file. In this section, we’ll create a PDF document. The input XML document for the PDF report is shown below.

<?xml version="1.0" encoding="UTF-8"?>
<!--A Oracle Magazine Catalog--> 
<catalog  title="Oracle Magazine" publisher="Oracle Publishing"> 

  <magazine date="March-April 2006"> 
  <article>
    <title>Using Bind Variables</title>
    <author>Steve Muench</author> 
   </article>
  <article>
    <title>Commanding ASM</title>
    <author>Arup Nanda</author> 
   </article>
  
  </magazine>
  <magazine date="May-June 2006"> 
  <article>
    <title>Tuning Your View Objects</title>
    <author>Steve Muench</author> 
  
   </article>
  <article>
    <title>Managing Oracle Portal</title>
    <author>Aradhana Puri</author> 
   </article>

  </magazine>
</catalog>

To generate a PDF report, you’ll need an XSL-FO file. Formatting objects are explained in the XSL specification. Here you'll define an XSLT style sheet that will convert the XML file to an XSL-FO file. We’ll then convert that file to a report by using the FO Processor Engine.

An XSL-FO file specifies how data will be formatted in a report, including layout, fonts, and tables. Elements in an XSL-FO file are in the ‘fo’ prefix namespace, which is specified with the namespace declaration xmlns:fo=http://www.w3.org/1999/XSL/Format. The DTD for an XSL-FO file is available from fo.zip.

You can validate an XSL-FO file with an XML schema by converting the DTD for an XSL-FO file to an XML schema. Oracle JDeveloper can register the XML schema for XSL-FO files and generate or validate instances of XSL-FO files. Validating an XSL-FO file implies checking the format of the XSL-FO file. Some of the elements in the XSL-FO file are shown in Table 1.

Table 1. XSL-FO Document Elements

Element Description

fo:root

Root element in an XSL-FO document

fo:layout-master-set

Specifies a set of page masters

fo:simple-page-master

Page layout

fo:page-sequence

Specifies the order of page masters

fo:flow

Page content

fo:block

Block content

fo:list-block

Specifies a list

fo:list-item

List item

fo:table

Table

fo:table-column

Table column

fo:table-header

Table header

fo:table-body

Table body

fo:table-row

Table row

fo:table-cell

Table cell

The example XSLT style sheet, catalog.xsl, is used to generate an XSL-FO file from the input XML file, catalog.xml.

catalog.xsl

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.1" 
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
    xmlns:fo="http://www.w3.org/1999/XSL/Format">
  <xsl:output method="xml" version="1.0" 
  omit-xml-declaration="no" indent="yes"/>
  <!-- ========================= -->
  <!-- root element: catalog -->
  <!-- ========================= -->
  <xsl:template match="/catalog">
    <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format">
      <fo:layout-master-set>
        <fo:simple-page-master master-name="simpleA4" page-height="29.7cm"
                    page-width="21cm" margin-top="2cm" margin-bottom="2cm" 
         margin-left="2cm" margin-right="2cm">
          <fo:region-body/>
        </fo:simple-page-master>
      </fo:layout-master-set>
      <fo:page-sequence master-reference="simpleA4">
        <fo:flow flow-name="xsl-region-body">
          <fo:block font-size="16pt" font-weight="bold" space-after="5mm">
             Catalog:  <xsl:value-of select="@title"/>
          </fo:block>
 <fo:block font-size="16pt" font-weight="bold" space-after="5mm">
             Publisher:  <xsl:value-of select="@publisher"/>
          </fo:block>
          <fo:block font-size="10pt">
           

 <fo:table table-layout="fixed">
              <fo:table-column column-width="4cm"/>
              <fo:table-column column-width="4cm"/>
              <fo:table-column column-width="5cm"/>
            <fo:table-header>
<fo:table-row font-weight="bold"><fo:table-cell>
        <fo:block>
          <xsl:text>Date</xsl:text>
        </fo:block>
      </fo:table-cell>
 <fo:table-cell>
        <fo:block>
          <xsl:text>Title</xsl:text>
        </fo:block>
      </fo:table-cell>
<fo:table-cell>
        <fo:block>
          <xsl:text>Author</xsl:text>
        </fo:block>
      </fo:table-cell>
 </fo:table-row>

</fo:table-header>

  <fo:table-body>
               <xsl:apply-templates select="magazine"/>
              </fo:table-body>
            </fo:table>
          </fo:block>
        </fo:flow>
      </fo:page-sequence>
    </fo:root>
  </xsl:template>
 
 <xsl:template match="magazine">  
 
 <xsl:for-each select="article">
 <fo:table-row>
         <fo:table-cell>
        <fo:block>
          <xsl:value-of select="../@date"/>
        </fo:block>
      </fo:table-cell>
      <fo:table-cell>
        <fo:block>
          <xsl:value-of select="title"/>
        </fo:block>
      </fo:table-cell>
      <fo:table-cell>
        <fo:block>
          <xsl:value-of select="author"/>
        </fo:block>
      </fo:table-cell>
    </fo:table-row>
  
</xsl:for-each>
  </xsl:template>
</xsl:stylesheet>

Next, you’ll develop a Java application to generate reports with the Oracle XML Publisher APIs. In the XMLPublisher.java class, import the Oracle XML Publisher classes:

import oracle.apps.xdo.template.FOProcessor;
import oracle.apps.xdo.template.fo.util.FOUtility;
import oracle.apps.xdo.common.pdf.util.PDFDocMerger;
import oracle.apps.xdo.dataengine.DataProcessor;
import oracle.apps.xdo.XDOException;

Create an FOProcessor object. The FOProcessor class is the main class for using the FO Processing Engine.

FOProcessor processor = new FOProcessor();

Set the input XML file:

processor.setData("catalog.xml");

Set the XSLT template:

processor.setTemplate("catalog.xsl");

Set the output file and the output format for a PDF document:

processor.setOutput("catalog.pdf");
processor.setOutputFormat(FOProcessor.FORMAT_PDF);

Table 2 lists the supported output formats.

Table 2. FO Processor Output Formats

Output Format Description

FORMAT_AWT

AWT format

FORMAT_EXCEL

Excel spreadsheet format

FORMAT_HTML

HTML format

FORMAT_PDF

PDF format

FORMAT_RTF

RTF format

FORMAT_UIX

UIX format

If an HTML output is required, specify an HTML output file and an HTML output format:

processor.setOutput("catalog.html"); 
processor.setOutputFormat(FOProcessor.FORMAT_HTML);

Run the FO Processor Engine:

processor.generate();

You’ll find the PDF report, catalog.pdf, which was generated with the FO Processor Engine, in the sample code zip.

XSL-FO Utility

In the previous section, you generated an Oracle XML Publisher report from an XML file and an XSLT file. The input can also be a set of XML files and XSLT files. The XSL-FO Utility generates an XSL-FO file from a set of input XML and XSLT files.

For example, let’s create an XSL-FO file from the following two input XML files, catalog2.xml and catalog3.xml.

catalog2.xml

<?xml version="1.0" encoding="UTF-8"?>
<!--A Oracle Magazine Catalog--> 
<catalog  title="Oracle Magazine" publisher="Oracle Publishing"> 

  <magazine date="July-August 2006"> 
  <article>
    <title>Archiving Data Using XML</title>
    <author>Arup Nanda</author> 
   </article>
  </magazine>
</catalog>

catalog3.xml

<?xml version="1.0" encoding="UTF-8"?>
<!--A Oracle Magazine Catalog--> 
<catalog  title="Oracle Magazine" publisher="Oracle Publishing"> 
  <magazine date="July-August 2006"> 
  <article>
    <title>XML in Databases</title>
    <author>Ari Kaplan</author> 
   </article>
  
  </magazine>
  <magazine date="Sept-Oct 2006"> 
  <article>
    <title>Harnessing the Active Data Model</title>
    <author>Steve Muench</author>
   </article>
  </magazine>
</catalog>

We’ll use the XSLT file, catalog.xsl, to generate XSL-FO files for the input XML files, and then merge the XSL-FO files to generate a single XSL-FO file.

Create an array of InputStream objects for the XSL-FO files to be generated from the input XML and XSLT files:

InputStream[] input = new  InputStream[2];

Create XSL-FO files from the input XML and XSLT files with the XSL-FO Utility’s main class FOUtility. Use the static method createFO(java.lang.String xmlFile,java.lang.String xslFile) to create the XSL-FO files:

InputStream firstFOStream =  FOUtility.createFO("catalog2.xml", 
"catalog.xsl");InputStream secondFOStream = 
FOUtility.createFO("catalog3.xml",  "catalog.xsl");

Set the XSL-FO InputStream objects in the InputStream array:

Array.set(input, 0,  firstFOStream);
Array.set(input, 1, secondFOStream);

Merge the XSL-FO InputStream objects using the static method mergeFOs():

InputStream mergedFOStream = FOUtility.mergeFOs(input, null);

Create an FOProcessor object to generate a PDF report from the merged XSL-FO file:

FOProcessor processor = new  FOProcessor();

Set the merged XSL-FO InputStream on the FOProcessor object:

processor.setData(mergedFOStream);

If an XSL-FO file is specified as the datasource to an FOProcessor, you don’t need to set an XSLT document. Set the XSLT template to null:

processor.setTemplate((String)null);

Set the output PDF file and the output format, and generate a PDF report:

processor.setOutput("catalog2.pdf");
processor.setOutputFormat(FOProcessor.FORMAT_PDF);
processor.generate();

You’ll find the PDF report, catalog2.pdf, which was generated from the merged XSL-FO InputStream, in the sample code.

PDF Document Merger

Sometimes, you have to merge PDF documents. The PDF Document Merger combines PDF documents and optionally adds page numbering to the merged document. In this section, we’ll merge catalog.pdf and catalog2.pdf, which we generated in the previous sections.

First, create an InputStream array from catalog.pdf and catalog2.pdf:

FileInputStream[] inputStreams = new FileInputStream[2];
inputStreams[0] = new FileInputStream("catalog.pdf");
inputStreams[1] = new  FileInputStream("catalog2.pdf");

Create a FileOutputStream for the merged PDF document:

FileOutputStream  outputStream = new FileOutputStream("catalog3.pdf");

Merge the PDF documents with the PDFDocMerger class:

PDFDocMerger pdfMerger =  new PDFDocMerger(inputStreams, outputStream);

To add page numbering, specify the page numbering coordinates and the page numbering font:

pdfMerger.setPageNumberCoordinates(300, 20);
pdfMerger.setPageNumberFontInfo("Courier", 10);

Set the page numbering value with the setPageNumberValue(int initialValue, int startPageIndex) method. The initialValue specifies the initial value of page numbering. The startPageIndex specifies the page number from which numbering should start:

pdfMerger.setPageNumberValue(1, 1);

Run the PDF Document Merger:

pdfMerger.process();

You’ll find the merged PDF document, catalog3.pdf, in the sample code.

Data Engine

The Data Engine API creates an XML document from database data. The DataProcessor class is used to generate an XML document from a data template. This template is an XML file that specifies the input parameters, the SQL query to retrieve data from the database, and the data structure of the XML document to be generated. One advantage of the Data Engine API over the XML SQL Utility (which also generates an XML document from a database) is that it lets you generate a hierarchy of elements in an XML document. Table 3 shows some of the commonly used elements in the data template.

Table 3. Data Template Elements

Element Description Attributes

dataTemplate (Required)

Root element

name(required)
version(required)

parameters

Specifies input parameters to the SQL query. Consists of <parameter> elements. Parameter values may be set at runtime.

name(required)
dataType - values may be “character”, “date” or “number”. Default value is “character”.

dataQuery(Required)

Specifies the SQL queries to retrieve data from the database. Consists of <sqlstatement> elements.

-

sqlstatement (Required)

Specifies the SQL statement.

name(required)

dataStructure(Required for multiple queries)

Defines structure of output XML. Consists of <group> and <element> elements. If not specified for a single query, the output XML consists of elements corresponding to the columns in the SQL query.

-

group

Specifies a group of elements and subgroups. Hierarchies of elements may be specified with subgroup elements.

name(required)
source(required) - Specifies the query identifier for the corresponding SQL statement from which the group’s elements are derived.

element (Required)

Specifies an element in output XML document

name(required)
value(required) - Specifies the column name for the SQL statement.

This example data template, catalogDataTemplate.xml, is used to generate an XML document from the database table:

catalogDataTemplate.xml

<?xml version="1.0" encoding="WINDOWS-1252" ?> 
 <dataTemplate name="catalogDataTemplate" description="Magazine 
Catalog" defaultPackage="" Version="1.0">
 <parameters>
 <parameter name="id" dataType="character" /> 
 </parameters>
 <dataQuery>
 <sqlStatement name="Q1">
 <![CDATA[ 
   SELECT CatalogId, Journal, Publisher, Edition, Title, 
   Author from OE.CATALOG WHERE CatalogId=:id]]> 
  </sqlStatement>
  </dataQuery>
  <dataStructure>
  <group name="G_Catalog" source="Q1">
  <element name="CATALOGID" value="CatalogId" /> 
  <element name="JOURNAL" value="Journal" /> 
  <element name="PUBLISHER" value="Publisher"/> 
  <element name="EDITION" value="Edition" /> 
  <element name="TITLE" value="Title"/> 
  <element name="AUTHOR" value="Author" /> 
  </group>
  </dataStructure>
  </dataTemplate>

The example data template specifies a parameter, id, of type character. Bind variable is used in the SQL query to set the value of the CatalogId column with the id parameter. The value of the CatalogId column is set at runtime. All the columns in the example query are of type VARCHAR. The following column type may be specified in a SQL query: VARCHAR2, CHAR, NUMBER, DATE, TIMESTAMP, BLOB, CLOB, and XMLType.

Next, we’ll generate an XML document from database data with the Data Engine API. First, create a DataProcessor object:

DataProcessor dataProcessor  = new DataProcessor();

Set the data template on the DataProcessor object:

dataProcessor.setDataTemplate("catalogDataTemplate.xml");

Specify values for parameters and set the parameters on the DataProcessor object:

Hashtable parameters = new Hashtable();
parameters.put("id","catalog1");
dataProcessor.setParameters(parameters);

Create a JDBC connection with Oracle Database and set the connection on the DataProcessor object:

Class.forName("oracle.jdbc.OracleDriver");
String url="jdbc:oracle:thin:@localhost:1521:ORCL";
java.sql.Connection jdbcConnection = DriverManager.getConnection(url,
                   "OE", "password");
dataProcessor.setConnection(jdbcConnection);

Set the output XML document and run the data processor:

dataProcessor.setOutput("catalogData.xml");
dataProcessor.processData();

The database generates an XML document, catalogData.xml, as shown below:

<?xml version="1.0" encoding="UTF-8"?>

<catalogDataTemplate>
<id>catalog1</id>
<LIST_G_CATALOG>
<G_CATALOG>
<CATALOGID>catalog1</CATALOGID>
<JOURNAL>Oracle Magazine</JOURNAL>
<PUBLISHER>Oracle Publishing</PUBLISHER>
<EDITION>March-April 2006</EDITION>
<TITLE>Commanding ASM</TITLE>
<AUTHOR>Arup Nanda</AUTHOR>
</G_CATALOG>
</LIST_G_CATALOG>
</catalogDataTemplate>

Here's the XMLPublisher.java class:

package xmlpublisher;

import com.sun.java.util.collections.Hashtable;

import oracle.apps.xdo.XDOException;
import oracle.apps.xdo.common.pdf.util.PDFDocMerger;
import oracle.apps.xdo.dataengine.DataProcessor;
import oracle.apps.xdo.template.FOProcessor;
import oracle.apps.xdo.template.fo.util.FOUtility;

import oracle.xml.parser.v2.NSResolver;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStream;

import java.lang.reflect.Array;

import java.sql.DriverManager;
import java.sql.SQLException;


public class XMLPublisher {
    public XMLPublisher() {
    }

    public void foProcessorEngine() {
        try {
            FOProcessor processor = new FOProcessor();
            processor.setData("catalog.xml");
            processor.setTemplate("catalog.xsl");
            processor.setOutput("catalog.pdf");
            processor.setOutputFormat(FOProcessor.FORMAT_PDF);

            processor.generate();
        } catch (XDOException e) {
            System.out.println("XDOException " + e.getMessage());
        }
    }

    public void xslFoUtility() {
        try {
            InputStream[] input = new InputStream[2];
            InputStream firstFOStream =  FOUtility.createFO("catalog2.xml", "catalog.xsl");
            InputStream secondFOStream = FOUtility.createFO("catalog3.xml",  "catalog.xsl");
            Array.set(input, 0, firstFOStream);
            Array.set(input, 1, secondFOStream);

            InputStream mergedFOStream = FOUtility.mergeFOs(input, null);

            if (mergedFOStream == null) {
                System.out.println("Merge failed.");
            }

            FOProcessor processor = new FOProcessor();
            processor.setData(mergedFOStream);
            processor.setTemplate((String) null);
            processor.setOutput("catalog2.pdf");
            processor.setOutputFormat(FOProcessor.FORMAT_PDF);
            processor.generate();
        } catch (XDOException e) {
            System.out.println("XDOException" + e.getMessage());
        }
    }

    public void pdfDocumentMerger() {
        try {
            FileInputStream[] inputStreams = new FileInputStream[2];
            inputStreams[0] = new FileInputStream("catalog.pdf");
            inputStreams[1] = new FileInputStream("catalog2.pdf");

            FileOutputStream outputStream = new FileOutputStream("catalog3.pdf");
            PDFDocMerger pdfMerger = new PDFDocMerger(inputStreams, outputStream);

            pdfMerger.setPageNumberCoordinates(300, 20);
            pdfMerger.setPageNumberFontInfo("Courier", 10);
            pdfMerger.setPageNumberValue(1, 1);
            pdfMerger.process();
            pdfMerger = null;
        } catch (XDOException e) {
            System.out.println("XDOException" + e.getMessage());
        } catch (FileNotFoundException e) {
            System.out.println("FileNotFoundException " + e.getMessage());
        }
    }

    public void dataEngine() {
        try {
            Class.forName("oracle.jdbc.OracleDriver");

            String url = "jdbc:oracle:thin:@localhost:1521:ORCL";
            java.sql.Connection jdbcConnection = DriverManager.getConnection(url,
                    "OE", "password");

            DataProcessor dataProcessor = new DataProcessor();
            dataProcessor.setDataTemplate("catalogDataTemplate.xml");

            Hashtable parameters = new Hashtable();
            parameters.put("id", "catalog1");
            dataProcessor.setParameters(parameters);
            dataProcessor.setConnection(jdbcConnection);

            dataProcessor.setOutput("catalogData.xml");
            dataProcessor.processData();
        } catch (SQLException e) {
            System.out.println("SQLException " + e.getMessage());
        } catch (ClassNotFoundException e) {
            System.out.println("ClassNotFoundException " + e.getMessage());
        } catch (XDOException e) {
            System.out.println("XDOException" + e.getMessage());
        }
    }

    public static void main(String[] argv) {
        XMLPublisher xmlPublisher = new XMLPublisher();
        xmlPublisher.foProcessorEngine();
        xmlPublisher.xslFoUtility();
        xmlPublisher.pdfDocumentMerger();
        xmlPublisher.dataEngine();
    }
}

Next, run the Oracle XML Publisher application. Right-click the XMLPublisher.java class and select Run, as shown in Figure 3. This will generate PDF and XML reports:

Figure 3
Figure 3. Running XMLPublisher.java.

If the output format in the FO Processor Engine section is set to HTML, it will generate an output HTML report, as shown in Figure 4:

Figure 4
Figure 4. HTML report.

The XMLPublisher APIs that are not discussed may also be integrated with a similar procedure.

  • The XML Publisher class for PDF Form Processing Engine is oracle.apps.xdo.template.FormProcessor
  • The class for RTF Processor is oracle.apps.xdo.template.RTFProcessor
  • The class for Document Processor is oracle.apps.xdo.batch.DocumentProcessor
  • And, the class for PDF Book Binder Processor is oracle.apps.xdo.template.pdf.book.PDFBookBinder

Conclusion

Congratulations, you have  integrated Oracle XML Publisher APIs with Oracle JDeveloper to generate PDF, Excel, HTML, and XML reports.


Deepak Vohra ( dvohra09@yahoo.com) is a NuBean Consultant, a web developer, a Sun Certified Java Programmer, and an Oracle Certified Associate.