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中加入如下配置:

  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文件,加入如下配置:

  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”文件,添加如下配置:

  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>元素标签之下加入:

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

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

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

7.文件上传处理:

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

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

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

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

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

  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:

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

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

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

  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配置文件,配置要发布的服务:

  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导出器:

  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配置:

  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导出器类似,不同之处在于配置发布的服务:

  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。如:

  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= 对外发布的服务名)。如:

  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).对外发布服务:

  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开发客户端:

  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方式除了代理工厂不同以外,其他均相同:

  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相应的配置如下:

  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的相关配置如下:

  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服务如下:

  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的缩写),这个文件负责描述服务的名称、入口等信息,其内容如下:

  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发布的服务:

  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期的客户端请求创建一个对象。
  指定方法如下:

  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文件中加入如下配置:

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

(3).为WebService引入Handler:

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

  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>嵌套,具体配置如下:

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

9.WebService传递复杂对象:

(1).创建Qname:

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

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

如:

  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).返回值类型设置:

如:

  1. call.setReturnClass(ArrayList.class);  
 

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

如:

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

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

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

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

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

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

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

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

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

如:

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

11.Webservice的RMI调用方式:

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

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

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

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

12.WebService传递异常对象:

(1).自定义异常。

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

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

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

  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).服务器端方法:

  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文件进行如下配置:

  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对象:

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

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

  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-SecurityWS-ReliableMessagingWS-AddressingWS-CoordinationWS-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:

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

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

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

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

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

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

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

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

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

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

  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).在定义数组类型时只能使用一维数组,如果想传递多维数组,可以使用分隔符进行分割,如:

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

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

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

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

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

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

  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).服务端:

  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).客户端:

  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:

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

(2).获取value:

  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如下:

  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,文件内容是:

  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”文件,分别发布。



posted @ 2012-09-20 18:49  ajian005  阅读(1558)  评论(0编辑  收藏  举报