WebLogic Web Services: Advanced Programming

     Previous  Next    Open TOC in new window    View as PDF - New Window  Get Adobe Reader - New Window
Content starts here

Using JMS Transport as the Connection Protocol

The following sections provide information about using JMS transport as the connection protocol:

WARNING: This feature can be implemented only for a JAX-RPC 1.1-based Web Service; you cannot implement it for a JAX-WS 2.0 Web Service.

 


Overview of Using JMS Transport

Typically, client applications use HTTP/S as the connection protocol when invoking a WebLogic Web Service. You can, however, configure a WebLogic Web Service so that client applications use JMS as the transport instead. You configure transports using either JWS annotations or child elements of the jwsc Ant task, as described in later sections.

When a WebLogic Web Service is configured to use JMS as the connection transport, the endpoint address specified for the corresponding port in the generated WSDL of the Web Service uses jms:// in its URL rather than http://. An example of a JMS endpoint address is as follows:

jms://myHost:7001/transports/JMSTransport?URI=JMSTransportQueue

The URI=JMSTransportQueue section of the URL specifies the JMS queue that has been configured for the JMS transport feature. Although you cannot invoke the Web Service using HTTP, you can view its WSDL using HTTP, which is how the clientgen is still able to generate JAX-RPC stubs for the Web Service.

For each transport that you specify, WebLogic Server generates an additional port in the WSDL. For this reason, if you want to give client applications a choice of transports they can use when they invoke the Web Service (JMS, HTTP, or HTTPS), you should explicitly add the transports using the appropriate JWS annotations or child elements of jwsc.

Caution: Using JMS transport is an added-value WebLogic feature; non-WebLogic client applications, such as a.NET client, may not be able to invoke the Web Service using the JMS port.

 


Using JMS Transport Starting From Java: Main Steps

To use JMS transport when starting from Java, you must peform at least one of the following tasks:

Note: Because you might not know at the time that you are coding the JWS file which transport best suits your needs, it is often better to specify the transport at build-time using the <WLJmsTransport> child element.

The following procedure describes the complete set of steps required so that your Web Service can be invoked using the JMS transport when starting from Java.

Note: It is assumed that you have already created a basic JWS file that implements a Web Service and that you want to configure the Web Service to be invoked using JMS. It is also assumed that you have set up an Ant-based development environment and that you have a working build.xml file that includes targets for running the jwsc Ant task and deploying the service. For more information, see:
  1. Configure the WebLogic Server domain for the required JMS components.
  2. You can either configure these resources yourself, or you can use the Configuration Wizard to extend the WebLogic Server domain using a Web Services-specific extension template. Using the Configuration Wizard greatly simplifies the required configuration steps; for details, see Configuring Your Domain For Web Services Features.

    If, however, you prefer to configure the resources yourself, follow these steps:

    1. Invoke the Administration Console in your browser, as described in Invoking the Administration Console.
    2. Using the Administration Console, create and configure the following JMS components, if they do not already exist:
      • JMS Server. See Create JMS servers.
      • JMS Module, targeted to the preceding JMS server. See Create JMS system modules.
      • JMS Queue, contained within the preceding JMS module. You can either specify the JNDI name of the JMS queue that WebLogic Web Services listen to by default (weblogic.wsee.DefaultQueue) or specify a different name. If you specify a different JNDI name, you later pass this name to the Web Service itself. When you configure the queue, be sure you specify that this JMS queue is local, typically by setting the local JNDI name.See Create queues in a system module.
      • Except for the JNDI name of the JMS queue, you can name the other components anything you want.

  3. Add the @WLJmsTransport annotation to your JWS file.
  4. This step is optional. If you do not add the @WLJmsTransport annotation to your JWS file, then you must add a <WLJmsTransport> child element to the jwsc Ant task, as described in Step 3. See Using the @WLJmsTransport JWS Annotation.

  5. Add a <WLJmsTransport> child element to the jwsc Ant task.
  6. Use the <WLJmsTransport> child element to override the transports defined in the JWS file. This step is required if you did not add the @WLJmsTransport annotation to your JWS file in Step 2. Otherwise, this step is optional.

    See Using the <WLJmsTransport> Child Element of the jwsc Ant Task for details.

  7. Rebuild your Web Service by re-running the target in the build.xml Ant file that calls the jwsc task.
  8. For example, if the target that calls the jwsc Ant task is called build-service, then you would run:

    prompt> ant build-service
  9. Redeploy your Web Service to WebLogic Server.

