Hospedagem Profissional

Hospedagem Profissional
Clique aqui e ganhe US$ 10,00 para testar durante 1 mês a melhor hospedagem: Digital Ocean!

segunda-feira, 16 de março de 2009

Getting Started with JAX-WS Web Services

Navegando na documentação e tutoriais disponibilizados pelo NetBeans, descobri um ótimo tutorial sobre como utilizar o NetBeans 6.5 para a confecção de webservices e três exemplos de como consumir esse web sercive a partir de uma classe java, um servlet e um jsp.

Me impressionou o grau de automatização em que o netbeans trata as duas operações, principalmente no ato de consumir um web service.

Interessante citar também que o objetivo é deixar que o desenvolver mantenha seu foco somente nas regras negociais do web service, deixando todas as “chatices” das configurações e deployments para os wizards do netbeans.

Realmente vale a pena conferir

ACESSE TAMBÉM O POST “Developing JAX-WS Web Service Clients” PARA UM TUTORIAL MAIS DETALHADO SOBRE DESENVOLVIMENTO DE CLIENTES QUE CONSOMEM WEB SERVICES A PARTIR DO NETBEANS.

 

 

Java API for XML Web Services (JAX-WS) 2.0/2.1, JSR 224, is an important part of the Java EE 5 platform. A follow-up to the 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 demonstrates the basics of using the IDE to develop a JAX-WS web service. After you create the web service, you write three different web service clients that use the web service over a network, which is called "consuming" a web service. The three clients are a Java class in a Java SE application, a servlet, and a JSP page in a web application. A more advanced tutorial focusing on clients is Developing JAX-WS Web Service Clients.

Contents

Content on this page applies to NetBeans IDE 6.0, 6.1 and 6.5

To follow this tutorial, you need the following software and resources.

Software or Resource
Version Required

NetBeans IDE
Java version 6.5

Java Development Kit (JDK)
version 6 or version 5
Note: If you are using JDK 6,
you must have JDK 6 Update 7 or later.

Java EE-compliant web or application server
Tomcat web server 6.0 and/or
GlassFish application server v2

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

Both Tomcat and GlassFish can be installed with the Web and Java EE distribution of NetBeans IDE. Alternatively, you can visit the GlassFish downloads page or the Apache Tomcat downloads page.

Creating a Web Service

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.

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. 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 Web category or EJB Module from the Enterprise category.
  2. Name the project CalculatorWSApplication.
  3. Depending on the deployment server that you want to use, do the following:
    • For GlassFish, set the Java EE Version to Java EE 5.
    • For the Tomcat Web Server, unselect the Set Source Level to 1.4 checkbox.
  4. Click through the remaining pages and click Finish.

    Creating a project in NetBeans 6.1 includes new options which can be left at the default. For example, the Use Dedicated Folder for Storing Libraries checkbox may be left unselected.

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, type org.me.calculator in Package, and click Finish.

    The Projects window displays the structure of the new web service and the visual designer is shown in the editor area. For web applications you now see the following:

    Projects window displaying the web service

Designing the Web Service

The goal of this exercise is to add to the web service an operation that adds two numbers received from a client.

Adding an Operation to the Web Service
  1. Click Add Operation in the visual designer. A dialog box appears where you can define the new operation.
  2. In the upper part of the Add Operation dialog box, type add in Name and type int in the Return Type drop-down list. In the lower part of the Add Operation dialog box, click Add and create a parameter of type int named i. Then click Add again and create a parameter of type int called j.

    You now see the following:

    Add Operation dialog

  3. Click OK at the bottom of the Add Operation dialog box.

    The visual designer now displays the following:

    Web service visual designer showing added operation

  4. Click Source and notice that the source code that has been generated in the previous steps is as follows:
    Result
  5. In the editor, extend the skeleton add operation to the following (changes are in bold):
        @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 preceding code, the web service simply receives two numbers and then returns their sum. In the next section, you use the IDE to test the web service.



Deploying and Testing the 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 GlassFish, is integrated into the IDE for this purpose. For the Tomcat Web Server, there is a similar tool. However, while GlassFish'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:




  1. Right-click the project and choose Undeploy and Deploy. The IDE starts the application server, builds the application, and deploys the application to the server. You can follow the progress of these operations in the CalculatorWSApplication (run-deploy) and GlassFish V2 or Tomcat tabs in the Output view.


  2. In the IDE's Projects tab, expand the Web Services node of the CalculatorWSApplication project. Right-click the CalculatorWS node, and choose Test Web Service.

    Projects tab showing Test Web Service context menu option

    The IDE opens the tester page in your browser, if you deployed a web application to GlassFish. For the Tomcat Web Server and deployment of EJB modules, the situation is different:




    • If you deployed to GlassFish, type two numbers in the tester page, as shown below:

      Web service tester page when service successfully deployed to GlassFish

      The sum of the two numbers is displayed:



      Web page showing result of web service test




    • If you deployed to the Tomcat Web Server, you will see the following instead, which indicates that you have successfully deployed your web service:

      Web page displayed when web service was successfully deployed to Tomcat server


    • Right-click the project node, choose Properties, and click Run. Depending on the deployment server that you want to use, do the following:

      • For GlassFish, type /CalculatorWSService?Tester in the Relative URL field.


      • For the Tomcat Web Server, type /CalculatorWS?Tester in the Relative URL field.



      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.







Consuming the Web Service



Now that you have deployed the web service, you need to create a client to make use of the web service's add method. Here, you 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 Developing JAX-WS Web Service Clients.



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:



    New web service client in Java SE application displayed in the Projects window




  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 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. 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.



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 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:



    New web service client in servlet displayed in the Projects window




  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. Right-click the CalculatorWSServletClient project node and choose Properties. Open the Run properties and unselect Deploy on Save.


  7. To make the servlet the entry point to your application, right-click the project node, choose Properties, click Run, and type /ClientServlet in Relative URL. Click OK.


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



        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.




  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:

    New web service client in servlet displayed in the Projects window





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.




  1. Choose File > New Project (Ctrl-Shift-N). Select Web Application from the 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:



    New web service client in servlet displayed in the Projects window




  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.




  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:



    JSP page showing result







Fonte : http://www.netbeans.org/kb/docs/websvc/jax-ws.html