Start the IDE. Choose Tools → Servers from the main menu.

The Servers window appears.

Click Add Server.

Select GlassFish V2 or V3 or Sun Java System Application Server, and click Next.

The platform folder location window displays.

Specify the platform location of the server instance and the domain to which you want to register, then click Next.

The Servers window displays.

If requested, type the admin username and password that you supplied when you installed the web container (the defaults are admin and adminadmin), then click Finish.

Click the Services tab in the left pane, expand the Servers node, and verify that GlassFish is listed in the left pane. If it is not listed, register it by following the steps in Registering GlassFish with the IDE.

Choose File → New Project, select Java Web from Category, select Web Application from Projects, and click Next.

Assign the project a name that is representative of services that will be provided by the web service (for example, CalculatorApplication), set the Project Location to the location where you'd like to create the project, and click Next. Verify that GlassFish V2 or V3 is the Server and that Java EE Version is Java EE 5 or above. Click Finish.

Right-click the CalculatorApplication node and choose New → Web Service.

Type the web service name (CalculatorWS) and the package name (org.me.calculator) in the Web Service Name and the Package fields respectively.

Select Create Web Service from Scratch and click Finish.

The IDE then creates a skeleton CalculatorWS.java file for the web service. This file displays in Source mode in the right pane.

In the Operations box of the Design view of CalculatorWS.java, click Add Operation.

In the upper part of the Add Operation dialog box, type add in Name.

Type int into the Return Type field.

In the Return Type field, you can either enter a primitive data type or select Browse to select a complex data type.

In the lower part of the Add Operation dialog box, click Add and create a parameter named i of type int. Click Add again and create a parameter named j of type int.

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

Notice that the add method has been added in the Operations design box.

Click the Source tab for CalculatorWS.java in the right pane. Notice that the add method has been added to the source code.

@WebMethod(operationName="add")
public int add(@WebParam(name = "i") int i, @WebParam(name = "j") int j) {
    // TODO write your implementation code here
    return 0;
}

Change the add method to the following :

@WebMethod(operationName="add")
public int add(@WebParam(name = "i") int i, @WebParam(name = "j") int j) {
    int k = i + j;
    return k;
}

Save the CalculatorWS.java file.

In the Projects window, expand the Web Services node under the CalculatorApplication node, right-click the CalculatorWSService node, and choose Edit Web Service Attributes, as shown in Editing Web Service Attributes.

Figure 2.1. Editing Web Service Attributes

Select the Reliable Message Delivery check box, as shown in Reliable Messaging Configuration Window, and click OK.

Figure 2.2. Reliable Messaging Configuration Window

This setting ensures that the service sends an acknowledgement to the clients for each message that is delivered, thus enabling clients to recognize message delivery failures and to retransmit the message. This capability makes the web service a "reliable" web service.

In the left pane, expand the Web Pages node and the WEB-INF node, and double-click the wsit-endpoint-classname.xml (wsit-org.me.calculator.CalculatorWS.xml) file to view this file. Click the Source tab.

The following tags enable reliable messaging:

<wsp:Policy wsu:Id="CalculatorWSPortBindingPolicy">
    <wsp:ExactlyOne>
        <wsp:All>
            <wsam:Addressing wsp:Optional="false"/>
            <wsrm:RMAssertion/>
        </wsp:All>
    </wsp:ExactlyOne>
</wsp:Policy>

Right-click CalculatorApplication in the Project node, and select Properties, then select Run.

Type /CalculatorWSService?wsdl in the Relative URL field and click OK.

Right-click the Project node and choose Run. The first time GlassFish is started, you will be prompted for the admin password.

The IDE starts the web container, builds the application, and displays the WSDL file page in your browser. You have now successfully deployed a Metro-based web service.

Choose File → New Project, select Web Application from the Java Web category and click Next.

Name the project, for example, CalculatorWSServletClient, and click Next.

Verify that GlassFish V2 or V3 is the Server and that Java EE Version is Java EE 5 or above. Click Finish.

Right-click the CalculatorWSServletClient node and select New → Web Service Client.

The New → Web Service Client window displays.

Select the WSDL URL option.

Cut and paste the URL of the web service that you want the client to consume into the WSDL URL field.

For example, here is the URL for the CalculatorWS web service:

http://localhost:8080/CalculatorApplication/CalculatorWSService?wsdl

When JAX-WS generates the web service, it appends Service to the class name by default.

Click Finish.

Right-click the CalculatorWSServletClient project node and choose New → Servlet.

Name the servlet ClientServlet, specify the package name, for example, org.me.calculator.client and click Finish.

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

If ClientServlet.java is not already open in the Source Editor, open it.

In the Source Editor, remove the line that comments out the body of the processRequest method.

This is the start-comment line that starts the section that comments out the code:

/* TODO output your page here

Delete the end-comment line that ends the section of commented out code:

*/

Add some empty lines after the following line:

out.println("<h1>Servlet ClientServlet at " +
        request.getContextPath () + "</h1>");

Right-click in one of the empty lines that you added, then choose Insert Code... action and select Call Web Service Operation. Note that for older NetBeans releases, this action was present under "Web Service Client Resources → Call Web Service Operation".

Then Select Operation to Invoke dialog box appears.

Browse to the Add operation and click OK.

The processRequest method is as follows, with bold indicating code added by the IDE:

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 values for int i and int j to other numbers, such as 3 and 4.

Add a line that prints out an exception, if an exception is thrown.

The try/catch block is as follows (new and changed lines from this step and the previous step are highlighted in bold text):

try { // Call Web Service Operation
    org.me.calculator.client.CalculatorWS port =
            service.getCalculatorWSPort();
    // TODO initialize WS operation arguments here
    int i = 3;
    int j = 4;
    // TODO process result here
    int result = port.add(i, j);
    out.println("<p>Result: " + result);
} catch (Exception ex) {
    out.println("<p>Exception: " + ex);
}

If Reliable Messaging is enabled, the client needs to close the port when done or the server log will be overwhelmed with messages. To close the port, first add the following line to the import statements at the top of the file:

import com.sun.xml.ws.Closeable;

Then add the line in bold at the end of the try block, as shown below.

try { // Call Web Service Operation
    org.me.calculator.client.CalculatorWS port =
            service.getCalculatorWSPort();
    // TODO initialize WS operation arguments here
    int i = 3;
    int j = 4;
    // TODO process result here
    int result = port.add(i, j);
    out.println("<p>Result: " + result);
    ((Closeable)port).close();
} catch (Exception ex) {
    out.println("<p>Exception: " + ex);
}

Save ClientServlet.java.

Right-click the project node and choose Run.

The server starts (if it was not running already), the application is built, deployed, and run. The browser opens and displays the calculation result.

After starting Eclipse, select the J2EE perspective: Windows → Open Perspective → Others → J2EE

In the lower window you should see a tab with label Servers. Select the tab and right click in the window and select new → Server.

To download the GlassFish server, select Download additional server adapters. Accept the license and wait for Eclipse to restart.

After Eclipse has restarted, you can create a new GlassFish V2 Java EE5 server.

In the creation dialog select Installed Runtimes and select the directory where your GlassFish installation resides.

To create the HelloWorld service, create a new dynamic Web project. Give it a name (e.g. helloworld) and select as target runtime GlassFish

Deploy the service by selecting the project and select Run as → Run on server.

Check in the server Window that the helloworld project has a status of Synchronized. If this is not the case, right-click in the server window and select publish.

You can check that the GlassFish server is started and contains the Web service by going to the GlassFish admin console (localhost:4848)

Create a new project for the HelloWorld client (an ordinary Java project suffices).

Select Add Glassfish v2 as Server Runtime in Build Path.

Open a command window and go into the source directory of that project in Eclipse. For example, if the Eclipse workspace is in path

c:\home\vivekp\workspace

and the name of the project is HelloWorldClient, then you need to go to

c:\home\vivekp\workspace\helloworld\src

In this directory execute

wsimport -keep http://localhost:8080/helloworld/HelloWorldService?wsdl

On Linux or with Cygwin on Windows, you need to escape the ? by using \? instead.

Select refresh in the project view to see the generated files.

Now you can create the client class HelloWorldClient

You can execute the client, by selecting the HelloWorldClient in the package explorer of Eclipse and selecting Run → Java Application. In the console window of Eclipse, you should see "Hello World".

Select helloworldclient in Package Exp and create a new file build.xml

In this file (build.xml) copy the sample ant build script

Then select build.xml in the package explorer, then right click Run As → Ant Build...

Invoke client target, it will run wsimport ant task and generate the client side stubs

Invoke run to invoke the endpoint and run the client or you can execute the client, by selecting the HelloWorldClient in the package explorer of Eclipse and selecting Run → Java Application. In the console window of Eclipse, you should see "Hello World".

Inside Eclipse, install SOAP UI Plugin

Select Help → Software Updates → Find and Install...

Press the New Remote Site button and add http://www.soapui.org/eclipse/update/site.xml as the plugin URL

Select Finish and the follow the dialogs to install the soapUI feature

Create a new project for the HelloWorld client (an ordinary Java project suffices).

Select Add Glassfish v2 as Server Runtime in Build Path.

right click BuildPath+Add Library+ServerRuntime+Glassfish v2

Select the project and right click Soap UI → Add SOAPUI Nature, SOAP UI WebService item will be added in Project Explorer

Select HelloWorldPortBinding and right click GenerateCode → JAX-WS Artifacts

Enter the appropriate info in the JAX-WS Artifacts window

Figure 2.3. SOAP UI - JAX-WS Artifacts

Click Tools and enter the location of JAX-WS Wsimport, for example c:\glassfish\bin

Figure 2.4. SOAP UI - Preferences

Click OK

Then click Generate on JAX-WS Artifacts window, it will display a dialog box that the operation was successful. Switch back to Java Perspective, then refresh the src folder and you can see the wsimport generated classes

Now implement your client code

package sample;

public class HelloWorldClient {

   /**
    * @param args
    */
    public static void main(String[] args) {
        //Create Service
        HelloWorldService service = new HelloWorldService();

        //create proxy
        HelloWorld proxy = service.getHelloWorldPort();

        //invoke
        System.out.println(proxy.hello("hello"));
    }
}          

You can execute the client by selecting the HelloWorldClient in the package explorer of Eclipse and selecting Run → Java Application. In the console window of Eclipse, you should see "Hello World".