The following table describes the Java and XML data type mappings built into JEUS web services.

The QName of the XML type can be used to specify a data type in a DII client

String NS_XSD = “http://www.w3.org/2001/XMLSchema”;
String XSD_DATETIME = new QName(NS_XSD, “dateTime”);
call.addParameter(“arg1”, XSD_DATETIME, PARAM_MODE_IN);

JEUS web services also support arrays that are defined by the JAX-RPC types. For example, int[ ], String[ ], and multidimensional arrays, such as java.math.BigDecimal[ ][ ], are supported.

JEUS web services also support any user-defined types implemented in an application. The JAX-RPC specification refers to such classes as 'value types'. To be supported by JEUS web services, user-defined classes must conform to the following rules.

The class may contain public, private, or protected fields. To pass a field value during a web service call, the field must meet the following conditions.

JavaBeans components, which conform to these rules, are also supported.

The following is the source code for the CalcService class, ‘Calculator.java’.

package calc;

public class Calculator implements CalculatorIF {
    public Calculator() { }
    public double calc(CalcData data) {
        String op = data.getOp();
        double num1 = data.getNum1();
        double num2 = data.getNum2();
        double ret = -9999.0;

        if (op.equals("plus")) {
            ret = num1 + num2;
        } else if (op.equals("minus")) {
            ret = num1 - num2;
        } else if (op.equals("mult")) {
            ret = num1 * num2;
        } else if (op.equals("div")) {
            if (num2 != 0)
                ret = num1 / num2;
        }
        return ret;
    }
}

The calc( ) method takes an argument of the CalcData type and returns '–9999.0' when an error occurs. A more detailed error handling procedures will be described later.

The following is the source code of CalcData.java.

package calc;

public class CalcData {
    private double num1;
    private double num2;
    private String op;

    public CalcData() { }
    public double getNum1() { return num1; }
    public double getNum2() { return num2; }
    public String getOp() { return op; }

    public void setNum1(double n) { num1 = n; }
    public void setNum2(double n) { num2 = n; }
    public void setOp(String s) { op = s; }
}

The CalcData class meets the requirements of a JAX-RPC value type. This means that an instance of the CalcData class can be copied on the fly by value.

The following is the service endpoint interface file, 'CalculatorIF.java'.

package calc;

import java.rmi.Remote;
import java.rmi.RemoteException;

public interface CalculatorIF extends Remote {
    public double calc(CalcData data) throws RemoteException;
}

Execute the following command to compile the source code and generate web service artifacts.

ant compile

This command generates the class files under the build directory.

Execute the following command to create a deployable EAR file.

ant wsear

Now, deploy the created web service module. The following is the web service URL.

http://localhost:8088/Calculator1Service/Calculator1Service?wsdl

The following command generates a Proxy client for the 'CalcService' web service.

ant wsdl2java

Assume that the package name of the generated stub code is 'com.test.calc'.

The following is the source code for the client program.

import com.test.calc.*;
import javax.xml.rpc.soap.SOAPFaultException;

public class CalcClient {
    public static void main(String[] args) {
        CalcClient calc = new CalcClient();

        if (args.length != 3) {
            System.out.println("usage: java CalcClient num1 op num2");
            System.out.println(" where op is one of " + "'plus', 'minus',
                     'mult', 'div'");
            System.exit(1);
        }
        try {
            calc.run(args);
        } catch (SOAPFaultException e) {
            System.err.println("faultcode = " + e.getFaultCode());
            System.err.println("faultString = " + e.getFaultString());
        } catch (Exception e) {
            System.err.println(e.toString());
            e.printStackTrace();
        }
    }
    public void run(String[] args) throws Exception {
        CalculatorIF port = new
        Calculator1Service_Impl().getCalculatorIFPort();
        CalcData data = new CalcData();
        data.setNum1((new Double(args[0])).doubleValue());
        data.setNum2((new Double(args[2])).doubleValue());
        data.setOp(args[1]);

        double ret = port.calc(data);
        System.out.println(ret);
    }
}

Once a client code has been implemented, you can compile the client and stub codes by using the following command

ant build

Execute Ant task to execute the client

ant runclient

If executed successfully, the following result will be displayed.

2.0

JEUS web services provide JAX-RPC holder classes for simple data types. The standard holder classes provided by JAX-RPC are shown in the following table.

Use the value field of each holder class to access its data. The following is the modified source code for 'Caculator.java'.

package calc;

import javax.xml.rpc.holders.DoubleHolder;

public class Calculator implements CalculatorIF {
    public Calculator() { }

