The following sections describe the procedures for upgrading WebLogic Web services from WebLogic Server 9.x or 10.x to the WebLogic Server 12.1.x release. It also describes how to upgrade 8.1 WebLogic Web services to 12.1.x WebLogic Web services.
This chapter includes the following sections:
Note:
10.3.x WebLogic Web services (JAX-WS or JAX-RPC) will continue to run, without any changes, on version 12.1.x of WebLogic Server because the associated Web services run time is still supported in this release, although they are deprecated and will be removed from the product in future releases. For this reason, Oracle highly recommends that you follow the instructions in this chapter to upgrade your 10.3.x Web service to 12.1.x.In 10.3.x, a set of pre-built shared libraries were delivered with WebLogic Server to support Jersey 1.9 and 1.1.5.1 Java API for RESTful Web Services (JAX-RS) Reference Implementations (RIs). In order to use the shared libraries, you needed to register them with the WebLogic Server instance, and modify the web.xml and weblogic.xml deployment descriptors to use the Jersey servlet and reference the shared libraries, respectively.
In 12.2.1, WebLogic Server supports the Jersey 2.21 (JAX-RS 2.0 RI).
The following section explains how to upgrade your 10.3.x RESTful web services applications to 12.2.1.
To use the Jersey 2.5.1 (JAX-RS 2.0 RI), you need to modify your 10.3.x RESTful web service application to register and use the shared libraries, as follows:
Register the Jersey 2.5.1 (JAX-RS 2.0 RI) shared library with your WebLogic Server instances, as described in "Registering the Jersey 2.5.1 (JAX-RS 2.0 RI) Shared Library With Your WebLogic Server Instances" in Developing and Securing RESTful Web Services for Oracle WebLogic Server.
Update the weblogic.xml packaged with your application to change any shared library references to Jersey 2.5.1 (JAX-RS 2.0 RI), as described in "Configuring the Web Application to Use the Jersey 2.5.1 (JAX-RS 2.0 RI)" in Developing and Securing RESTful Web Services for Oracle WebLogic Server.
Update the web.xml packaged with your application to no longer delegate Web requests to the Jersey servlet, com.sun.jersey.spi.container.servlet.ServletContainer. For example, remove the following <web-app> content:
<web-app>
<servlet>
<display-name>My Jersey Application</display-name>
<servlet-name>MyJerseyApp</servlet-name>
<servlet-class>com.sun.jersey.spi.container.servlet.ServletContainer</servlet-class>
<init-param>
<param-name>javax.ws.rs.Application</param-name>
<param-value>myPackage.myJerseyApplication</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>MyJerseyApp</servlet-name>
<url-pattern>/*</url-pattern>
</servlet-mapping>
</web-app>
For additional advanced configuration options, see Jersey 2.5.1 User Guide.
Update your clients to use the javax.ws.rs.client API, as described in "Developing RESTful Web Service Client Using Jersey 2.5.1 (JAX-RS 2.0 RI)" in Developing and Securing RESTful Web Services for Oracle WebLogic Server.
The Jersey 1.x JAX-RS RI client APIs are not compatible with Jersey 2.5.1 (JAX-RS 2.0 RI).
No steps are required to upgrade a 10.x WebLogic Web service to 12.2.x; you can redeploy the JAX-WS Web service to WebLogic Server 12.2.x without making any changes or recompiling.
In the 12.1.2 release, the 8.1 WebLogic Web services run time has been removed. If you are using 8.1 WebLogic Web services, you need to upgrade the 8.1 WebLogic Web service applications to Web service stacks available in this release. The 8.1 WebLogic Web services rely on Apache XMLBeans for the purpose of mapping XML elements in SOAP payloads into Java objects and vice versa. XMLBeans are not supported in 12.1.2. The following upgrade paths are available:
Upgrade to the WebLogic JAX-RPC stack: This is the simplest upgrade path in terms of level of effort required for upgrade. XMLBeans support in the WebLogic JAX-RPC stack is compatible with 8.1 WebLogic Web services. For more information, see "Upgrading an 8.1 WebLogic Web Service to the WebLogic JAX-RPC Stack".
Upgrade to the JAX-WS stack: This is the best upgrade path from the standpoint of taking advantage of latest technologies and standard support in WebLogic Server. This path requires a manual upgrade process, and the level of effort is determined by the nature of the existing 8.1 Web service applications. For example, if the applications have little XMLBeans usage, then the upgrade process is relatively easy. For 8.1 Web Service applications with heavy XMLBeans dependencies, you must modify the business logic in the service implementation in order to use JAXB classes instead of XMLBeans classes. Please note that JAX-WS does not support RPC-encoded style, and 8.1 Web Service applications with RPC-encoded style will need to adopt more interoperable literal style service contracts. For more information, see "Upgrading an 8.1 WebLogic Web Service to the WebLogic JAX-WS Stack".
This section describes how to upgrade an 8.1 WebLogic Web service to use the WebLogic JAX-RPC run-time environment. The WebLogic JAX-RPC run time is based on the JSR 109: Implementing Enterprise Web Services specification at http://www.jcp.org/en/jsr/detail?id=109. The 12.1.x programming model uses standard JDK 1.5 metadata annotations, as specified by the JSR 181: Web Services Metadata for the Java Platform specification (JSR-181) at http://www.jcp.org/en/jsr/detail?id=181.
Upgrading your 8.1 Web service includes the following high-level tasks; the procedures in later sections go into more detail:
Update the 8.1 Java source code of the Java class or stateless session EJB that implements the Web service so that the source code uses JWS annotations.
In 12.1.x, WebLogic Web services are implemented using JWS files, which are Java files that contains JWS annotations. The jwsc Ant Task always implements the Web service as a plain Java file unless you explicitly implement javax.ejb.SessionBean in your JWS file. This latter case is not typical. This programming model differs from that of 8.1, where you were required to specify the type of back-end component (Java class or EJB).
Update the Ant build script that builds the Web service to call the 12.1.x WebLogic Web service Ant task jwsc instead of the 8.1 servicegen task.
In the sections that follow it is assumed that:
You previously used servicegen to generate your 8.1 Web service and that, more generally, you use Ant scripts in your development environment to iteratively develop Web services and other Java Platform, Enterprise Edition (Java EE) Version 5 artifacts that run on WebLogic Server. The procedures in this section direct you to update existing Ant build.xml files.
You have access to the Java class or EJB source code for your 8.1 Web service.
This section does not discuss the following topics:
Upgrading a JMS-implemented 8.1 Web service, because the WebLogic Web services JAX-RPC run time does not support JMS-implemented services.
Upgrading Web services from versions previous to 8.1.
Upgrading a client application that invokes an 8.1 Web service to one that invokes a 12.1.x Web service. For details on how to write a client application that invokes a 12.1.x Web service, see "Invoking a Web Service from a Java SE Client" and "Invoking a Web Service from Another Web Service" in Developing JAX-RPC Web Services for Oracle WebLogic Server.
To upgrade an 8.1 Java class-implemented Web service to use the WebLogic Web services JAX-RPC run time:
Open a command window and set your WebLogic Server 12.1.x environment by executing the setDomainEnv.cmd (Windows) or setDomainEnv.sh (UNIX) script, located in the bin subdirectory of your 12.1.x domain directory.
The default location of WebLogic Server domains is ORACLE_HOME/user_projects/domains/domainName, where ORACLE_HOME is the Oracle home directory you specified at installation and domainName is the name of your domain.
Create a project directory:
prompt> mkdir /myExamples/upgrade_pojo
Create a src directory under the project directory, as well as sub-directories that correspond to the package name of the new 12.1.x JWS file (shown later in this procedure) that corresponds to the old 8.1 Java class:
prompt> cd /myExamples/upgrade_pojo
prompt> mkdir src/examples/webservices/upgrade_pojo
Copy the old Java class that implements the 8.1 Web service to the src/examples/webservices/upgrade_pojo directory of the working directory. Rename the file, if desired.
Edit the Java file, as described in the following steps. See the old and new sample Java files in Example of an 8.1 Java File and the Corresponding 12.1.x JWS File for specific examples.
If needed, change the package name and class name of the Java file to reflect the new 12.1.x source environment.
Add import statements to import both the standard and WebLogic-specific JWS annotations.
Add, at a minimum, the following JWS annotation:
The standard @WebService annotation at the Java class level to specify that the JWS file implements a Web service.
Oracle recommends you also add the following annotations:
The standard @SOAPBinding annotation at the class-level to specify the type of Web service, such as document-literal-wrapped or RPC-encoded.
The WebLogic-specific @WLHttpTransport annotation at the class-level to specify the context and service URIs that are used in the URL that invokes the deployed Web service.
The standard @WebMethod annotation at the method-level for each method that is exposed as a Web service operation.
See "Programming the JWS File" in Developing JAX-RPC Web Services for Oracle WebLogic Server for general information about using JWS annotations in a Java file.
You might need to add additional annotations to your JWS file, depending on the 8.1 Web service features you want to carry forward to 12.1.x. In 8.1, many of these features were configured with attributes of servicegen. See Mapping of servicegen Attributes to JWS Annotations or jwsc Attributes for a table that lists equivalent JWS annotation, if available, for features you enabled in 8.1 using servicegen attributes.
Copy the old build.xml file that built the 8.1 Web service to the 12.1.x working directory.
Update your Ant build.xml file to execute the jwsc Ant task, along with other supporting tasks, instead of servicegen.
Oracle recommends that you create a new target, such as build-service, in your Ant build file and add the jwsc Ant task call to compile the new JWS file you created in the preceding steps. Once this target is working correctly, you can remove the old servicegen Ant task.
The following procedure lists the main steps to update your build.xml file; for details on the steps, see the standard iterative development process outlined in "Developing WebLogic Web Services Starting From Java: Main Steps" and "Developing WebLogic Web Services Starting From a WSDL File: Main Steps" in Developing JAX-RPC Web Services for Oracle WebLogic Server.
See Example of an 8.1 and Updated 12.1.x Ant Build File for Java Class-Implemented Web Services for specific examples of the steps in the following procedure.
Add the jwsc taskdef to the build.xml file.
Create a build-service target and add the tasks needed to build the 12.1.x Web service, as described in the following steps.
Add the jwsc task to the build file. Set the srdir attribute to the src directory (/myExamples/upgrade_pojo/src, in this example) and the destdir attribute to the root Enterprise application directory you created in the preceding step.
Set the file attribute of the <jws> child element to the name of the new JWS file, created earlier in this procedure.
You may need to specify additional attributes to the jwsc task, depending on the 8.1 Web service features you want to carry forward to 12.1.x. In 8.1, many of these features were configured using attributes of servicegen. See Mapping of servicegen Attributes to JWS Annotations or jwsc Attributes for a table that describes if there is an equivalent jwsc attribute for features you enabled using servicegen attributes.
Execute the build-service Ant target. Assuming all the tasks complete successfully, the resulting Enterprise application contains your upgraded 12.1.x Web service.
See "Deploying and Undeploying WebLogic Web Services" and "Browsing to the WSDL of the Web Service" in Developing JAX-RPC Web Services for Oracle WebLogic Server for additional information about deploying and testing your Web service.
Based on the sample Java code shown in the following sections, the URL to invoke the WSDL of the upgraded 12.1.x Web service is:
http://host:port/upgradePOJO/HelloWorld?WSDL
Assume that the following sample Java class implemented a 8.1 Web service:
package examples.javaclass;
/**
* Simple Java class that implements the HelloWorld Web service. It takes
* as input an integer and a String, and returns a message that includes these
* two parameters.
*/
public final class HelloWorld81 {
/**
* Returns a text message that includes the integer and String input
* parameters.
*
*/
public String sayHello(int num, String s) {
System.out.println("sayHello operation has been invoked with arguments " + s + " and " + num);
String returnValue = "This message brought to you by the letter "+s+" and the number "+num;
return returnValue;
}
}
An equivalent JWS file for a 12.1.x Java class-implemented Web service is shown below, with the differences shown in bold. Note that some of the JWS annotation values are taken from attributes of the 8.1 servicegen Ant task shown in Example of an 8.1 and Updated 12.1.x Ant Build File for Java Class-Implemented Web Services.
package examples.webservices.upgrade_pojo; // Import standard JWS annotations import javax.jws.WebService; import javax.jws.WebMethod; import javax.jws.soap.SOAPBinding; // Import WebLogic JWS anntoation import weblogic.jws.WLHttpTransport; /** * Simple Java class that implements the HelloWorld92 Web service. It takes * as input an integer and a String, and returns a message that includes these * two parameters. */ @WebService(name="HelloWorld92PortType", serviceName="HelloWorld", targetNamespace="http://example.org") @SOAPBinding(style=SOAPBinding.Style.DOCUMENT, use=SOAPBinding.Use.LITERAL, parameterStyle=SOAPBinding.ParameterStyle.WRAPPED) @WLHttpTransport(contextPath="upgradePOJO", serviceUri="HelloWorld", portName="HelloWorld92Port") public class HelloWorld92Impl { /** * Returns a text message that includes the integer and String input * parameters. * */ @WebMethod() public String sayHello(int num, String s) { System.out.println("sayHello operation has been invoked with arguments " + s + " and " + num); String returnValue = "This message brought to you by the letter "+s+" and the number "+num; return returnValue; } }
The following simple build.xml file shows the 8.1 way to build a WebLogic Web service using the servicegen Ant task; in the example, the Java file that implements the 8.1 Web service has already been compiled into the examples.javaclass.HelloWorld81 class:
<project name="javaclass-webservice" default="all" basedir=".">
<!-- set global properties for this build -->
<property name="source" value="."/>
<property name="build" value="${source}/build"/>
<property name="war_file" value="HelloWorldWS.war" />
<property name="ear_file" value="HelloWorldApp.ear" />
<property name="namespace" value="http://examples.org" />
<target name="all" depends="clean, ear"/>
<target name="clean">
<delete dir="${build}"/>
</target>
<!-- example of old 8.1 servicegen call to build Web Service -->
<target name="ear">
<servicegen
destEar="${build}/${ear_file}"
warName="${war_file}">
<service
javaClassComponents="examples.javaclass.HelloWorld81"
targetNamespace="${namespace}"
serviceName="HelloWorld"
serviceURI="/HelloWorld"
generateTypes="True"
expandMethods="True">
</service>
</servicegen>
</target>
</project>
An equivalent build.xml file that calls the jwsc Ant task to build a 12.1.x Web service is shown below, with the relevant tasks discussed in this section in bold. In the example, the new JWS file that implements the 12.1.x Web service is called HelloWorld92Impl.java:
<project name="webservices-upgrade_pojo" default="all">
<!-- set global properties for this build -->
<property name="wls.username" value="weblogic" />
<property name="wls.password" value="weblogic" />
<property name="wls.hostname" value="localhost" />
<property name="wls.port" value="7001" />
<property name="wls.server.name" value="myserver" />
<property name="ear.deployed.name" value="upgradePOJOEar" />
<property name="example-output" value="output" />
<property name="ear-dir" value="${example-output}/upgradePOJOEar" />
<taskdef name="jwsc"
classname="weblogic.wsee.tools.anttasks.JwscTask" />
<taskdef name="wldeploy"
classname="weblogic.ant.taskdefs.management.WLDeploy"/>
<target name="all" depends="clean,build-service,deploy" />
<target name="clean" depends="undeploy">
<delete dir="${example-output}"/>
</target>
<target name="build-service">
<jwsc
srcdir="src"
destdir="${ear-dir}">
<jws file="examples/webservices/upgrade_pojo/HelloWorld92Impl.java" />
</jwsc>
</target>
<target name="deploy">
<wldeploy action="deploy" name="${ear.deployed.name}"
source="${ear-dir}" user="${wls.username}"
password="${wls.password}" verbose="true"
adminurl="t3://${wls.hostname}:${wls.port}"
targets="${wls.server.name}" />
</target>
<target name="undeploy">
<wldeploy action="undeploy" name="${ear.deployed.name}"
failonerror="false"
user="${wls.username}" password="${wls.password}" verbose="true"
adminurl="t3://${wls.hostname}:${wls.port}"
targets="${wls.server.name}" />
</target>
</project>
The following procedure describes how to upgrade an 8.1 EJB-implemented Web service to use the WebLogic Web services JAX-RPC run time.
The 12.1.x Web services programming model is quite different from the 8.1 model in that it hides the underlying implementation of the Web service. Rather than specifying up front that you want the Web service to be implemented by a Java class or an EJB, the jwsc Ant task always picks a plain Java class implementation, unless you have explicitly implemented javax.ejb.SessionBean in the JWS file, which is not typical. For this reason, the following procedure does not show how to import EJB classes or use EJBGen, even though the 8.1 Web service was explicitly implemented with an EJB. Instead, the procedure shows how to create a standard JWS file that is the 12.1.x equivalent to the 8.1 EJB-implemented Web service.
Open a command window and set your 12.1.x WebLogic Server environment by executing the setDomainEnv.cmd (Windows) or setDomainEnv.sh (UNIX) script, located in the bin subdirectory of your 12.1.x domain directory.
The default location of WebLogic Server domains is ORACLE_HOME/user_projects/domains/domainName, where ORACLE_HOME is the Oracle home you specified at installation and domainName is the name of your domain.
Create a project directory:
prompt> mkdir /myExamples/upgrade_ejb
Create a src directory under the project directory, as well as sub-directories that correspond to the package name of the new 12.1.x JWS file (shown later on in this procedure) that corresponds to your 8.1 EJB implementation:
prompt> cd /myExamples/upgrade_ejb
prompt> mkdir src/examples/webservices/upgrade_ejb
Copy the 8.1 EJB Bean file that implemented javax.ejb.SessionBean to the src/examples/webservices/upgrade_ejb directory of the working directory. Rename the file, if desired.
Note:
You do not need to copy over the 8.1 Home and Remote EJB files.Edit the EJB Bean file, as described in the following steps. See the old and new sample Java files in Example of 8.1 EJB Files and the Corresponding 12.1.x JWS File for specific examples.
If needed, change the package name and class name of the Java file to reflect the new 12.1.x source environment.
Optionally remove the import statements that import the EJB classes (javax.ejb.*). These classes are no longer needed in the upgraded JWS file.
Add import statements to import both the standard and WebLogic-specific JWS annotations.
Ensure that the JWS file does not implement javax.ejb.SessionBean anymore by removing the implements SessionBean code from the class declaration.
Remove all the EJB-specific methods:
ejbActivate()
ejbRemove()
ejbPassivate()
ejbCreate()
Add, at a minimum, the following JWS annotation:
The standard @WebService annotation at the Java class level to specify that the JWS file implements a Web service.
Oracle recommends you also add the following annotations:
The standard @SOAPBinding annotation at the class-level to specify the type of Web service, such as document-literal-wrapped or RPC-encoded.
The WebLogic-specific @WLHttpTransport annotation at the class-level to specify the context and service URIs that are used in the URL that invokes the deployed Web service.
The standard @WebMethod annotation at the method-level for each method that is exposed as a Web service operation.
See "Programming the JWS File" in Developing JAX-RPC Web Services for Oracle WebLogic Server for general information about using JWS annotations in a Java file.
You might need to add additional annotations to your JWS file, depending on the 8.1 Web service features you want to carry forward to 12.1.x. In 8.1, many of these features were configured using attributes of servicegen. See Mapping of servicegen Attributes to JWS Annotations or jwsc Attributes for a table that lists equivalent JWS annotation, if available, for features you enabled in 8.1 using servicegen attributes.
Copy the old build.xml file that built the 8.1 Web service to the 12.1.x working directory.
Update your Ant build.xml file to execute the jwsc Ant task, along with other supporting tasks, instead of servicegen.
Oracle recommends that you create a new target, such as build-service, in your Ant build file and add the jwsc Ant task call to compile the new JWS file you created in the preceding steps. Once this target is working correctly, you can remove the old servicegen Ant task.
The following procedure lists the main steps to update your build.xml file; for details on the steps, see the standard iterative development process outlined in
See Example of an 8.1 and Updated 12.1.x Ant Build File for an 8.1 EJB-Implemented Web Service for specific examples of the steps in the following procedure.
Add the jwsc taskdef to the build.xml file.
Create a build-service target and add the tasks needed to build the 12.1.x Web service, as described in the following steps.
Add the jwsc task to the build file. Set the srdir attribute to the src directory (/myExamples/upgrade_ejb/src, in this example) and the destdir attribute to the root Enterprise application directory you created in the preceding step.
Set the file attribute of the <jws> child element to the name of the new JWS file, created earlier in this procedure.
You may need to specify additional attributes to the jwsc task, depending on the 8.1 Web service features you want to carry forward to 12.1.x. In 8.1, many of these features were configured using attributes of servicegen. See Mapping of servicegen Attributes to JWS Annotations or jwsc Attributes for a table that indicates whether there is an equivalent jwsc attribute for features you enabled using servicegen attributes.
Execute the build-service Ant target. Assuming all tasks complete successfully, the resulting Enterprise application contains your upgraded 12.1.x Web service.
See "Deploying and Undeploying WebLogic Web Services" and "Browsing to the WSDL of the Web Service" in Developing JAX-RPC Web Services for Oracle WebLogic Server for additional information about deploying and testing your Web service.
Based on the sample Java code shown in the following sections, the URL to invoke the WSDL of the upgraded 12.1.x Web service is:
http://host:port/upgradeEJB/HelloWorldService?WSDL
Assume that the Bean, Home, and Remote classes and interfaces, shown in the next three sections, implemented the 8.1 stateless session EJB which in turn implemented an 8.1 Web service.
The equivalent 12.1.x JWS file is shown in Equivalent 12.1.x JWS File. The differences between the 8.1 and 12.1.x classes are shown in bold. Note that some of the JWS annotation values are taken from attributes of the 8.1 servicegen Ant task shown in Example of an 8.1 and Updated 12.1.x Ant Build File for an 8.1 EJB-Implemented Web Service.
package examples.statelessSession;
import javax.ejb.CreateException;
import javax.ejb.SessionBean;
import javax.ejb.SessionContext;
/**
* HelloWorldBean is a stateless session EJB. It has a single method,
* sayHello(), that takes an integer and a String and returns a String.
* <p>
* The sayHello() method is the public operation of the Web service based on
* this EJB.
*/
public class HelloWorldBean81 implements SessionBean {
private static final boolean VERBOSE = true;
private SessionContext ctx;
// You might also consider using WebLogic's log service
private void log(String s) {
if (VERBOSE) System.out.println(s);
}
/**
* Single EJB business method.
*/
public String sayHello(int num, String s) {
System.out.println("sayHello in the HelloWorld EJB has "+
"been invoked with arguments " + s + " and " + num);
String returnValue = "This message brought to you by the "+
"letter "+s+" and the number "+num;
return returnValue;
}
/**
* This method is required by the EJB Specification,
* but is not used by this example.
*
*/
public void ejbActivate() {
log("ejbActivate called");
}
/**
* This method is required by the EJB Specification,
* but is not used by this example.
*
*/
public void ejbRemove() {
log("ejbRemove called");
}
/**
* This method is required by the EJB Specification,
* but is not used by this example.
*
*/
public void ejbPassivate() {
log("ejbPassivate called");
}
/**
* Sets the session context.
*
* @param ctx SessionContext Context for session
*/
public void setSessionContext(SessionContext ctx) {
log("setSessionContext called");
this.ctx = ctx;
}
/**
* This method is required by the EJB Specification,
* but is not used by this example.
*
*/
public void ejbCreate () throws CreateException {
log("ejbCreate called");
}
}
package examples.statelessSession;
import java.rmi.RemoteException;
import javax.ejb.EJBObject;
/**
* The methods in this interface are the public face of HelloWorld.
* The signatures of the methods are identical to those of the EJBean, except
* that these methods throw a java.rmi.RemoteException.
*/
public interface HelloWorld81 extends EJBObject {
/**
* Simply says hello from the EJB
*
* @param num int number to return
* @param s String string to return
* @return String returnValue
* @exception RemoteException if there is
* a communications or systems failure
*/
String sayHello(int num, String s)
throws RemoteException;
}
package examples.statelessSession;
import java.rmi.RemoteException;
import javax.ejb.CreateException;
import javax.ejb.EJBHome;
/**
* This interface is the Home interface of the HelloWorld stateless session EJB.
*/
public interface HelloWorldHome81 extends EJBHome {
/**
* This method corresponds to the ejbCreate method in the
* HelloWorldBean81.java file.
*/
HelloWorld81 create()
throws CreateException, RemoteException;
}
The differences between the 8.1 and 12.1.x files are shown in bold. The value of some JWS annotations are taken from attributes of the 8.1 servicegen Ant task shown in Example of an 8.1 and Updated 12.1.x Ant Build File for an 8.1 EJB-Implemented Web Service.
package examples.webservices.upgrade_ejb; // Import the standard JWS annotations import javax.jws.WebMethod; import javax.jws.WebService; import javax.jws.soap.SOAPBinding; // Import the WebLogic specific annotation import weblogic.jws.WLHttpTransport; // Class-level annotations @WebService(name="HelloWorld92PortType", serviceName="HelloWorldService", targetNamespace="http://example.org") @SOAPBinding(style=SOAPBinding.Style.DOCUMENT, use=SOAPBinding.Use.LITERAL, parameterStyle=SOAPBinding.ParameterStyle.WRAPPED) @WLHttpTransport(contextPath="upgradeEJB", serviceUri="HelloWorldService", portName="HelloWorld92Port") /** * HelloWorld92Impl is the JWS equivalent of the HelloWorld81 EJB that * implemented the 8.1 Web Service. It has a single method, * sayHello(), that takes an integer and a String and returns a String. */ public class HelloWorld92Impl { /** the sayHello method will become the public operation of the Web * Service. */ @WebMethod() public String sayHello(int num, String s) { System.out.println("sayHello in the HelloWorld92 Web Service has "+ "been invoked with arguments " + s + " and " + num); String returnValue = "This message brought to you by the "+ "letter "+s+" and the number "+num; return returnValue; } }
The following simple build.xml file shows the 8.1 way to build an EJB-implemented WebLogic Web service using the servicegen Ant task. Following this example is an equivalent build.xml file that calls the jwsc Ant task to build a 12.1.x Web service.
<project name="ejb-webservice" default="all" basedir=".">
<!-- set global properties for this build -->
<property name="source" value="."/>
<property name="build" value="${source}/build"/>
<property name="ejb_file" value="HelloWorldWS.jar" />
<property name="war_file" value="HelloWorldWS.war" />
<property name="ear_file" value="HelloWorldApp.ear" />
<property name="namespace" value="http://examples.org" />
<target name="all" depends="clean,ear"/>
<target name="clean">
<delete dir="${build}"/>
</target>
<!-- example of old 8.1 servicegen call to build Web Service -->
<target name="ejb">
<delete dir="${build}" />
<mkdir dir="${build}"/>
<mkdir dir="${build}/META-INF"/>
<copy todir="${build}/META-INF">
<fileset dir="${source}">
<include name="ejb-jar.xml"/>
</fileset>
</copy>
<javac srcdir="${source}" includes="HelloWorld*.java"
destdir="${build}" />
<jar jarfile="${ejb_file}" basedir="${build}" />
<wlappc source="${ejb_file}" />
</target>
<target name="ear" depends="ejb">
<servicegen
destEar="${build}/${ear_file}"
warName="${war_file}">
<service
ejbJar="${ejb_file}"
targetNamespace="${namespace}"
serviceName="HelloWorldService"
serviceURI="/HelloWorldService"
generateTypes="True"
expandMethods="True">
</service>
</servicegen>
</target>
</project>
An equivalent build.xml file that calls the jwsc Ant task to build a 12.1.x Web service is shown below, with the relevant tasks discussed in this section in bold:
<project name="webservices-upgrade_ejb" default="all">
<!-- set global properties for this build -->
<property name="wls.username" value="weblogic" />
<property name="wls.password" value="weblogic" />
<property name="wls.hostname" value="localhost" />
<property name="wls.port" value="7001" />
<property name="wls.server.name" value="myserver" />
<property name="ear.deployed.name" value="upgradeEJB" />
<property name="example-output" value="output" />
<property name="ear-dir" value="${example-output}/upgradeEJB" />
<taskdef name="jwsc"
classname="weblogic.wsee.tools.anttasks.JwscTask" />
<taskdef name="wldeploy"
classname="weblogic.ant.taskdefs.management.WLDeploy"/>
<target name="all" depends="clean,build-service,deploy" />
<target name="clean" depends="undeploy">
<delete dir="${example-output}"/>
</target>
<target name="build-service">
<jwsc
srcdir="src"
destdir="${ear-dir}">
<jws file="examples/webservices/upgrade_ejb/HelloWorld92Impl.java" />
</jwsc>
</target>
<target name="deploy">
<wldeploy action="deploy" name="${ear.deployed.name}"
source="${ear-dir}" user="${wls.username}"
password="${wls.password}" verbose="true"
adminurl="t3://${wls.hostname}:${wls.port}"
targets="${wls.server.name}" />
</target>
<target name="undeploy">
<wldeploy action="undeploy" name="${ear.deployed.name}"
failonerror="false"
user="${wls.username}" password="${wls.password}" verbose="true"
adminurl="t3://${wls.hostname}:${wls.port}"
targets="${wls.server.name}" />
</target>
</project>
The following table maps the attributes of the 8.1 servicegen Ant task to their equivalent 12.1.x JWS annotation or jwsc attribute.
The attributes listed in the first column are a mixture of attributes of the main servicegen Ant task and attributes of the four child elements of servicegen (<service>, <client>, <handlerChain>, and <security>)
See "JWS Annotation Reference" and "jwsc" in the WebLogic Web Services Reference for Oracle WebLogic Server for more information about the 12.1.x JWS annotations and jwsc Ant task.
Table 4-1 Mapping of servicegen Attributes to JWS Annotations or jwsc Attributes
| servicegen or Child Element of servicegen Attribute | Equivalent JWS Annotation or jwsc Attribute |
|---|---|
|
|
Note: Because this is a WebLogic-specific annotation, you can use it to generate only a JAX-RPC Web service, and not a JAX-WS Web service. |
|
|
|
|
|
|
|
|
No equivalent. |
|
|
No equivalent. |
|
|
|
|
(attribute of the |
No direct equivalent, because the Indirect equivalent is the |
|
(attribute of the |
No equivalent. |
|
(attribute of the |
No equivalent. |
|
(attribute of the |
No equivalent. |
|
(attribute of the |
No equivalent. |
|
(attribute of the |
No equivalent. |
|
(attribute of the |
No direct equivalent, because the Indirect equivalent is the |
|
(attribute of the |
No equivalent because JMS-implemented Web services are not supported in the 12.1.x release. |
|
(attribute of the |
No equivalent because JMS-implemented Web services are not supported in the 12.1.x release. |
|
(attribute of the |
No equivalent because JMS-implemented Web services are not supported in the 12.1.x release. |
|
(attribute of the |
No equivalent because JMS-implemented Web services are not supported in the 12.1.x release. |
|
(attribute of the |
No equivalent because JMS-implemented Web services are not supported in the 12.1.x release. |
|
(attribute of the |
No equivalent because JMS-implemented Web services are not supported in the 12.1.x release. |
|
(attribute of the |
One of the following WebLogic-specific annotations:
Note: Because these are WebLogic-specific annotations, you can use them to generate only a JAX-RPC Web service, and not a JAX-WS Web service. |
|
(attribute of the |
|
|
(attribute of the |
Note: Because these are WebLogic-specific annotations, you can use them to generate only a JAX-RPC Web service, and not a JAX-WS Web service. |
|
(attribute of |
|
|
(attribute of the |
No equivalent. |
|
(attribute of the |
|
|
(attribute of the |
Note: Because this is a WebLogic-specific annotation, you can use it to generate only a JAX-RPC Web service, and not a JAX-WS Web service. |
|
(attribute of |
No equivalent. |
|
(attribute of the |
No direct equivalent. Use the |
|
(attribute of the |
No equivalent. |
|
(attribute of the |
No equivalent. |
|
(attribute of the |
Standard |
|
(attribute of the |
Standard |
|
(attribute of the |
No direct equivalent. Use WebLogic-specific See "Using Web Service Reliable Messaging" in Developing JAX-RPC Web Services for Oracle WebLogic Server. |
|
(attribute of the |
No direct equivalent. Use WebLogic-specific In this release, the equivalent is valid for JAX-RPC Web services only. See "Using Web Service Reliable Messaging" in Developing JAX-RPC Web Services for Oracle WebLogic Server. |
|
(attribute of the |
No direct equivalent. Use WebLogic-specific Note: Because this is a WebLogic-specific annotation, you can use it to generate only a JAX-RPC Web service, and not a JAX-WS Web service. See "Configuring Message-Level Security" in Securing WebLogic Web Services for Oracle WebLogic Server. |
|
(attribute of the |
No direct equivalent. Use WebLogic-specific Note: Because this is a WebLogic-specific annotation, you can use it to generate only a JAX-RPC Web service, and not a JAX-WS Web service. See "Configuring Message-Level Security" in Securing WebLogic Web Services for Oracle WebLogic Server. |
|
(attribute of the |
No direct equivalent. Use WebLogic-specific Note: Because this is a WebLogic-specific annotation, you can use it to generate only a JAX-RPC Web service, and not a JAX-WS Web service. See "Configuring Message-Level Security" in Securing WebLogic Web Services for Oracle WebLogic Server. |
|
(attribute of the |
No direct equivalent. Use WebLogic-specific See "Configuring Message-Level Security" in Securing WebLogic Web Services for Oracle WebLogic Server. |
|
(attribute of the |
No direct equivalent. Use WebLogic-specific Note: Because this is a WebLogic-specific annotation, you can use it to generate only a JAX-RPC Web service, and not a JAX-WS Web service. See "Configuring Message-Level Security" in Securing WebLogic Web Services for Oracle WebLogic Server. |
|
(attribute of the |
No direct equivalent. Use WebLogic-specific Note: Because this is a WebLogic-specific annotation, you can use it to generate only a JAX-RPC Web service, and not a JAX-WS Web service. See "Configuring Message-Level Security" in Securing WebLogic Web Services for Oracle WebLogic Server. |
|
(attribute of the |
No direct equivalent. Use WebLogic-specific Note: Because this is a WebLogic-specific annotation, you can use it to generate only a JAX-RPC Web service, and not a JAX-WS Web service. See "Configuring Message-Level Security" in Securing WebLogic Web Services for Oracle WebLogic Server. |
This section summarizes how to upgrade an 8.1 WebLogic Web service to use the WebLogic JAX-WS stack.
The WebLogic JAX-WS run time is based on the JAX-WS (The Java API for XML-Based Web Services) 2.2 specification and the Web Services for Java EE v1.3 (JSR 109) specifications. These define annotations that are used in a Java Web Service (JWS) source file to define a Web service. Ant tasks are then used to compile the JWS into a Java class and generate all the associated artifacts. The Java Web Service (JWS) is the core of your JAX-WS web service.
Upgrading your 8.1 Web service includes the following high-level tasks:
Upgrade any Web service EJBs from 2.x to 3.x.
JAX-WS supports EJB 3.0 and 3.x. It does not support EJB 2.x.
Rewrite the 8.1 Web service class as a JAX-WS JWS file and map any proprietary 8.x features to similar JAX-WS features.
Note that there is not a one-to-one correspondence between 8.1 Web service features and JAX-WS 12.1.x features.
Update the Ant build script that builds the Web service to call the 12.1.x WebLogic Web service Ant task jwsc instead of the 8.1 servicegen task.
Generate new JAX-WS clients using the JAX-WS clientgen Ant task.
Before upgrading to JAX-WS, you should consider the following:
The JAX-WS specification supports the "document-literal" and "rpc-literal" styles, but not "rpc-encoded".
SOAP Arrays are not supported by JAX-WS.
For more information about JAX-WS, refer to Developing JAX-WS Web Services for Oracle WebLogic Server.