Interoperability is the key to fulfillment of the Web services promises. In heterogeneous environments, incompatibility issues might be encountered at the protocol level (beyond basic HTTP), the message level (data type conversion across platforms), or the WSDL level (quality of services). The WS-I organization specifies what it means for a Web services framework to be interoperable via the WS-I Basic Profile. The WS-I Basic Profile 1.0^[3]mandates support for SOAP 1.1, WSDL 1.1, HTTP 1.1, HTTP binding (or HTTPS), and XML Schema (Parts 1 and 2). The Oracle AS Web Service framework is compliant with WS-I Basic Profile 1.0, but also focuses pragmatically on interoperability with the specifics of other vendors and open source frameworks.

Web Services security ensures transport-level security (TLS), as well as message-level security (MLS) and furnishes the following services: identification, authentication, authorization, data integrity, confidentiality, and nonrepudiation. The Oracle AS (OC4J) 10.1.3 Web services implements WS-Security and integrates it with the Oracle Web Services Manager (see later) and enterprise security frameworks, such as JAAS Security Provider (Oracle SSO integration), Oracle Identity Management (SAML token propagation, SSO support), third-party LDAP, COREid Access, and COREid Identity. The Oracle Web Services Manager tool lets you secure database Web services via WS-Security using agents and gateways and/or Oracle Enterprise Manager.

The Oracle Web Services Manager (OWSM) furnishes Web services access control, single sign-on, centralized security policy management, enforcement of regulations (e.g., Sarbanes-Oxley, Gramm-Leach-Bliley, and HIPAA), monitoring of WS-Security, and Web Services Reliable Messaging. These features are exposed through a series of Java Management Extensions (JMX) Management beans (Mbeans). The Policy Manager allows configuring operational rules and propagating them to the enforcement components. The Monitoring Dashboard collects data from gateways and agents and displays results in a graphical format.

Reliable messaging for SOAP-based Web services ensures that the message is sent at least once (guaranteed delivery), sent at most once (guaranteed duplicate elimination), sent exactly once (guaranteed delivery and duplicate elimination), and received in the same sequence (message ordering). The Oracle Application Server Web Services currently implements the OASIS standard WS-Reliability, and Oracle is working as part of the OASIS WSReliableExchange group to converge WS-Reliability with WS-ReliableMessaging to ensure an interoperable, industry-wide adopted reliable messaging standard (WS-RX). In the meantime, the Oracle database as Web services provider can benefit from WS-Reliability; however, the Web Services requester’s framework must also support WS-Reliability.

Auditing allows saving and accessing copies of SOAP requests, responses, and fault messages at both the client and server ends.

Logging allows administrators to log parts of the SOAP messages at the provider end. The configuration is accomplished as follows:

BPEL is the emerging standard for business process definition; think of it as the workflow for Web services. The Oracle BPEL Process Manager^[4] (BPEL PM) supports RPC encoded and document literal message formats. A database Web service can be part of a complex Web service workflow process orchestrated by the BPEL PM.

WSIF provides a standard API allowing the Web service client to use native protocols such as RMI, IIOP, or JDBC, instead of SOAP, for interacting with the server (in connected environments). Adding WSIF binding to the WSDL enables supporting other protocols, in addition to HTTP, JMS, and UDP. Database Web services can be reached directly through WSIF. See Chapter 9 of the Oracle Application Server, Advanced Web Services Developer’s Guide 10 g Release 3 (10.1.3) for more details.

The other new features and enhancements in 10.1.3 include the following:

See the Oracle Application Server, Web Services Developer’s Guide 10 g Release 3 (10.1.3) for more details.

The service implementation in the database manipulates SQL types while the Web services manipulate XML types. Table 15.1 summarizes SQL types mapping to XML types according to the message style (i.e., Literal or Encoded).

A PL/SQL stored procedure or a SQL statement can be mapped into one or several Web service operations. Typically, a SQL query or a PL/SQL function (i.e., <name>), which returns a REF CURSOR, will be mapped to the following methods: <name>Beans, <name>XMLRowSet, and<name>XMLSource:

First, download the latest release of JDeveloper (i.e., jdevstudio1013.zip) from the Oracle Technology Network (see OC4J download link). JDeveloper installation consists of unzipping the download object. Upon the installation, launch the IDE by clicking on its icon.

