Java API for XML Web Services (JAX-WS) 2.0, JSR 224, is an important part of the Java EE 5 platform. A follow-on release of Java API for XML-based RPC 1.1(JAX-RPC), JAX-WS simplifies the task of developing web services using Java technology. It addresses some of the issues in JAX-RPC 1.1 by providing support for multiple protocols such as SOAP 1.1, SOAP 1.2, XML, and by providing a facility for supporting additional protocols along with HTTP. JAX-WS uses JAXB 2.0 for data binding and supports customizations to control generated service endpoint interfaces. With its support for annotations, JAX-WS simplifies web service development and reduces the size of runtime JAR files.
This document takes you through the basics of using the IDE to develop a JAX-WS web service and to consume it in three different clients—either a Java class in a Java SE application, or a servlet or JSP page in a web application. The three clients that you create in this document are separate applications, all consuming the same web service.
Contents |
Before you begin, you need to install the following software on your computer:
The goal of this exercise is to create a project appropriate to the deployment container that you decide to use. Once you have a project, you will create a web service in it.
You can either deploy your web service in a web container or in an EJB container. This depends on implementation choices. For example, if you plan to deploy to the Tomcat Web Server, which only has a web container, you should choose to create a web application, and not an EJB module.
The Projects window displays the structure of the new web service and the visual designer is shown in the editor area. For example, for web applications you should now see the following:
The goal of this exercise is to do something meaningful with the files and code that the IDE has generated for you. You will add an operation that will add two numbers received from a client.
A dialog box appears, where you can define the new operation.
You should now see the following:
The visual designer now displays the following:
@WebMethod public int add(@WebParam(name = "i") int i, @WebParam(name = "j") int j) { int k = i + j; return k; }
As you can see from the code above, the web service simply receives two numbers and then returns their sum. In the next section, we use the IDE to test our web service.
When you deploy a web service to a web container, the IDE lets you test the web service to see if it functions as you expect. The Tester application, provided by the Sun Java System Application Server, is integrated into the IDE for this purpose. For the Tomcat Web Server, there is a similar tool. However, while the Sun Java System Application Server's Tester page lets you enter values and test them, the Tomcat Web Server does not. In the latter case, you can only see that the web service is deployed, you cannot test the values. No facility for testing whether an EJB module is deployed successfully is currently available.
To test successful deployment to a web container:
The IDE starts the application server, builds the application, and opens the tester page in your browser, if you deployed a web application to the Sun Java System Application Server. For the Tomcat Web Server and deployment of EJB modules, the situation is different:
The sum of the two numbers is displayed:
Note: Since the result of a deployed EJB module is not displayed in a browser, you cannot take the step above if you are working with an EJB module.
Now that we have deployed our web service, we need to create a client to make use of the web service's add method. Here, we create three clients— a Java class in a Java SE application, a servlet, and a JSP page in a web application.
Note: A more advanced tutorial focusing on clients is Getting Started with JAX-WS Web Service Clients.
In this section, we create a standard Java application. The wizard that we use to create the application will also create a Java class. We will then use the IDE's tools to consume the web service that we created at the start of this tutorial.
The Projects window displays the new web service client, with a node for the add method that you created:
public static void main(String[] args) { try { // Call Web Service Operation org.me.calculator.client.CalculatorWSService service = new org.me.calculator.client.CalculatorWSService(); org.me.calculator.client.CalculatorWS port = service.getCalculatorWSPort(); // TODO initialize WS operation arguments here int i = 0; int j = 0; // TODO process result here int result = port.add(i, j); System.out.println("Result = "+result); } catch (Exception ex) { // TODO handle custom exceptions here } }
Note: Alternatively, instead of dragging the add node, you can right-click in the editor and then choose Web Service Client Resources > Call Web Service Operation.
The Output window should now show the sum:
compile: run: Result = 7 BUILD SUCCESSFUL (total time: 1 second)
In this section, we create a new web application, after which we create a servlet. We then use the servlet to consume the web service that we created at the start of this tutorial.
The New Web Service Client wizard appears.
You should now see the following:
Click Finish.
The Web Service References node in the Projects window displays the structure of your newly created client, including the add operation that you created earlier in this tutorial:
/* TODO output your page here
Next, delete the line that ends the section of commented out code:
*/
Add some empty lines after this line:
out.println("<h1>Servlet ClientServlet at " + request.getContextPath () + "</h1>");
Now, drag the node that represents the add operation into the space that you created.
The processRequest method now looks as follows (the added code is in bold below):
protected void processRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { response.setContentType("text/html;charset=UTF-8"); PrintWriter out = response.getWriter(); out.println("<html>"); out.println("<head>"); out.println("<title>Servlet ClientServlet</title>"); out.println("</head>"); out.println("<body>"); out.println("<h1>Servlet ClientServlet at " + request.getContextPath () + "</h1>"); try { // Call Web Service Operation org.me.calculator.client.CalculatorWS port = service.getCalculatorWSPort(); // TODO initialize WS operation arguments here int i = 0; int j = 0; // TODO process result here int result = port.add(i, j); out.println("Result = "+result); } catch (Exception ex) { // TODO handle custom exceptions here } out.println("</body>"); out.println("</html>"); out.close(); }
Change the value for i and j to more meaningful numbers, such as 3 and 4.
The server starts, if it wasn't running already; the application is built and deployed, and the browser opens, displaying the calculation result, as shown below:
In this section, we create a new web application and then consume our web service in the default JSP page that the Web Application wizard creates.
You should now see the following:
Click Finish.
The Projects window displays the new web service client, as shown below:
<% try { org.me.calculator.client.CalculatorWSService service = new org.me.calculator.client.CalculatorWSService(); org.me.calculator.client.CalculatorWS port = service.getCalculatorWSPort(); // TODO initialize WS operation arguments here int i = 0; int j = 0; // TODO process result here int result = port.add(i, j); out.println("Result = "+result); } catch (Exception ex) { // TODO handle custom exceptions here } %>
Change the value for i and j from 0 to more meaningful numbers, such as 3 and 4.
The server starts, if it wasn't running already; the application is built and deployed, and the browser opens, displaying the calculation result:
For more information about using NetBeans IDE 6.0 to develop Java EE applications, see the following resources:
To send comments and suggestions, get support, and keep informed on the latest developments on the NetBeans IDE Java EE development features, join the [email protected] mailing list.