See Invoking a WebLogic Web Service Using JMS Transport for information about updating your client application to invoke the Web Service using JMS transport.

 


Using JMS Transport Starting From WSDL: Main Steps

To use JMS transport when starting from WSDL, you must peform at least one of the following tasks:

Note: Because you might not know at the time that you are coding the JWS file which transport best suits your needs, it is often better to specify the transport at build-time using the <WLJmsTransport> child element.

The following procedure describes the complete set of steps required so that your Web Service can be invoked using the JMS transport when starting from WSDL.

Note: It is assumed in this procedure that you have an existing WSDL file.
  1. Configure the WebLogic Server domain for the required JMS components.
  2. You can either configure these resources yourself, or you can use the Configuration Wizard to extend the WebLogic Server domain using a Web Services-specific extension template. Using the Configuration Wizard greatly simplifies the required configuration steps; for details, see Configuring Your Domain For Web Services Features.

    If, however, you prefer to configure the resources yourself, follow these steps:

    1. Invoke the Administration Console in your browser, as described in Invoking the Administration Console.
    2. Using the Administration Console, create and configure the following JMS components, if they do not already exist:
      • JMS Server. See Create JMS servers.
      • JMS Module, targeted to the preceding JMS server. See Create JMS system modules.
      • JMS Queue, contained within the preceding JMS module. You can either specify the JNDI name of the JMS queue that WebLogic Web Services listen to by default (weblogic.wsee.DefaultQueue) or specify a different name. If you specify a different JNDI name, you later pass this name to the Web Service itself. When you configure the queue, be sure you specify that this JMS queue is local, typically by setting the local JNDI name.See Create queues in a system module.
      • Except for the JNDI name of the JMS queue, you can name the other components anything you want.

  3. Update the WSDL to use JMS transport.
  4. This step is optional. If you do not update the WSDL to use JMS transport, then you must do at least one of the following:

    • Edit the stubbed out JWS file to add the @WLJmsTransport annotation to your JWS file, as described in Step 4.
    • Add a <WLJmsTransport> child element to the jwsc Ant task, as described in Step 5.
    • See Updating the WSDL to Use JMS Transport.

  5. Run the wsdlc Ant task against the WSDL file.
  6. For example, if the target that calls the wsdlc Ant task is called generate-from-wsdl, then you would run:

    prompt> ant generate-from-wsdl
  7. Update the stubbed-out JWS file.
  8. The wsdlc Ant task generates a stubbed-out JWS file. You need to add your business code to the Web Service so it behaves as you want.

    If you updated the WSDL to use the JMS transport in Step 2, the JWS file includes the @WLJmsTransport annotation that defines the JMS transport. If the @WLJmsTransport annotation is not included in the JWS file, you must do at least one of the following:

    • Edit the JWS file to add the @WLJmsTransport annotation to your JWS file, as described in Using the @WLJmsTransport JWS Annotation.
    • Add a <WLJmsTransport> child element to the jwsc Ant task, as described in Step 5.
  9. Add a <WLJmsTransport> child element to the jwsc Ant task.
  10. Use the <WLJmsTransport> child element to override the transports defined in the JWS file. This step is required if the JWS file does not include the @WLJmsTransport annotation, as noted in Step 4. Otherwise, this step is optional. See Using the <WLJmsTransport> Child Element of the jwsc Ant Task.

  11. Run the jwsc Ant task against the JWS file to build the Web Service.
  12. Specify the artifacts generated by the wsdlc Ant task as well as your updated JWS implementation file, to generate an Enterprise Application that implements the Web Service. See Running the jwsc WebLogic Web Services Ant Task.

  13. Deploy your Web Service to WebLogic Server.
  14. See Deploying and Undeploying WebLogic Web Services.