    public void calc(CalcData data, DoubleHolder result){
        String op = data.getOp();
        double num1 = data.getNum1();
        double num2 = data.getNum2();
        double ret = -9999.0;

        if (op.equals("plus")) {
            ret = num1 + num2;
        } else if (op.equals("minus")) {
            ret = num1 - num2;
        } else if (op.equals("mult")) {
            ret = num1 * num2;
        } else if (op.equals("div")) {
            if (num2 != 0)
                ret = num1 / num2;
        }
    
        result.value = ret;
    }
}

The source code imports the built-in holder class, javax.xml.rpc.holders.Double Holder.

import javax.xml.rpc.holders.DoubleHolder;

The signature of calc( ) method has also been modified. Its return type is void, and it accepts holder object as its second parameter.

public void calc(CalcData data, DoubleHolder result){
. . .
}

To access the value of the holder object, use the value field of the holder class.

result.value = ret;

The web service must be packaged and deployed before creating a web service client for the service. The client program, 'CalcClient.java', must also be modified.

The following shows the run( ) method in the client source code, 'CalcClient.java'.

    public void run(String[] args) throws Exception {
        CalculatorIF port = new CalcService_Impl().getCalculatorIFPort();
        CalcData data = new CalcData();
        data.setNum1((new Double(args[0])).doubleValue());
        data.setNum2((new Double(args[2])).doubleValue());
        data.setOp(args[1]);

        DoubleHolder ret = new DoubleHolder();
        port.calc(data, ret);
        System.out.println(ret.value);
    }

The following are the steps for creating a holder class for the user-defined class.

The CalcService example will be modified to illustrate how to use a holder class of the JAX-RPC value type. This is the CalcData class that includes the result value as its member variable. A private member variable called 'result' and its getter/setter methods are added to the following class.

package calc;

public class CalcData {
    private double num1;
    private double num2;
    private String op;
    private double result;

    public CalcData() { }
    public double getNum1() { return num1; }
    public double getNum2() { return num2; }
    public String getOp() { return op; }
    public double getResult() { return result; }

    public void setNum1(double n) { num1 = n; }
    public void setNum2(double n) { num2 = n; }
    public void setOp(String s) { op = s; }
    public void setResult(double n) { result = n; }
}

The holder class of the CalcData class is called CalcDataHolder. The CalcDataHolder class has a public 'value' field whose data type is CalcData and two constructors that initialize the 'value' field.

package calc;
import javax.xml.rpc.holders.Holder;

public class CalcDataHolder implements Holder {
    public CalcData value;

    public CalcDataHolder() {
    }

    public CalcDataHolder(CalcData value) {
        this.value = value;
    }
}

The following is the source code in 'Calculator.java' that uses the holder class. The calc( ) method defines a parameter whose data type is CalcDataHolder. The public 'value' field is used to access the object that the holder object holds.

package calc;

public class Calculator implements CalculatorIF {
    public Calculator() { }
    
