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 <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文件，加入如下配置：
[xhtml] view plain copy <? 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”文件，添加如下配置：
[xhtml] view plain copy <? 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>元素标签之下加入：
[xhtml] view plain copy <inHandlers> <handler handlerClass=”自定义Handler的全路径”/> …… </inHandlers> <outHandlers> <handler handlerClass=”自定义Handler的全路径”/> …… </outHandlers>(3).客户端Handler的配置：
[java] view plain copy Client client = Client.getInstance(客户端得到的服务对象); client.addInHandler(new 自定义Handler()); client.addOutHandler(new 自定义Handler());7.文件上传处理：
(1).将文件用DataHandler包装后传递到服务器端。
(2).服务器端根据得到的DataHandler对象.getInputStream()得到文件输入流，将其写到服务器端。
(3).对SOAP消息进行MTOM编码。
[java] view plain copy org.codehaus.xfire.client.Client client = ((XFireProxy)Proxy.getInVocationHandler(服务对象)).getClient(); client.setProperty(SoapConstants.MTOM_ENABLED, “true”);(4).对输入输出流指定UTF-8字符集：
[java] view plain copy InputStreamReader input = new InputStreamReader(handler.getInputSream(), “UTF-8”); OutputStreamWriter writer output = new OutputStreamWriter(new FileOutputStream(file), “UTF-8”);(5).在对应的services.xml文件中，上传文件的Service必须添加如下的Property：
[xhtml] view plain copy <properties> <property key=”mtom-enabled”>true</property> </properties>8.XFire与Spring的集成(服务器端使用XFire导出器方式)：
(1).在web.xml中指定XFire和Spring的配置文件如下：
[xhtml] view plain copy <context-param> <param-name>classpath:org/codehaus/xfire/spring/xfire.xml, /WEB-INF/applicationContext.xml</param-name> </context-param>(2).在Spring配置文件中导入XFire配置文件，配置要发布的服务：
[xhtml] view plain copy <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导出器：
[xhtml] view plain copy <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配置：
[xhtml] view plain copy <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导出器类似，不同之处在于配置发布的服务：
[xhtml] view plain copy <bean id=”服务id” class=”服务名”> <property name=”name” value=”服务名”/> <property name=”namespace” value=”服务命名空间”/> <property name=”serviceClass” value=”服务接口全路径”/> <property name=”serviceBean” value/ref=”服务实现类”/> </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 package service; import javax.jws.WebService; @WebService public interface OrderProcess { String processOrder(Order order); }(2).实现服务接口：
在实现类上也添加Webservice注解：@WebService(endpointInterface = 服务接口全路径, serviceName= 对外发布的服务名)。如：
[java] view plain copy 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).对外发布服务：
[java] view plain copy //创建web服务工厂 JaxWsServerFactoryBean factory = new JaxWsServerFactoryBean(); //设置服务类 factory.setServiceClass(服务接口实现类.class); //设置对外发布服务地址 factory.setAddress(对外发布的服务地址); //创建服务 Server server = factory.create(); //启动服务 server.start();5.CXF使用JAX-WS开发客户端：
[java] view plain copy //创建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方式除了代理工厂不同以外，其他均相同：
[java] view plain copy //创建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相应的配置如下：
[xhtml] view plain copy <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的相关配置如下：
[xhtml] view plain copy <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服务如下：
[xhtml] view plain copy <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的缩写），这个文件负责描述服务的名称、入口等信息，其内容如下：
[xhtml] view plain copy <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发布的服务：
[java] view plain copy 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期的客户端请求创建一个对象。 指定方法如下：
[xhtml] view plain copy <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文件中加入如下配置：
[xhtml] view plain copy <handler name=”handler名称” type=”java:handler全路径名”> <parameter name=”handler变量名” value=”……”/> …… </handler>(3).为WebService引入Handler：
在wsdd文件的<service>中加入如下配置：
[xhtml] view plain copy <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>嵌套，具体配置如下：
[xhtml] view plain copy <chain name=”chain名”> <handler type=”java:chain的全路径”/> ...... </chain>9.WebService传递复杂对象：
(1).创建Qname：
[java] view plain copy Qname表示XML规范中定义的限定名称，由名称空间URI、本地部分和前缀组成，如： //第一个参数是名称空间，第二个参数是本地部分 Qname qn = new Qname(”urn:AddressManager”, ”Address”);(2).注册对象类型映射：
如：
[java] view plain copy call.registerTypeMapping(对象.class, QName, new org.apache.axis.encoding.ser.BeanSerializerFactory(对象.class, QName), new org.apache.axis.encoding.ser.BeanDeSerializerFactory(对象.class, QName));
(3).返回值类型设置：
如：
[java] view plain copy call.setReturnClass(ArrayList.class);
(4).设置传递的方法参数类型：
如：
[java] view plain copy call.addParameter(“参数名”, XMLType.XSD_ANYTYPE, ParameterModel.IN);
(5).在wsdd文件中加上类型映射：
在<service>标签中加入如下配置：
[xhtml] view plain copy <beanMapping qname=”前缀:本地名” xmlns:前缀=”urn:名称空间” languageSpecificType=”java:自定义类型全路径”/>10.WebService传递带有内部类的复杂对象：
(1).内部类必须是可序列化的，内部类必须是静态的，否则不能被序列化。
(2).内部类也要像自定义类一样进行映射和注册，如：
[java] view plain copy call.registerTypeMapping(外部类.内部类.class, QName, BeanSerializerFactory.class, BeanDeSerializerFactory.class);(3).在wsdd文件中配置内部类的相关映射：
如：
[xhtml] view plain copy <beanMapping qname=”本地名” xmlns:前缀=”urn:名称空间” languageSpecificType=”java:外部类全路径$内部类名”/>
11.Webservice的RMI调用方式：
本地实现一个Remote接口，其中包含远程webservice的调用方法(同名、同返回类型、同参数类型)，则通过service可以获得一个对远程webservice对象的引用，用该引用可以直接像调用本地方法一样调用远程方法。
(1).服务器端不用继承或者实现任何接口。
(2).通过如下方法使本地的远程接口获取webservice引用：
[java] view plain copy 接口类型 对象 = (接口类型)Service对象.getPort(endpoint/QName, ProxyInterface.class);12.WebService传递异常对象：
(1).自定义异常。
(2).方法中抛出该异常对象。
(3).在wsdd文件中加入如下配置：
在<service>元素的<operation>标签中加入<fault>子标签如下：
[xhtml] view plain copy <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).服务器端方法：
[java] view plain copy 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文件进行如下配置：
[xhtml] view plain copy <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对象：
[java] view plain copy DataHandler dh = new DataHandler(new FileDataSource(文件路径名));文件路径名的获取一般写法如：
[java] view plain copy 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 RPCServiceClient client = new RPCServiceClient(); Options options = client.getOptions();(2).指定调用WebService的URL：
[java] view plain copy EndpointReference targetURL = new EndpointReference(“WebService发布的URL地址”); Options.setTo(targetURL);(3).指定调用服务方法的参数值：
[java] view plain copy Object[] parameters = new Object[]{参数值};(4).指定方法返回值的数据类型，如：
[java] view plain copy Class[] classes = new Class[]{String.class};(5).指定要调用方法名和WSDL文件的命名空间：
[java] view plain copy //命名空间为wsdl文件中<wsdl:definitions>元素的targetNamespace属性值 QName qname = new QName(“命名空间”, “调用方法名”);(6).调用服务的方法：
[java] view plain copy //三个参数第一个为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).在定义数组类型时只能使用一维数组，如果想传递多维数组，可以使用分隔符进行分割，如：
[java] view plain copy String[] strArray = new String[]{“自行车, 飞机, 火箭”, “中国, 美国, 德国”, “超人, 蜘蛛侠, 钢铁侠”};可以将该数组看作是一个3×3的二维数组。
(2).当传递自定义的类或接口时，请务必实现序列化。
8.使用services.xml方式发布WebService：
(1).编写服务端的类。
(2).在工程META-INF目录下建services.xml文件，添加如下内容：
[xhtml] view plain copy <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).服务端：
[java] view plain copy 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).客户端：
[java] view plain copy 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：
[java] view plain copy MessageContext mc = MessageContext.getCurrentMessageContext(); ServiceContext sc = mc.getServiceContext(); sc.setProperty(key, value);(2).获取value：
[java] view plain copy 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 <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,文件内容是：
[xhtml] view plain copy <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”文件，分别发布。
原文