See Invoking a WebLogic Web Service Using JMS Transport for information about updating your client application to invoke the Web Service using JMS transport.

 


Using the @WLJmsTransport JWS Annotation

If you know at the time that you program the JWS file that you want client applications to use JMS transport (instead of HTTP/S) to invoke the Web Service, you can use the @WLJmsTransport to specify the details of the invoke. Later, at build-time, you can override the one in the JWS file and add additional JMS transport specifications, by specifying the <WLJmsTransport> child element of the jwsc Ant task, as described in Using the <WLJmsTransport> Child Element of the jwsc Ant Task.

Follow these guidelines when using the @WLJmsTranport annotation:

The following example shows a simple JWS file that uses the @WLJmsTransport annotation, with the relevant code in bold:

package examples.webservices.jmstransport;
import javax.jws.WebMethod;
import javax.jws.WebService;
import javax.jws.soap.SOAPBinding;
import weblogic.jws.WLJmsTransport;
@WebService(name="JMSTransportPortType",
serviceName="JMSTransportService",
targetNamespace="http://example.org")
@SOAPBinding(style=SOAPBinding.Style.DOCUMENT,
use=SOAPBinding.Use.LITERAL,
parameterStyle=SOAPBinding.ParameterStyle.WRAPPED)
// WebLogic-specific JWS annotation that specifies the context path and
// service URI used to build the URI of the Web Service is
// "transports/JMSTransport"
@WLJmsTransport(contextPath="transports", serviceUri="JMSTransport",
queue="JMSTransportQueue", portName="JMSTransportServicePort")
/**
* This JWS file forms the basis of simple Java-class implemented WebLogic
* Web Service with a single operation: sayHello
*
* @author Copyright (c) 2005 by BEA Systems. All rights reserved.
*/
public class JMSTransportImpl {
  @WebMethod()
public String sayHello(String message) {
System.out.println("sayHello:" + message);
return "Here is the message: '" + message + "'";
}
}

 


Using the <WLJmsTransport> Child Element of the jwsc Ant Task

You can also specify the JMS transport at build-time by using the <WLJmsTransport> child element of the <jws> element of the jwsc Ant task. Reasons for specifying the transport at build-time include:

If you specify a transport to the jwsc Ant task, it takes precedence over any transport annotation in the JWS file.

The following example shows how to specify a transport to the jwsc Ant task:

  <target name="build-service">
    <jwsc
srcdir="src"
destdir="${ear-dir}">
<jws file="examples/webservices/jmstransport/JMSTransportImpl.java">
        <WLJmsTransport
contextPath="transports"
serviceUri="JMSTransport"
portName="JMSTransportServicePort"
queue="JMSTransportQueue"/>
      </jws>
    </jwsc>
  </target>

The preceding example shows how to specify the same values for the URL and JMS queue as were specified in the JWS file shown in Using the @WLJmsTransport JWS Annotation.

For more information about using the jwsc Ant task, see jwsc.

 


Updating the WSDL to Use JMS Transport

To update the WSDL to use JMS transport, you need to add <wsdl:binding> and <wsdl:service> definitions that define JMS transport information. You can add the definitions in one of the following ways:

In either case, you must modify the <wsdl:binding> and <wsdl:service> definitions to use JMS transport as follows:

 


Invoking a WebLogic Web Service Using JMS Transport

You write a client application to invoke a Web Service using JMS transport in the same way as you write one using the HTTP transport; the only difference is that you must ensure that the JMS queue (specified by the @WLJmsTransport annotation or <WLJmsTransport> child element of the jwsc Ant task) and other JMS objects have already been created. See Using JMS Transport Starting From Java: Main Steps or Using JMS Transport Starting From WSDL: Main Steps for more information.

Although you cannot invoke a JMS-transport-configured Web Service using HTTP, you can view its WSDL using HTTP, which is how the clientgen Ant task is still able to create the JAX-RPC stubs for the Web Service. For example, the URL for the WSDL of the Web Service shown in this section would be:

http://host:port/transports/JMSTransport?WSDL

However, because the endpoint address in the WSDL of the deployed Web Service uses jms:// instead of http://, and the address includes the qualifier ?URI=JMS_QUEUE, the clientgen Ant task automatically creates the stubs needed to use the JMS transport when invoking the Web Service, and your client application need not do anything different than normal. An example of a JMS endpoint address is as follows:

jms://host:port/transports/JMSTransport?URI=JMSTransportQueue
WARNING: If you have specified that the Web Service you invoke using JMS transport also runs within the context of a transaction (in other words, the JWS file includes the @weblogic.jws.Transactional annotation), you must use asynchronous request-response when invoking the service. If you do not, a deadlock will occur and the invocation will fail.

For general information about invoking a Web Service, see Invoking Web Services.

Overriding the Default Service Address URL

When you write a client application that uses the clientgen-generated JAX-RPC stubs to invoke a Web Service, the default service address URL of the Web Service is the one specified in the <address> element of the WSDL file argument of the Service constructor.

Sometimes, however, you might need to override this address, in particular when invoking a WebLogic Web Service that is deployed to a cluster and you want to specify the cluster address or a list of addresses of the managed servers in the cluster. You might also want to use the t3 protocol to invoke the Web Service. To override this service endpoint URL when using JMS transport, use the weblogic.wsee.jaxrpc.WLStub.JMS_TRANSPORT_JNDI_URL stub property as shown in the following example:

package examples.webservices.jmstransport.client;
import weblogic.wsee.jaxrpc.WLStub;
import java.rmi.RemoteException;
import javax.xml.rpc.ServiceException;
import javax.xml.rpc.Stub;
/**
* This is a simple standalone client application that invokes the
* the <code>sayHello</code> operation of the JMSTransport Web service.
*
* @author Copyright (c) 2004 by BEA Systems. All Rights Reserved.
*/
public class Main {
  public static void main(String[] args)
throws ServiceException, RemoteException{
    JMSTransportService service = new JMSTransportService_Impl(args[0] + "?WSDL" );
JMSTransportPortType port = service.getJMSTransportServicePort();
    Stub stub = (Stub) port;
    stub._setProperty(WLStub.JMS_TRANSPORT_JNDI_URL,
"t3://shackell01.amer.bea.com:7001");
try {
String result = null;
      result = port.sayHello("Hi there! ");
      System.out.println( "Got JMS result: " + result );
    } catch (RemoteException e) {
throw e;
}
}
}

See WLStub reference documentation for additional stub properties.

Using JMS BytesMessage Rather Than the Default TextMessage

When you use JMS transport, the Web Services runtime uses, by default, the javax.jms.TextMessage object to send the message. This is usually adequate for most client applications, but sometimes you might need to send binary data rather than ordinary text; in this case you must request that the Web Services runtime use javax.jms.BytesMessage instead. To do this, use the WLStub.JMS_TRANSPORT_MESSAGE_TYPE stub property in your client application and set it to the value WLStub.JMS_BYTESMESSAGE, as shown in the following example:

    stub._setProperty(WLStub.JMS_TRANSPORT_MESSAGE_TYPE,
WLStub.JMS_BYTESMESSAGE);

The Web Services runtime sends back the response using the same message data type as the request.

See “Overriding the Default Service Address URL” on page 1-7 for a full example of a client application in which you can set this property. See WLStub reference documentation for additional stub properties.

Disabling HTTP Access to the WSDL File

As described in “Invoking a WebLogic Web Service Using JMS Transport” on page 1-6, the WSDL of the deployed Web Service is, by default, still accessible using HTTP. If you want to disable access to the WSDL file, in particular if your Web Service can be accessed outside of a firewall, then you can do one of the following:


  Back to Top       Previous  Next