Using SOAP with Java | The Client | Part 2

The client

Now we come to the most important part of writing the client. As described in previous sections, the client now has the added responsibilities of defining the type mappings and the Serializer/DeSerialzer classes to be used and set them correctly in the SOAP mapping registry.

public static void main(String[] args)
    {
        String urlString = args[0];
        String name = args[1];
        SoapClient client = new SoapClient(urlString);
        System.out.println("*** Assigned the url for the sopa router as: "+urlString);
        /** construct a Person object**/
        Person nameObject = new Person();
        nameObject.setName(name);
        nameObject.setAge(22);

Now we can prepare the Call object as usual.

Call call = new Call();
       call.setTargetObjectURI("urn:greetingService");
       call.setMethodName("sayGreeting");
       call.setEncodingStyleURI(Constants.NS_URI_SOAP_ENC);

Here we will define and setup the mapping registry. We first create a new instance of the SOAPMappingRegistry.

    //create the type mapping registry
           SOAPMappingRegistry smr = new SOAPMappingRegistry();

Now we create a new instance of the BeanSerializer class.

//new instance of the serializer class
BeanSerializer bsr = new BeanSerializer();

We will create a QName object to represent the compound Person data-type.

//create a qname object
QName qn = new QName("urn:greetingService", "sam.soap.client.Person");

Now we will create the type mapping by invoking the maptype method on the SOAPMappingRegistry object.

//map the type
smr.mapTypes
   (Constants.NS_URI_SOAP_ENC, qn, sam.soap.client.Person.class, bsr, bsr);

The mapTypes method accepts the encoding style, the QName object, the class of the java bean , serializer class and the deserializer class as the arguments. If you recall the discussion on the mechanism of the serialization, then you will at once understand that these parameters are used to construct the four Hashtables defined.

Now we set the type mapping to the SOAP mapping registry.

//telling the call object to use this mapping
           call.setSOAPMappingRegistry(smr);

We will create a Parameter object with the Person object and pass it to the call object subsequently.

//creating the parameters
        Vector v = new Vector();
        Parameter param1 = 
 new Parameter("name", sam.soap.client.Person.class, nameObject, null);
        v.addElement(param1);
        call.setParams(v);

As you have noticed that the parameter object now holds a compound type Person object. The Person object in turn holds the value for its properties name and age. If we now invoke the remote method, we will see the required result.

//invoke the soap method
      System.out.println("invoking....");
      Response res = call.invoke(new URL(client.urlString), "");
      
      //if there is no fault in the method invocation, get the result
      if( res.generatedFault() ==false)
      {
          Parameter retValue = res.getReturnValue();
          Object value = retValue.getValue();
          System.out.println(value);
      }else
      {
          System.out.println("The fault is: "+res.getFault().getFaultString());
      }

If you deploy the service properly with the new deployment descriptor and run the client you will get the desired result.

Conclusion

In this installment we have examined how to use customised Java beans as parameters to the SOAP Remote Procedure Call. We have also analysed the underlying principles and protocols of Serialization mechanism underlying SOAP. The world is much brighter for us. But surely if you are an astute reader, you might have figured out that the world may be full of more complex objects which are more than Java beans. Next month we will see how to write our own Serializers and will also learn some exciting new aspects of SOAP. Happy coding.

 1 
About | Sitemap | Contact