    public void calc(CalcDataHolder calcData) {
        CalcData data = calcData.value;
        String op = data.getOp();
        double num1 = data.getNum1();
        double num2 = data.getNum2();
        double ret = -9999.0;

        if (op.equals("plus")) {
            ret = num1 + num2;
        } else if (op.equals("minus")) {
            ret = num1 - num2;
        } else if (op.equals("mult")) {
            ret = num1 * num2;
        } else if (op.equals("div")) {
            if (num2 != 0)
                ret = num1 / num2;
        }
        data.setResult(ret);
        
        // The following line is not necessary in this case.
        // But we will use it to show the usage of holder class.
        calcData.value = data;
    }
}

The following is the client source code. The 'ant wsdl2java' command also generates holder classes for the client from WSDL document. Note that the holder classes generated in this way can be different from the one that is manually created.

import com.test.calc.*; // generated by ant process-wsdl 
import com.test.calc.holders.*; // generated by ant process-wsdl 

public class CalcClient {
    public static void main(String[] args) {
        CalcClient calc = new CalcClient();

        if (args.length != 3) {
            System.out.println("usage: java CalcClient num1 op num2");
            System.out.println(" where op is one of " + "'plus', 'minus', 
                  'mult', 'div'");
            System.exit(1);
        }

        try {
            calc.run(args);
        } catch (Exception e) {
            System.err.println(e.toString());
            e.printStackTrace();
        }
    }

    public void run(String[] args) throws Exception {
        CalculatorIF port = new Calculator3Service_Impl().getCalculatorIFPort();
        CalcData data = new CalcData();
        CalcDataHolder dataHolder = new CalcDataHolder(data);

        data.setNum1((new Double(args[0])).doubleValue());
        data.setNum2((new Double(args[2])).doubleValue());
        data.setOp(args[1]);
        
        port.calc(dataHolder);
        System.out.println(dataHolder.value.getResult());
    }
}

The following is an example of a web service WSDL that contains a MIME part.

<message name="submission">
    <part name="title" type="xsd:string" />
    <part name="price" type="xsd:float" />
    <part name="attachment" type="xsd:hexBinary" />
</message>
. . .
<operation name="submit">
    . . .
    <input>
        . . .
        <mime:part>
            <mime:content part="attachment" type="application/xml" />
        </mime:part>
        . . .
    </input>
    . . .
</operation>

By default, when a service endpoint interface is generated by using wsdl2java based on the previous WSDL, the MIME type 'application/xml' becomes mapped to the javax.xml.transform.Source type.

public interface SubmitBook extends java.rmi.Remote {
  public String submit(String title, float price,
                       javax.xml.transform.Source attachment)
                       throws java.rmi.RemoteException;
}

When the attribute called 'dataHandlerOnly' is set to 'true' through Ant task and wsdl2java, or when the '–datahandleronly' option is used through the command-line tool, the MIME part is always mapped to javax.activation. DataHandler type, regardless of the MIME type.

public interface SubmitBook extends java.rmi.Remote {
  public String submit(String title, float price,
                       javax.activation.DataHandler attachment)
                       throws java.rmi.RemoteException;
}

Hence, the web service client must send the attachment as the DataHandler type.

The following is an example of the web service client that uses the DataHandler type.

// Creates a FileInputStream from the specified path name
FileInputStream inputStream =
    new FileInputStream(new File("attachment/book.xml"));
DataHandler dataHandler = new DataHandler(inputStream, "application/xml");

// Get a Service port
SubmitBook port = new SubmitBookService_Impl().getSubmitBookPort();
String result = port.submit("Sample for a option: datahandleronly", 
                12.34f, dataHandler);
System.out.println("response = " + result);

The following is an example of a WSDL described as a Document/Literal.

<definitions name="BookQuoteService" ... >
    <types>
        <xsd:schema targetNamespace="...">
            <xsd:complexType name="Book">
                <xsd:sequence>
                    <xsd:element name="title" type="xsd:string" />
                    <xsd:element name="isbn" type="xsd:string" />
                    <xsd:element name="authors" type="xsd:string" />
                </xsd:sequence>
            </xsd:complexType>
            <xsd:element name="Book" type="mh:Book" />
            <xsd:element name="Result" type="xsd:float" />
        </xsd:schema>
    </types>

    <message name="getBookPriceRequest">
        <part name="book" element="mh:Book" />
    </message>
    <message name="getBookPriceResponse">
        <part name="result" element="mh:Result" />
    </message>
    . . .
  
    <binding name="BookServiceSoapBinding" type="mh:BookQuote">
        <soap:binding style="document" ... />
        <operation name="getBookPrice">
            <input>
                <soap:body use="literal" ... />
            </input>
            <output>
                <soap:body use="literal" ... />
            </output>
        </operation>
    </binding>
    . . .
</definitions>

The service endpoint interface generated by wsdl2java from the previous WSDL has the following input parameter.

public interface BookQuote extends java.rmi.Remote {
    public float getBookPrice(sample.nodatabinding.stub.Book book)
    throws java.rmi.RemoteException;
}

When creating an SEI through wsdl2java, if the attribute called 'noDataBinding' is set to 'true' through wsdl2java Ant task or the '–nodatabinding' option is set to 'true' through the command-line tool, the input parameters and return value types must always be javax.xml.soap.SOAPElement, regardless of the XML type.

public interface BookQuote extends java.rmi.Remote {
public javax.xml.soap.SOAPElement
    getBookPrice(javax.xml.soap.SOAPElement book)
    throws java.rmi.RemoteException;
}

The 'nodatabinding' option for wsdl2java is only valid in a Document/Literal WSDL.

In this case, the web service client developer must manually create a message as the SOAPElement type. The following is an example of the web service client that uses the SOAPElement type.

// Creates a FileDataSource from the specified path name
SOAPFactory factroy = SOAPFactory.newInstance();

// Create a SOAPElement object
SOAPElement book = factroy.createElement( "Book", "mh", 
                   "http://www.tmaxsoft.com/j2eews/BookQuote");

SOAPElement title = factroy.createElement("title");
title.addTextNode("Sample for a option: nodatabinding");
book.addChildElement(title);

SOAPElement isbn = factroy.createElement("isbn");
isbn.addTextNode("123-456-789");
book.addChildElement(isbn);

SOAPElement authors = factroy.createElement("authors");
authors.addTextNode("TmaxSoft Co., Ltd.");
book.addChildElement(authors);

// Get a Service port
BookQuote port = new BookQuoteService_Impl().getBookQuotePort();
SOAPElement price = port.getBookPrice(book);
System.out.println("price = " + price.getValue());