此部分继续描述WSDL 1.1到Java映射的其他部分。  

　　2.3.2 参数次序和返回类型

　　Wsdl:operation元素可以有一个parameterOrder属性，它定义了映射的Java方法中的参数顺序，如下：

　　1 <!-- WSDL extract -->

　　2 <types>

　　3 <xsd:element name="setLastTradePrice">

　　4 <xsd:complexType>

　　5 <xsd:sequence>

　　6 <xsd:element name="tickerSymbol" type="xsd:string"/>

　　7 <xsd:element name="lastTradePrice" type="xsd:float"/>

　　8 </xsd:sequence>

　　9 </xsd:complexType>

　　10 </xsd:element>

　　11

　　12 <xsd:element name="setLastTradePriceResponse">

　　13 <xsd:complexType>

　　14 <xsd:sequence/>

　　15 </xsd:complexType>

　　16 </xsd:element>
　
　　17 </types>

　　18

　　19 <message name="setLastTradePrice">

　　20 <part name="setLastTradePrice"

　　21 element="tns:setLastTradePrice"/>

　　22 </message>

　　23

　　24

　　25 <message name="setLastTradePriceResponse">

　　26 <part name="setLastTradePriceResponse"

　　27 element="tns:setLastTradePriceResponse"/>

　　28 </message>

　　29

　　30

　　31 <portType name="StockQuoteUpdater">

　　32 <operation name="setLastTradePrice">

　　33 <input message="tns:setLastTradePrice"/>

　　34 <output message="tns:setLastTradePriceResponse"/>

　　35 </operation>

　　36 </portType>

　　37

　　38 // non-wrapper style mapping

　　39 SetLastTradePriceResponse setLastTradePrice(

　　40 SetLastTradePrice setLastTradePrice);

　　41

　　42 // wrapper style mapping

　　43 void setLastTradePrice(String tickerSymbol， float lastTradePrice);

　　2.3.3 Holder类

　　Holder类用来在映射的方法签名里支持out和in/out参数。他们为不可变的对象引用提供一个可变的包装。JAX-WS定义了一个一般的holder类（javax.xml.ws.Holder<T>），可以被任何Java类使用。

　　如果参数的XML数据类型可以自然地被映射成为一个Java原始类型（比如，xsd:int到int），那么它可以不被映射到一个Holder。比如一个out或in/out参数，它的XML数据类型可以很自然地映射到Java的int类型，而不用映射到Holder（java.lang.Integer）。

　　2.3.4 异步

　　除了wsdl:operation的不同映射之外，客户端的异步的映射也是支持的。异步映射被期待在一些情况而不是所有情况下有用。因此对于用户来说，客户端的异步方法的产生是可选的。

　　异步映射要求实现必须支持异步映射。

　　2.3.4.1 标准的异步映射接口

　　异步操作映射用到下面的标准接口：

　　javax.xml.ws.Response         一个普通的接口，用来将带有响应上下文的方法调用结果分组。Response继承了Future<T>来提供异步结果投票表决能力。

　　javax.xml.ws.AsyncHandler  一个普通的接口，客户端实现这个接口来接收异步回调结构。

　　2.3.4.2 Operation（操作）

　　每一个wsdl:operation在相应的SEI（service endpoint interface）被映射到两个附加的方法：

　　Polling方法  polling方法返回一个Response<ResponseBean>，它可以使用继承自Future<T>的方法来决定什么时候操作完成以及得到结果。

　　Callback方法  回调方法有一个额外的final参数，它是AsyncHandler<ResponseBean>的一个实例，返回一个Future<？>，这个通配符可以投票决定操作什么时候完成。Future<？>.get()返回的对象没有标准的类型。客户端代码不该试图将这个对象映射为任何一个特殊的类型，因为这将导致不方便的行为。

　　应用可以使用jaxws:method来定制这个映射。

　　2.3.4.3 message和part

　　异步映射支持包装和非包装映射类型，但是它如何映射out和in/out部分是不同的。

　　in    part或wrapper child被映射到方法在2.3.1中描述。

　　out   part或wrapper child被映射到响应bean的属性里

　　In/out part或wrapper child被映射到方法参数以及响应应bean的属性里

　　2.3.4.4 Response Bean

　　response bean是一个操作输出信息的映射，它包含每一个out以及in/out消息part或wrapper child的属性。

　　2.3.4.5 Faults（错误）

　　WSDL错误到服务特有异常的映射对于异步和同步是相同的。2.5部分描述了这个映射。然而，映射的异步方法不能直接抛出服务特定的异常。相反，当一个客户端试图通过Response.get获取异步方法调用的时候，java.util.concurrent.ExecutionException被抛出。

　　Response是一个静态的接口，它的get方法不能抛出服务特定异常。Response实例会抛出ExecutionException而不抛出一个服务特定的异常。

　　2.3.4.6 映射举例及使用

　　下面将展示一个异步操作映射的例子。

　　1 <!-- WSDL extract -->

　　2 <message name="getPrice">

　　3 <part name="ticker" type="xsd:string"/>

　　4 </message>

　　5

　　6

　　7 <message name="getPriceResponse">

　　8 <part name="price" type="xsd:float"/>

　　9 </message>

　　10

　　11

　　12 <portType name="StockQuote">
　
　　13 <operation name="getPrice">

　　14 <input message="tns:getPrice"/>

　　15 <output message="tns:getPriceResponse"/>

　　16 </operation>

　　17 </portType>

　　18

　　19 <!-- Synthesized response bean element -->

　　20 <xsd:element name="getPriceResponse">

　　21 <xsd:complexType>

　　22 <xsd:sequence>

