Creating a client for the Axis2 Web Service

In this post I'm going to explain how to implement a client application for the Axis2 web service we created in my previous post.

We can use the WSDL2Java tool in Axis2 to generate the client side stubs to interact with the service. You can use either the command line version of this tool or the Ant task as mentioned in the Axis2 guide [1].

In this post I will use the axis2-wsdl2code-maven-plugin to generate the client side stub.

You can use this pom to configure the axis2-wsdl2code-maven-plugin to genrate the stub code and the project structure.

  
  
       axis2-webservice-client
       4.0.0  
       jar  
       org.wso2.training.manorama  
       1.0  
         
            1.6.2  
            1.2.16  
         
         
              
                   
                      /src/main/resources
                      true  
                   
              
              
                   
                      org.apache.axis2  
                      axis2-wsdl2code-maven-plugin  
                      1.6.2  
                        
                             
                                  
                                     wsdl2code  
                                  
                                  
                                     http://localhost:8080/axis2/services/OrderProcessingService?wsdl  
                                     adb  
                                     org.wso2.training.orderprocessor.stub
                                     src/main/java  
                                     true  
                                  
                             
                        
                   
                   
                      org.apache.maven.plugins  
                      maven-compiler-plugin  
                   
              
         
         
              
                 org.apache.axis2  
                 axis2-kernel  
                 ${axis2.version}  
              
              
                 org.apache.axis2  
                 axis2-adb  
                 ${axis2.version}  
              
              
                 org.apache.axis2  
                 axis2-transport-http  
                 ${axis2.version}  
              
              
                 org.apache.axis2  
                 axis2-transport-local  
                 ${axis2.version}  
              
              
                 org.apache.axis2  
                 axis2-xmlbeans  
                 ${axis2.version}  
              
              
                 log4j  
                 log4j  
                 ${log4j.version}  
              
         
  

• Create a directory with the name SampleClient (with any name you prefer). 
• Save the above pom.xml with the required configuration.
• Note the <wsdlFile> element contains the path to the WSDL file. In this case it is the WSDL file of the OrderProcessingService deployed in the Axis2 Server. So the Axis2Server should be up and running. <packageName> element contains the package name which contains the generated stub java code.
• And configure the groupId, output directory as you prefer.

To generate the client stubs and the project structure go inside the folder SampleClient and give the following command.

$mvn clean install

You will be able to see the generated folders src and target. Now you can open this maven project using your preferred IDE. Here I'm using IntellijIdea.

You will see the project structure similar to the image below.

Now it's time to write the client code to send request.

I've created another package called orderclient. Inside that I've added  a new Java class Client.java

package org.wso2.training.orderclient;

import org.apache.axis2.AxisFault;
import org.wso2.training.orderprocessor.stub.OrderProcessingServiceStub;

import java.rmi.RemoteException;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Created with IntelliJ IDEA.
 * User: manorama
 * Date: 11/28/14
 * Time: 1:14 PM
 * To change this template use File | Settings | File Templates.
 */
public class Client {

    private static final Logger logger = Logger.getLogger(Client.class.getName());

    public static void main(String[] args) {

        OrderProcessingServiceStub stub = null;
        try {
            stub = new OrderProcessingServiceStub();

            // Create the request - In-only
            OrderProcessingServiceStub.SubmitOrder request = new OrderProcessingServiceStub.SubmitOrder();
            request.setOrderID("25");
            request.setAmount(240);
            stub.submitOrder(request);

            // Invoke the service - In-out service
            OrderProcessingServiceStub.GetAmount getAmount = new OrderProcessingServiceStub.GetAmount();
            getAmount.setOrderID("25");
            OrderProcessingServiceStub.GetAmountResponse response = stub.getAmount(getAmount);

            logger.info("Response from OrderProcessing service [OrderID : 25]: " + response.get_return());

        } catch (AxisFault axisFault) {
            logger.log(Level.SEVERE, axisFault.getMessage());
        } catch (RemoteException e) {
            logger.log(Level.SEVERE, e.getMessage());
        }


    }
}

It's time to compile and run the client.

References:
[1] https://axis.apache.org/axis2/java/core/tools/CodegenToolReference.html
[2] http://briansjavablog.blogspot.com/2013/01/axis2-web-service-client-tutorial.html 
[3] https://axis.apache.org/axis2/java/core/tools/maven-plugins/maven-wsdl2code-plugin.html

How to Create an Axis2 Web Service

In this post I'm going to explain a simple way to implement an Axis2 Web Service and how to deploy it.

This is a simple Order Processing service. I will start with a simple Java class and show you how to make a web service from it by including necessary configuration and packaging.

First create a maven project with this pom.

 

    4.0.0
    OrderProcessingService
    OrderProcessingService
    1.0    

Next add a Java class to your project with the name of the web service. This Java class contains all the methods which will be exposed as the operations of the web service.

import java.util.HashMap;  
  
/** 
 * Created with IntelliJ IDEA. 
 * User: manorama 
 * Date: 11/27/14 
 * Time: 2:22 PM 
 * To change this template use File | Settings | File Templates. 
 */  
public class OrderProcessingService {  
  
    private HashMap ordersMap = new HashMap();  
  
    public double getAmount(String orderID) {  
  
        Double price = (Double) ordersMap.get(orderID);  
        if(price != null){  
            return price.doubleValue();  
        }  
        return 0.00;  
    }  
  
    public void submitOrder(String orderID, double amount) {  
  
        ordersMap.put(orderID, amount);  
    }  
}

Next we have to add a service descriptor to the project. This is an xml file with the name services.xml. Each Axis2 service must have a service descriptor. The service descriptor informs Axis2 about the service.


Create a folder META-INF inside resources folder. And create an xml file services.xml inside that folder.

For the Order Processing Service, the service descriptor is as follows.

    
        Order Processing Service
    
    
        
        
    
    
        OrderProcessingService
    

We write the details about a web service inside the <service > element. We define message receivers that need to be used for the web service operations inside < messageReceivers > element. < parameter > element contains the name of the service implementation class.

Now we're done with the coding. Next step is to package the service implementation and configuration files according to the Axis2 format.

First compile the above code. It will create the directory target which contains the compiled class files inside the classes folder in it. Then simply change the directory to target/classes.

$cd target/classes

You can see the .class files and the META-INF directory containing the services.xml.

Now run the following command to package all the files into an aar archive with the relevant service name. In this example it is OrderProcessingService.aar

$jar -cvf OrderProcessingService.aar  *

To deploy the web service, copy the generated OrderProcessingService.aar into $AXIS2_HOME/repository/services

You can see the deployed service once you start the Axis2 server and point the browser to http://localhost:8080/axis2/services.

To invoke this web service using a client follow this tutorial.

Reference :
[1] http://wso2.com/library/95/

Append to $PATH vs import $PATH

We know .bashrc file inside our Ubuntu home folder is the file in which we set the environment variables for a single user. This is the bash script file.

Linux determines the executable search path with the $PATH environment variable

For example, after installing JDK we set $JAVA_HOME variable and update the $PATH variable.

To set those variables, we add the following lines at the end of the .bashrc file.

JAVA_HOME=/home/user/Java/jdk1.7.0_03
export JAVA_HOME
PATH=$PATH:$JAVA_HOME/bin
export PATH

So, what is the actual use of export even after appending the relevant path to the $PATH environment variable? Why do we need to export even after appending it to the $PATH variable?

The reason is,

Appending only to the $PATH is not sufficient because, it is same as setting a value inside a script (Here, only in .bashrc script). Thus that change is effective only within the script. In Ubuntu, it will be effective only within bash.

To make this change effective to any program called by bash we need to export the environment variable.