Choosing a Container

You can either deploy your web service in a web container or in an EJB container. This depends on your choice of implementation. If you are creating a Java EE 6 application, use a web container in any case, because you can put EJBs directly in a web application. For example, if you plan to deploy to the Tomcat Web Server, which only has a web container, create a web application, not an EJB module.

1. Choose File > New Project (Ctrl-Shift-N). Select Web Application from the Java Web category or EJB Module from the Java EE category.

   You can create a JAX-WS web service in a Maven project. Choose File > New Project (Ctrl-Shift-N) and then Maven Web Application or Maven EJB module from the Maven category. If you haven't used Maven with NetBeans before, see Maven Best Practices.

2. Name the project CalculatorWSApplication. Select a location for the project. Click Next.
3. Select your server and Java EE version and click Finish.

   To use the Oracle WebLogic server, register the server with the IDE. Also, if you are using the WebLogic server, watch the screencast on Deploying a Web Application to Oracle WebLogic.

Creating a Web Service from a Java Class

1. Right-click the CalculatorWSApplication node and choose New > Web Service.
2. Name the web service CalculatorWS and type org.me.calculator in Package. Leave Create Web Service from Scratch selected.
3. If you are creating a Java EE 6 project, select Implement Web Service as a Stateless Session Bean.
   
4. Click Finish. The Projects window displays the structure of the new web service and the source code is shown in the editor area.
   

Client 1: Java Class in Java SE Application

In this section, you create a standard Java application. The wizard that you use to create the application also creates a Java class. You then use the IDE's tools to create a client and consume the web service that you created at the start of this tutorial.

If you are using JDK 6 with NetBeans IDE 6.5, you must have JDK 6 Update 7 or later.

1. Choose File > New Project (Ctrl-Shift-N). Select Java Application from the Java category. Name the project CalculatorWS_Client_Application. Leave Create Main Class selected and accept all other default settings. Click Finish.
2. Right-click the CalculatorWS_Client_Application node and choose New > Web Service Client.
3. In Project, click Browse. Browse to the web service that you want to consume. When you have selected the web service, click OK.
4. Leave the other settings at default and click Finish.

   The Projects window displays the new web service client, with a node for the add method that you created:

   
   
5. Double-click Main.java so that it opens in the Source Editor. Delete the TODO comment and then drag the add node above into the empty line. You now see the following:

   public static void main(String[] args) {
   
       try { // Call Web Service Operation
           org.me.calculator.CalculatorWSService service = new org.me.calculator.CalculatorWSService();
           org.me.calculator.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 (in version 6.7 and later) Insert Code > Call Web Service Operation or (in version 6.5.1 and earlier) Web Service Client Resources > Call Web Service Operation.

6. Initialize the two ints. Just change the values of the two ints above from 0 to other integers, such as 3 and 4.
7. In the catch block, replace the commented out TODO with System.out.println("exception" + ex);.
8. Right-click the project node and choose Run.

   The Output window now shows the sum:

       compile:
       run:
       Result = 7
         BUILD SUCCESSFUL (total time: 1 second)

Client 2: Servlet in Web Application

In this section, you create a new web application, after which you create a servlet. You then use the servlet to consume the web service that you created at the start of this tutorial.

Important: If you are using JDK 6, you must have JDK 6 Update 7 or later.

1. Choose File > New Project (Ctrl-Shift-N). Select Web Application from the Java Web category. Name the project CalculatorWSServletClient. Click Next and then click Finish.
2. Right-click the CalculatorWSServletClient node and choose New > Web Service Client.

   The New Web Service Client wizard appears.

3. In Project, click Browse. Browse to the web service that you want to consume. When you have selected the web service, click OK.
4. Leave the other settings at default and 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:

   
   
5. Right-click the CalculatorWSServletClient project node and choose New > Servlet. Name the servlet ClientServlet and place it in a package called org.me.calculator.client. Click Finish.
6. To make the servlet the entry point to your application, right-click the CalculatorWSServletClient project node and choose Properties. Open the Run properties and type /ClientServlet in the Relative URL field. Click OK.
7. If you are using NetBeans IDE 6.5, you need to disable the Deploy on Save feature. Open the Run properties again and unselect Deploy on Save.
8. If there are error icons for ClientServlet.java, right-click the project node and select Clean and Build.
9. In the Source Editor, remove the line that comments out the body of the processRequest method. This is the line:

       /* 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):

   Note: The added code is for JDK 6. In JDK 5, the service is also instantiated explicitly. In JDK 6, the service is instantiated by the @WebServiceRef annotation.

       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.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 values for i and j to positive integers, such as 3 and 4, and replace the commented out TODO line in the catch block with out.println("exception" + ex);.

   Note: Alternatively, instead of dragging the add node, you can right-click in the editor and then choose (in version 6.7 and later) Insert Code > Call Web Service Operation or (in version 6.5.1 and earlier) Web Service Client Resources > Call Web Service Operation.

10. Right-click the project node and choose Run.

    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:
    

Client 3: JSP Page in Web Application

In this section, you create a new web application and then consume the web service in the default JSP page that the Web Application wizard creates.

If you are using JDK 6, you must have JDK 6 Update 7 or later.

If you want to run a JSP web application client on Oracle WebLogic, see Running a Java Server Faces 2.0 Application on WebLogic.

1. Choose File > New Project (Ctrl-Shift-N). Select Web Application from the Java Web category. Name the project CalculatorWSJSPClient. Click Finish.
2. Right-click the CalculatorWSJSPClient node and choose New > Web Service Client.
3. In Project, click Browse. Browse to the web service that you want to consume. When you have selected the web service, click OK.
4. Leave the other settings at default and click Finish.

   The Projects window displays the new web service client, as shown below:

   
   
5. In the Web Service References node, expand the node that represents the web service. The add operation, which you will invoke from the client, is now exposed.
6. Drag the add operation to the client's index.jsp page, and drop it below the H1 tags. The code for invoking the service's operation is now generated in the index.jsp page, as you can see here:

   <%
   try {
       org.me.calculator.CalculatorWSService service =
           new org.me.calculator.CalculatorWSService();
       org.me.calculator.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 other integers, such as 3 and 4. Replace the commented out TODO line in the catch block with out.println("exception" + ex);.

7. Right-click the project node and choose Run.

   The server starts, if it wasn't running already. The application is built and deployed, and the browser opens, displaying the calculation result: