开发者在线 Builder.com.cn 更新时间:2007-09-23作者：中国IT实验室 来源:中国IT实验室

本文关键词： Ant 编程 Java

http://java.sun.com/webservices/reference/tutorials/wsit/doc/DataBinding.html

Data Contracts

This chapter describes guidelines for  :

A WSIT client/service uses JAXB 2.0 for XML serialization, generating XML schemas from Java classes and generating Java classes from XML schemas. A WCF client/service uses either XmlSerializer or DataContractSerializer for like tasks. JAXB 2.0 and the WCF XML serialization mechanisms differ in two fundamental ways. First, JAXB 2.0 supports all of XML schema. .NET's DataContractSerializer and XmlSerializer support different XML schema sets. Second, WCF's XMLSerializer/DataContractSerializer and JAXB 2.0 differ in their mapping of programming language datatypes to XML Schema constructs. As a result, a XML schema generated from a programming language on one platform and consumed on another platform may result in less than developer-friendly bindings. This chapter discusses some of the common databinding differences between the two systems and recommends ways to address them.

二 论坛:
http://forums.java.net/jive/thread.jspa?threadID=23398

Summary: There are multiple threads related to DataSet in these forums. This is an area that needs some guidelines in general.

First, consider how a DataSet is mapped.

    [DataContract]
    public class Foo {
 
        [DataMember]
        public DataSet ds;
     }
 

will map to

[ code ]
<xs:complexType name="Foo">
<xs:sequence>
<xs:element minOccurs="0" name="ds" nillable="true">
<xs:complexType>
<xs:annotation>
<xs:appinfo>
<ActualType Name="DataSet" Namespace="http://schemas.datacontract.org/2004/07/System.Data" xmlns="http://schemas.microsoft.com/2003/10/Serialization/" />
</xs:appinfo>
</xs:annotation>
<xs:sequence>
<xs:element ref="xs:schema" />
<xs:any />
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:sequence>
</xs:complexType>
<xs:element name="Foo" nillable="true" type="tns:Foo" />

[/code]

Notice that <element ref="xs:schema"/> . This will cause wsimport to fail. There is an issue already logged against this. https://jaxp.dev.java.net/issues/show_bug.cgi?id=14 . The generated schema allows the schema to be deferred until runtime ; since a DataSet can be filled at runtime, there is no way of knowing what the schema is at design time.

One way to avoid to this to pass a strongly typed dataset. For example,

[DataContract]
public class Foo {
 
        [DataMember]
        public  BooksDataSet bds;
}
 
public class BooksDataSet : DataSet {...}
 

This will generate a different schema. Notice that <element ref ="xs:schema"/> is no longer generated.

  <xs:complexType name="Foo">
    <xs:sequence>
      <xs:element minOccurs="0" name="bds" nillable="true" type="tns:BooksDataSet" />
    </xs:sequence>
  </xs:complexType>
  <xs:element name="Foo" nillable="true" type="tns:Foo" />
  <xs:complexType name="BooksDataSet">
    <xs:sequence>
      <xs:any namespace="" />
    </xs:sequence>
  </xs:complexType>
  <xs:element name="BooksDataSet" nillable="true" type="tns:BooksDataSet" />

The above should be consumable by wsimport. However, the object model is driven by the above schema. So one would get java.lang.Object for xs:any.

In short, DataSets work well in MS specific environment but not cross platform.
Other suggestions on the forum and/or elsewhere indicate that other types could be used instead of a strongly typed DataSet - e.g. arrays, XmlNode, or XmlDataDocument.