Assume you have a running JDeveloper, and now you need to:

The following screenshots illustrate the various steps for assembling the PL/SQL Web service from the package; alternatively, you may create the Web service from a project.

Step 0: This initial step consists of opening the database schema by right-clicking on the database connection in the navigator and locating the existing packages.

Step 1: Right-click on the desired package and select “Publish as Web Service” to launch the PL/SQL Web Services wizard. Accept or set the Web services name and the Java package.

Step 2: As Figure 15.4 depicts, the wizard lets you specify the Web service name, the Java package for the service wrapper, and the binding options: SOAP 1.1, SOAP 1.2, and WSIF. For this demo, accept or edit the default and go to the next step.

Figure 15.4. PL/SQL Web Services: Name,Package, and Binding

Step 3: As depicted by Figure 15.5, the wizard lets you choose the message format; accept the default SOAP message format (i.e., Document Wrapped).

Figure 15.5. PL/SQL Web Services: Message Format

Step 4: As depicted by Figure 15.6, the wizard lists all the functions in the package. Select/check the ones you want to be accessible as service operations and go to the next step.

Figure 15.6. PL/SQL Web Services: Operations Selection

Step 5: As depicted by Figure 15.7, the wizard lets you specify the type mappings. Click on the Help button at the bottom of the screen for more details on the various choices. For this demo, we’ll accept the default settings and go to the next step.

Figure 15.7. PL/SQL Web Services: Type-Mapping Options

Step 6: Optionally, as depicted by Figure 15.8, you may specify the user-defined type mapping between SQL or PL/SQL types and Java wrapper classes, as discussed in Chapter 13 and summarized in Table 13.2. You may also specify the mapping of the PL/SQL types unsupported by JDBC or the Web services framework, using the in-database conversion approach covered in Chapter 13. This demo does not have such a requirement, so you can go to the next step.

Figure 15.8. PL/SQL Web Services: User-Defined Type Mapping

Step 7: During this step, as depicted by Figure 15.9, you may specify user-defined SOAP message handlers. These classes are used to process request messages (client handlers) and response messages (server handlers) and implement logging, auditing, and encryption/decryption. There is no user-defined handler for this demo, so click on the Next or Finish button to trigger the generation of the Web service.

Figure 15.9. PL/SQL Web Services: SOAP Message Handler

At this stage, the WSDL has been generated, as depicted by Figure 15.10, which shows a nice structure of the WSDL, including the services, bindings, port types, and messages. Chapter 14 explains the meaning of each component of the WSDL. See, in the following text, the actual values of the services, bindings, port types, and message components of the PL/ SQL Web Services WSDL.

Figure 15.10. PL/SQL Web Services: WSDL Structure

The following XML fragment specifies the mapping of SQL NUMBER to XML decimal:

<element name="pono" type="decimal" nillable="true"/>

The following XML fragment specifies the mapping of SYS.XMLTYPE to XML any (literal style):

 <element name="result" nillable="true">
       <complexType>
           <sequence> <any/> </sequence>
        </complexType>
 </element>

Step 8: Deploy the PL/SQL Web service; as depicted in Figure 15.11, right-clicking and selecting Run on the WSDL results in the deployment of the generated Java proxy representing the PL/SQL package at the returned endpoint. In this example, the Web service has been deployed against the embedded OC4J in JDeveloper, but, depending on the application server connection specified, you may deploy against a stand-alone OC4J or a full-fledged Oracle Application Server.

Figure 15.11. PL/SQL Web Services Deployment

The wizard returns the endpoint at which the PL/SQL Web service is listening:

http://kmensah-lap1:8988/DBWS-PLSQLWS-context-root/
PLSQLWSSoapHttpPort

Step 9 (Optional): At this stage, you may add quality of services, such as security, reliability, logging, auditing, and analyze the WSDL for WS-I interoperability, using the Web Services Editor, as depicted in Figures 15.12 and 15.13.

Figure 15.12. Web Services Editor: Reliability

Figure 15.13. Web Services Editor: Security

These quality of services can also be added using Oracle Enterprise Manager 10g Application Control.

As depicted in Figure 15.14, a browser-based test page (i.e., Web Service Home Page) has been generated at the following endpoint:

Figure 15.14. PL/SQL Web Service Test Page

http://kmensah-lap1:8988/DBWS-PLSQLWS-context-root/
PLSQLWSSoapHttpPort

Step 10: Invoking the Web service through the test page. As illustrated by Figure 15.15, you can invoke the service using the purchase order number.

Figure 15.15. Invoking PL/SQL Web Service through the Test Page

As illustrated by Figure 15.16, you can see the SOAP request and the SOAP response messages:

Figure 15.16. PL/SQL Web Service Request and Response SOAP Messages

SOAP Request
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/
envelope/">
    <soap:Body xmlns:ns1="http://dbconnection1/PLSQLWS.wsdl/
types/">
        <ns1:getpoElement>
            <ns1:pono>2004</ns1:pono>
        </ns1:getpoElement>
    </soap:Body>
</soap:Envelope>

SOAP response
<?xml version="1.0" encoding="UTF-8"?>
<env:Envelope xmlns:env="http://schemas.xmlsoap.org/soap/
envelope/" xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:ns0="http://dbconnection1/PLSQLWS.wsdl/types/
"><env:Body><ns0:getpoResponseElement><ns0:result><PORDER
PONUM="2004"> <CLIENT> <CLNUM>2000</CLNUM> <CLNAME>Bobo
Lafleur</CLNAME> <ADDRESS> <STREET>24 Cartoon Drive </STREET>
<CITY>San Francisco</CITY> <STATE>CA</STATE> <ZIP>94313</ZIP>
</ADDRESS> <PHONES> <VARCHAR2>415-666-0000</VARCHAR2> </
PHONES> </CLIENT> <ORDERDATE>10-FEB-06</ORDERDATE>
<SHIPDATE>12-FEB-06</SHIPDATE> <LITEMS> <LITEM_TYP
ItemNum="1"> <ITEM StockNo="1324"> <PRICE>199</PRICE>
<TAXRATE>8</TAXRATE> </ITEM> <QUANTITY>11</QUANTITY>
<DISCOUNT>10</DISCOUNT> </LITEM_TYP> <LITEM_TYP ItemNum="2">
<ITEM StockNo="2324"> <PRICE>299</PRICE> <TAXRATE>8</TAXRATE>
</ITEM> <QUANTITY>22</QUANTITY> <DISCOUNT>20</DISCOUNT>  </
LITEM_TYP> </LITEMS> <SHIPTOADDRESS/> </PORDER></
ns0:result></ns0:getpoResponseElement></env:Body></
env:Envelope>

At this stage, the PL/SQL Web service has been deployed and listening for incoming requests at its endpoint. But remember, Web services are about application-to-application interaction using XML messaging such as SOAP, and the client application can be implemented in any language and reside on any platform. As a Web service assembler (“developer” is not appropriate here), you certainly don’t want to code to SOAP; fortunately, most Web services frameworks furnish tools/utilities that generate the client proxy specific to the Web service client framework from the WSDL (i.e., a Java proxy for a Java Web services framework, a .NET proxy code for .NET framework). So, for this demo to be complete, the next section takes you through the generation of a Java client proxy from the PL/SQL Web service WSDL.

Step 1: Generate the proxy template.

JDeveloper lets you specify the target platform hosting the service, since the Web service may be hosted on the embedded OC4J, a stand-alone OC4J, or a full-fledged Oracle Application Server.

For this demo, we have deployed the service on the embedded OC4J in JDeveloper, so right-click on the PLSQLWS.wsdl, and select Generate Web Service Proxy; accept the default and proceed to the generation of the Java proxy. And here is the generated PLSQLWSSoapHttpPortClient.java.

PLSQLWSSoapHttpPortClient.java
==============================
package dbconnection1;

import oracle.webservices.transport.ClientTransport;
import oracle.webservices.OracleStub;
import javax.xml.rpc.ServiceFactory;
import javax.xml.rpc.Stub;

import oracle.xml.parser.v2.XMLElement;

...
public class PLSQLWSSoapHttpPortClient {

/**
  * @param args
  */
   public static void main(String[] args) {
   try
   {
      dbconnection1.PLSQLWSSoapHttpPortClient myPort =
         new dbconnection1.PLSQLWSSoapHttpPortClient();
      System.out.println("calling " + myPort.getEndpoint());
      // Add your own code here

    } catch (Exception ex) {
            ex.printStackTrace();
    }
 }
}

The code generator cannot guess which parameter to use from the client application, so this is the only place where you need a little Java expertise to come up with the following instruction to invoke the service with the appropriate parameter (as we did using the test page).

((XMLElement)myPort.getpo(new
java.math.BigDecimal("2004"))).print(System.out);

Update the proxy code as follows:

/**
  * @param args
  */
   public static void main(String[] args) {
   try
   {
      dbconnection1.PLSQLWSSoapHttpPortClient myPort =
         new dbconnection1.PLSQLWSSoapHttpPortClient();
      System.out.println("calling " + myPort.getEndpoint());
      // Add your own code here
      ((XMLElement)myPort.getpo(new
          java.math.BigDecimal("2004"))).print(System.out);

    } catch (Exception ex) {
            ex.printStackTrace();
    }
}

Note: You also need to accept the following import statement that JDeveloper has inserted in the resulting PLSQLWSSoapHttpPortClient.java:

import oracle.xml.parser.v2.XMLElement;

Save and proceed to step 2.

Step 2: Compile and run the Web Services Proxy.

To see the HTTP traffic between the WS Proxy and the WS, select “HTTP Analyzer” in the View panel. Then, in the application navigation panel, right-click on PLSQLWSSoapHttpPortClient.java and select Run. As depicted in Figure 15.17, you will see the SOAP request (same as in the test page case) and the SOAP response (more nicely displayed than in the test page invocation).

Figure 15.17. PL/SQL Web Services Invocation from Proxy

That’s it.

The following restrictions apply to PL/SQL Web services generation using JDeveloper (some of these limitations are specific to JDeveloper):

This concludes the wizard-driven approach for assembling PL/SQL Web services. The next section introduces you to the command-line approach, which supports more database programming models than JDeveloper, including PL/SQL, Java in the database (see Part I), SQL query, SQL DML, and streams AQ.

Provide the PL/SQL package and the information described in the Prerequisites section as input to the Web Services Assembler plsqlAssemble command described hereafter:

java -jar wsa.jar
-plsqlAssemble
-appName RefCurWS
-sql refcur
-dataSource jdbc/OracleManagedDS
-dbConnection jdbc:oracle:thin:@//<your global database name>
-dbUser scott/tiger
-style rpc
-use encoded

Here is the effective command (you need to replace <your global database name> with the actual global database name in your environment):

$ java -jar $ORACLE_HOME/webservices/lib/wsa.jar -
plsqlAssemble -appName PLSQLRefCurWS -sql refcur -dataSource
jdbc/OracleManagedDS –dbConnection jdbc:oracle:thin:@//
localhost:5521/<global database name> -dbUser scott/tiger -
style rpc -use encoded 

This command generates the following files and directory structures:

As mentioned in Table 15.1, WSA generates the following three interfaces to map REF CURSOR according to the encoding (literal/encoded) to: an Array of Beans (Array/Array), an XMLTYpe (any/text_xml), and an OracleWebRowSet (swaRef/text_xml). See the getcurfuncXMLSource(), getcurfuncXMLRowSet(), andgetcurfuncBeans() interfaces in refcur.java.

refcur.java
===========

package oracle.generated;

import java.sql.SQLException;
import java.sql.Connection;
import java.io.*;

public interface refcur extends java.rmi.Remote{


  public javax.xml.transform.Source  getcurfuncXMLSource()
throws java.rmi.RemoteException;
  public javax.xml.transform.Source  getcurfuncXMLRowSet()
throws java.rmi.RemoteException;
  public GetcurfuncRowUser[] getcurfuncBeans() throws
java.rmi.RemoteException;
}

For more details, see the “Mapping PL/SQL IN and IN OUT Parameters to XML IN OUT Parameters” section in the Oracle AS 10.1.3 Web Services Guide.

Alternatively, you can use an Ant task for generating PL/SQL Web services. The following code fragment is an Ant task for the Web Services Assembler to be inserted in the build.xml:

<oracle:plsqlAssemble
dbUser="scott/tiger"
sql="refcur"
dbConnection="jdbc:oracle:thin:@ :@//localhost:5521/
lab.regress.rdbms.dev.us.oracle.com "
dataSource="jdbc/OracleManagedDS"
appName="RefCurWS"
style="rpc"
use="encoded"
/>

If WSA generates PL/SQL wrappers (RECORD and INDEX-BY-TABLE), these must be loaded into the user schema in the database either manually using SQL*Plus (just run the wrapper) or automatically by WSA using the following option of plsqlAssemble:

No wrapper has been generated for this demo.

Not necessary (or already done).

J2EE_HOME being the file system directory where the OC4J is installed, and 23791 the RMI port, you can deploy the service into a running instance of OC4J and bind the application, using the following command:

$ java -jar $J2EE_HOME/admin_client.jar
deployer:oc4j:localhost:23791 oc4jadmin welcome -deploy -file
PLSQLRefCurWS.ear -deploymentName PLSQLRefCurWS -
bindAllWebApps

06/02/12 20:48:49 Notification ==>Uploading file
PLSQLRefCurWS.ear ...
06/02/12 20:48:49 Notification ==>Application Deployer for
PLSQLRefCurWS STARTS.
06/02/12 20:48:49 Notification ==>Undeploy previous
deployment
06/02/12 20:48:49 Notification ==>Initialize /kmensah_oc4j/
j2ee/home/applications/PLSQLRefCurWS.ear begins...
06/02/12 20:48:49 Notification ==>Initialize /kmensah_oc4j/
j2ee/home/applications/PLSQLRefCurWS.ear ends...
06/02/12 20:48:49 Notification ==>Starting application :
PLSQLRefCurWS
06/02/12 20:48:49 Notification ==>Initializing ClassLoader(s)
06/02/12 20:48:49 Notification ==>Initializing EJB container
06/02/12 20:48:49 Notification ==>Loading connector(s)
06/02/12 20:48:49 Notification ==>Starting up resource
adapters
06/02/12 20:48:49 Notification ==>Initializing EJB sessions
06/02/12 20:48:49 Notification ==>Committing ClassLoader(s)
06/02/12 20:48:49 Notification ==>Initialize PLSQLRefCurWS-
web begins...
06/02/12 20:48:49 Notification ==>Initialize PLSQLRefCurWS-
web ends...
06/02/12 20:48:49 Notification ==>Started application :
PLSQLRefCurWS
06/02/12 20:48:49 Notification ==>Binding web application(s)
to site default-web-site begins...
06/02/12 20:49:03 Notification ==>Binding web application(s)
to site default-web-site ends...
06/02/12 20:49:03 Notification ==>Application Deployer for
PLSQLRefCurWS COMPLETES. Operation time: 14047 msecs

$

You can check that the Web service is indeed deployed, as depicted in Figure 15.18, by connecting to Oracle Enterprise Manager (oc4jadmin) at the following URL:

Figure 15.18. Oracle Enterprise Manager (oc4jadmin)

http://<hostname>:8888/em

See the OC4J Deployment Guide for more information on deploying EAR files.

Test the service by clicking on Test Service on the OEM screen (top left), as depicted by Figure 15.19. The test page will give three functions: getcurfuncBeans, which retrieves an array of Beans; getcurfuncXMLSource(), which retrieves an XML (i.e., any/text_xml); and getcurfuncXMLRowSet(), which retrieves an XMLRowSet (i.e., swaRef/text_xml).

Figure 15.19. Web Services Test Page

As you can see, getcurfuncBeans has been selected because the test page only support simple types such as primitive types and bean or array of such types; selecting the other functions will hang the browser.

Generate the Web Service Proxy using the -genProxy option of the Web Services Assembler:

$java -jar $OC4J_HOME/webservices/lib/wsa.jar -genProxy -wsdl
"http://<hostname>:8888/PLSQLRefCurWS/PLSQLRefCurWS?wsdl"  -
output ./wsclient

This command generates the following files and directories:

wsclient/oracle/generated/GetcurfuncRowUser.java
HttpSoap11Client.java
======================
...
/**
     * @param args
     */
    public static void main(String[] args) {
        try {
            oracle.generated.HttpSoap11Client myPort =
             new oracle.generated.HttpSoap11Client();
            System.out.println("calling " +
                 myPort.getEndpoint());
            // Add your own code here

        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
PLSQLRefCurWS.java  Refcur.java
runtime/

Similar to the Web service proxy generated using JDeveloper, you need to edit HttpSoap11Client.java and insert the following fragment into the proxy class below the “//Add your own code”:

GetcurfuncRowUser user;
GetcurfuncRowUser[] users = myPort.getcurfuncBeans();
int le = users.length;
for (int i=0; i<le; i++) {
user = users[i];
System.out.println("Employee " + user.getEname());
System.out.println("Emp# " + user.getEmpno());
System.out.println("Department# " + user.getDeptno());
System.out.println("Manager " + user.getMgr());
//System.out.println("Hiredate " + user.getHiredate());
System.out.println("Job " + user.getJob());
System.out.println("Salary " + user.getSal());
System.out.println("Commission " + user.getComm());}

Compile and run the client using the following command (you may add the additional JAR files to the CLASSPATH beforehand):

javac -classpath ${CLASSPATH}:${OC4J_HOME}/webservices/lib/
wsclient_extended.zip:${OC4J_HOME}/webservices/lib/jaxrpc-
api.jar oracle/generated/HttpSoap11Client.java

You may need to compile the Java classes in Oracle/generated/runtime:

javac oracle/generated/runtime/*.java

Then run the client application:

$ java -classpath ${CLASSPATH}: ${OC4J_HOME}/webservices/lib/
wsclient_extended.jar:
${OC4J_HOME}/webservices/lib/jaxrpc-api.jar:
${J2EE_HOME}/lib/jax-qname-namespace.jar:
${J2EE_HOME}/lib/activation.jar:${J2EE_HOME}/lib/mail.jar:
${J2EE_HOME}/lib/http_client.jar:
${OC4J_HOME}/lib/xmlparserv2.jar oracle/generated/HttpSoap11Client
$ java -classpath ${CLASSPATH}:${OC4J_HOME}/webservices/lib/
wsclient_extended.zip:${OC4J_HOME}/webservices/lib/jaxrpc-
api.jar:${J2EE_HOME}/lib/jax-gname-namespace.jar:${J2EE_HOME}/lib/
activation.jar:{J2EE_HOME}/lib/mail.jar:${J2EE_HOME}/lib/
http_client.jar:${ORACLE_HOME}/lib/xmlparserv2.jar oracle/generated/
HttpSoap11Client
calling http://<hostname>:8888/PLSQLRefCurWS/PLSQLRefCurWS
Employee SCOTT
Emp# 7788
Department# 20
Manager 7566
Job ANALYST
Salary 4350
Commission null

At this stage, you may add the quality of services using the Web Service Administration page of Oracle Enterprise Manager Application Control, as depicted in Figure 15.20.

Figure 15.20. OEM Application Control, Web Service Administration

Voilà!

For retrieving XML documents instead of Array of Beans, try adding the following code fragment to HttpSoap11Client.java in Step 7:

System.out.println("*** XML Document ***");
 Element soapElem = eme.getcurfuncXMLSource();
 Source source = new DOMSource(soapElem);
 Transformer trans =
TransformerFactory.newInstance().newTransformer();
    ByteArrayOutputStream buf = new ByteArrayOutputStream();
    StreamResult streamr = new StreamResult(buf);
    trans.transform(source, streamr);
    System.out.println(buf.toString()); 

For WebRowSet, try adding the following code in HttpSoap11Client.java in Step 7:

   System.out.println("*** WebRowSet ***");
    soapElem = eme.getcurfuncXMLRowSet();
    source = new DOMSource(soapElem);
    trans = TransformerFactory.newInstance().newTransformer();
    buf = new ByteArrayOutputStream();
    streamr = new StreamResult(buf);
    trans.transform(source, streamr);
    InputStream istream =
            new ByteArrayInputStream(buf.toString().getBytes());
    OracleWebRowSet rowset = new OracleWebRowSet();
    System.setProperty("http.proxyHost", "www-proxy.us.oracle.com");
    System.setProperty("http.proxyPort", "80");
    //System.setProperty("javax.xml.parsers.DocumentBuilderFactory",
             "oracle.xml.jaxp.JXDocumentBuilderFactory");
    System.setProperty("org.xml.sax.driver",
                   "oracle.xml.parser.v2.SAXParser");
    System.out.println("rowset read xml");
    rowset.readXml(new InputStreamReader(istream));
    System.out.println("rowset write xml");
    rowset.writeXml(new PrintWriter(System.out));
    System.out.flush();  

The fully qualified name of the server-side Java class. It may contain any of the following types as parameters and return types:

"jdbc:oracle:thin:@//localhost:5521/<global database
name>
scott/tiger 

Alternatively, you may use an Ant task with the Web Services Assembler dbJavaAssemble command:

<oracle:dbJavaAssemble
appName="javacallin"
dbJavaClassName="REFCUR"
dbConnection="jdbc:oracle:thin:@<hostname>:<port>/<service>"
dataSource="jdbc/OracleManagedDS"
dbUser="scott/tiger"
sysUser="system/manager"
/>

Steps 2 through 6 are similar to the PL/SQL equivalent.

Provide the SQL statements or query, the name and password for the database that they are based on, and the other information described in the Prerequisites section as input to the Web Services Assembler sqlAssemble command, as in the following example:

java -jar wsa.jar
-sqlAssemble
-appName query
-dataSource jdbc/OracleManagedDS
-sqlstatement "getEmpCount=select ename, sal from emp where
sal>:{mysal NUMBER}"
-sqlstatement "getEmpBySal=select ename, sal from emp where
sal>:{mysal NUMBER}"
-sqlstatement "updateEmp=update emp SET sal=sal+500 where
ename=:{myname VARCHAR}"
-dbConnection jdbc:oracle:thin:@stacd15:1521:lsqlj
-dbUser scott/tiger

Use the Ant task for generating Query or DML Web Services: The current release provides Ant tasks for Web services development. The following example shows how the Web Services Assembler sqlAssemble command can be performed as an Ant task:

<oracle:sqlAssemble
appName="query"
dataSource="jdbc/OracleManagedDS"
dbConnection="jdbc:oracle:thin:@dsunrde22:1521:sqlj"
dbUser="scott/tiger">
<sqlstatement="getEmpCount=select ename, sal from emp where
sal>:{mysal
NUMBER}"/>
<sqlstatement="getEmpBySal=select ename, sal from emp where
sal>:{mysal
NUMBER}"/>
<sqlstatement="updateEmp=update emp SET sal=sal+500 where
ename=:{myname
VARCHAR}"/>
/>

Furnish the inputs to Web Services Assembler -aqAssemble command:

java -jar $ORACLE_HOME/webservices/lib/wsa.jar
-aqAssemble
-appName queue
-dataSource jdbc/OracleManagedDS
-portName assembleQueuePort
-sql sample_queue
-dbConnection jdbc:oracle:thin:@stacd15:1521:lsqlj
-dbUser scott/tiger

Queues and topics must be deployed in different services using different values for sql and appName options.

Alternatively, an Ant task may be used instead:

<aqAssemble
appName="queue"
dataSource="jdbc/OracleManagedDS"
sql="sample_queue"
portName="assembleQueuePort"
dbConnection="jdbc:oracle:thin:@localhost:1521:lsqlj"
dbUser="scott/tiger"
/>

Steps 2 to 4 are identical to previous models.

Developing Client Code to Access a Stream AQ Queue Web Service

SampleQueuePortClient queue = new SampleQueuePortClient();
QueueMessageUser m;
queue.send(new QueueMessageUser( "star chopper", "sample
1"));
queue.send(new QueueMessageUser("easy blocks", "sample 2"));
queue.send(new QueueMessageUser("back to future", "sample
3"));
m = queue.receive();
while (m != null) {
System.out.println("Message received from SampleQueue: " +
m.getSubject()
+ ": " + m.getText());
m = queue.receiveNoWait();
}
This client returns the following responses.
Message received from SampleQueue: sample 1: star chopper
Message received from SampleQueue: sample 2: easy blocks
Message received from SampleQueue: sample 3: back to future

The Web Services Assembler aqAssemble option lets you access the Oracle Streams AQ queue via the JMS queue instance. By setting either of the following options instead of datasource, the Web service will use a JMS queue at runtime instead of a JDBC-based queue: