创建WebService使用Axis2和CXF的区别

webService基本概念、元素及简单编码实现webService"⽹络服务"（Web Service）的本质，就是通过⽹络调⽤其他⽹站的资源。

⽹络服务是相对于本地服务来说的，本机完成本机需要完成的任务，叫“本地服务”，⽽“⽹络服务”则是通过⽹络来调⽤其他服务器提供的服务。

webService和中间件的关系：webService是⼀种技术⼿段，是⼀种⽹络中系统之间进⾏交互的⽅式。

⽽中间件则是实现这种交互的⼀种⼿段（⼀种软件、服务）。

定义：WebService是⼀种跨编程语⾔和跨操作系统平台的远程调⽤技术（rpc）。

实现平台⽆关性和语⾔⽆关性的关键是⽤⼀种标准来统⼀定义相互通信的接⼝，⽽WebService平台技术就是旨在解决统⼀标准的问题。

引⽤：WebService平台技术XML+XSD,SOAP和WSDL就是构成WebService平台的三⼤技术。

SOAP和WSDL的详细格式和解析可见： orXML和XSD： WebService采⽤HTTP协议传输数据，采⽤XML格式封装数据（即XML中说明调⽤远程服务对象的哪个⽅法，传递的参数是什么，以及服务对象的返回结果是什么）。

XML是WebService平台中表⽰数据的格式。

除了易于建⽴和易于分析外，XML主要的优点在于它既是平台⽆关的，⼜是⼚商⽆关的。

⽆关性是⽐技术优越性更重要的：软件⼚商是不会选择⼀个由竞争对⼿所发明的技术的。

XML解决了数据表⽰的问题，但它没有定义⼀套标准的数据类型，更没有说怎么去扩展这套数据类型。

例如，整形数到底代表什么？16位，32位，64位？这些细节对实现互操作性很重要。

XML Schema(XSD)就是专门解决这个问题的⼀套标准。

它定义了⼀套标准的数据类型，并给出了⼀种语⾔来扩展这套数据类型。

WebService平台就是⽤XSD来作为其数据类型系统的。

当你⽤某种语⾔(如或C#)来构造⼀个Web service时，为了符合WebService 标准，所有你使⽤的数据类型都必须被转换为XSD类型。

java webservice几种调用方式Java Web Service是一种流行的技术，用于通过网络在不同系统之间实现通讯和集成。

在Java中，有多种方式可以调用Web Service。

下面将介绍几种常用的调用方式。

1.使用SOAP（Simple Object Access Protocol）协议SOAP是一种基于XML的通讯协议，可以在网络上使用HTTP、SMTP等协议发送和接收消息。

在Java中，可以使用SOAP协议调用Web Service。

SOAP使用WSDL（Web Services Description Language）来描述Web Service的接口和功能。

可以使用轻量级的SOAP框架Apache CXF或Metro来创建和调用SOAP Web Service。

调用方式主要包括以下几步：-创建一个Java类来表示Web Service的接口，并使用注解来定义接口的操作。

-使用工具，如Apache CXF或Metro，将该类生成WSDL文档。

-使用WSDL文档生成客户端代码，以便在调用Web Service时使用。

-创建一个客户端程序，通过调用生成的客户端代码来调用Web Service的方法。

2.使用JAX-WS（Java API for XML Web Services）标准JAX-WS是一种Java的Web Service规范，它提供了一种简单的方式来创建和调用Web Service。

JAX-WS提供了注解，用于将Java类转换为Web Service，并且可以使用Java的代理类来调用Web Service 的方法。

调用方式包括以下几步：-创建一个Java类，并用@WebService注解来标记它作为一个Web Service的实现。

-在该类中定义Web Service的操作，并使用@WebMethod注解来标记这些方法。

-使用工具，如JDK的wsimport命令或Eclipse的WebService工具来生成客户端代码。

Axis2与CXF易用性比较一． CXF与spring集成1.简介：CXF是基于JAX-WS实现的，JAX-WS规范是一组XML web services的JA V A 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.实现过程：a)为CXF设置编译和开发环境在/download.html下载相应的CXF包，/lib目录下的jar 文件引入工程b) 新建工程，cxfspring，包含WebRoot/WEB-INF目录c) 编写服务首先写一个服务接口，例子中的HelloWorld.java。

我们要注意的是这个例子使用了JSR181规范中的声明“@WebService”。

package demo.spring;import javax.jws.WebService;@WebServicepublic interface HelloWorld {String sayHi(String text);}下一步实现这个服务接口，例子中的HelloWorldImpl.java。

这个例子代码中的“@WebService”标签只包含一个endpointInterface的属性，这个属性让CXF 知道根据哪个接口生成WSDL文件。

这里有点和我们第一个例子不同，没有包含ServiceName属性。

WebService框架JWS、Axis2、XFire、CXF的区别1、JWS是Java语言对WebService服务的一种实现，用来开发和发布服务。

而从服务本身的角度来看JWS服务是没有语言界限的。

但是Java语言为Java开发者提供便捷发布和调用WebService服务的一种途径。

2、Axis2是Apache下的一个重量级WebService框架，准确说它是一个Web Services / SOAP / WSDL 的引擎，是WebService框架的集大成者，它能不但能制作和发布WebService，而且可以生成Java和其他语言版WebService客户端和服务端代码。

这是它的优势所在。

但是，这也不可避免的导致了Axis2的复杂性，使用过的开发者都知道，它所依赖的包数量和大小都是很惊人的，打包部署发布都比较麻烦，不能很好的与现有应用整合为一体。

但是如果你要开发Java之外别的语言客户端，Axis2提供的丰富工具将是你不二的选择。

3、XFire是一个高性能的WebService框架，在Java6之前，它的知名度甚至超过了Apache的Axis2，XFire的优点是开发方便，与现有的Web整合很好，可以融为一体，并且开发也很方便。

但是对Java之外的语言，没有提供相关的代码工具。

XFire后来被Apache收购了，原因是它太优秀了，收购后，随着Java6 JWS的兴起，开源的WebService引擎已经不再被看好，渐渐的都败落了。

4、CXF是Apache旗下一个重磅的SOA简易框架，它实现了ESB （企业服务总线）。

CXF来自于XFire项目，经过改造后形成的，就像目前的Struts2来自WebWork一样。

可以看出XFire的命运会和WebWork的命运一样，最终会淡出人们的视线。

CXF不但是一个优秀的Web Services / SOAP / WSDL 引擎，也是一个不错的ESB总线，为SOA的实施提供了一种选择方案，当然他不是最好的，它仅仅实现了SOA架构的一部分。

WebService流行框架之Axis和CXF前言上节课我们对WebService进行了简单的介绍，对于其所应用到的技术有了一定的了解。

今天主要讲解下WebService的两个流行的框架Axis和CXF。

正题一、服务端发布WebService在讲解之前，我们先来看一下这篇博客主要讲解的内容：每一种框架都有自己的特点，有自己的侧重，但是他们的共同之处在于对发布WebService进行了封装，所以我们只需编写一个配置文件或者使用@WebService注解就可以发布WebService，我们这里着重说一下他们各自的特点：1.Axis1Axis1有两种发布方式：1）JWS方式a.这种方式很简单，只需要将源码java文件放到AXIS_HOME下面，然后将后缀改为.jws，这样，Axis 会自动编译.jws文件，并把它自动加入到Java WebServie的服务中。

b.但是这种方式的缺点是：只能是java源代码，同时类中不能含有包名。

2）WSDD方式1.写一个java类（需要引入axis的jar包）2.配置web.xml文件（配置AxisServlet，AdminServlet，SOAPMonitorService和AxisHTTPSessionListener）3.写一个deloy.wsdd文件，部署项目（tomcat启动就可以部署项目）安装axis1到tomcat：1.Axis官方网站：/axis/，可以在官网下载最新1.4的包：axis-bin-1_4.zip2.将解压后的axis-1_4\webapps\下的axis目录考到%TOMCAT_HOME%/Webapps/目录下3.启动tomcat后在浏览器里输入http://localhost:port/axis4.点击上图中的Validataion链接,页面上会提示已经有的包和缺少的包的信息,根据提示将必须的包下载全，将这些类包复制到%tomcathome%/webapps/axis/WEB-INF/lib/目录下重新启动tomcat,直到Validation页面中看不到有Error与Warning的提示信息。

WebService介绍(WebService基础知识、XFire、CXF（基于XFire 和Celtix项目整合而来，与Spring融合好）、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消息基本结构：/2001/12/soap-envelope”soap:encodingStyle=”/2001/12/soap-encoding”>——>SOAP信封——>SOAP消息头......——>SOAP消息体，包含所有的调用和响应信息……——>可选的，处理错误消息……——>SOAP消息附件——>SOAP信封(2).SOAP消息组成元素：SOAP Envelope：SOAP信封，用于描述消息，标识SOAP内容和信封的处理信息。

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

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

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

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

CXF2对比了一下CXF2 和AXIS 2 还是选择在框架中集成CXF2。

不过CXF2的文档更新的真是慢啊，试了一下，目前CXF2支持的两种绑定方式jaxb2和aegis，看了半天源码总算调通了。

又忍不住批一下他的文档，给的都是半调子的例子，希望开发小组能尽快完善啊！先放一个HelloWold的aegis的配置:一、server 端:1. HelloWorld.java代码1. package demo.spring;2.3. import javax.jws.WebService;4.5. @WebService6. public interface HelloWorld {7. String sayHi(String text);8. }2.HelloWorldImpl.java代码1. package demo.spring;2.3. import javax.jws.WebService;4.5. @WebService(endpointInterface = "demo.spring.HelloWorld")6. public class HelloWorldImpl implements HelloWorld {7.8. public String sayHi(String text) {9. return "Hello " + text;10. }11. }3.beans.xml代码1. <beans xmlns="/schema/beans"2. xmlns:xsi="http://www.w/2001/XMLSchema-instance"3. xmlns:jaxws="/jaxws"4. xsi:schemaLocation="5. /schema/beans /schema/beans/spring-beans.xsd6. /jaxws /schemas/jaxws.xsd">7.8. <import resource="classpath:META-INF/cxf/cxf.xml" />9. <import resource="classpath:META-INF/cxf/cxf-extension-soap.xml" />10. <import resource="classpath:META-INF/cxf/cxf-servlet.xml" />11.12. <bean id="jaxWsServiceFactoryBean"13. class="org.apache.cxf.jaxws.support.JaxWsServiceFactoryBean">14. <property name="wrapped" value="true" />15. <property name="dataBinding" ref="aegisBean" />16. </bean>17.18. <bean id="aegisBean"19. class="org.apache.cxf.aegis.databinding.AegisDatabinding" />20.21. <jaxws:endpoint id="CollectiveServices"22. implementor="demo.spring.HelloWorldImpl" address="/HelloWorld">23. <jaxws:serviceFactory>24. <ref bean="jaxWsServiceFactoryBean"/>25. </jaxws:serviceFactory>26. </jaxws:endpoint>27. </beans>4.web.xml代码1. <web-app version="2.4" xmlns="/xml/ns/j2ee"2. xmlns:xsi="http://www.w/2001/XMLSchema-instance"3. xsi:schemaLocation="/xml/ns/j2ee /xml/ns/j2ee/web-app_2_4.xsd">4.5. <context-param>6. <param-name>contextConfigLocation</param-name>7. <param-value>WEB-INF/beans.xml</param-value>8. </context-param>9.10. <listener>11. <listener-class>12. org.springframework.web.context.ContextLoaderListener13. </listener-class>14. </listener>15.16. <servlet>17. <servlet-name>CXFServlet</servlet-name>18. <servlet-class>19. org.apache.cxf.transport.servlet.CXFServlet20. </servlet-class>21. <load-on-startup>1</load-on-startup>22. </servlet>23.24. <servlet-mapping>25. <servlet-name>CXFServlet</servlet-name>26. <url-pattern>/ws/*</url-pattern>27. </servlet-mapping>28.29. </web-app>二、客户端1.ClientTest.java代码1. package demo.spring.client;2.3. import static org.junit.Assert.assertEquals;4.5. import org.apache.cxf.aegis.databinding.AegisDatabinding;6. import org.apache.cxf.frontend.ClientProxyFactoryBean;7. import org.junit.AfterClass;8. import org.junit.BeforeClass;9. import org.junit.Test;10. import org.springframework.context.support.ClassPathXmlApplicationContext;11.12. import demo.spring.HelloWorld;13.14. public final class ClientTest {15.16. private static ClassPathXmlApplicationContext context;17.18. @BeforeClass19. public static void beforeClass() {20. context = new ClassPathXmlApplicationContext(21. new String[] { "demo/spring/client/client-beans.xml" });22. }23.24. @AfterClass25. public static void afterClass() {26. context = null;27. }28.29. @Test30. public void testSayHiWithSpringConfig() throws Exception {31.32. HelloWorld client = (HelloWorld) context.getBean("client");33.34. String response = client.sayHi("Joe");35. assertEquals("Hello Joe", response);36. }37.38. /**39. * 这个官方有例子（/CXF20DOC/aegis-databinding.html）40. *41. * @throws Exception42. */43. @Test44. public void testSayHiByCode() throws Exception {45.46. ClientProxyFactoryBean factory = new ClientProxyFactoryBean();47. factory.setServiceClass(HelloWorld.class);48. factory.setAddress("http://localhost:8080/testCxf/ws/HelloWorld");49. factory.getServiceFactory().setDataBinding(new AegisDatabinding());50. HelloWorld client = (HelloWorld) factory.create();51.52. assertEquals("Hello Joe", client.sayHi("Joe"));53. }54. }55.2.client_beans.xml(testSayHiWithSpringConfig()中需要使用的配置文件)代码1. <beans xmlns="/schema/beans"2. xmlns:xsi="http://www.w/2001/XMLSchema-instance"3. xmlns:jaxws="/jaxws"4. xsi:schemaLocation="5. /schema/beans /schema/beans/spring-beans-2.0.xsd6. /jaxws /schema/jaxws.xsd">7.8.9. <bean id="aegisBean"10. class="org.apache.cxf.aegis.databinding.AegisDatabinding" />11.12. <bean id="serviceFactoryBean" class="org.apache.cxf.jaxws.support.JaxWsServiceFactoryBean">13. <property name="dataBinding" ref="aegisBean" />14. </bean>15.16. <bean id="client" class="demo.spring.HelloWorld"17. factory-bean="clientFactory" factory-method="create" />18.19. <bean id="clientFactory"20. class="org.apache.cxf.frontend.ClientProxyFactoryBean">21. <property name="serviceFactory" ref="serviceFactoryBean" />22. <property name="serviceClass"23. value="demo.spring.HelloWorld" />24. <property name="address"25. value="http://localhost:8080/testCxf/ws/HelloWorld" />26. </bean>27.28. </beans>。

Axis2,CXF,xifire1. Axis2.x (3)1.1. 开发准备工作 (3)1.1.1. 环境 (3)1.1.2. 单独启动AXIS2服务 (4)1.1.3. 将axis2-1.6.2-bin.zip中的项目打成axis2.war包 (4)1.1.4. Axis2脚本 (5)1.1.5. 安装eclipse插件（可选） (7)1.1.6. axis2-bin文件目录结构 (8)1.1.7. 部署axis2.war到tomcat (8)1.1.8. 上传services(Uploading Services) (9)1.2. Axis2开发部署 (9)1.2.1. 编写服务器代码，和配置文件 (10)1.2.2. 发布 (11)1.2.3. 通过class文件生成wsdl文件（java2wsdl） (13)1.2.4. 通过wsdl文件生成Java访问代码（wsdl2java） (13)1.2.5. 调用：Axis2开发WebService客户端的3种方式 (14)1.2.6. PS:配置文件介绍 (21)1.3. 大病系统ESB接口开发 (25)1.3.1. esb接口标准 (26)1.3.2. esb接口开发 (31)1.3.3. esb接口调试测试 (53)1.3.4. esb接口发布 (53)2. CXF (53)2.1. 准备工作 (54)2.2. 开发示例 (54)2.2.1. 编写服务端接口 (55)2.2.2. 编写服务实现 (56)2.2.3. 编写webServiceApp.java类来暴露web服务 (57)2.2.4. 启动服务 (57)2.2.5. 编写客户端访问服务 (57)2.2.6. 测试 (58)2.2.7. 集成到spring (58)2.2.8. 通过wsdl文件生成客户端和服务器端代码 (61)3. xfire (62)3.1. 准备工作 (62)3.2. 开发步骤 (62)3.2.1. 建立目录结构 (62)3.2.2. 添加依赖包 (63)3.2.3. 编写服务端代码 (63)3.2.4. 配置web.xml (66)3.2.5. 创建xfire配置文件 (67)3.2.6. services.xml的作用 (68)3.2.7. 在服务器上运行服务 (69)4. Axis与XFire的比较 (72)4.1. XFire与Axis1性能的比较 (72)4.2. XFire与Axis2的比较 (72)5. cxf与axis2比较 (73)6. WSDL文件 (74)6.1. 抽象定义 (74)6.2. 具体定义 (74)7. JAXB (76)7.1. Java SE中的JAXB (76)7.2. 使用 (77)7.3. 缺省的数据类型绑定 (77)7.4. 代码示例 (78)1.Axis2.xWeb Service是现在最适合实现SOAP的技术，而Axis2是实现Web Service的一种技术框架（架构）。

CXF使⽤教程（⼆）——webService⾃动⽣成客户端代码webService⾃动⽣成客户端代码有四种⽅法：⼀：使⽤Axis⽣产客户端代码（另存为bat⽂件）需要注意的是：⽬录包含空格，⽐如Axis_Lib，Output_Pathset Axis_Lib=F:\axis1.4\axis\WEB-INF\libset Java_Cmd=java -Djava.ext.dirs=%Axis_Lib%set Output_Path=D:\Workspacesset Package=com.axis.sub%Java_Cmd% org.apache.axis.wsdl.WSDL2Java -o%Output_Path% -p%Package% http://192.168.11.62:8090/rainLogin?wsdl pause⼆：使⽤JDK1.6的wsimport.exe（在jdk的bin⽬录下）产⽣客户端代码(之前要将JDK的bin添加到环境变量Path中)wsimport -keep -p com.jdk6.sub -s JavaSrc http://192.168.11.62:8090/rainLogin?wsdl1. -s(src):在当前路径下的JavaSrc(要⼿动创建)⽂件夹中⽣成客户端代码2. -p(package):定义客户端代码的包名3. -keep 保留.class⽂件三：使⽤CXF wsdl2java.bat (要先将CXF的bin⽬录添加到环境变量Path下)在cmd本项⽬SCR⽬录下运⾏下⾯代码，就会在src下⽣成客户端代码wsdl2java http://192.168.11.62:8080/FFWebservice/services/PortalServices?wsdl四：使⽤Myeclipse⾃带⼯具⽣成客户端代码finnish 就可以⽣成客户端代码了。

个⼈⼀般⽐较喜欢⽤第⼆种⽅法。

目前主要的java webservice框架剩下了axis2和cxf。

本文对两个框架的目标、标准支持、开发和部署等方面进行了简单的对比。

对于在现有web应用中发布webservice，本文建议使用cxf。

更进一步，本文介绍了cxf的嵌入式代码和web容器两种发布方式。

本文中的例子使用maven进行构建。

Table of Contents∙ 1 对比Axis2和CXF∙ 2 编写服务类∙ 3 以endpoint发布∙ 4 在webapp中发布1 对比Axis2和CXFjws的发布对java webservice框架产生了巨大的影响，经过大浪淘沙，目前java开发webservice的框架主要包括axis2和cxf。

axis2和cxf都是apache旗下的产品，但是其目的不同，导致webservice开发方法也不一样。

两个框架都得到了开发者的支持。

有必要对二者进行以下对比。

结论：1.如果希望以一种一致的方式实现webservice，特别是有跨语言的需求时，应该使用Axis22.如果需要在现有的java程序（包括web应用）中增加webservice支持，应该使用CXF2 编写服务类从Java6开始，WebService API从Java EE复制到了Java SE。

并遵循了一系列的标准，比如JSR181(Web Service 元数据），JSR224（JAX-WS,基于XML的WebService API），JSR67（SAAJ，SOAP附件标准）等。

并分别定义到javax.jws, javax.xml.ws 和javax.xml.soap包中。

JSR181支持使用标注（annotation）来定义WebService。

在javax.jws中主要的标注类包括：使用标注可以在不改变代码逻辑的前提下让外部代码能够获得更多的元数据。

下面就用javax.jws定义的标注来声明一个WebService:∙创建maven工程mvn archetype:create -DgroupId=com.mycompany -DartifactId=cxfdemo -DarchetypeArtifactId=maven-archetype-webapp∙增加CXF依赖<dependency><groupId>org.apache.cxf</groupId><artifactId>apache-cxf</artifactId><version>${cxf.version}</version><type>pom</type></dependency>∙配置jetty插件<build><plugins><plugin><groupId>org.mortbay.jetty</groupId><artifactId>maven-jetty-plugin</artifactId></plugin></plugins></build>∙创建服务接口package cxfdemo;import javax.jws.WebService;@WebServicepublic interface CXFDemo {public String sayHello(String foo);}∙实现服务类package cxfdemo;import javax.jws.WebService;@WebService()public class CXFDemoImpl implements CXFDemo {public String sayHello(String foo) {return "hello "+foo;}}3 以endpoint发布到目前为止，使用的都是标准Java SE中的东西。

Visual Studio Code 是一个轻量级但功能强大的集成开发环境，它支持多种编程语言，包括 Java。

在使用 Visual Studio Code 进行 Java 开发时，经常需要调用 WebService 方法来实现与其他系统的数据交互。

本文将详细介绍在Visual Studio Code 中如何调用 WebService 方法的各种方法。

使用 Axis2 插件Axis2 是一个流行的 WebService 框架，它提供了丰富的工具来生成WebService 客户端代码。

在 Visual Studio Code 中，可以通过安装 Axis2 插件来使用其功能。

首先，在 Visual Studio Code 中搜索并安装 Axis2 插件，然后按照插件的指引配置 WebService 的 WSDL 地址和生成客户端代码。

最后，根据生成的客户端代码，调用 WebService 方法并处理返回结果。

使用 Apache CXF 插件Apache CXF 是另一个优秀的 WebService 框架，它也提供了丰富的工具来生成 WebService 客户端代码。

在 Visual Studio Code 中，可以通过安装Apache CXF 插件来使用其功能。

首先，在 Visual Studio Code 中搜索并安装Apache CXF 插件，然后按照插件的指引配置 WebService 的 WSDL 地址和生成客户端代码。

最后，根据生成的客户端代码，调用 WebService 方法并处理返回结果。

使用 JAX-WS 注解JAX-WS 是 Java API for XML Web Services 的缩写，它提供了一种基于注解的方式来定义和调用 WebService。

在 Visual Studio Code 中，可以直接使用JAX-WS 注解来定义 WebService 客户端。

首先，通过在 Java 类中使用@WebServiceClient 注解来定义 WebService 客户端，然后使用 @WebMethod 注解来定义调用的 WebService 方法。

创建WebService使用Axis2和CXF的区别创建WebService使用Axis2和CXF的区别J2EE中WebService的建立可以使用Axis2，也可以使用Apache CXF，两者的区别与优缺点如下：Web Services 框架如Axis2、CXF 都是由现有的项目中逐渐演化而来的，Axis2 是由Axis 1.x 系列演化过来，而Apache CXF 则是由Celtix 和XFire 项目整合而生，并且刚刚发布了2.0.2 的最新版本，不过仍是Apache 的一个孵化项目。

Axis2 是对Axis 进行了彻底的重写的一个新项目了，它使用了新的模块化架构，更方便于功能性的扩展等等。

Apache CXF 则是由XFire 和Celtix 两个现有的项目进行了重组。

先比较一下它们的不同之处：1、Apache CXF 支持WS-Addressing、WS-Policy、WS-RM、WS-Security和WS-I BasicProfile2、Axis2 支持WS-Addressing、WS-RM、WS-Security和WS-I BasicProfile，WS-Policy将在新版本里得到支持3、Apache CXF 是根据Spring哲学来进行编写的，即可以无缝地与Spring进行整合4、Axis2 不是5、Axis2 支持更多的data bindings，包括XMLBeans、JiBX、JaxMe 和JaxBRI，以及它原生的data binding（ADB）。

6、Apache CXF 目前仅支持JAXB 和Aegis，并且默认是JAXB 2.0，与XFire 默认是支持Aegis 不同，XMLBeans、JiBX 和Castor 将在CXF 2.1 版本中得到支持，目前版本是2.0.27、Axis2 支持多种语言，它有C/C++ 版本。

8、Apache CXF 提供方便的Spring整合方法，可以通过注解、Spring标签式配置来暴露Web Services和消费Web Services 如何抉择：1、如果应用程序需要多语言的支持，Axis2 应当是首选了；2、如果应用程序是遵循Spring 哲学路线的话，Apache CXF 是一种更好的选择，特别对嵌入式的Web Services 来说；3、如果应用程序没有新的特性需要的话，就仍是用原来项目所用的框架，比如Axis1，XFire，Celtrix 或BEA 等等厂家自己的Web Services 实现，就别劳民伤财了因为CXF可以和Spring无缝的进行结合，而我的项目用到了spring ,所以我选的是CXF。

详解java开发webservice的⼏种⽅式webservice的应⽤已经越来越⼴泛了，下⾯介绍⼏种在Java体系中开发webservice的⽅式，相当于做个记录。

1.Axis2Axis是apache下⼀个开源的webservice开发组件，出现的算是⽐较早了，也⽐较成熟。

这⾥主要介绍Axis+eclipse开发webservice，当然不⽤eclipse也可以开发和发布webservice，只是⽤eclipse会⽐较⽅便。

（3）下载eclipse的axis2插件（4）eclipse安装axis2插件1）在任意⽬录下新建⼀个Axis2⽂件夹，在该⽂件夹下新建eclipse⽬录，在eclipse⽬录中新建plugins⽬录和features⽬录，例如：D:\programSoftware\eclipse-SVN\Axis2\eclipse；2）把下载的axis2插件解压，并把解压的⽂件放到新建的eclipse的plugins⽬录下；3）在%eclipse_home%的⽬录下新建links⽬录，并在links⽬录下新建axis2.link⽂件，内容为:path=D:\programSoftware\eclipse-SVN\Axis2;4）重启eclipse，点击·file-new-other,如果看到Axis2 Wizards，则表明插件安装成功。

（5）安装axis2（6）使⽤eclipse新建web⼯程，创建⼀个普通java类，⾄少包含⼀个⽅法。

（7）发布webservice1）点击eclipse的File-New-other，打开Axis2 Wizards，选择Axis2 Service Archiver，然后Next;2）选择Class File Location，也就是类⽂件存放路径，注意：只选到classes⽬录，不要包括包⽂件夹，然后Next;3）选择Skip WSDL，然后Next4）⼀路Next到Select the Service XML file to be included in the Service archive，勾选Generate theservice xml automatically；5）Service Name-填写你的service名称，Class Name-填写类名称，要包括包名，然后点击load，然后点击Finish，这时webservice就发布成功了；6）然后到%TOMCAT_HOME%/webapps/axis2/WEB-INF/services 看看是否多了⼀个.aar的⽂件；2.Apche CXFCXF开发webservice也是⽐较⽅便和简单的，它和spring的集成可以说是⾮常地好。

Webservice 之CXF一、关于CXFApache CXF = Celtix + XFire，Apache CXF 的前身叫Apache CeltiXfire，现在已经正式更名为Apache CXF 了，以下简称为CXF。

CXF 继承了Celtix 和XFire 两大开源项目的精华，提供了对JAX-WS全面的支持，并且提供了多种Binding 、DataBinding、Transport 以及各种Format 的支持，并且可以根据实际项目的需要，采用代码优先（Code First）或者WSDL 优先（WSDL First）来轻松地实现Web Services 的发布和使用。

Apache CXF已经是一个正式的Apache顶级项目。

Apache CXF 是一个开源的Services 框架，CXF 帮助您利用Frontend 编程API 来构建和开发Services ，像JAX-WS 。

这些Services 可以支持多种协议，比如：SOAP、XML/HTTP、RESTful HTTP 或者CORBA ，并且可以在多种传输协议上运行，比如：HTTP、JMS 或者JBI，CXF 大大简化了Services 的创建，同时它继承了XFire 传统，一样可以天然地和Spring 进行无缝集成。

二、CXF/AXIS/AXIS2比较请参考互联网中使用者文章，在此用cxf主要是能与spring无缝隙整合。

三、CXF+spring整合1.工程目录结构：2.所需要包：这些是添加最少的包了。

如果运行中报错，在添加相应的包就可以。

3.Demo中的类实体：package com.fly.bean;import java.io.Serializable;import javax.xml.bind.annotation.XmlAccessType; import javax.xml.bind.annotation.XmlAccessorType; import javax.xml.bind.annotation.XmlType;@XmlAccessorType(XmlAccessType.FIELD)@XmlType(name = "user")public class User implements Serializable { private String name;public String getName() {return name;}public void setName(String name) { = name;}public User(){}public User(String name){ = name;}}接口：package com.fly.service;import java.util.List;import javax.jws.WebParam;import javax.jws.WebService;import er;@WebServicepublic interface IHelloWorld {public String sayHi(@WebParam(name="params")String params);public String sayHiToUser(User user);public String[] sayHiToList(List<User> list);}接口实现类：package com.fly.service.impl;import java.util.LinkedHashMap;import java.util.List;import java.util.Map;import javax.jws.WebService;import er;import com.fly.service.IHelloWorld;@WebService(endpointInterface="com.fly.service.IHelloWorld",serviceNa me="HelloWorld",targetNamespace="")public class HelloWorldImpl implements IHelloWorld {@Overridepublic String sayHi(String params) {return"hello , "+params;}@Overridepublic String sayHiToUser(User user) {// TODO Auto-generated method stubreturn"hello , name="+user.getName();}@Overridepublic String[] sayHiToList(List<User> list) {String[] result = new String[list.size()];int i=0;for(User u:list){result[i] = "Hello " + u.getName();System.out.println(u.getName());i++;}return result;}}applicationContext.xml：<?xml version="1.0"encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:jaxws="/jaxws"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd /jaxws/schemas/jaxws.xsd"><!-- 此三个文件在cxf.jar保重，将文件放到src目录下，并去掉此注释<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"/>--><!-- 服务可通过两种方式公布，一种JAX-WS标准点的API；另一种 jaxws标签 --> <jaxws:endpoint id="helloWorld"implementor="com.fly.service.impl.HelloWorldImpl"address="/helloWorld"/><!-- spring客户端调用时配置方式一 --><jaxws:client id="helloClient"serviceClass="com.fly.service.IHelloWorld"address="http://localhost:8080/cxftest/webservice/helloWorld" /><!-- spring客户端调用时配置方式二<bean id="helloClient" class="com.fly.service.IHelloWorld"factory-bean="clientFactory" factory-method="create"/><bean id="clientFactory"class="org.apache.cxf.jaxws.JaxWsProxyFactoryBean"><property name="serviceClass"value="com.fly.service.IHelloWorld"/><property name="address"value="http://localhost:8080/cxftest/webservice/helloWorld"/></bean>--></beans>Webx.xml配置<?xml version="1.0"encoding="UTF-8"?><web-app version="3.0"xmlns="/xml/ns/javaee"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/xml/ns/javaee/xml/ns/javaee/web-app_3_0.xsd"><display-name></display-name><!-- Spring ApplicationContext配置文件的路径,可使用通配符,多个路径用,号分隔此参数用于后面的Spring Context Loader --><context-param><param-name>contextConfigLocation</param-name><param-value>classpath:/applicationContext.xml</param-value></context-param><listener><listener-class>org.springframework.web.context.ContextLoaderListener </listener-class></listener><!-- Character Encoding filter --><filter><filter-name>encodingFilter</filter-name><filter-class>org.springframework.web.filter.CharacterEncodingFil ter</filter-class><init-param><param-name>encoding</param-name><param-value>UTF-8</param-value></init-param></filter><filter-mapping><filter-name>encodingFilter</filter-name><url-pattern>/*</url-pattern></filter-mapping><!-- Spring 刷新Introspector防止内存泄露 --><listener><listener-class>org.springframework.web.util.IntrospectorCleanupL istener</listener-class></listener><servlet><servlet-name>CXFServlet</servlet-name><servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-c lass><load-on-startup>1</load-on-startup></servlet><servlet-mapping><servlet-name>CXFServlet</servlet-name><url-pattern>/webservice/*</url-pattern></servlet-mapping><welcome-file-list><welcome-file>index.jsp</welcome-file></welcome-file-list></web-app>四、客户端调用package com.fly.client;import java.awt.List;import java.util.ArrayList;import org.springframework.context.ApplicationContext;importorg.springframework.context.support.ClassPathXmlApplicationContext;import er;import com.fly.service.IHelloWorld;public class Client {/*** @param args*/public static void main(String[] args) {//spring bean 方式调用ApplicationContext ctx = newClassPathXmlApplicationContext("applicationContext.xml");IHelloWorld helloClient = (IHelloWorld)ctx.getBean("helloClient");System.out.println(helloClient.sayHi(" 涛哥"));System.out.println(helloClient.sayHiToUser(new User(" 童安格")));ArrayList list = new ArrayList();list.add(new User(" 普弟"));System.out.println(helloClient.sayHiToList(list));//纯cxf调用方式/**JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();factory.getInInterceptors().add(new LoggingInInterceptor());factory.getOutInterceptors().add(new LoggingOutInterceptor());factory.setServiceClass(IHelloWorld.class);factory.setAddress("http://localhost:8080/cxftest/webservice/hell oWorld");IHelloWorld client = (IHelloWorld) factory.create();String reply = client.sayHi(" 涛哥");System.out.println("Server said: " + reply);System.exit(0);*/}}此demo为服务与客户端同工程，如果为不同工程的，请参看注释自行调整。

几种流行Webservice框架性能对比1摘要开发webservice应用程序中离不开框架的支持，当open-open网站列举的就有30多种，这对于开发者如何选择带来一定的疑惑。

性能Webservice的关键要素，不同的框架性能上存在较大差异，而当前在官方网站、网络资料中可以方便的找到各自框架的介绍，但是很少有针对不同框架性能测试数据。

本文选择了比较流行几个框架：Apache Axis1、Apache Axis2、Codehaus XFire、Apache CXF等，采用java作为测试用例，通过本机和远程两种进行测试方式，对这几种框架进行了性能测试，并对测试结果分析和性能比较，最后并对性能优异的框架进行了推荐。

关键词：Axis1、Axis2、XFire、CXF、Spring、SOAP、StAX、WSDL2框架介绍2.1Apache Axis1Axis本质上就是一个SOAP引擎（Apache Axis is an implementation of the SOAP），提供创建服务器端、客户端和网关SOAP操作的基本框架。

但Axis 并不完全是一个SOAP引擎，它还包括：●是一个独立的SOAP服务器。

●是一个嵌入Servlet引擎（例如Tomcat）的服务器。

●支持WSDL。

●提供转化WSDL为Java类的工具。

●提供例子程序。

●提供TCP/IP数据包监视工具。

2.2Apache Axis2Apache Axis2相比Apache Axis1更加有效、更加模块化、更加面向xml，支持容易插件模块扩展新功能和特性，例如安全和可靠。

Apache Axis2是基于Apache AXIOM，它是一个高性能、pull-based XML对象模型。

Apache Axis2的关键特性：●解析xml更快。

采用自己的对象模型和StAX (Streaming API forXML)。

●更低的内存占用。

●支持热部署。

webservice接口实现方式WebService是一种跨平台的通信技术，可以通过网络进行数据交互。

在软件开发中，WebService接口的实现方式有多种选择，本文将介绍几种常见的实现方式。

一、SOAP协议SOAP（Simple Object Access Protocol）是一种基于XML的通信协议，可以在不同的操作系统和编程语言之间进行通信。

在WebService中，SOAP协议通常用于实现接口。

通过SOAP协议，可以将数据封装成XML格式，然后在网络上进行传输。

接收方可以解析XML数据，获取其中的信息。

二、RESTful风格RESTful（Representational State Transfer）是一种基于HTTP协议的软件架构风格，常用于构建Web服务。

在RESTful风格中，每个资源都有唯一的URI（Uniform Resource Identifier），通过HTTP方法（GET、POST、PUT、DELETE）对资源进行操作。

通过RESTful风格，可以实现简洁、灵活的接口。

三、JSON-RPCJSON-RPC（JavaScript Object Notation Remote Procedure Call）是一种基于JSON格式的远程过程调用协议。

它通过HTTP 协议传输数据，并使用JSON格式进行序列化和反序列化。

JSON-RPC可以轻松实现跨平台的接口调用，支持多种编程语言。

四、XML-RPCXML-RPC是一种基于XML格式的远程过程调用协议。

它通过HTTP协议进行数据传输，使用XML格式进行数据编码和解码。

XML-RPC可以实现跨平台的接口调用，支持多种编程语言。

五、JAX-WSJAX-WS（Java API for XML Web Services）是Java EE平台中用于构建Web服务的标准API。

通过JAX-WS，可以使用Java语言轻松地创建和发布Web服务。

1、特点对比1)CXF支持WS-Addressing，WS-Policy，WS-RM，WS-Security和WS-I Basic Profile；Axis2不支持WS-Policy。

2)CXF可以很好支持Spring；Axis2不能。

3)Axis2支持更广泛的数据并对，如XMLBeans，JiBX，JaxMe，JaxBRI和它自定义的数据绑定ADB；CXF只支持JAXB和Aegis。

4)Axis2支持多语言，除了Java，还支持C/C++版本。

5)Axis2的开发方式类似一个小型的应用服务器，Axis2的开发包要以WAR 的形式部署到Servlet容器中，比如Tomcat，通过这些容器可以对工作中的Web Service进行很好的监控和管理，Axis2允许自己作为独立的应用来发布Web Service。

CXF更注重开发人员的工效和嵌入能力。

大多数配置都可以API来完成，替代了比较繁琐的XML配置文件，CXF强调代码优先的设计方式，使用了简单的API使得从现有的应用开发服务变得方便。

2、适用场合1)如果应用程序需要多语言的支持，应当选择Axis2。

2)如果应用程序是遵循Spring 哲学路线的话，CXF 是一种更好的选择，特别对嵌入式的Web Services来说。

3)如果应用程序没有新的特性需要的话，二者都可以。

3、效率对比（来源于资料）1)无WS-Security 的性能图1显示了Axis2、Metro和CXF未使用任何WS-Security时的测试时间。

图1在与XML 之间的数据转换方面，三个运行速度基本相同。

Metro和CXF 都使用JAXB 参考实现来进行转换。

从这些结果中可以判断，Axis2所使用的默认Axis2 Databinding Framework (ADB)绑定实现的运行速度与JAXB相当。

2) 使用WS-Security 时的性能1°响应较少时间对比下图展示了以下安全配置的测试时间plain：无安全（与图1 中的值相同）username：针对请求的WS-Security纯文本UsernameTokensign：主体和头部的WS-Security签名，使用时间戳signencr：主体和头部的WS-Security签名，使用时间戳和主体加密图2显示了1000个请求而响应较少时的时间：图2图3显示了同样1000个请求响应较少时的相对时间（已标准化为CXF 结果）：图3可以看出，Axis2要比CXF慢一半还多。

基于Axis2和CXF的Web Service传输性能测试方案研究汤瀚秋
【期刊名称】《人天科学研究》
【年(卷),期】2012(011)006
【摘要】Web Service是一种常见的服务发布方式,其灵活性和易用性使其在各种系统中起到中间件的作用。

Web Service的实现方式不同,其传输性能也不尽相同。

使用Axis2和CXF作为Web Service的具体实现,并对它们的传输性能进行测试
比较,以便在进行Web Service实现的选择时,提供科学的选择方法和评估数据。

【总页数】2页(P15-16)
【作者】汤瀚秋
【作者单位】上海大学计算机工程与科学学院,上海200444
【正文语种】中文
【中图分类】TP302
【相关文献】
1.基于CXF的RESTful Web Service访问服务研究 [J], 陈铁
2.基于Axis2的CORBA/Web Services集成方案 [J], 向寒坤;钟金宏;李兴国
3.基于Axis2和CXF的Web Service传输性能测试方案研究 [J], 汤瀚秋
4.基于Axis2架构+TC-ITK实现Teamcenter系统的Web Service接口 [J], 袁
远
5.基于Axis2架构+TC-ITK实现Teamcenter系统的Web Service接口 [J], 袁
远
因版权原因，仅展示原文概要，查看原文内容请购买。