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中加入如下配置:
- <servlet>
- <servlet-name>XFireServlet</servlet-name>
- <servlet-class>org.codehaus.xfire.transport.http.XFireConfigurableServlet</servlet-class>
- </servlet>
- <servlet-mapping>
- <servlet-name>XFireServlet</servlet-name>
- <url-pattern>/services/*</url-pattern>
- </servlet-mapping>
(2).创建services.xml文件,加入如下配置:
- <? xml version=”1.0” encoding=”UTF-8” ?>
- <beans>
- <service xmlns=”http://xfire.codehaus.org/config/1.0”>
- <name>webservice名</name>
- <namespace>http://包名的逆序/服务类名</namespace>
- <serviceClass>提供服务的接口全路径</serviceClass>
- <implementationClass>服务实现类全路径</implementationClass>
- <scope>服务存活范围</scope>
- </service>
- ……
- </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”文件,添加如下配置:
- <? xml version=”1.0” encoding=”UTF-8” ?>
- <mappings>
- <mapping>
- <method name=”接口中的方法名”>
- <!--配置方法参数类型,索引从0开始-->
- <parameter index=”0” componentType=”参数类型全路径(如:java.lang.String)”/>
- ……
- <return-Type componentType=”返回值类型全路径”/>
- </method>
- ……
- </mapping>
- </mappings>
注意:适用于Map等传递自定义对象这种情况。
6.XFire的Handler:
一个Handler可以看成是XFire的一个加工套件,XFire通过它们定义SOAP发送和接收之前的各种加工处理逻辑。如Handler可以对SOAP体的内容进行加工处理,或者SOAP头进行处理。
(1).编写自定义Handler:
继承AbstractHandler类。
(2).服务器配置Handler:
在services.xml文件中加入如下配置:
在<scope>元素标签之下加入:
- <inHandlers>
- <handler handlerClass=”自定义Handler的全路径”/>
- ……
- </inHandlers>
- <outHandlers>
- <handler handlerClass=”自定义Handler的全路径”/>
- ……
- </outHandlers>
(3).客户端Handler的配置:
- Client client = Client.getInstance(客户端得到的服务对象);
- client.addInHandler(new 自定义Handler());
- client.addOutHandler(new 自定义Handler());
7.文件上传处理:
(1).将文件用DataHandler包装后传递到服务器端。
(2).服务器端根据得到的DataHandler对象.getInputStream()得到文件输入流,将其写到服务器端。
(3).对SOAP消息进行MTOM编码。
- org.codehaus.xfire.client.Client client = ((XFireProxy)Proxy.getInVocationHandler(服务对象)).getClient();
- client.setProperty(SoapConstants.MTOM_ENABLED, “true”);
(4).对输入输出流指定UTF-8字符集:
- InputStreamReader input = new InputStreamReader(handler.getInputSream(), “UTF-8”);
- OutputStreamWriter writer output = new OutputStreamWriter(new FileOutputStream(file), “UTF-8”);
(5).在对应的services.xml文件中,上传文件的Service必须添加如下的Property:
- <properties>
- <property key=”mtom-enabled”>true</property>
- </properties>
8.XFire与Spring的集成(服务器端使用XFire导出器方式):
(1).在web.xml中指定XFire和Spring的配置文件如下:
- <context-param>
- <param-name>classpath:org/codehaus/xfire/spring/xfire.xml,
- /WEB-INF/applicationContext.xml</param-name>
- </context-param>
(2).在Spring配置文件中导入XFire配置文件,配置要发布的服务:
- <import resource=”classpath:org/codehaus/xfire/spring/xfire.xml”/>
- <bean id=”服务id” parent=”baseWebService”>
- <property name=”name” value=”服务名”/>
- <property name=”serviceClass” value=”服务接口全路径”/>
- <property name=”serviceBean” value=”服务实现类”/>
- </bean>
(3).在Spring中配置XFire导出器:
- <bean id=” baseWebService” class=”org.codehaus.xfire.spring.remoting.XFireExporter” lazy-init=”false” abstract=”true”>
- <property name=”serviceFactory” ref=”xfire serviceFactory”/>
- <property name=”xfire” ref=”xfire”/>
- </bean>
(4).客户端Spring配置:
- <bean id=”客户端服务名” class=”org.codehaus.xfire.spring.remoting.XFireClientFactoryBean”>
- <property name=”serviceClass” value=”服务接口全路径”/>
- <property name=”wsdlDocument” value=”服务的WSDL地址”/>
- </bean>
在客户端就可以像使用普通java对象一样使用被spring管理起来的web服务了。
9.XFire与Spring的集成(服务器端不使用XFire导出器方式):
和服务器端使用XFire导出器类似,不同之处在于配置发布的服务:
- <bean id=”服务id” class=”服务名”>
- <property name=”name” value=”服务名”/>
- <property name=”namespace” value=”服务命名空间”/>
- <property name=”serviceClass” value=”服务接口全路径”/>
- <property name=”serviceBean” value/ref=”服务实现类”/>
- </bean>
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。如:
- package service;
- import javax.jws.WebService;
- @WebService
- public interface OrderProcess {
- String processOrder(Order order);
- }
(2).实现服务接口:
在实现类上也添加Webservice注解:@WebService(endpointInterface = 服务接口全路径, serviceName= 对外发布的服务名)。如:
- package service;
- import javax.jws.WebService;
- @WebService(endpointInterface = "service.OrderProcess",serviceName=”order”)
- public class OrderProcessImpl implements OrderProcess {
- public String processOrder(Order order) {
- return "hello world"+order;
- }
- }
(3).对外发布服务:
- //创建web服务工厂
- JaxWsServerFactoryBean factory = new JaxWsServerFactoryBean();
- //设置服务类
- factory.setServiceClass(服务接口实现类.class);
- //设置对外发布服务地址
- factory.setAddress(对外发布的服务地址);
- //创建服务
- Server server = factory.create();
- //启动服务
- server.start();
5.CXF使用JAX-WS开发客户端:
- //创建web服务代理工厂
- JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();
- //设置要调用的web服务服务端发布地址
- factory.setAddress(web服务的发布地址);
- //设置要调用的web服务
- factory.setServiceClass(web服务接口.class);
- //创建web服务对象
- 服务接口 对象 = (服务接口) factory.create();
- 通过对象调用web服务的方法
6.CXF使用POJO开发服务端:
- 和使用JAX-WS开发方式前两步完全一样,第三步稍有不同如下:
- //创建web服务工厂
- ServiceFactoryBean svrFactory = new ServiceFactoryBean();
- //设置服务类
- svrFactory.setServiceClass(服务接口实现类.class);
- //设置对外发布服务地址
- svrFactory.setAddress(对外发布的服务地址);
- //创建服务
- Server server = svrFactory.create();
- //启动服务
- server.start();
7.CXF使用POJO开发客户端:
和JAX-WS方式除了代理工厂不同以外,其他均相同:
- //创建web服务代理工厂
- ClientProxyFactoryBean factory = new ClientProxyFactoryBean();
- //设置要调用的web服务服务端发布地址
- factory.setAddress(web服务的发布地址);
- //设置要调用的web服务
- factory.setServiceClass(web服务接口.class);
- //创建web服务对象
- 服务接口 对象 = (服务接口) factory.create();
通过对象调用web服务的方法
8.CXF与Spring的集成:
(1).对工程引入spring支持。
(2).在web.xml文件中添加spring和CXF相应的配置如下:
- <web-app>
- <context-param>
- <param-name>contextConfigLocation</param-name>
- <param-value>spring配置文件路径</param-value>
- </context-param>
- <listener>
- <listener-class>
- org.springframework.web.context.ContextLoaderListener
- </listener-class>
- </listener>
- <servlet>
- <servlet-name>CXFServlet</servlet-name>
- <display-name>CXF Servlet</display-name>
- <servlet-class>
- org.apache.cxf.transport.servlet.CXFServlet
- </servlet-class>
- <load-on-startup>1</load-on-startup>
- </servlet>
- <servlet-mapping>
- <servlet-name>CXFServlet</servlet-name>
- <url-pattern>/service/*</url-pattern>
- </servlet-mapping>
- </web-app>
(3).在spring配置文件中导入CXF的相关配置如下:
- <import resource="classpath:META-INF/cxf/cxf.xml" />
- <import resource="classpath:META-INF/cxf/cxf-extension-soap.xml" />
- <import resource="classpath:META-INF/cxf/cxf-servlet.xml" />
(4).在spring配置文件中配置要发布的web服务如下:
- <jaxws:endpoint
- id="……"
- implementor="服务接口实现类全路径"
- 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的缩写),这个文件负责描述服务的名称、入口等信息,其内容如下:
- <deployment xmlns="http://xml.apache.org/axis/wsdd/" xmlns:java="http://xml.apache.org/axis/wsdd/providers/java">
- <!--provider=””java:RPC”是服务类型,除了RPC方式以外,还有Document、Wrapped和Message方式-->
- <service name="服务名" provider="java:RPC">
- <!--告诉服务应该调用的类-->
- <parameter name="className" value="服务实现类全路径"/>
- <!--告诉服务可以调用这个类中的任何的Public方法,也可以指定方法名-->
- <parameter name="allowedMethods" value="*"/>
- <parameter name=”scope” value=”request”/>
- </service>
- </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发布的服务:
- String url =”AXIS服务的发布地址路径”;
- Service serv = new Service();
- Call call = (Call)serv.createCall();
- call.setTargetEndpointAddress(url);
- call.setOperationName(new QName(url, “调用服务的方法名”));
- call.invoke(new Object[]{参数对象});
7. AXIS支持三种对象范围:
(1).request范围:这是默认的情况,每一次Soap请求的时候都将创建新的对象。
(2).application范围:将会为所有的请求生成一个单独的共享的对象。
(3).session范围:为每一个session期的客户端请求创建一个对象。
指定方法如下:
- <service name="MyService"...>
- <parameter name="scope" value="对象范围"/>
- ...
- </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文件中加入如下配置:
- <handler name=”handler名称” type=”java:handler全路径名”>
- <parameter name=”handler变量名” value=”……”/>
- ……
- </handler>
(3).为WebService引入Handler:
在wsdd文件的<service>中加入如下配置:
- <requestFlow>或者<responseFlow>
- <handler type=”handler名”/>
- </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>嵌套,具体配置如下:
- <chain name=”chain名”>
- <handler type=”java:chain的全路径”/>
- ......
- </chain>
9.WebService传递复杂对象:
(1).创建Qname:
- Qname表示XML规范中定义的限定名称,由名称空间URI、本地部分和前缀组成,如:
- //第一个参数是名称空间,第二个参数是本地部分
- Qname qn = new Qname(”urn:AddressManager”, ”Address”);
(2).注册对象类型映射:
如:
- call.registerTypeMapping(对象.class, QName,
- new org.apache.axis.encoding.ser.BeanSerializerFactory(对象.class, QName),
- new org.apache.axis.encoding.ser.BeanDeSerializerFactory(对象.class, QName));
(3).返回值类型设置:
如:
- call.setReturnClass(ArrayList.class);
(4).设置传递的方法参数类型:
如:
- call.addParameter(“参数名”, XMLType.XSD_ANYTYPE, ParameterModel.IN);
(5).在wsdd文件中加上类型映射:
在<service>标签中加入如下配置:
- <beanMapping qname=”前缀:本地名”
- xmlns:前缀=”urn:名称空间”
- languageSpecificType=”java:自定义类型全路径”/>
10.WebService传递带有内部类的复杂对象:
(1).内部类必须是可序列化的,内部类必须是静态的,否则不能被序列化。
(2).内部类也要像自定义类一样进行映射和注册,如:
- call.registerTypeMapping(外部类.内部类.class, QName,
- BeanSerializerFactory.class, BeanDeSerializerFactory.class);
(3).在wsdd文件中配置内部类的相关映射:
如:
- <beanMapping qname=”本地名”
- xmlns:前缀=”urn:名称空间”
- languageSpecificType=”java:外部类全路径$内部类名”/>
11.Webservice的RMI调用方式:
本地实现一个Remote接口,其中包含远程webservice的调用方法(同名、同返回类型、同参数类型),则通过service可以获得一个对远程webservice对象的引用,用该引用可以直接像调用本地方法一样调用远程方法。
(1).服务器端不用继承或者实现任何接口。
(2).通过如下方法使本地的远程接口获取webservice引用:
- 接口类型 对象 = (接口类型)Service对象.getPort(endpoint/QName, ProxyInterface.class);
12.WebService传递异常对象:
(1).自定义异常。
(2).方法中抛出该异常对象。
(3).在wsdd文件中加入如下配置:
在<service>元素的<operation>标签中加入<fault>子标签如下:
- <operation name=”……”>
- <fault name=”……”
- qname=”……”
- type=”tns:ServerException”/>
- </operation>
- <typeMapping qname=”……”
- type=”java:自定义异常类全路径”
- serializer=”org.apache.axis.encoding.ser.BeanSerializerFactory”
- deserializer=“org.apache.axis.encoding.ser.BeanDeSerializerFactory”
- encodingStyle=http://schemas.xmlsoap.org/soap/encoding/”/>
13.WebService传递文件:
(1).服务器端方法:
- public String receive(DataHandler handler, String fileName){
- File file = new File(fileName);
- if(handler == null || filename == null || fileName.equals(“”)){
- return “failure”;
- }
- InputStream input = null;
- FileOutputStream fos = null;
- try{
- input = handler.getInputStream();
- fos = new FileOutputStream(file);
- byte[] buffer = new byte[1024];
- while(input.read(buffer) != -1){
- fos.writer(buffer);
- }
- }catch(Exception e){
- e.printStackTrace();
- }finally{
- if(input != null){
- try{
- input.close();
- }catch(IOException e){
- }
- }
- if(fos != null){
- try{
- fos.close();
- }catch(Exception e){
- }
- }
- }
- return “success”;
- }
注意:DataHandler是一个专门的传送器,通过它可以把文件进行序列化。
(2).wsdd文件进行如下配置:
- <service name=”FileReceiverServer” provider=”java:RPC”>
- <parameter name=”className” value=”服务器文件接收类全路径”/>
- ……
- <operatiojn name=”receive”
- qname=”operNS:receive”
- xmlns:operNS=”receive”
- returnType=”rtns:String”
- xmlns:rtns=”http://www.w3.org/2001/xmlSchema”>
- <parameter name=”handler” type=”myns:DataHandler”
- xmlns:myns=http://www.w3.org/XmlSchema”/>
- <parameter name=”fileName” type=”tns:String”
- xmlns:tns=http://www.w3.org/XmlSchema”/>
- </operation>
- <typeMapping qname=”myns:DataHandler”
- xmlns:myns=”DataHandler”
- languageSpecific=”java:javax.activation.DataHandler”
- serializer=”org.apache.axis.encoding.ser.JAFDataHandlerSerializerFactory”
- deserializer=”org.apache.axis.encoding.ser.JAFDataHandlerDeSerializerFactory” encodingstyle=http://schemas.xmlsoap.org/soap/encoding/”/>
- </service>
(3).客户端传递DataHandler对象:
- DataHandler dh = new DataHandler(new FileDataSource(文件路径名));
文件路径名的获取一般写法如:
- 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:
- RPCServiceClient client = new RPCServiceClient();
- Options options = client.getOptions();
(2).指定调用WebService的URL:
- EndpointReference targetURL = new EndpointReference(“WebService发布的URL地址”);
- Options.setTo(targetURL);
(3).指定调用服务方法的参数值:
- Object[] parameters = new Object[]{参数值};
(4).指定方法返回值的数据类型,如:
- Class[] classes = new Class[]{String.class};
(5).指定要调用方法名和WSDL文件的命名空间:
- //命名空间为wsdl文件中<wsdl:definitions>元素的targetNamespace属性值
- QName qname = new QName(“命名空间”, “调用方法名”);
(6).调用服务的方法:
- //三个参数第一个为QName对象,表示要调用的方法名;第二个参数表示要调用的//WebService方法的参数值;第三个参数表示WebService方法的返回值类型
- 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).在定义数组类型时只能使用一维数组,如果想传递多维数组,可以使用分隔符进行分割,如:
- String[] strArray = new String[]{“自行车, 飞机, 火箭”, “中国, 美国, 德国”, “超人, 蜘蛛侠, 钢铁侠”};
可以将该数组看作是一个3×3的二维数组。
(2).当传递自定义的类或接口时,请务必实现序列化。
8.使用services.xml方式发布WebService:
(1).编写服务端的类。
(2).在工程META-INF目录下建services.xml文件,添加如下内容:
- <serviceGroup>
- <!--第一种服务发布方式-->
- <service name=”服务名”>
- <parameter name=”ServiceClass”>发布的服务类全路径</parameter>
- <!--处理WebService的处理器-->
- <messageReceivers>
- <!--有返回值的处理器-->
- <messageReceiver mep=”http://www.w3.org/2004/08/wsdl/in-out”
- class=”org.apache.axis2.rpc.receivers.RPCMessageReceiver”/>
- <!--无返回值的处理器-->
- <messageReceiver mep=”http://www.w3.org/2004/08/wsdl/in-only”
- class=”org.apache.axis2.rpc.receivers.RPCInOnlyMessageReceiver”/>
- </messageReceivers>
- </service>
- <!--第二种服务发布方式-->
- <service name=”服务名”>
- <parameter name=”ServiceClass”>发布的服务类全路径</parameter>
- <operation name=”服务的方法名”>
- <messageReceiver class=”处理WebService方法的处理器(如,RPCMessageReceiver类)”/>
- </operation>
- ……
- </service>
- ......
- </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).服务端:
- private void writeInputStreamToFile(InputStream is, OutputStream os) throw Exception{
- int n = 0;
- byte[] byffer = new byte[1024];
- while((n = is.read(buffer)) > 0){
- os.write(buffer, 0, n);
- }
- }
- public boolean uploadFileWithDataHandler(DataHandler handler, String fileName){
- FileOutputStream fos = null;
- try{
- fos = new FileOutputStream(fileName);
- writeInputStreamToFile(handler.getInputStream, fos);
- fos.close();
- }catch(Exception e){
- return false;
- }finally{
- if(fos != null){
- try{
- fos.close();
- }catch(IOException e){}
- }
- }
- return true;
- }
(2).客户端:
- File file = new File(文件路径);
- DataHandler dh = new DataHandler(new FileDataSource(file));
- Object[] parameters = new Object[]{dh, “文件名”};
- QName qname = new QName(“targetNamespace”, “服务端方法名(如:uploadFileWithDataHandler)”);
- Class[] classes = new Class[]{Boolean.class};
- 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:
- MessageContext mc = MessageContext.getCurrentMessageContext();
- ServiceContext sc = mc.getServiceContext();
- sc.setProperty(key, value);
(2).获取value:
- 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如下:
- <bean id= "applicationContext"
- class = "org.apache.axis2.extensions.spring.receivers.ApplicationContextHolder"/>
- <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,文件内容是:
- <service name= "服务名" >
- <description>服务描述</description>
- <!--注意:不再是ServiceClass,而是有Spring提供-->
- <parameter name= "ServiceObjectSupplier" >
- org.apache.axis2.extensions.spring.receivers.SpringAppContextAwareObjectSupplier
- </parameter>
- <parameter name= "SpringBeanName" >在spring配置文件中配置的服务id</parameter>
- <messageReceivers>
- <messageReceiver mep= "http://www.w3.org/2004/08/wsdl/in-only"
- class = "org.apache.axis2.rpc.receivers.RPCInOnlyMessageReceiver" />
- <messageReceiver mep= "http://www.w3.org/2004/08/wsdl/in-out"
- class = "org.apache.axis2.rpc.receivers.RPCMessageReceiver"/>
- </messageReceivers>
- </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”文件,分别发布。
原文