This is an area where we could use guidlines. Please post your feedback on this thread and I will incorporate it into a future version of the DataContracts chapter
(go to http://weblogs.java.net/blog/sekhar/archive/2007/02/jaxb_and_wcf_da_2.html ; follow the link to Data Contracts chapter).

Message was edited by: sekhar


----------------------------------------
The suggestion was not to expose DataSet to from the .NET service. Instead, map DataSet to another .NET type and expose that datatype. For e.g in your .NET service,
1. Use a strongly typed dataset instead of DataSet (above example).
2. Map DataSet to a jagged array ( e.g. object[][] )
3. Map DataSet to a System.Xml.XmlNode . For e.g.

    DataSet ds;
    //... fill in dataset
    XmlNode xmlnode = new XmlDataDocument( ds );
   

A few months ago I wrote a couple of articles (WCF-ORA, ORA-WCF) about Message Transmission Optimization Mechanism (MTOM) interoperability between Oracle Application Server and Microsoft Windows Communication Foundation (WCF).  Most of the feedback I got from those posts was related with MTOM interoperability scenarios using other Web Service technologies toolkits. Based on that, I decided to post a few more demos that reflect MTOM interoperability scenarios for different vendors. Specifically, this paper shows how to achieve MTOM interoperability between Oracle App Server and Sun Web Service Interoperability Technology (WSIT - Project Tango).  Believe it or not, I am sorry .NET developers; there is no .NET code in this paper.

This post does not intend to provide a formal introduction to MTOM. Suffice to say that after a few years and three predecessors' specifications, MTOM has become the preferred Standard for SOAP-encoded binary messaging optimization. MTOM relies on the XML Optimized Processing (XOP) Standard as the serialization mechanism to represent binary data as a MIME/Multipart Related package. If you are interested in the importance of MTOM interoperability you might want to read my previous paper or this post by John Evdemon.

Sun WSIT and MTOM

WSIT is part of Project Metro which is the Web Services stack from Sun Microsystems. Specifically, WSIT is the component of Project Metro that implements some of the most important WS-* protocols emphasizing in interoperability with Microsoft WCF. Needless to say, that WSIT also interoperates really well with other Web Services technologies including Oracle App Server. At the moment WSIT implements some of the most important WS-* protocols for areas such as Security, Reliability, Transactions and messaging optimization (a.k.a MTOM). The typical scenarios for applying MTOM are Web Services that handles binary data like byte[] as part of their contract. The following code illustrates a WSIT Service that can be highly optimized with the use of MTOM.

 Now we need to configure the service policy in order to optimize the message exchange using MTOM.  The trick here, in order to achieve interoperability with Oracle App Server, is to remove the default WSIT WS-Addressing settings. This is due to the fact that Oracle App Server and Sun WSIT implement different versions of WS-Addressing. The change is not required if the client side supports MTOM with WS-Addressing 1.0 like WCF does. Also, If you are using a development IDE such as NetBeans there is no need to manually configure the policy except for removing the use of WS-Addressing; instead you can the Web Service configuration editor which provides a nice interface for configuring the different WS-* protocols for a particular service.

Now we are ready to deploy the service, for the purposes of this demo we used Sun Glassfish.

Oracle App Server and MTOM

Now it's time to implement an Oracle client for the WSIT service created on the previous section. The first natural step is to generate the proxy using the Web Service Proxy Wizard included in JDeveloper or the corresponding command-line tool. In order to interface with WCF using MTOM, the client code should set the MTOM_SUPPORT property to "True" either programmatically or using the configuration file. The following code shows a sample client that interacts with the WCF service created in the previous section

 Messages Messages

After hosting the WSIT service in Sun Glassfish and running the Oracle client the following message sequence is produced

 SOAP request produced by the Oracle client

SOAP response produced by the Sun WSIT service

You can notice that the byte[] in the request message its been optimized using MTOM and XOP.

In the next weeks I will be posting more demos about WS-* protocols interoperability between some of the top Web Services technologies in the market.

主要包括三部分内容，一是EndpointReference定义，实际上一个定义了一个服端点的模型。二是MAP属性的定义，即消息寻址需要设定和支持的相关属性，三是协议的绑定方式，即如何将协议绑定到现有的协议实现之上如WSDL和SOAP。

主要用来解决以下问题：一是实现与底层传输的隔离，通过将寻址信息放在SOAP头部从而摆脱了对底层协议寻址的依赖。二是结合实现基于消息的路由，可以根据ReplyTo属性实现基于消息的路由。三是实现有状态的会话，基于MessageID和RelatesTO属性实现对会话状态保存机制，从而提供有状态的服务。

下面基于以上内容对Axis2和CXF关于WS-Addressing的实现情况进行简单的对比

EndPointReferance在Axis2里是一个核心概念，它通过EndpointReference类型来实现，它所提供的方法完全支持WS-Addressing协议所定义infoset中所有元素的操作。在Axis2中对服务的定位全部是基于EndPointReferance的。

MDP所定义的属性和相应的操作接口都提供了实现。

WSDL addressing-binding在目前版本中没有明确支持，但在一个开发成员的邮件中显示目前已经准备提供支持，但尚无发布相应模块。SOAP -binding在Axis2内核中得到完全的支持。需要明确引入Addresing模块才能处理，事实上仅仅在输入输出流中打开了相关的处理选项。

使用方法：

1．服务端：

在服务端默认情况下Addressing处理是已经嵌入的。加入Addressing需要将Addressing.mar模块放到module目录下，可以有以下几种方式：

一是通过在Axis2.xml配置文件中添加<module ref="addressing"/>，并在相应的管道如in flow和in faultflow中添加AddressingBasedDispatcher即可（注：Axis2中默认已经添加相应内容）

二是在管理控制台Engage相应addressing模块。在axis2.xml 配置文件中添加以下模块引用<module ref="addressing"/>

2．客户端：

在客户总端有两种方式加入Addressing处理模块:

一是在程序中显示加入。如下所示：（注意需要将Addressing.mar放到可访问路径下）

stub._getServiceClient().engageModule(new　

javax.xml.namespace.QName( org.apache.axis2.Constants.MODULE_ADDRESSING ) );

二是在axis2.xml 配置文件中添加以下模块引用<module ref="addressing"/>（需要建立相应的ConfigurationContexst）

其它说明：

在Axis2中对服务进行定位时，根据以下四个信息来定位：HTTP request uri、SOAPAction、QName of the first child of SOAP Body element、WS-Addressing is enabled the address of To EPR。而且上述为默认的顺序，可以通过更改配置文件重新更改顺序。在启用Addressing时，SOAP头部信息的相关内容会自动覆盖重复的内容。

Axis2中设置Addressing Properties是通过MessageContext来自动实现的，可以通过在MessageContext中设置相应的选项信息。在服务端， AddressingBasedDispatcher根据在消息头部信息中取得的属性信息来填充到MessageContext中，包括from、replyto、messagID等信息，并在返回时自动根据这些信息在返回头部中加入上述信息。

在客户可以通过两种方式来加入，一个使用ServiceClient,通过如下方式来加入的：

Options options = new Options();

options.setTo(new      EndpointReference("http://address-to-webservice.org/MyService/MyOperation"));

ServiceClient sender = new ServiceClient();

sender.setOptions(options);

测试代码说明：

                      subScribe (MessageId: A)

Client -------------------------------------------------> PostOffice

             getInfo (MessageId: B, RelatesTo:null)

Client -----------------------------------------------à PostOffice

           printPublishInfo (MessageId: C, RelatesTo: B)   

PostOffice ---------------------------------------------->Publisher 

            returnInfo (MessageId: D, RelatesTo: B)   

Publisher ---------------------------------------------->Client 

MDP所定义的属性属性都定义了相应的操作接口。

SOAP addressing-binding在CXF中得到支持，但需要嵌入Addresing Interceptor才能处理。

使用方法：

1．服务端和客户端可以有以下几种方式：

一是通过在配置文件中添加下面的内容在BUS上加入Addressing Interceptor。

</cxf:bus>，

二是在通过spring配置文件加入

三是程序中显示加入

例子再说吧：

<?xml version='1.0' encoding='UTF-8'?>
   <soapenv:Envelope xmlns:soapenv="http://www.w3.org/2003/05/soap-envelope">
      <soapenv:Header xmlns:wsa="http://www.w3.org/2005/08/addressing">
         <wsa:To>http://127.0.0.1:3673/WCFService1/Service.svc</wsa:To>
         <wsa:ReplyTo>
           <wsa:Address>http://www.w3.org/2005/08/addressing/anonymous</wsa:Address>
         </wsa:ReplyTo>
         <wsa:MessageID>urn:uuid:651A41AA122CE788291212918783422</wsa:MessageID>
         <wsa:Action>http://tempuri.org/IMyService/MyOperation2</wsa:Action>
      </soapenv:Header>
      <soapenv:Body>
         <ns1:MyOperation2 xmlns:ns1="http://tempuri.org/">
            <ns1:myValue1>33</ns1:myValue1>
         </ns1:MyOperation2>
      </soapenv:Body>
   </soapenv:Envelope>

它与basicHttpBinding有什么区别？区别在于多了Soapenv:Header部分，而且使用了WS-Addressing。所以要使AXIS2的WS-Addressing enable，怎么弄？网上找了很久，说是sample中有的，就去看sample：axis2-1.4\samples\userguide\src\userguide\clients\ClientSideModuleEngagement.java
原来要先读一个axis2.xml这样的配置文件

我在最长的构造函数中加入了这么一句：
 public WSHttpBinding_IMyServiceStub(
   org.apache.axis2.context.ConfigurationContext configurationContext,
   java.lang.String targetEndpoint, boolean useSeparateListener)
{
  if(configurationContext == null)
  {
         File repository = new File("D:\\Program Files\\axis2-1.4\\repository");
         if (!repository.exists()) {
             try {
     throw new FileNotFoundException("Repository Doesnot Exist");
    } catch (FileNotFoundException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
    }
         }
         //copy the LoggingModule.mar to "modules" folder.
         //then modify the axis2.xml that is generating there according to
         //phases that being included in the "module.xml"
         configurationContext = ConfigurationContextFactory.
                 createConfigurationContextFromFileSystem(repository.getAbsolutePath(),
"D:\\Program Files\\axis2-1.4\\conf\\axis2.xml");
  }
...
}

一般装好的axis2.xml都会加入所有的modules，其中会包括addressing，所以是有效的。能不能最简自己再试试吧。
然后再加入以下几句：
  _serviceClient.engageModule(new javax.xml.namespace.QName( org.apache.axis2.Constants.MODULE_ADDRESSING ) );//编译器说这个过时了，新的不知道怎么写，先将就着吧
  
  _serviceClient.getOptions().setTo(new EndpointReference(http://127.0.0.1:3673/WCFService1/Service.svc)); //写上<soapenv:header>中<wsa:To>的地址

  _serviceClient.getOptions().setProperty( AddressingConstants.INCLUDE_OPTIONAL_HEADERS, Boolean.TRUE); // 不加这句的话在<soapenv:header>只有<wsa:To> 和<wsa:Action>还有<wsa:MessageID>，其中MessageID是自动生成的一个唯一的编号


三、Mtom
经过上面的折磨，Mtom相对来说简单一点，只要在WCF服务器端打开Mtom，然后客户端在axis2.xml中有个<parameter name="enableMTOM">false</parameter>，改成true就好了。

Is there a way to make it work under 1.3.1. Are other people having these problems with it?

Here's my code:
// get proxy and port from command line
SecureClient.proxyhost = args[2]; //
SecureClient.proxyport = args[3]; //

// set the JSSE system properties
System.setProperty("https.proxyHost", SecureClient.proxyhost);
System.setProperty("https.proxyPort", SecureClient.proxyport);

System.out.println("using proxy: "+ SecureClient.proxyhost + " port " + SecureClient.proxyport);

// now create http authentication

// this didn't work
// System.setProperty("http.proxyUser", "myuser");
// System.setProperty("http.proxyPassword", "mypassword");

// this worked in 1.4.1
Authenticator.setDefault( new httpAuthenticateProxy() );
..........................................

and here's my authenticator class:

public class httpAuthenticateProxy extends Authenticator {

protected PasswordAuthentication getPasswordAuthentication() {
// username, password
// sets http authentication
return new PasswordAuthentication("myuser","mypassword".toCharArray());
}

}
.............................................

Axis2 压缩 Gzip:
_operationClient.getOptions().setProperty(org.apache.axis2.transport.http.HTTPConstants.MC_ACCEPT_GZIP, Boolean.TRUE);

WSIT:
  Service s = new Service();
  BindingProvider bt = (BindingProvider) s.getWSHttpBindingIService();
  bt.getRequestContext().put(BindingProvider.SESSION_MAINTAIN_PROPERTY, true);
  
 
  IService t = (IService) bt;

  String str = t.doWork("aa1");
  System.out.println(str);
  
  Headers headers = (Headers) bt.getResponseContext().get(MessageContext.HTTP_RESPONSE_HEADERS);
  Headers headersForRequest = new Headers();

  Iterator<String> iterator = headers.keySet().iterator();
  
  for(; iterator.hasNext();)
  {
   String key = iterator.next();
   List<String> value = headers.get(key);
   
   
   System.out.println(key);
   System.out.println(value);
   System.out.println("----");
   

   
   if(key != null)
   {
    if(key.toLowerCase().equals("set-cookie"))
    {
     key = "cookie";
    }
    
    headersForRequest.put(key, value);
   }
  }

  String str2 = t.doWork("aa2");
  System.out.println(str2);
  

  
  Service2 ss = new Service2();
  BindingProvider btt = (BindingProvider) ss.getWSHttpBindingIService2();
  btt.getRequestContext().put(BindingProvider.SESSION_MAINTAIN_PROPERTY, true);
  btt.getRequestContext().put(MessageContext.HTTP_REQUEST_HEADERS, headersForRequest);
 
  
  
  IService2 tt = (IService2) btt;
  

  String vstr = tt.doWork("aabb1");
  System.out.println(vstr);
  
  String vstr2 = tt.doWork("aabb2");
  System.out.println(vstr2);
//  XWSSecurityConfiguration.MESSAGE_SECURITY_CONFIGURATION;