All the primitive types and common data types like int, String and QName are predefined.

For more information about primitive type mapping, see the section Primitive Types.

Extra support is dedicated to Java containers. The Schemas for these data structures are pre-generated. If usage of some of these types is required, XML Schema describing these types is inserted into the target file.

For more information about containers, see Java Collections.

Schemas for Java containers can be found in WSO2 SOA Enablement Server Built-in XML Schema Files.

For information about containers compatible with Microsoft .NET for RPC/encoded style, please see .NET-Compatible Containers for SOAP Encoded.

For information about containers for document/literal style, please see .NET-Compatible Containers for SOAP Literal.

WSO2 SOA Enablement Server fully supports remote references, which are classes that implement the java.rmi.Remote interface. Such classes are mapped to QName {http://idoox.com/interface}serviceReference.

More information about references can be found in Remote References.

WSO2 SOA Enablement Server security features are also supported by the Java2Schema tool. There are two classes, java.security.Key and java.security.cert.Certificate, which are mapped to special structures in the namespace http://idoox.com/security.

Extra support is given to message attachments. The following classes are treated as attachments by WSO2 SOA Enablement Server:

Each attachment is mapped as a {http://www.w3.org/2001/XMLSchema}base64Binary type and transmitted via HTTP using Multi-part /related or DIME encoding.

More about attachments can be found in Service Using Attachments and Processing Attachments.

Java2Schema can handle a number of Java types which have extra representations in generated XML Schema.

These are enumeration, choice and any.

For more information, please see Advanced XML Schema Constructs.

The previous section described those types that have special mapping support. A different situation occurs for classes with a more complex structure. A complex structure may contain public attributes, getter/setter functions, or other elements. Mapping of these structures follows the type mapping described in Complex Types and Structures.

The inheritance and polymorphism solution is an important part of the mapping algorithm. While mapping, type inheritance in the XML Schema follows the same structure as in Java. For example, if class A inherits attribute M from class B, the XML Schema will contain structure A extending structure B, which has member M. Resolution of the multiple inheritance problem can be found in the section Multiple Inheritance.

For each generated schema structure, a target namespace is first chosen. The namespace is constructed from a default prefix (http://wso2.com/wsdl/) and the Java type's package name. When a type is primitive or has no package, the suffix default/ is used. If an array is generated, the namespace is chosen from the data type that comprises the array. In document/literal, each type used in an operation must be mapped to an element. Each element is stored to the namespace http://wso2.com/xsd/SchemaTypes/.

Table 1 shows a few examples of how mapping is provided.

To use custom mapping for a specific data type, you can give a custom XML Schema to the compiler. Each generated type can be annotated in the following way:

<xsd:complexType name="SimpleStruct">
    <xsd:annotation>
        <xsd:appinfo>
            <map:java-type name="examples.SimpleStruct" 
                xmlns:map="http://systinet.com/mapping/"/>
        </xsd:appinfo>
    </xsd:annotation> ...
</xsd:complexType>

For example, if the examples.SimpleStruct class has to be mapped, no type will be created. Instead, a pregenerated type will be referenced. The given schema will be imported everywhere it is used. Finally, it will be directly inserted or referenced in the target WSDL.

Consider a class which contains secret attributes and is extended by a public class. The secret attributes will appear in any mappings that result from using the Java2Schema tool. To prevent this, exclude such secret classes from the mapping.

Java2Schema can exclude a single class or a whole package. If a majority of the classes in a package must be excluded, exclude all classes in the package and include the individual classes from the package that are needed. Keep in mind that inclusion always has higher priority than exclusion.

For example, the following command excludes all classes in the package java.util except java.util.Set, which is specifically included:

Java2Schema --include-class java.util.Set --exclude-class java.util.*

Another problem arises in the case of multiple inheritance because XML Schema supports only simple inheritance. The algorithm for choosing the inheritance path is:

The default inheritance path can be changed. If class A extends B and implements interface C, while B implements interface D, it can be said that A follows these inheritance paths: A-C or A-D.

The following command tells class A to follow inheritance path A-C:

Java2Schema --inheritance "A-C" A

Java type mapping can be customized using deployment descriptors (please see Deployment Descriptors). If you already have a descriptor, simply tell Java2Schema to use it, as shown in the following command:

Java2Schema --deployment-descriptor package.xml --processing Processing example.service.MyService

Note that both deployment descriptor and processing options must be set at the start. The first option causes Java2Schema to parse the deployment descriptor file package.xml. The processing node named Processing inside the descriptor is taken and put into the mapping context. If the descriptor contains additional information--about type mapping, for example--WSO2 SOA Enablement Server will change its behavior to hold new settings.

Java2Schema uses several built-in Default XML Schemas. The conversion from Java classes to XML schema definition (.xsd) is driven by mapping information that is contained in the WSO2 SOA Enablement Server configuration. If this mapping points to a built-in schema, part of the type declaration is taken from the built-in schema and included in the generated .xsd file.

Each class that will be mapped, or that will be used in mapping, must be in the classpath. Java2Schema can extend the classpath for custom purposes, as shown in the following command:

Java2Schema --classpath c:\temp classname

The Java2Schema tools can be used in a simplified way by passing a class in the classpath as an argument on the command line, as in this command for passing the SimpleStructure class:

Java2Schema example.tools.java2schema.SimpleStructure.SimpleStructure

// Copyright WSO2 Inc. All rights reserved.
// Use is subject to license terms.
package example.tools.java2schema.SimpleStructure;

public class SimpleStructure {
    public int i;
    public String s;
}

A WSDL file named Schema_example_tools_java2schema_SimpleStructure.xs --insert MyType.xsdd is generated for direct use.

<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema elementFormDefault="qualified"
    targetNamespace="http://systinet.com/wsdl/example/tools/java2schema/SimpleStructure/"
    xmlns:map="http://systinet.com/mapping/"
    xmlns:tns="http://systinet.com/wsdl/example/tools/java2schema/SimpleStructure/" 
    xmlns:xsd="http://www.w3.org/2001/XMLSchema">
    <xsd:complexType name="SimpleStructure">
        <xsd:annotation>
            <xsd:appinfo>
                <map:java-type 
                    name="example.tools.java2schema.SimpleStructure.SimpleStructure"/>
            </xsd:appinfo>
        </xsd:annotation>
        <xsd:sequence>
            <xsd:element name="i" type="xsd:int"/>
            <xsd:element name="s" nillable="true" type="xsd:string"/>
        </xsd:sequence>
    </xsd:complexType>
</xsd:schema>

Data types can be generated either in RPC/encoded or document/literal style. If in RPC/encoded style, the types are generated according to the SOAP 1.1 encoding rules. Use the --soap-encoding-style command to set encoding styles, as shown below for the RPCEncoded class.

Java2Schema example.tools.java2schema.RPCEncoded.SoapStructure
           --soap-encoding-style encoded

// Copyright WSO2 Inc. All rights reserved.
// Use is subject to license terms.
package example.tools.java2schema.RPCEncoded;

public class SoapStructure {
  public int[] ints;
  public long[] longs;
  public String[][] strings;
}

The default behavior of WSO2 SOA Enablement Server is to generate a service in document/literal style. To make certain of this, use the --soap-encoding-style or --ses option, as shown here for the SoapStructure class:

Java2Schema example.tools.java2schema.DocumentLiteral.SoapStructure --soap-encoding-style literal

// Copyright WSO2 Inc. All rights reserved.
// Use is subject to license terms.
package example.tools.java2schema.DocumentLiteral;

public class SoapStructure {
  public int[] ints;
  public long[] longs;
  public String[][] strings;
}

The generated XML Schema will differ from the previous example if some of attributes are arrays or Java containers. See Literal vs. Encoded Serialization

To include or exclude a class, or all of the package, simply name it on the command line. Do not forget to take care of the default included and excluded classes named in the WSO2 SOA Enablement Server configuration file. If class A extends from B, but B has secret attributes, you can simply deny B, as shown in the following command. No prohibited extension will be written into the target Schema and only non-excluded attributes will occur in the final XML structure.

Java2Schema example.tools.java2schema.ClassExclusion.A --insert MyType.xsd
                    --exclude-class src.example.tools.java2schema.ClassExclusion.B

// Copyright WSO2 Inc. All rights reserved.
// Use is subject to license terms.
package example.tools.java2schema.ClassExclusion;

public class A extends B {
    public int memberA;
}

// Copyright WSO2 Inc. All rights reserved.
// Use is subject to license terms.
package example.tools.java2schema.ClassExclusion;

public class B {
    public String memberB;
}

A problem can occur due to multiple inheritance, as it is not supported by XML Schema. It can be partially solved by setting an explicit inheritance path. If class A extends class B and implements interfaces C and D, you can use the --inherit parameter to change the inheritance to A-C or A-D, as shown in this command:

Java2Schema example.tools.java2schema.Inheritance.A --inherit
         example.tools.java2schema.Inheritance.A - example.tools.java2schema.Inheritance.C

See Example 190.

// Copyright WSO2 Inc. All rights reserved.
// Use is subject to license terms.
package example.tools.java2schema.Inheritance;

public class A extends B implements C {
}

// Copyright WSO2 Inc. All rights reserved.
// Use is subject to license terms.
package example.tools.java2schema.Inheritance;

public class B implements D {
}

// Copyright WSO2 Inc. All rights reserved.
// Use is subject to license terms.
package example.tools.java2schema.Inheritance;

public interface C {
}

// Copyright WSO2 Inc. All rights reserved.
// Use is subject to license terms.
package example.tools.java2schema.Inheritance;

public interface D {
}

Choosing another inheritance, where Class A derives Class D, you use this command:

Java2Schema example.tools.java2schema.Inheritance.A --inherit
            example.tools.java2schema.Inheritance.A-example.tools.java2schema.Inheritance.D

If a type should be managed in some way other than the default, you can deliver a custom XML Schema that describes how the type should be mapped. To hold references, this Schema can be either inserted into the target WSDL or just referenced by the import element as the following command shows for the Structure and MyType classes:

Java2Schema example.tools.java2schema.OwnMapping.Structure --insert MyType.xsd

// Copyright WSO2 Inc. All rights reserved.
// Use is subject to license terms.
package example.tools.java2schema.OwnMapping;

public class Structure {
  public MyType myType;
  public int otherType;
}


class MyType {
  public int[] arr;
  public String s;
}

MyType.xsd contains the custom mapping of class MyType:

<?xml version='1.0'?>
<xsd:schema targetNamespace="http://systinet.com/wsdl/SchemaTypes/"
    xmlns:tns="http://systinet.com/wsdl/SchemaTypes/"
    xmlns:xsd="http://www.w3.org/2001/XMLSchema">
    <xsd:complexType name="MyType">
        <xsd:annotation>
          <xsd:appinfo>
            <map:java-type name="example.tools.java2schema.OwnMapping.MyType" 
            xmlns:map="http://systinet.com/mapping/"/>
          </xsd:appinfo>
        </xsd:annotation>
        <xsd:sequence>
            <xsd:element maxOccurs="unbounded" minOccurs="0" name="string" type="xsd:string"/>
        </xsd:sequence>
    </xsd:complexType>
</xsd:schema>