　　23 <xsd:element name="price" type="xsd:float"/>

　　24 </xsd:sequence>

　　25 </xsd:complexType>

　　26 </xsd:element>

　　27

　　28 // synchronous mapping

　　29 @WebService

　　30 public interface StockQuote {

　　31 float getPrice(String ticker);

　　32 }

　　同步的使用：

　　1 Service service = ...;

　　2 StockQuote quoteService = (StockQuote)service.getPort(portName);

　　3 Float quote = quoteService.getPrice(ticker);

　　异步使用：

　　Asynchronous polling use.

　　1 Service service = ...;

　　2 StockQuote quoteService = (StockQuote)service.getPort(portName);

　　3 Response<Float> response = quoteService.getPriceAsync(ticker);

　　4 while (!response.isDone()) {

　　5 // do something while we wait

　　6 }

　　7 Float quote = response.get();

　　Asynchronous callback use.

　　1 class MyPriceHandler implements AsyncHandler<Float> {

　　2 ...

　　3 public void handleResponse(Response<Float> response) {

　　4 Float price = response.get();

　　9 Service service = ...;

　　10 StockQuote quoteService = (StockQuote)service.getPort(portName) ;

　　11 MyPriceHandler myPriceHandler = new MyPriceHandler();

　　12 quoteService.getPriceAsync(ticker， myPriceHandler);

　　2.4 Types

　　<wsdl:types>

　　<xs:schema attributeFormDefault="unqualified" 　　elementFormDefault="unqualified" 　　　targetNamespace="http://service.cxf.cvicse.com/" 　　xmlns:tns="http://service.cxf.cvicse.com/" 　　xmlns:xs="http://www.w3.org/2001/XMLSchema">

　　  <xs:element name="findUsers" type="tns:findUsers" />

　　  <xs:element name="findUsersResponse" type="tns:findUsersResponse" />

　　  <xs:element name="say" type="tns:say" />

　　  <xs:element name="sayResponse" type="tns:sayResponse" />

　　  <xs:element name="sayUserName" type="tns:sayUserName" />

　　  <xs:element name="sayUserNameResponse" type="tns:sayUserNameResponse" />

　　<xs:complexType name="findUsers">

　　  <xs:sequence />

　　  </xs:complexType>

　　<xs:complexType name="findUsersResponse">

　　- <xs:sequence>

　　  <xs:element maxOccurs="unbounded" minOccurs="0" name="return" type="xs:anyType" />

　　  </xs:sequence>

　　  </xs:complexType>

　　<xs:complexType name="say">

　　- <xs:sequence>

　　  <xs:element minOccurs="0" name="arg0" type="xs:string" />

　　  </xs:sequence>

　　  </xs:complexType>

　　<xs:complexType name="sayResponse">

　　- <xs:sequence>

　　  <xs:element minOccurs="0" name="return" type="xs:string" />

　　  </xs:sequence>

　　  </xs:complexType>

　　<xs:complexType name="sayUserName">
　
　　- <xs:sequence>

　　  <xs:element minOccurs="0" name="user" type="tns:User" />

　　  <xs:element minOccurs="0" name="id" type="xs:string" />

　　  </xs:sequence>

　　  </xs:complexType>

　　<xs:complexType name="User">

　　- <xs:sequence>

　　  <xs:element minOccurs="0" name="id" type="xs:int" />

　　  <xs:element minOccurs="0" name="name" type="xs:string" />

　　  </xs:sequence>

　　  </xs:complexType>

　　<xs:complexType name="sayUserNameResponse">

　　- <xs:sequence>

　　  <xs:element minOccurs="0" name="return" type="xs:string" />

　　  </xs:sequence>

　　  </xs:complexType>
　
　　  </xs:schema>

　　  </wsdl:types>

　　XML Schema类型到Java的映射由JAXB 2.0规范描述。wsdl:types部分的内容随同一些其他的type或元素声明被传递到JAXB。

　　JAXB支持将XML types映射到Java接口或类。默认地，JAX-WS使用JAXB的基于类的映射，当然也支持基于接口的映射。

　　2.5 Fault

　　一个wsdl:fault元素被映射到一个Java异常。

　　2.6 Binding

　　从WSDL 1.1到Java的映射是基于wsdl:portType的抽象描述以及相关的操作。然而，protType到协议的绑定可以引入映射里的变化。

　　1 <!-- WSDL extract -->

　　2 <types>

　　3 <xsd:schema targetNamespace="...">

　　4 <xsd:element name="faultDetail">

　　5 <xsd:complexType>

　　6 <xsd:sequence>

　　7 <xsd:element name="majorCode" type="xsd:int"/>

　　8 <xsd:element name="minorCode" type="xsd:int"/>

　　9 </xsd:sequence>

　　10 </xsd:complexType>

　　11 </xsd:element>

　　12 </xsd:schema>

　　13 </types>

　　14

　　15 <message name="operationException">

　　16 <part name="faultDetail" element="tns:faultDetail"/>

　　17 </message>

　　18

　　19

　　20 <portType name="StockQuoteUpdater">

　　21 <operation name="setLastTradePrice">

　　22 <input .../>

　　23 <output .../>

　　24 <fault name="operationException"

　　25 message="tns:operationException"/>

　　26 </operation>

　　27 </portType>

　　28

　　29 // fault mapping

　　30 @WebFault(name="faultDetail"， targetNamespace="...")

　　31 class OperationException extends Exception {

　　32 OperationException(String message， FaultDetail faultInfo) {...}

　　33 OperationException(String message， FaultDetail faultInfo，

　　34 Throwable cause) {...}

　　35 FaultDetail getFaultInfo() {...}

　　36 }