WebService介绍(WebService基础知识、XFire、CXF（基于XFire和Celtix项目整合而来，与Spring融合好）、AXIS1、AXIS2(有AXIS1转换而来，有Java)

1 WebSerice基础
2 XFire基础(2007年之后XFire发布1.2.6后停止开发，后续转为CXF项目)
3 CXF基础（基于XFire和Celtix项目整合而来，与Spring融合好）
4 AXIS1基础(Axis 1.4 Final 2006年后停止开发,转而AXIS2)

5 AXIS2基础(有AXIS1转换而来，有Java和C版)

1 WebSerice基础

1.WebService的主要标准和技术：

SOAP：简单对象访问协议。

UDDI：通用描述、发现和集成。

WSDL：Web服务定义语言。

ebXML：电子商务XML。

2.WebService基本操作模型：

3.SOAP简介：

SOAP：是一种基于XML的轻量级消息交换协议，利用SOAP可以在两个或多个对等实体之间进行信息交换。

(1).SOAP消息基本结构：

<xml version=”1.0” ?>

<soap:Envelopexmlns:soap=”http://www.w3.org/2001/12/soap-envelope”

soap:encodingStyle=”http://www.w3.org/2001/12/soap-encoding”>   ——>SOAP信封

<soap:Header>       ——>SOAP消息头

......

</soap:Header>

<soap:Body>          ——>SOAP消息体，包含所有的调用和响应信息

……

<soap:Fault>          ——>可选的，处理错误消息

……

</soap:Fault>

</soap:Body>

<soap:Attachment/>——>SOAP消息附件

</soap:Envelope>——>SOAP信封

(2).SOAP消息组成元素：

SOAP Envelope：SOAP信封，用于描述消息，标识SOAP内容和信封的处理信息。

SOAP Transport：定义HTTP和SMTP等底层传输协议的绑定。

SOAP Encoding：定义将应用程序特定数据类型的实例映射为XML元素的一组编码规则。

SOAP RPC：定义RPC请求和响应的表现形式，这些SOAP请求和响应被作为一种数据类型编码传递到SOAP消息正文中。

一个SOAP消息包括一个SOAP信封，带有0个到多个附件，SOAP信封包含消息头和消息主体。

(3).SOAP通信两种模式：

a.SOAP RPC：同步通信，请求/响应方式发送和接收消息

b.SOAP Messaging：文档驱动的同步和异步消息交换模式。

4.SOAP消息交换模式：

(1).单向消息：只请求，无需响应(客户端只向服务器端发出请求，服务器端无需响应)。

(2).请求/响应交换。

(3).单请求多响应模式。

(4).通知模式：服务器端向客户端发送请求，无需客户端响应，和单向消息类似。

(5).征求/响应模式：服务器端向客户端发送请求，客户端向服务器端返回响应。

5.WSDL文档结构：

<definitions>                 ——>WSDL文档的根元素，定义Webservice的名称和命名空间

<types>                 ——>WebService使用的数据类型

……

</types>

<message>            ——>WebService使用的请求和响应消息，即输入输出参数

       <part>            ——>WebServicer的请求参数或者响应返回值

              ……

       </part>

……

</message>

<portType>           ——>WebService使用的操作，即调用的接口，接口中的每个方法映射为operation，方法参数和返回值用message表示

……

</portType>

<binding>              ——>WebService使用的通信协议，用于指定特定元素<portType>定义的操作和消息的具体协议和数据格式

……

</binding>

<port>             ——>指定WebService的绑定地址

       ……

</port>

<service>               ——>聚集一组相关的<port>元素，指定对外发布的Web服务

       ……

</service>

</definitions>

6.UDDI是一种用于存储有关Web服务信息的目录，是一种由WSDL描述的Web服务界面的目录，经由SOAP进行通信。

三种级别的UDDI注册表：

(1).白页级别：只注册公司的基本信息。

(2).黄页级别：根据公司业务类别来划分信息类别。

(3).绿页级别：发布描述其Web服务的行为和所支持的功能。

7.UDDI编程API：

(1).查询API：

<find_business>、<find_relatedBusiness>、<find_service>、<find_binding>、<find_tModel>等。

若要获取更详细的信息，可以使用如下的API：

<get_businessDetail>、<get_businessDetailExt>、<get_serviceDetail>、<get_bindingDetail>、<get_tModelDetail>等。

(2).发布API：

<save_business>、<save_publisherAssertions>、<add_publisherAssertions>、<save_service>、<save_binding>、<save_tModel>等。

(3).删除API：

<delete_business>、<delete_publisherAssertions>、<delete_service>、<delete_binding>、<delete_tModel>等。

(4).身份鉴别API：

<get_authToken>、<discard_authToken>等。

8.UDDI的数据结构：

(1).<businessEntity>：表示公司的主要信息。

(2).<publisherAssertion>：用于建立两个<businessEntity>之间的关系，注意：除非两个<businessEntity>都进行了相同的声明，否则这一关系无法建立。

(3).<businessService>：表示公司的服务，这些服务可以是Web服务或任何其他类型的服务。

(4).<bindingTemplate>：由指向技术说明的指针和服务的接入URL构成，即Web服务的技术说明。

(5).<tModel>：提供特定规范或服务行为的描述，是UDDI中最基本的结构。

(6).<identifierBag>：<businessEntity>或<tModel>的标识信息。

(7).<categoryBag>：根据任何分类机制对<businessEntity>、<businessService>和<tModel>结构进行分类。

9.通过使用Web服务，可以将应用程序转换为网络应用程序，向全世界发布信息，提供某些功能的服务，基本的web服务平台：XML+HTTP。

Web服务两种类型的应用：

(1).可重复使用的应用程序组件。

(2).连接集成现有的软件系统。

10. Web服务的工作流程：

11.jax-ws是java开发webservice的标准API：

(1).javax.jws中常用的注解：

a.@Webservice：将一个类声明为webservice。

b.@Webparam：指定webservice的参数。

c.@WebResul：指定webservice的返回值。

d.@WebMethod：指定某个方法为webservice对外提供的方法。

(2).javax.jws.soap中常用的注解：

@SOAPBinding：将某个接口绑定为webservice。

12.WebService的调用过程：

由图可以看出，webservice交互过程中需要XML和程序对象进行相互转换，Java中提供了一种新的API——JAXB专门处理java对象和XML数据的相互转换。

13.JAXB(java API for XML Bing)：

JAXB是一种java对象和xml数据格式之间相互转换的API。

(1).JAXB的作用：

Java Object ——> JAXB ——> XML

(2).JAXB的工作原理：

(3).JAXB的常用注解：

a.@XmlRootElement：将Java类映射为XML的根节点。

b.@XmlElement：将属性或方法映射为XML的节点。

c.@XmlAccessorType：指明映射那些方法或者字段。

d.@XmlTransient：指明那些方法或者字段不需要和xml进行映射。

e.@XmlJavaTypeAdapter：Xml和Java对象的转换。

2 XFire基础（基于XFire和Celtix项目整合而来，与Spring融合好）

1.XFire是codehaus推出的下一代的java SOAP框架，通过提供的简单的API和支持标准协议，可以方面地开发webservice程序。XFire最大的特点就是支持将POJO通过非常简单的方式发布为WebService，同时还拥有很高的性能。

2.XFire将 POJO 发布成 Web 服务的基本步骤：

(1).创建 Web 服务接口，声明该 Web 服务对外暴露的接口；

(2).创建 Web 服务实现类，为 Web 服务接口提供实现；

(3).修改 XFire 框架的服务发布文件 ---- services.xml，将 POJO 发布成 Web 服务。

3.简单的XFire开发过程：

(1).在web.xml中加入如下配置：

[xhtml] view plain copy

1. <servlet>  
2.        <servlet-name>XFireServlet</servlet-name>  
3.        <servlet-class>org.codehaus.xfire.transport.http.XFireConfigurableServlet</servlet-class>  
4. </servlet>  
5. <servlet-mapping>  
6.        <servlet-name>XFireServlet</servlet-name>  
7.        <url-pattern>/services/*</url-pattern>  
8. </servlet-mapping>  

 

(2).创建services.xml文件，加入如下配置：

[xhtml] view plain copy

1. <? xml version=”1.0” encoding=”UTF-8” ?>  
2. <beans>  
3.        <service xmlns=”http://xfire.codehaus.org/config/1.0”>  
4.               <name>webservice名</name>  
5.               <namespace>http://包名的逆序/服务类名</namespace>  
6.               <serviceClass>提供服务的接口全路径</serviceClass>  
7.               <implementationClass>服务实现类全路径</implementationClass>  
8.               <scope>服务存活范围</scope>  
9.        </service>  
10.        ……  
11. </beans>  

 

4.XFire配置文件元素：

(1).service：service 标签和它所包含的 xml 内容为发布成 Web 服务的 POJO 提供完整的描述。

(2).name：Web 服务被发布时所采用的唯一名称。

(3).namespace：Web 服务发布时所使用的命名空间。

(4).serviceClass：Web 服务接口类的全名，包括包名和类名。

(5).implemetationClass：Web 服务实现类的全名，包括包名和类名。

5.XFire传递复杂对象：

分两种情况：

(1).客户端创建一个实现Remote接口的类，方法名、参数类型和返回值类型均与WebService服务相同，则传递自定义的复杂对象参数和返回值时不用特殊配置和处理。

注意：只适用于在自定义对象中传递List、Map、数组等的复杂对象。

(2).服务器端实现一个接口(非Remote接口)，客户端通过该接口来调用WebService对象，则必须在服务器端接口同一目录下建立一个名为“服务端接口名.aegis.xml”文件，添加如下配置：

[xhtml] view plain copy

1. <? xml version=”1.0” encoding=”UTF-8” ?>  
2. <mappings>  
3.        <mapping>  
4.               <method name=”接口中的方法名”>  
5.                      <!--配置方法参数类型，索引从0开始-->  
6.                      <parameter index=”0” componentType=”参数类型全路径(如：java.lang.String)”/>  
7.                      ……  
8.                      <return-Type componentType=”返回值类型全路径”/>  
9.               </method>  
10.               ……  
11.        </mapping>  
12. </mappings>  

 

注意：适用于Map等传递自定义对象这种情况。

6.XFire的Handler：

一个Handler可以看成是XFire的一个加工套件，XFire通过它们定义SOAP发送和接收之前的各种加工处理逻辑。如Handler可以对SOAP体的内容进行加工处理，或者SOAP头进行处理。

(1).编写自定义Handler：

继承AbstractHandler类。

(2).服务器配置Handler：

在services.xml文件中加入如下配置：

在<scope>元素标签之下加入：

[xhtml] view plain copy

1. <inHandlers>  
2.        <handler handlerClass=”自定义Handler的全路径”/>  
3.        ……  
4. </inHandlers>  
5. <outHandlers>  
6.        <handler handlerClass=”自定义Handler的全路径”/>  
7.        ……  
8. </outHandlers>  

 

(3).客户端Handler的配置：

[java] view plain copy

1. Client client = Client.getInstance(客户端得到的服务对象);  
2. client.addInHandler(new 自定义Handler());  
3. client.addOutHandler(new 自定义Handler());  

 

7.文件上传处理：

(1).将文件用DataHandler包装后传递到服务器端。

(2).服务器端根据得到的DataHandler对象.getInputStream()得到文件输入流，将其写到服务器端。

(3).对SOAP消息进行MTOM编码。

[java] view plain copy

1. org.codehaus.xfire.client.Client client = ((XFireProxy)Proxy.getInVocationHandler(服务对象)).getClient();  
2. client.setProperty(SoapConstants.MTOM_ENABLED, “true”);  

 

(4).对输入输出流指定UTF-8字符集：

[java] view plain copy

1. InputStreamReader input = new InputStreamReader(handler.getInputSream(), “UTF-8”);  
2. OutputStreamWriter writer output = new OutputStreamWriter(new FileOutputStream(file), “UTF-8”);  

 

(5).在对应的services.xml文件中，上传文件的Service必须添加如下的Property：

[xhtml] view plain copy

1. <properties>  
2.        <property key=”mtom-enabled”>true</property>  
3. </properties>  

 

8.XFire与Spring的集成(服务器端使用XFire导出器方式)：

(1).在web.xml中指定XFire和Spring的配置文件如下：

[xhtml] view plain copy

1. <context-param>  
2.        <param-name>classpath:org/codehaus/xfire/spring/xfire.xml,  
3.                             /WEB-INF/applicationContext.xml</param-name>  
4. </context-param>  

 

(2).在Spring配置文件中导入XFire配置文件，配置要发布的服务：

[xhtml] view plain copy

1. <import resource=”classpath:org/codehaus/xfire/spring/xfire.xml”/>  
2. <bean id=”服务id” parent=”baseWebService”>  
3.        <property name=”name” value=”服务名”/>  
4.        <property name=”serviceClass” value=”服务接口全路径”/>  
5.        <property name=”serviceBean” value=”服务实现类”/>  
6. </bean>  

 

(3).在Spring中配置XFire导出器：

[xhtml] view plain copy

1. <bean id=” baseWebService” class=”org.codehaus.xfire.spring.remoting.XFireExporter” lazy-init=”false” abstract=”true”>  
2.        <property name=”serviceFactory” ref=”xfire serviceFactory”/>  
3.        <property name=”xfire” ref=”xfire”/>  
4. </bean>  

 

(4).客户端Spring配置：

[xhtml] view plain copy

1. <bean id=”客户端服务名” class=”org.codehaus.xfire.spring.remoting.XFireClientFactoryBean”>  
2.        <property name=”serviceClass” value=”服务接口全路径”/>  
3.        <property name=”wsdlDocument” value=”服务的WSDL地址”/>  
4. </bean>  

 

在客户端就可以像使用普通java对象一样使用被spring管理起来的web服务了。

9.XFire与Spring的集成(服务器端不使用XFire导出器方式)：

和服务器端使用XFire导出器类似，不同之处在于配置发布的服务：

[xhtml] view plain copy

1. <bean id=”服务id” class=”服务名”>  
2.        <property name=”name” value=”服务名”/>  
3.        <property name=”namespace” value=”服务命名空间”/>  
4.        <property name=”serviceClass” value=”服务接口全路径”/>  
5.        <property name=”serviceBean” value/ref=”服务实现类”/>  
6. </bean> 
   

3 CXF基础（基于XFire和Celtix项目基础开发）

1.CXF是基于JAX-WS实现的，JAX-WS规范(JAVA API XML-WEB SERVICE)是一组XML web services的JAVA API，它使用户无需编写复杂的SOAP ENV,WSDL。在 JAX-WS中，一个远程调用可以转换为一个基于XML的协议例如SOAP。在使用JAX-WS过程中，开发者不需要编写任何生成和处理SOAP消息的代码。JAX-WS的运行时实现会将这些API的调用转换成为对于SOAP消息。

在服务器端，用户只需要通过Java语言定义远程调用所需要实现的接口SEI (service endpoint interface)，并提供相关的实现，通过调用JAX-WS的服务发布接口就可以将其发布为WebService接口。 
在客户端，用户可以通过JAX-WS的API创建一个代理（用本地对象来替代远程的服务）来实现对于远程服务器端的调用。

2.使用CXF开发Webservice工程步骤： 

1).为CXF设置编译和开发环境 
在http://cxf.apache.org/download.html下载相应的CXF包，/lib目录下的jar 文件引入工程 
2).创建基于XCF的Webservice服务端工程。
3).编写Webservice的客户端程序，调用服务端服务。

3.CXF中的Factory：

CXF不但可以使用JAX-WS开发web服务，也可以将POJO发布为web服务，对于这两种不同的方式，对应的factory如下：

                                 服务端                                        客户端  

JAX-WS                      JaxWsServerFactoryBean             JaxWsProxyFactoryBean

POJO                         ServiceFactoryBean                     ClientProxyFactoryBean

4.CXF使用JAX-WS开发服务端：

(1).定义服务接口：

在接口上添加Webservice注解：@WebService。如：

[java] view plain copy

1. package service;  
2. import javax.jws.WebService;  
3. @WebService  
4. public interface OrderProcess {  
5.     String processOrder(Order order);  
6. }  

(2).实现服务接口：

在实现类上也添加Webservice注解：@WebService(endpointInterface = 服务接口全路径,   serviceName= 对外发布的服务名)。如：

[java] view plain copy

1. package service;  
2. import javax.jws.WebService;  
3. @WebService(endpointInterface = "service.OrderProcess"，serviceName=”order”)  
4. public class OrderProcessImpl implements OrderProcess {  
5.     public String processOrder(Order order) {  
6.         return "hello world"+order;  
7.     }  
8. }  

 

(3).对外发布服务：

[java] view plain copy

1. //创建web服务工厂  
2. JaxWsServerFactoryBean factory = new JaxWsServerFactoryBean();  
3. //设置服务类  
4. factory.setServiceClass(服务接口实现类.class);  
5. //设置对外发布服务地址  
6. factory.setAddress(对外发布的服务地址);  
7. //创建服务  
8. Server server = factory.create();  
9. //启动服务  
10. server.start();  

 

5.CXF使用JAX-WS开发客户端：

[java] view plain copy

1. //创建web服务代理工厂  
2. JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();  
3. //设置要调用的web服务服务端发布地址  
4. factory.setAddress(web服务的发布地址);  
5. //设置要调用的web服务  
6. factory.setServiceClass(web服务接口.class);  
7. //创建web服务对象  
8. 服务接口 对象 = (服务接口) factory.create();  
9. 通过对象调用web服务的方法

6.CXF使用POJO开发服务端：  

1. 和使用JAX-WS开发方式前两步完全一样，第三步稍有不同如下：  
2. //创建web服务工厂  
3. ServiceFactoryBean svrFactory = new ServiceFactoryBean();  
4. //设置服务类  
5. svrFactory.setServiceClass(服务接口实现类.class);  
6. //设置对外发布服务地址  
7. svrFactory.setAddress(对外发布的服务地址);  
8. //创建服务  
9. Server server = svrFactory.create();  
10. //启动服务  
11. server.start();  

 

7.CXF使用POJO开发客户端：

和JAX-WS方式除了代理工厂不同以外，其他均相同：

[java] view plain copy

1. //创建web服务代理工厂  
2. ClientProxyFactoryBean factory = new ClientProxyFactoryBean();  
3. //设置要调用的web服务服务端发布地址  
4. factory.setAddress(web服务的发布地址);  
5. //设置要调用的web服务  
6. factory.setServiceClass(web服务接口.class);  
7. //创建web服务对象  
8. 服务接口 对象 = (服务接口) factory.create();  

通过对象调用web服务的方法

8.CXF与Spring的集成：

(1).对工程引入spring支持。

(2).在web.xml文件中添加spring和CXF相应的配置如下：

[xhtml] view plain copy

1. <web-app>  
2.   <context-param>  
3.   <param-name>contextConfigLocation</param-name>  
4.   <param-value>spring配置文件路径</param-value>  
5.  </context-param>  
6.  <listener>  
7.   <listener-class>  
8.    org.springframework.web.context.ContextLoaderListener  
9.   </listener-class>  
10.  </listener>  
11.  <servlet>  
12.   <servlet-name>CXFServlet</servlet-name>  
13.   <display-name>CXF Servlet</display-name>  
14.   <servlet-class>  
15.    org.apache.cxf.transport.servlet.CXFServlet  
16.   </servlet-class>  
17.   <load-on-startup>1</load-on-startup>  
18.  </servlet>  
19.  <servlet-mapping>  
20.   <servlet-name>CXFServlet</servlet-name>  
21.   <url-pattern>/service/*</url-pattern>  
22.  </servlet-mapping>  
23. </web-app>  

 

(3).在spring配置文件中导入CXF的相关配置如下：

[xhtml] view plain copy

1. <import resource="classpath:META-INF/cxf/cxf.xml" />  
2. <import resource="classpath:META-INF/cxf/cxf-extension-soap.xml" />  
3. <import resource="classpath:META-INF/cxf/cxf-servlet.xml" />  

 

(4).在spring配置文件中配置要发布的web服务如下：

[xhtml] view plain copy

1. <jaxws:endpoint  
2.    id="……"  
3.    implementor="服务接口实现类全路径"  
4.    address="/web服务发布地址(相对地址)" /> 
   

4 AXIS1基础(Axis 1.4 Final 2006年后停止开发,转而AXIS2)

1.AXIS简介：

Axis1是Apache组织推出的SOAP引擎，Axis项目是Apache组织著名的SOAP项目的后继项目，目前最新版本是采用Java开发的1.4版本，C++的1.5版本。
但是Axis1不仅仅是一个SOAP引擎，它还包括：

(1). 一个独立运行的SOAP服务器。
(2).一个servlet引擎的插件，这个servlet引擎可以是Tomcat。
(3).对WSDL的扩展支持。

(4).一个将WSDL的描述生成JAVA类的工具。
(5).一些示例代码。
(6).还有一个监控TCP/IP包的工具。

2.Axis1安装配置：

(1)、环境 J2SE SDK, Servlet 容器，如Tomcat 6.0。

(2)、到 http://ws.apache.org/Axis/网站下载Axis安装包。
(3)、解压缩安装包，将Axis_UNZIP_PATH/Axis-version/webapps下的Axis包拷贝到TOMCAT_HOME/webapps目录下，以下约定Axis_HOME为该TOMCAT_HOME/webapps/Axis目录。

(4)、启动tomcat,访问http://localhost:8080/Axis 检查安装是否成功。

(5)、以上步骤执行成功，可以开发webservice例子了。

3.AXIS的发布方式：

AXIS提供了两种Webservice的发布方式：

及时发布(InstantDeployment)。

定制发布(CustomDeployment)。

4.AXIS的及时发布方式——java web service（jws）：

(1).对即时发布的支持是Axis的特色之一，使用即时发布只需将提供服务的Java类的源代码后缀改为”.jws”，然后将该jws文件放到”%Tomcat_HOME%/webapps/axis”目录下，即可将其迅速发布成Web服务。每当用户调用这类服务的时候，Axis会自动进行编译，即使服务器重启了也不必对其做任何处理，使用非常简单快捷。

(2).需要注意的是：JWS的web服务发布是一个很简单的Web服务发布方式，在页面中你不能使用包，而且由于代码是在运行期被编译的，所以在部署之后，你也很难找到错误所在。

5.AXIS定制发布方式——wsdd方式：

(1).即时发布是一项令人激动的技术，它使Web服务的开发变得如此简单；然而即时发布并不总是最好的选择，比如有些应用系统是第三方提供的，我们没有购买源代码，只有.class文件，但我们又希望将这个应用系统的一些功能对外发布成Web服务，使其能够在更大范围内产生作用，这个时候即时发布技术就无能为力了。此外，即时发布技术并不灵活，无法进行更多的服务配置，这使得它并不能满足一些特定系统的需求。

(2).将java源代码编译成.class文件，放置到“%Tomcat_HOME%/webapps/axis/”目录下，即可着手进行发布。定制发布不需要构建.jws文件，但必须在” %Tomcat_HOME%/webapps/axis/WEB-INF/”目录下创建服务发布描述文件deploy.wsdd（Web Service Deployment Descriptor的缩写），这个文件负责描述服务的名称、入口等信息，其内容如下：

[xhtml] view plain copy

1. <deployment xmlns="http://xml.apache.org/axis/wsdd/" xmlns:java="http://xml.apache.org/axis/wsdd/providers/java">  
2. <!--provider=””java:RPC”是服务类型，除了RPC方式以外，还有Document、Wrapped和Message方式-->  
3.        <service name="服务名" provider="java:RPC">  
4. <!--告诉服务应该调用的类-->  
5.  <parameter name="className" value="服务实现类全路径"/>  
6. <!--告诉服务可以调用这个类中的任何的Public方法，也可以指定方法名-->  
7.  <parameter name="allowedMethods" value="*"/>  
8. <parameter name=”scope” value=”request”/>  
9.        </service>  
10.   </deployment>  

 

(3).部署定制服务：

使用Axis提供的一个客户端管理工具——AdminClient来完成服务的定制发布。
   在“%Tomcat_HOME%/webapps/axis/”目录下，运行：

   java -cp %AXISCLASSPATH%org.apache.axis.client.AdminClient deploy.wsdd

或

java -cp %AXISCLASSPATH%org.apache.axis.client.AdminClient -l http://localhost:8081/WebServiceTest/services/WebServiceServer.WSServerdeploy.wsdd

如果运行时说没有找到类，那么可能是类路径没有配置好，建议将所有的与axis相关的jar都写到classpath中去。这样只要运行:

   javaorg.apache.axis.client.AdminClient deploy.wsdd
   可以看到以下运行结果：

 Processing file deploy.wsdd
 <Admin>Doneprocessing</Admin>

　　这表明服务定制发布完成。
 
   你也可以调用：
 java org.apache.axis.client.AdminClient undeploy.wsdd  来取消部署。

   你也可以调用：
 java org.apache.axis.client.AdminClient list 来获得所有的已经部署的服务的列表。在这里你会看到services,handlers, transports等等，注意这个调用只是列出了WEB-INF/server-config.wsdd的文件内容。

(4).注意：编译后的class文件要拷贝到WEB-INF/classes的目录中，如果该文件中有包存在的话，别忘了还要在classes目录下创建包的目录
   通过访问http://localhost:8080/axis/services/工程名称?wsdl可以看到这个服务的WSDL描述文件，这说明服务被成功发布了。

6.客户端调用AXIS发布的服务：

[java] view plain copy

1. String url =”AXIS服务的发布地址路径”;  
2. Service serv = new Service();  
3. Call call = (Call)serv.createCall();  
4. call.setTargetEndpointAddress(url);  
5. call.setOperationName(new QName(url, “调用服务的方法名”));  
6. call.invoke(new Object[]{参数对象});  

 

7. AXIS支持三种对象范围：
(1).request范围：这是默认的情况，每一次Soap请求的时候都将创建新的对象。
(2).application范围：将会为所有的请求生成一个单独的共享的对象。
(3).session范围：为每一个session期的客户端请求创建一个对象。
  指定方法如下：

[xhtml] view plain copy

1. <service name="MyService"...>  
2. <parameter name="scope" value="对象范围"/>  
3. ...  
4. </service>  

 8. AXIS的Handler和Handlers Chain：

 Webservice的Handler可以在Webservice每个方法调用之前或之后做一些特定事情，如权限验证，记录日志等等常用操作。

(1).定义Handler：

自定义的Handler必须要继承BasicHandler类，并实现其中的invoke(MessageContextcontext)方法，其中MessageContext参数是AXIS上下文。

Handler通过getOperation(String string)方法获得配置文件的属性值，通过<requestFlow>标签来讲Handler引入到某个Service中。

(2).配置Handler：

在wsdd文件中加入如下配置：

[xhtml] view plain copy

1. <handler name=”handler名称” type=”java:handler全路径名”>  
2.        <parameter name=”handler变量名” value=”……”/>  
3.        ……  
4. </handler>  

 

(3).为WebService引入Handler：

在wsdd文件的<service>中加入如下配置：

[xhtml] view plain copy

1. <requestFlow>或者<responseFlow>  
2.        <handler type=”handler名”/>  
3. </requestFlow>或者</responseFlow>  

 

(4).Hanlder Chain：

a.定义Handler Chain：

Handler Chain是实现一连串多个Handler的链，Chain必须继承SimpleChain类，然后在构造方法中使用：this.addHandler(handler对象);将Handler加入到Chain中。

b.配置Handler Chain：

在wsdd文件中，Chain的配置和Handler有些不同，<chain>元素中的子元素只允许是<handler>或者<chain>，即允许<chain>嵌套，具体配置如下：

[xhtml] view plain copy

1. <chain name=”chain名”>  
2.        <handler type=”java:chain的全路径”/>  
3.        ......  
4. </chain>  

 

9.WebService传递复杂对象：

(1).创建Qname：

[java] view plain copy

1. Qname表示XML规范中定义的限定名称，由名称空间URI、本地部分和前缀组成，如：  
2. //第一个参数是名称空间，第二个参数是本地部分  
3. Qname qn = new Qname(”urn:AddressManager”, ”Address”);  

 

(2).注册对象类型映射：

如：

[java] view plain copy

1. call.registerTypeMapping(对象.class, QName,  
2. new org.apache.axis.encoding.ser.BeanSerializerFactory(对象.class, QName),  
3. new org.apache.axis.encoding.ser.BeanDeSerializerFactory(对象.class, QName));  

 

(3).返回值类型设置：

如：

[java] view plain copy

1. call.setReturnClass(ArrayList.class);  

 

(4).设置传递的方法参数类型：

如：

[java] view plain copy

1. call.addParameter(“参数名”, XMLType.XSD_ANYTYPE, ParameterModel.IN);  

 

(5).在wsdd文件中加上类型映射：

在<service>标签中加入如下配置：

[xhtml] view plain copy

1. <beanMapping qname=”前缀:本地名”  
2. xmlns:前缀=”urn:名称空间”  
3. languageSpecificType=”java:自定义类型全路径”/>  

 

10.WebService传递带有内部类的复杂对象：

(1).内部类必须是可序列化的，内部类必须是静态的，否则不能被序列化。

(2).内部类也要像自定义类一样进行映射和注册，如：

[java] view plain copy

1. call.registerTypeMapping(外部类.内部类.class, QName,  
2. BeanSerializerFactory.class, BeanDeSerializerFactory.class);  

 

(3).在wsdd文件中配置内部类的相关映射：

如：

[xhtml] view plain copy

1. <beanMapping qname=”本地名”  
2. xmlns:前缀=”urn:名称空间”  
3. languageSpecificType=”java:外部类全路径$内部类名”/>  

 

11.Webservice的RMI调用方式：

本地实现一个Remote接口，其中包含远程webservice的调用方法(同名、同返回类型、同参数类型)，则通过service可以获得一个对远程webservice对象的引用，用该引用可以直接像调用本地方法一样调用远程方法。

(1).服务器端不用继承或者实现任何接口。

(2).通过如下方法使本地的远程接口获取webservice引用：

[java] view plain copy

1. 接口类型 对象 =  (接口类型)Service对象.getPort(endpoint/QName, ProxyInterface.class);  

 

12.WebService传递异常对象：

(1).自定义异常。

(2).方法中抛出该异常对象。

(3).在wsdd文件中加入如下配置：

在<service>元素的<operation>标签中加入<fault>子标签如下：

[xhtml] view plain copy

1. <operation name=”……”>  
2.        <fault name=”……”  
3. qname=”……”  
4. type=”tns:ServerException”/>  
5. </operation>  
6. <typeMapping qname=”……”  
7. type=”java:自定义异常类全路径”  
8. serializer=”org.apache.axis.encoding.ser.BeanSerializerFactory”  
9. deserializer=“org.apache.axis.encoding.ser.BeanDeSerializerFactory”  
10. encodingStyle=http://schemas.xmlsoap.org/soap/encoding/”/>  

 

13.WebService传递文件：

(1).服务器端方法：

[java] view plain copy

1. public String receive(DataHandler handler, String fileName){  
2.        File file = new File(fileName);  
3. if(handler == null || filename == null || fileName.equals(“”)){  
4.        return “failure”;  
5. }  
6. InputStream input = null;  
7. FileOutputStream fos = null;  
8. try{  
9.        input = handler.getInputStream();  
10.        fos = new FileOutputStream(file);  
11.        byte[] buffer = new byte[1024];  
12.        while(input.read(buffer) != -1){  
13.               fos.writer(buffer);  
14. }  
15. }catch(Exception e){  
16.        e.printStackTrace();  
17. }finally{  
18.        if(input != null){  
19.               try{  
20.        input.close();  
21. }catch(IOException e){  
22. }  
23. }  
24. if(fos != null){  
25.        try{  
26.        fos.close();  
27. }catch(Exception e){  
28. }  
29. }  
30. }  
31. return “success”;  
32. }  

 

注意：DataHandler是一个专门的传送器，通过它可以把文件进行序列化。

(2).wsdd文件进行如下配置：

[xhtml] view plain copy

1. <service name=”FileReceiverServer” provider=”java:RPC”>  
2.        <parameter name=”className” value=”服务器文件接收类全路径”/>  
3.        ……  
4.        <operatiojn name=”receive”  
5. qname=”operNS:receive”  
6. xmlns:operNS=”receive”  
7. returnType=”rtns:String”  
8. xmlns:rtns=”http://www.w3.org/2001/xmlSchema”>  
9. <parameter name=”handler” type=”myns:DataHandler”  
10. xmlns:myns=http://www.w3.org/XmlSchema”/>  
11.               <parameter name=”fileName” type=”tns:String”  
12. xmlns:tns=http://www.w3.org/XmlSchema”/>  
13.        </operation>  
14.        <typeMapping qname=”myns:DataHandler”  
15. xmlns:myns=”DataHandler”  
16. languageSpecific=”java:javax.activation.DataHandler”  
17. serializer=”org.apache.axis.encoding.ser.JAFDataHandlerSerializerFactory”  
18. deserializer=”org.apache.axis.encoding.ser.JAFDataHandlerDeSerializerFactory” encodingstyle=http://schemas.xmlsoap.org/soap/encoding/”/>  
19. </service>  

 

(3).客户端传递DataHandler对象：

[java] view plain copy

1. DataHandler dh = new DataHandler(new FileDataSource(文件路径名));  

 

文件路径名的获取一般写法如：

[java] view plain copy

1. FileSenderClient.class.getResource(文件名).getPath();
   

5 AXIS2基础(有AXIS1转换而来，有Java和C版)

1.AXIS2简介：

Apache Axis2项目是一个基于Java语言的Webservices系统服务和客户端的实现。为了从Apache Axis 1.0中获取教训，Apache Axis2提供了一个完整的对象模型和模块化体系结构，这样可以很容易的添加功能以及支持一个新的与Web services相关的说明和建议。Axis2可以让你很容易的执行以下任务：

(1).发送SOAP消息。

(2).接收和处理SOAP消息。

(3).从一个普通的Java类建立Web service。

(4).用WSDL来建立实现服务和客户端的实现类。

(5).很容易的从一个服务来获取WSDL。

(6).发送和接收带有附件的SOAP消息。

(7).建立或者使用基于REST的Web service。

(8).建立或者使用从WS-Security, WS-ReliableMessaging, WS-Addressing, WS-Coordination和WS-AtomicTransaction获取优势的服务。

(9).当新建议出现时，使用Axis2的模块化结构来很容易的加入对它的支持。

2.配置AXIS2环境：

(1).下载Axis2，去http://ws.apache.org/axis2/下载axis2的最新版本，一般是两个zip文件，如axis2-1.4.1-bin.zip(包含了Axis2中所有的jar文件)和axis2-1.4.1-war.zip(用于将WebService发布到web容器中)。
(2). 把axis2-1.4.1-war.zip解压，将目录中的axis2.war文件放到Servlet容器的项目发布目录中，以Tomcat为例，放到”%Tomcat%/webapps”目录中，启动Tomcat。

(3).在浏览器地址栏中输入如下的URL：http://localhost:8080/axis2/”，应该可以进入axis2的欢迎界面，点击”Validate”如果没有报错，则说明axis2的环境已经配置好。

(4).点击”Administration”，初始用户名和密码分别是：admin和axis2，也可以到” %Tomcat%/webapps/axis2/WEB-INF/conf/axis2.xml”下修改用户名和密码。

3.POJO发布成AXIS2WebService的简单例子：

(1).编程普通的java类，将编译过后的”.class”文件拷贝到axis2的POJO发布目录”%Tomcat%/webapps/axis2/WEB-INF/POJO”中。
注意：若目录下没有POJO目录，则手动新建该目录即可。

(2).启动Tomcat，POJO即被发布成了WebService，java类中中所有的public方法即被发布成WebService的Operation。

注意：POJO类不能使用package关键字声明包，AXIS2默认是热部署的。

4.POJO无配置发布高级：

由于AXIS2的POJO发布方式不支持Package，若类中需要调用其他类的方法时，需要将所引用的类编译后的”.class”文件拷贝到”%Tomcat%/webapps/axis2/WEB-INF/classes”目录下。

5.AXIS2客户端的简单实现：

(1).使用RPC方式调用WebService：

[java] view plain copy

1. RPCServiceClient client = new RPCServiceClient();  
2. Options options = client.getOptions();  

 

(2).指定调用WebService的URL：

[java] view plain copy

1. EndpointReference targetURL = new EndpointReference(“WebService发布的URL地址”);  
2. Options.setTo(targetURL);  

 

(3).指定调用服务方法的参数值：

[java] view plain copy

1. Object[] parameters = new Object[]{参数值};  

 

(4).指定方法返回值的数据类型，如：

[java] view plain copy

1. Class[] classes = new Class[]{String.class};  

 

(5).指定要调用方法名和WSDL文件的命名空间：

[java] view plain copy

1. //命名空间为wsdl文件中<wsdl:definitions>元素的targetNamespace属性值  
2. QName qname = new QName(“命名空间”, “调用方法名”);  

 

(6).调用服务的方法：

[java] view plain copy

1. //三个参数第一个为QName对象，表示要调用的方法名；第二个参数表示要调用的//WebService方法的参数值；第三个参数表示WebService方法的返回值类型  
2. Object result = client.invokeBlocking(qname, parameters, classes)[0];  

 

注意：当方法没有参数时，第二个参数值不能为null，而要使用new Object[]{}。

当被调用的方法没有返回值时，应该使用RPCServiceClient类的invokeRobust方法。

6.使用wsdl2java简化客户端的编写：

在Windows控制台输出如下的命令行来生成调用WebService的代码：

%AXIS2_HOME%/bin/wsdl2java–uri wsdl的url –p 生成java类的包名 -s –o客户端存根目录名

其中-url参数指定wsdl文件的路径，可以说本地路径，也可以是网络路径。-p参数指定了生成的java类的包名，-o参数指定了生成的一系列文件保存的根目录。执行完命令后就会在当前目录下生成一个存根目录名的目录，里面就是wsdl2java生成的客户端代码。

7.AXIS2复合类型数据的传递：

AXIS2中可以直接使用将WebService方法的参数或返回值类型声明为数组或者类(接口)。

注意：

(1).在定义数组类型时只能使用一维数组，如果想传递多维数组，可以使用分隔符进行分割，如：

[java] view plain copy

1. String[] strArray = new String[]{“自行车, 飞机, 火箭”, “中国, 美国, 德国”, “超人, 蜘蛛侠, 钢铁侠”};  

 

可以将该数组看作是一个3×3的二维数组。

(2).当传递自定义的类或接口时，请务必实现序列化。

8.使用services.xml方式发布WebService：

(1).编写服务端的类。

(2).在工程META-INF目录下建services.xml文件，添加如下内容：

[xhtml] view plain copy

1. <serviceGroup>  
2.        <!--第一种服务发布方式-->  
3.        <service name=”服务名”>  
4.               <parameter name=”ServiceClass”>发布的服务类全路径</parameter>  
5.               <!--处理WebService的处理器-->  
6.               <messageReceivers>  
7.                      <!--有返回值的处理器-->  
8.                      <messageReceiver mep=”http://www.w3.org/2004/08/wsdl/in-out”  
9.                         class=”org.apache.axis2.rpc.receivers.RPCMessageReceiver”/>  
10.              <!--无返回值的处理器-->  
11.              <messageReceiver mep=”http://www.w3.org/2004/08/wsdl/in-only”  
12.                         class=”org.apache.axis2.rpc.receivers.RPCInOnlyMessageReceiver”/>  
13.         </messageReceivers>  
14.     </service>  
15.     <!--第二种服务发布方式-->  
16.     <service name=”服务名”>  
17.         <parameter name=”ServiceClass”>发布的服务类全路径</parameter>  
18.         <operation name=”服务的方法名”>  
19.             <messageReceiver class=”处理WebService方法的处理器(如，RPCMessageReceiver类)”/>  
20.         </operation>  
21.         ……  
22.     </service>  
23.     ......  
24. </serviceGroup>  

 

注意：有返回值的处理器为：org.apache.axis2.rpc.receivers.RPCMessageReceiver。

无返回值的处理器为：org.apache.axis2.rpc.receivers.RPCInOnlyMessageReceiver。

(3).将META-INF(包含services.xml)和编译好的类使用jar工具命令打包成”.aar”后缀名的文件。

(4).将打包的”.aar”文件发布到axis2的发布目录：”%Tomcat%/webapps/axis2/WEB-INF/Services”。

注意：此种方法允许使用package。

9.AXIS2使用DataHandler传输二进制文件：

(1).服务端：

[java] view plain copy

1. private void writeInputStreamToFile(InputStream is, OutputStream os) throw Exception{  
2.        int n = 0;  
3.        byte[] byffer = new byte[1024];  
4.        while((n = is.read(buffer)) > 0){  
5.               os.write(buffer, 0, n);  
6. }  
7. }  
8.    
9. public boolean uploadFileWithDataHandler(DataHandler handler, String fileName){  
10.        FileOutputStream fos = null;  
11.        try{  
12.               fos = new FileOutputStream(fileName);  
13.               writeInputStreamToFile(handler.getInputStream, fos);  
14.               fos.close();  
15. }catch(Exception e){  
16.        return false;  
17. }finally{  
18.        if(fos != null){  
19.               try{  
20.        fos.close();  
21. }catch(IOException e){}  
22. }  
23. }  
24.        return true;  
25. }  

 

(2).客户端：

[java] view plain copy

1. File file = new File(文件路径);  
2. DataHandler dh = new DataHandler(new FileDataSource(file));  
3. Object[] parameters = new Object[]{dh, “文件名”};  
4. QName qname = new QName(“targetNamespace”, “服务端方法名(如：uploadFileWithDataHandler)”);  
5. Class[] classes = new Class[]{Boolean.class};  
6. boolean result = Service.invokeBlocking(qname, parameters, classes)[0];  

 

10.AXIS2的状态管理：

(1).AXIS2管理WebService的状态基本上对开发人员是透明的，在WebService类需要使用org.apache,axis2.context.MessageContext和org.apache.axis2.context.ServiceContext类来保存与获取保存在服务端的状态信息，类似于使用HTTPSession接口的getAttribute和setAttribute方法获得与设置Session属性。

(2).此外，还需修改services.xml文件的内容，为<service>元素添加一个scope属性，该属性有4个可取的值：application、soapsession、transportsession和request(全部小写，request是默认值)。

其中transportsession和application分别实现同一个WebService类和跨WebService类的会话管理。

(3).在客户端需要使用setManageSession(true);打开session管理功能。

11.实现同一个WebService的Session管理步骤：

(1).使用MessageContext和ServiceContext获取与设置Session的key-value对。

(2).为要进行session管理的WebService类在services.xml中所对应的<service>元素添加一个scope属性，并将该属性值设置为”transportsession”。

(3).在客户端使用setManageSession(true);打开Session管理功能。

12.WebService的session管理操作代码：

(1).设置key-value：

[java] view plain copy

1. MessageContext mc = MessageContext.getCurrentMessageContext();  
2. ServiceContext sc = mc.getServiceContext();  
3. sc.setProperty(key, value);  

 

(2).获取value：

[java] view plain copy

1. sc.getProperty(key);  

 

(3).若用stub生成方式(进入axis2安装目录使用wsdl2java –uri wsdlURL –p 包名 –s –o 存放目录名)，则需要添加”-serviceClient.getOptions().setManageSession(true);”。

13.WebService跨服务会话管理：

在多个WebService服务之间共享会话状态，也称为跨服务会话管理，实现跨服务会话管理与实现同一个服务的会话管理类似，步骤如下：

(1).使用MessageContext和ServiceContext获取与设置Session的key-value对。

(2).为要进行session管理的WebService类在services.xml中所对应的<service>元素添加一个scope属性，并将该属性值设置为”application”。

(3).在客户端使用setManageSession(true);打开Session管理功能。

注意：java中只有将scope设置为application才支持跨服务的会话管理功能。

14.AXIS2和Spring的集成：

(1).为工程添加Spring支持，在web.xml文件中添加spring的相关配置。

(2).在spring配置文件中配置AXIS2的ServiceBean如下：

[xhtml] view plain copy

1. <bean id= "applicationContext"  
2.     class = "org.apache.axis2.extensions.spring.receivers.ApplicationContextHolder"/>  
3. <bean id= "服务id"   class = "Web服务类的全路径" ></bean>  

 

(3).在WEB-INF/services/下新建一个目录，这个名字可以起的随便，我们就起做test吧，然后在WEB-INF/services/test/下建立META-INF这个目录，最后在WEB-INF/services/test/META-INF/下建立service.xml,文件内容是：

[xhtml] view plain copy

1. <service name= "服务名" >  
2.        <description>服务描述</description>  
3.     <!--注意：不再是ServiceClass，而是有Spring提供-->  
4.     <parameter name= "ServiceObjectSupplier" >  
5.         org.apache.axis2.extensions.spring.receivers.SpringAppContextAwareObjectSupplier  
6.     </parameter>  
7.     <parameter name= "SpringBeanName" >在spring配置文件中配置的服务id</parameter>  
8.     <messageReceivers>  
9.         <messageReceiver mep= "http://www.w3.org/2004/08/wsdl/in-only"  
10.                         class = "org.apache.axis2.rpc.receivers.RPCInOnlyMessageReceiver" />  
11.               <messageReceiver mep= "http://www.w3.org/2004/08/wsdl/in-out"  
12.                         class = "org.apache.axis2.rpc.receivers.RPCMessageReceiver"/>  
13.        </messageReceivers>  
14. </service>  

 

15.AXIS2的异步调用WebService：

同步调用时，如果被调用的WebService方法长时间没有返回，则客户端将一直处于阻塞状态，知道方法返回为止。为了避免长时间被阻塞，需要使用异步调用。AXIS2异步调用有两种方法：

(1).多线程。

(2).RPCServiceClient类提供了一个invokeNoBlocking()方法实现对WebService的异步调用。具体用法如下：

serviceClient.invokeNoBlocking(qname,parameters, 一个实现了AXISCallback接口的实例对象);

实现AXISCallback接口需要实现其如下4个方法，实现异步回调：

onComplete()，onError(Exception e)，onFault(MessageContext mc)，onMessage(MessageContext mc)。

注意：当使用wsdl2java生成客户端调用stub时，会自动生成”服务名+CallbackHandler”的抽象回调类。

16.AXIS2的模块：

AXIS2可以通过模块(Module)进行扩展，AXIS2模块至少需要有两个类，这两个类分别实现了Module和Handler接口，开发和使用一个AXIS2的模板步骤如下：

(1).编写实现了Module接口的类，AXIS2模块在进行初始化、销毁等动作时会自动调用该类中的相应方法。

(2).编写实现了Handler接口的类，该类是AXIS2模块的业务处理类。

(3).编写module.xml文件，该文件放在工程的META-INF目录下，用于配置模块。

(4).在axis2.xml文件中配置AXIS2模块。

(5).在services.xml文件中配置AXIS2模块的引用，<moduleref=”模块名”/>。

(6).发布AXIS2模块，需要使用jar命令将AXIS2模块打包成”.mar”后缀名包，然后将该后缀名为”.mar”的文件拷贝到AXIS2模块发布目录” %Tomcat%/webapps/axis2/WEB-INF/modules”。

注意：模块和Service要分开打包，将module类，handler类和module.xml打成”.mar”文件，将service类和services.xml文件打成”.aar”文件，分别发布。