CXF教程
ApacheCXF基本使用
ApacheCXF基本使⽤⼀、服务端开发1、创建web项⽬2、导⼊jar包3、web.xml中配置Servlet1<!-- 配置CXF框架提供的Servlet -->2<servlet>3<servlet-name>cxf</servlet-name>4<servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>5<!-- 通过初始化参数指定CXF框架的配置⽂件位置 -->6<init-param>7<param-name>config-location</param-name>8<param-value>classpath:cxf.xml</param-value>9</init-param>10</servlet>11<servlet-mapping>12<servlet-name>cxf</servlet-name>13<url-pattern>/service/*</url-pattern>14</servlet-mapping4、在类路径下提供cxf.xml<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:jaxws="/jaxws"xmlns:soap="/bindings/soap"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd/bindings/soap/schemas/configuration/soap.xsd/jaxws/schemas/jaxws.xsd"><!-- 引⼊CXF Bean定义如下,早期的版本中使⽤ --><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"/></beans>5、开发⼀个接⼝和实现类1 @WebService2public interface CustomerService {34public List<Customer> findAll();5//查询未关联的6public List<Customer> findListNoAssociation();7//查询已经关联的8public List<Customer> findListHasAssociation(String id);9//定区关联客户10public void assigncustomerstodecidedzone(String decidedzoneId,Integer[] customerIds);11//根据客户的⼿机号查询客户信息12public Customer findByTelephone(String telephone);13//根据客户地址查询定区ID14public String findDecidedzoneIdByAddress(String address);15 }6、在cxf.xml中注册服务1<!-- 基于接⼝形式发布的服务 -->2<bean id="customerService" class="com.itheima.crm.service.impl.CustomerServiceImpl">3<property name="jdbcTemplate" ref="jdbcTemplate"></property>4</bean>5<jaxws:server id="myService" address="/customer">6<jaxws:serviceBean>7<ref bean="customerService"/>8</jaxws:serviceBean>9</jaxws:server>⼆、客户端开发1、使⽤wsimport或者CXF提供wsdl2java⽣成本地代码，只需要⽣成接⼝⽂件2、将bean及接⼝⽂件复制到项⽬中3、提供spring配置⽂件，注册客户端代理对象1<jaxws:client id="customerService" serviceClass="com.itheima.crm.CustomerService" address="http://localhost:8080/crm/service/customer"></jaxws:client>。
CXF教程
CXF基础教程第一部分SOAP 、WSDL简介Web Service的定义W3C组织对其的定义如下，它是一个软件系统，为了支持跨网络的机器间相互操作交互而设计。
Web Service服务通常被定义为一组模块化的API，它们可以通过网络进行调用，来执行远程系统的请求服务。
这里我们从一个程序员的视角来观察web service。
在传统的程序编码中，存在这各种的函数方法调用。
通常，我们知道一个程序模块M中的方法A，向其发出调用请求，并传入A方法需要的参数P，方法A执行完毕后，返回处理结果R。
这种函数或方法调用通常发生在同一台机器上的同一程序语言环境下。
现在的我们需要一种能够在不同计算机间的不同语言编写的应用程序系统中，通过网络通讯实现函数和方法调用的能力，而Web service正是应这种需求而诞生的。
最普遍的一种说法就是，Web Service = SOAP + HTTP + WSDL。
其中，SOAP Simple Object Access Protocol）协议是web service的主体，它通过HTTP或者SMTP等应用层协议进行通讯，自身使用XML文件来描述程序的函数方法和参数信息，从而完成不同主机的异构系统间的计算服务处理。
这里的WSDL（Web Services Description Language）web 服务描述语言也是一个XML文档，它通过HTTP向公众发布，公告客户端程序关于某个具体的Web service服务的URL信息、方法的命名，参数，返回值等。
下面，我们先来熟悉一下SOAP协议，看看它是如何描述程序中的函数方法、参数及结果对象的。
SOAP协议简介什么是SOAPSOAP 指简单对象访问协议，它是一种基于XML的消息通讯格式，用于网络上，不同平台，不同语言的应用程序间的通讯。
可自定义，易于扩展。
一条SOAP 消息就是一个普通的XML 文档，包含下列元素：• Envelope 元素，标识XML 文档一条SOAP 消息• Header 元素，包含头部信息的XML 标签• Body 元素，包含所有的调用和响应的主体信息的标签• Fault 元素，错误信息标签。
CXF入门教程（5）--webService异步调用模式
CXF入门教程（5）--webService异步调用模式除了常见的同步调用模式，CXF还支持如下两种形式的异步调用模式：•轮询方法（Polling approach） - 这种情况下调用远程方法，我们可以调用一个特殊的方法；该方法没有输出参数，但是返回一个 javax.xml.ws.Response 实例。
可以轮询该 Response 对象（继承自 javax.util.concurrency.Future 接口）来检查是否有应答消息到达。
•回调方法（Callback approach） -这种情况下调用远程方法，我们调用另外一个特殊的方法：该方法使用一个回调对象（javax.xml.ws.AsyncHandler类型）的引用作为一个参数。
只要有应答消息到达客户端，CXF运行时就会回调该 AsyncHandler 对象，并将应答消息的内容传给它。
下面是两种异步调用的方法的描述和示例代码。
异步调用示例使用的契约下面展示的是异步调用示例中使用的WSDL契约，为保证教程的连续性，本文使用的是前面教程（1）中生成的HelloWorld服务的WSDL契约。
[html] view plaincopyprint?1.<?xml version="1.0" ?>2.<wsdl:definitions name="HelloWorld"3.targetNamespace="/"4.xmlns:ns1="/soap/http" xmlns:soap="/wsdl/soap/"5.xmlns:tns="/" xmlns:wsdl="/wsdl/"6.xmlns:xsd="/2001/XMLSchema">7.<wsdl:types>8.<xs:schema attributeFormDefault="unqualified"9.elementFormDefault="unqualified" targetNamespace="/ "10.xmlns:tns="/" xmlns:xs="/2001/XMLSchema">11.<xs:element name="IntegerUserMap" type="tns:Integ erUserMap"></xs:element>12.<xs:complexType name="User">13.<xs:sequence>14.<xs:element minOccurs="0" name="name" type="xs:s tring"></xs:element>15.</xs:sequence>16.</xs:complexType>17.<xs:complexType name="IntegerUserMap">18.<xs:sequence>19.<xs:element maxOccurs="unbounded" minOccurs="0 " name="entry"20.type="tns:IdentifiedUser"></xs:element>21.</xs:sequence>22.</xs:complexType>23.<xs:complexType name="IdentifiedUser">24.<xs:sequence>25.<xs:element name="id" type="xs:int"></xs:element>26.<xs:element minOccurs="0" name="user" type="tns:U ser"></xs:element>27.</xs:sequence>28.</xs:complexType>29.<xs:element name="sayHi" type="tns:sayHi"></xs:ele ment>30.<xs:complexType name="sayHi">31.<xs:sequence>32.<xs:element minOccurs="0" name="text" type="xs:str ing"></xs:element>33.</xs:sequence>34.</xs:complexType>35.<xs:element name="sayHiResponse" type="tns:sayHiR esponse"></xs:element>36.<xs:complexType name="sayHiResponse">37.<xs:sequence>38.<xs:element minOccurs="0" name="return" type="xs: string"></xs:element>39.</xs:sequence>40.</xs:complexType>41.<xs:element name="sayHiToUser" type="tns:sayHiToU ser"></xs:element>42.<xs:complexType name="sayHiToUser">43.<xs:sequence>44.<xs:element minOccurs="0" name="arg0" type="tns: User"></xs:element>45.</xs:sequence>46.</xs:complexType>47.<xs:element name="sayHiToUserResponse" type="tns: sayHiToUserResponse"></xs:element>48.<xs:complexType name="sayHiToUserResponse">49.<xs:sequence>50.<xs:element minOccurs="0" name="return" type="xs: string"></xs:element>51.</xs:sequence>52.</xs:complexType>53.<xs:element name="getUsers" type="tns:getUsers">< /xs:element>54.<xs:complexType name="getUsers">55.<xs:sequence></xs:sequence>56.</xs:complexType>57.<xs:element name="getUsersResponse" type="tns:get UsersResponse"></xs:element>58.<xs:complexType name="getUsersResponse">59.<xs:sequence>60.<xs:element minOccurs="0" name="return" type="tns :IntegerUserMap"></xs:element>61.</xs:sequence>62.</xs:complexType>63.</xs:schema>64.</wsdl:types>65.<wsdl:message name="getUsers">66.<wsdl:part element="tns:getUsers" name="parameter s">67.</wsdl:part>68.</wsdl:message>69.<wsdl:message name="sayHi">70.<wsdl:part element="tns:sayHi" name="parameters">71.</wsdl:part>72.</wsdl:message>73.<wsdl:message name="sayHiT oUser">74.<wsdl:part element="tns:sayHiT oUser" name="param eters">75.</wsdl:part>76.</wsdl:message>77.<wsdl:message name="sayHiT oUserResponse">78.<wsdl:part element="tns:sayHiT oUserResponse" name ="parameters">79.</wsdl:part>80.</wsdl:message>81.<wsdl:message name="sayHiResponse">82.<wsdl:part element="tns:sayHiResponse" name="para meters">83.</wsdl:part>84.</wsdl:message>85.<wsdl:message name="getUsersResponse">86.<wsdl:part element="tns:getUsersResponse" name=" parameters">87.</wsdl:part>88.</wsdl:message>89.<wsdl:portType name="iHelloWorld">90.<wsdl:operation name="sayHi">91.<wsdl:input message="tns:sayHi" name="sayHi">92.</wsdl:input>93.<wsdl:output message="tns:sayHiResponse" name="s ayHiResponse">94.</wsdl:output>95.</wsdl:operation>96.<wsdl:operation name="sayHiT oUser">97.<wsdl:input message="tns:sayHiToUser" name="sayHi ToUser">98.</wsdl:input>99.<wsdl:output message="tns:sayHiT oUserResponse" na me="sayHiT oUserResponse">100.</wsdl:output>101.</wsdl:operation>102.<wsdl:operation name="getUsers">103.<wsdl:input message="tns:getUsers" name="getUsers ">104.</wsdl:input>105.<wsdl:output message="tns:getUsersResponse" name ="getUsersResponse">106.</wsdl:output>107.</wsdl:operation>108.</wsdl:portType>109.<wsdl:binding name="HelloWorldSoapBinding" type= "tns:iHelloWorld">110.<soap:binding style="document"111.transport="/soap/http"></soap:binding>112.<wsdl:operation name="sayHi">113.<soap:operation soapAction="" style="document">< /soap:operation>114.<wsdl:input name="sayHi">115.<soap:body use="literal"></soap:body>116.</wsdl:input>117.<wsdl:output name="sayHiResponse">118.<soap:body use="literal"></soap:body>119.</wsdl:output>120.</wsdl:operation>121.<wsdl:operation name="sayHiT oUser">122.<soap:operation soapAction="" style="document">< /soap:operation>123.<wsdl:input name="sayHiToUser">124.<soap:body use="literal"></soap:body>125.</wsdl:input>126.<wsdl:output name="sayHiToUserResponse">127.<soap:body use="literal"></soap:body>128.</wsdl:output>129.</wsdl:operation>130.<wsdl:operation name="getUsers">131.<soap:operation soapAction="" style="document">< /soap:operation>132.<wsdl:input name="getUsers">133.<soap:body use="literal"></soap:body>134.</wsdl:input>135.<wsdl:output name="getUsersResponse">136.<soap:body use="literal"></soap:body>137.</wsdl:output>138.</wsdl:operation>139.</wsdl:binding>140.<wsdl:service name="HelloWorld">141.<wsdl:port binding="tns:HelloWorldSoapBinding" na me="HelloWorldImplPort">142.<soap:address location="http://localhost:9000/helloW orld"></soap:address>143.</wsdl:port>144.</wsdl:service>145.</wsdl:definitions>生成异步 stub 代码异步调用需要额外的stub代码（例如，服务端点接口中定义的专用的异步方法）。
CXF 入门：HelloWorld接口发布
CXF 入门：HelloWorld接口发布第一步：在myeclipse中新建一个web项目名为myWs, 并导入依赖的jar包（cxf,spring,apache-commons相关）1、commons-logging-1.1.1.jar2、cxf-2.4.1.jar3、geronimo-activation_1.1_spec-1.1.jar4、geronimo-annotation_1.0_spec-1.1.1.jar5、geronimo-javamail_1.4_spec-1.7.1.jar6、geronimo-jaxws_2.2_spec-1.0.jar7、geronimo-servlet_3.0_spec-1.0.jar8、geronimo-stax-api_1.0_spec-1.0.1.jar9、geronimo-ws-metadata_2.0_spec-1.1.3.jar10、jettison-1.3.jar11、jetty-continuation-7.4.2.v20110526.jar12、jetty-http-7.4.2.v20110526.jar13、jetty-io-7.4.2.v20110526.jar14、jetty-server-7.4.2.v20110526.jar15、jetty-util-7.4.2.v20110526.jar16、neethi-3.0.0.jar17、saaj-api-1.3.jar18、saaj-impl-1.3.2.jar19、serializer-2.7.1.jarcxf结合spring时所需jar包，此例子也需要这些，用到了spring上下文加载(spring-asm-3.0.5.RELEASE.jarspring-beans-3.0.5.RELEASE.jarspring-context-3.0.5.RELEASE.jarspring-core-3.0.5.RELEASE.jarspring-expression-3.0.5.RELEASE.jarspring-aop-3.0.5.RELEASE.jarspring-web-3.0.5.RELEASE.jar)20、wsdl4j-1.6.2.jar21、xalan-2.7.1.jar22、xercesImpl.jar23、xml-resolver-1.2.jar24、xmlschema-core-2.0.jar第二步：在WEB-INF中创建基本的cxf-beans.xml内容如下(作用：主要做webservice接口属性配置,通过web.xml配置加载，文件名和位置可以顺便，web.xml配置会用到)Xml代码<?xml version="1.0" encoding="UTF-8"?> <beansxmlns="/schema/beans" xmlns:xsi="/2001/XMLSchema-instance" xmlns:jaxws="/jaxws"xmlns:cxf="/core"xsi:schemaLocation="/jaxws/schemas/jaxws.xsd/core/schemas/core.xsd/schema/beans/schema/beans/spring-bea ns-2.5.xsd" default-autowire="byType"default-lazy-init="true"> <description>使用Apache CXF的Web Service配置文件，以下三个为固定配置文件(不需要创建)</description> <import resource="classpath:META-INF/cxf/cxf.xml" /><importresource="classpath:META-INF/cxf/cxf-servlet.xml" /> <importresource="classpath:META-INF/cxf/cxf-extension-soap.xm l" /> <!--在这里配置相应内容--></beans>第三部：在web.xml中加入cxf相应配置,内容如下:Xml代码<!--cxf start--> <!--用于加载cxf-beans.xml配置信息--> <context-param> <param-name>contextConfigLocation</param-nam e><param-value>WEB-INF/cxf-beans.xml</param-val ue> </context-param> <!--使用spring ContextLoaderListener 加载cxf-beans.xml--> <listener><listener-class>org.springframework.web.context.Con textLoaderListener</listener-class></listener> <!--配置CXFServlet--><servlet><servlet-name>CXFServlet</servlet-name><display-name>CXF Servlet</display-name><servlet-class>org.apache.cxf.transport.servlet.CXFS ervlet</servlet-class><load-on-startup>1</load-on-startup></servlet> <servlet-mapping><servlet-name>CXFServlet</servlet-name><!-- url可自定义配置，用于CXFServlet请求地址拦截,访问会用到--><url-pattern>/services/*</url-pattern></servlet-mapping> <!--cxf end -->第四步：创建webservice接口及实现类Java代码1，创建接口@WebService()//此注解必须,里面name,portName,targetNamespace serviceName 可以不用指定public interface IHelloService { public String sayHello(); } 2，创建实现类public class HelloWorldServiceImpl implements IHelloService{ public String sayHello(){ System.out.println("It's my first webservice !"); return "你已经成功调用sayHello()方法！"; } }第五步：配置cxf-beans.xml，加入以下内容：Xml代码<!--id:随意配，implementor：指定接口具体实现类，address:随意配，访问时会用到,下面会做说明--> <jaxws:endpoint id="HelloWorldService"implementor="com.ws.HelloWorldServiceImpl"address="/IHelloService"> </jaxws:endpoint>第六步：发布webservice到tomcatJava代码1，验证ws是否发布成功: 1.1,如果项目发布放在TOMCAT_HOME/webapps下时：访问http://IP地址:端口/项目名/services/｛cxf-beans.xml中配置的address｝?wsdl 1.2,如果是在tomcat_home/conf的server.xml中配置的是外部站点（<Contextpath="/testWs" docBase="D:\Developer\myWs" debug="0" reloadable="false" />），那访问方式应该是http://IP:端口/path值(没有就不用加)/services/｛cxf-beans.xml中配置的address｝?wsdl，例如：http://localhost:8080/testWs/services/IHelloService?wsdl //services对应web.xml中的<url-pattern>/services/*</url-pattern> services验证是否能正常看到xml格式的页面可以用SoapUi 软件测试接口GOOD LUCKY!!!写的不明的地方，还请大家提出远程具体调用方式请参考：CXF 入门之远程接口调用。
cxf请求流程
cxf请求流程CXF请求流程Apache CXF是一个开源的、全功能的Web服务框架，它提供了多种Web服务标准和技术的实现，如JAX-WS和JAX-RS，同时还支持SOAP和RESTful风格的Web服务。
本文将介绍CXF请求的流程。
一、CXF请求的基本流程CXF请求的基本流程如下：1.创建客户端代理对象在使用CXF请求前，需要首先创建客户端代理对象。
客户端代理对象是用于调用Web服务方法的对象，它的创建通常需要指定Web 服务的WSDL地址或者服务端的API。
2.组装请求报文根据Web服务方法的参数，组装请求报文。
请求报文一般是一个XML文档，其中包含了请求的参数和请求的目标方法。
3.发送请求报文将组装好的请求报文发送到Web服务端。
CXF支持多种协议，如HTTP、HTTPS、JMS等，可以根据需要选择合适的协议。
4.接收响应报文Web服务端接收到请求报文后，会根据请求报文的内容执行相应的Web服务方法，并将执行结果封装为响应报文返回给客户端。
客户端需要接收响应报文，并根据响应报文的内容进行相应的处理。
5.处理响应结果根据响应报文的内容，处理Web服务方法的执行结果。
响应报文一般也是一个XML文档，其中包含了Web服务方法的执行结果。
二、CXF请求的详细流程CXF请求的详细流程如下：1.创建客户端代理对象创建客户端代理对象通常有两种方式：基于WSDL或基于服务端API。
基于WSDL的方式需要提供Web服务的WSDL地址，CXF可以根据WSDL文件自动生成客户端代理对象。
代码示例如下：```JaxWsProxyFactoryBean factory = newJaxWsProxyFactoryBean();factory.setAddress("http://localhost:8080/MyService"); factory.setServiceClass(MyService.class);MyService client = (MyService) factory.create();```其中，MyService是Web服务的接口，它定义了Web服务的方法。
cxf框架的使用流程
CXF框架的使用流程1. 什么是CXF框架？Apache CXF（前身是Xfire）是一个开源的Web服务框架，用于构建和开发服务导向架构（SOA）应用程序。
CXF提供了一种简单而强大的方式来创建、部署和管理Web服务，支持SOAP、REST、XML和JSON等多种协议。
它基于Java标准，可以与Java EE和Spring框架无缝集成，是一个功能丰富且灵活的框架。
2. CXF框架使用流程使用CXF框架开发Web服务通常有以下几个步骤：步骤一：创建Web服务的接口首先，需要定义Web服务的接口。
在接口中定义服务的方法，参数和返回值类型。
接口可以按照业务需求进行设计，并使用注解来标记服务方法。
步骤二：实现服务接口接下来，需要实现定义的接口。
在实现类中编写具体的服务逻辑代码。
可以根据业务需求调用其他服务或持久化数据。
步骤三：发布Web服务使用CXF框架提供的工具类将服务发布为Web服务。
可以通过Spring配置文件或Java代码的方式来发布服务。
步骤四：客户端调用服务编写客户端代码来调用已发布的Web服务。
可以使用CXF框架提供的工具类生成客户端代码，也可以手动编写客户端调用代码。
步骤五：部署和运行将服务端和客户端的代码部署到相应的容器或服务器上。
可以使用Maven等构建工具打包项目，并将生成的war或jar文件部署到Tomcat或其他容器中运行。
3. CXF框架使用示例下面是一个使用CXF框架开发Web服务的简单示例：步骤一：定义服务接口package com.example.service; import javax.jws.WebMethod;import javax.jws.WebService;@WebServicepublic interface HelloWorldService { @WebMethodString sayHello(String name);}步骤二：实现服务接口```java package com.example.service;import javax.jws.WebService;@WebService(endpointInterface =。
WebService CXF学习(进阶篇3)：对象传递
WebService CXF学习（进阶篇3）：对象传递前面几节都是讲一些理论知识，现在又用一个例子来说明一下，这一节我们就CXF框架对象传递进行讲解。
第一步：创建传输对象CustomerJava代码@XmlRootElement(name="Customer")@XmlAccessorType(XmlAccessType.FIELD)@XmlType(propOrder = {"name","age"}) public class Customer { private int age; private String name; public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getName() { return name; } public void setName(String name) { =name; } } @XmlRootElement-指定XML根元素名称（可选）@XmlAccessorType-控制属性或方法序列化四种方案：FIELD-对每个非静态，非瞬变属性JAXB工具自动绑定成XML，除非注明XmlTransient NONE-不做任何处理PROPERTY-对具有set/get方法的属性进行绑定，除非注明XmlTransientPUBLIC_MEMBER -对有set/get方法的属性或具有共公访问权限的属性进行绑定，除非注明XmlTransient@XmlType-映射一个类或一个枚举类型成一个XMLSchema类型第二步：创建WebService接口Java 代码@WebService public interface HelloService { public void save(Customer c1,Customer c2);public void test(String args); public Customer get(int id); } 每三步：创建WebService接口实现类Java代码@WebService public class HelloServiceImpl implements HelloService { public void save(Customer c1, Customer c2){ System.out.println(c1.getAge()+"---"+c2.getAge() );System.out.println(c1.getName()+"---"+c2.getName()); } public void test(String args){ System.out.println(args); } public Customer get(int id) { Customer cus = new Customer(); cus.setAge(100);cus.setName("Josen"); return cus; } } 第四步：创建服务端Java代码public class SoapServer { ublic static void main(String[] args){ //两种方法，任选一种发布WebService接口//Endpoint.publish("http://localhost:8080/helloService", new HelloServiceImpl()); JaxWsServerFactoryBean factory = newJaxWsServerFactoryBean();factory.setAddress("http://localhost:8080/helloService"); factory.setServiceClass(HelloServiceImpl.class); factory.getInInterceptors().add(new LoggingInInterceptor());factory.getOutInterceptors().add(new LoggingOutInterceptor()); factory.create(); }第五步：创建客户端Java代码public class SoapClient { public static void main(String[]args){ JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();factory.setAddress("http://localhost:8080/helloService"); factory.setServiceClass(HelloService.class);factory.setServiceClass(HelloServiceImpl.class); factory.getInInterceptors().add(new LoggingInInterceptor()); HelloService service = (HelloService)factory.create(); Customer c1 = new Customer(); c1.setAge(1);c1.setName("aaa"); Customer c2 = new Customer(); c2.setAge(2); c2.setName("bbb"); service.save(c1, c2);service.test("aaaaaaaaaaaaa"); } } 最后，测试程序运行服务端程序，在浏览器地址栏输入http://localhost:8080/helloService?wsdl查看接口是否发布成功。
CXF入门篇0102
WebService CXF学习(入门篇1)：CXF由来WebService介绍WebService让一个程序可以透明地调用互联网程序，不用管具体的实现细节。
只要WebService公开了服务接口，远程客户端就可以调用服务。
WebService是基于http协议的组件服务，WebService是分散式应用程序的发展趋势。
WebService的开源实现WebService更多是一种标准，而不是一种具体的技术。
不同的平台，不同的语言大都提供WebService的开发实现。
在JA V A领域，WebService的框架很多，例如：AXIS，XFire,CXF等。
AXIS，XFire相对比较成熟，资料相对较多。
在这里我们只对CXF进行讲解，其他大家想学习到互联网找相关资料学习。
CXF框架由来ApacheCXF项目是由ObjectWeb Celtix和CodeHaus XFire合并成立。
ObjectWeb Celtix是由IONA公司赞助，于2005年成立的开源Java ESB产品，XFire则是业界知名的SOAP堆栈。
合并后的ApacheCXF融合该两个开源项目的功能精华，提供了实现SOA所需要的核心ESB功能框架，包括SOA服务创建，服务路由，及一系列企业级QoS功能。
ApacheCXF架框的目标1.概述<>高性能<>可扩展<>直观易用2.支持标准<> JAX-WS, JSR-181, SAAJ, JAX-RS<> SOAP 1.1, 1.2, WS-I BasicProfile, WS-Security, WS-Addressing, WS-RM, WS-Policy<> WSDL 1.1<> MTOM3.传输方式，绑定，数据绑定，传送数据格式<> 绑定: SOAP, REST/HTTP<> 数据绑定: JAXB 2.x, Aegis, XMLBeans, SDO<> 传送数据格式: XML, JSON, FastInfoset<> 传输方式: HTTP, Servlet, JMS4.部署灵活<> 轻量级: 可以将服务部署到Tomcat或其支持Spring的容器中<> JBI整合: 部署一个服务引擎到JBI容器，例如：ServiceMix, OpenESB or Petals<> J2EE集成: 可以将服务部署到J2EE应用服务器上，例如：Geronimo, JOnAS, JBoss, WebLogic, 及WebSphere<> Java 客户端/服务端可以独立性5.支持多种编程语言<> 完全支持JAX-WS 2.x 客户端/服务端模式<> JAX-WS 2.x synchronous, asynchronous and one-way API's<> JAX-WS 2.x Dynamic Invocation Interface (DII) API<> 支持wrapped and non-wrapped 数据格式<> XML messaging API<> 支持JavaScript 和ECMAScript 4 XML (E4X)<> 支持CORBA<> 支持JBI及ServiceMix6.可编程环境<> Java to WSDL<> WSDL to Java<> XSD to WSDL<> WSDL to XML<> WSDL to SOAP<> WSDL to serviceWebService CXF学习（入门篇2）：HelloWorld理论联系实际，单单只讲理论那就成了纸上谈兵，用一个HelloWorld Demo可来说明事更加直观。
CXF使用教程（二）——webService自动生成客户端代码
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 就可以⽣成客户端代码了。
个⼈⼀般⽐较喜欢⽤第⼆种⽅法。
CXFWebService开发指南、技术文档
CXFWebService开发指南、技术文档CXF WebService上次介绍了Axis的WebService，现在我们来看看CXF是怎么完成WebService的。
Axis1 WebService 在线博文：Axis2 WebService 在线博文：一、准备工作1、 CXF官方网址：2、 Jar包下载地址：将下来的jar包解压后，目录大概就这样bin目录提供的是常用的dos控制台命令工具docs 帮助文档lib jar包、依赖库lib-samples 也是jar包，有jetty、httpclients、junit等jar包modules 打包好的WebService模块samples示例demo3、源码下载：有时候你可以看看源码，对你了解和学习CXF WebService都会有作用。
4、 CXF的特性有代码生成工具：Java to WSDL；WSDL to Java；XSD to WSDL；WSDL to XML；WSDL to SOAP；WSDL to Service；支持 JAX-WS、 JAX-WSA、JSR-181 和 SAAJ；支持 SOAP 1.1、1.2、WS-I BasicProfile、WS-Security、WS-Addressing、WS-RM 和 WS-Policy；支持 WSDL 1.1 、2.0；支持 MTOM；、JavaScript、通过 Yoko 支持 CORBA；通过 Tuscany 支持 SCA；通过 ServiceMix 支持 JBI内置Jetty应用服务器二、 CXF 入门实例又一HelloWorld示例，老套的HelloWorld是入门经典。
也是基础和必须掌握的，下面看看HelloWorldWebService，很简单。
需要的jar包如下：1、 HelloWorldService服务器端代码package com.hoo.service;import javax.jws.WebParam;import javax.jws.WebService;import javax.jws.soap.SOAPBinding;import javax.jws.soap.SOAPBinding.Style;/*** <b>function:</b>CXF WebService 服务器端helloWorld示例* @author hoojo* @createDate 2011-3-16 上午08:29:07* @file HelloWorld.java* @package com.hoo.service* @project CXFWebService* @blog /IBM_hoojo*@******************** @version 1.0*/@WebService@SOAPBinding(style = Style.RPC)public class HelloWorldService {} public String sayHello(@WebParam(name = "name") String name) { } return name + " say: Hello World ";要说明的是，上面的服务器端代码运用了JDK5的新特性Annotation，这个非常好用。
cxf绑定参数 -回复
cxf绑定参数-回复CXF绑定参数是指在使用Apache CXF框架进行Web服务开发时，将请求中的参数与Java对象进行绑定的过程。
本文将详细介绍CXF绑定参数的步骤和注意事项。
第一步：定义请求参数的Java对象模型要实现CXF绑定参数，首先需要定义一个Java对象来封装请求中的参数。
可以使用JavaBean的方式定义一个普通的POJO类，并为每个参数提供相应的getter和setter方法。
例如，假设我们需要绑定一个名为User 的Java对象来处理用户相关的请求，我们可以定义如下类：public class User {private String name;private int age;public String getName() {return name;}public void setName(String name) { = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}}上述代码定义了一个User类，包含了名为name和age的两个私有属性，并提供了对应的getter和setter方法。
第二步：编写服务接口接下来，我们需要编写一个服务接口，用于定义Web服务的协议和方法。
在接口方法中，可以将绑定请求参数的Java对象作为方法的参数。
例如，我们创建一个名为UserService的服务接口，并包含一个名为getUser 的方法：WebServicepublic interface UserService {WebMethodUser getUser(User user);}上述代码使用WebService和WebMethod注解分别标记了服务接口和接口方法。
getUser方法接受一个User对象作为参数，并返回一个User 对象。
第三步：实现服务接口接下来，我们需要实现UserService接口，以提供具体的服务逻辑。
CXF框架webservice教程
CXF框架实现webservice教程1 使用CXF实现一个简单的WEB SERVICE首先介绍如何用CXF实现一个基本的hello world首先到apache官网去下载CXF的开发jar包//cxf/2.4.3/apache-cxf-2.4.3.zip创建cxf webservice服务器端普通java项目，叫做HelloCxfServer，把必须用到的jar文件通过构建路径引入，为了省事，可以直接把所有的jar引入此处注意：如果是jdk1.6启动服务器会发生如下错误JAXB 2.1 API is being loaded from the bootstrap classloader, but this RI (from jar:file:/E:/javaLib/cxf_all_jar/jaxb-impl-2.2.1.1.jar!/com/sun/xml/bind/v2/model/impl/ModelBuilder.class) needs 2.2 API. Use the endorsed directory mechanism to place jaxb-api.jar in the bootstrap classloader.这是由于jdk1.6的jar包和cxf的jar包冲突造成的，需要把cxf lib中的endorsed目录拷入到D:\Program Files\Java\jdk1.6.0\jre\lib目录下创建一个接口HelloWorld和一个实现类HelloWorldImpl，只提供一个成员方法，叫做sayHello，给接口和实现类添加注解@WebService，这是最基本的注解/test/HellWorld.java源码package test;import javax.jws.WebService;@WebServicepublic interface HelloWorld {String sayHello(String name);}/test/HelloWorldImpl.java源码package test;import javax.jws.WebService;@WebServicepublic class HelloWorldImpl implements HelloWorld {@Overridepublic String sayHello(String name) {System.out.println("sayHello方法被调用...");return"hello," + name;}}CXF自带了一个Web Service容器Jetty，这是一个WEB容器，类似于tomcat，能够直接发布web service，下面创建一个发布服务类MainServer，执行这个类就会运行服务器，看到控制台输出日志信息，表示启动服务成功/test/MainServier.java源码package test;import org.apache.cxf.endpoint.Server;import org.apache.cxf.jaxws.JaxWsServerFactoryBean;public class MainServer {public static void main(String[] args) {//创建一个JaxWs服务器工厂JaxWsServerFactoryBean factory = new JaxWsServerFactoryBean();//设置发布类factory.setServiceClass(HelloWorldImpl.class);//设置服务发布的地址factory.setAddress("http://localhost:6666/MyCxfService");//根据设置创建一个服务器Server server = factory.create();//启动服务器server.start();}}发布成功以后，可以通过浏览器去查看生成的WSDL，在浏览器地址栏输入http://localhost:6666/MyCxfService?wsdl，效果如下：下面创建访问WebService的客户端，可以重新创建一个项目，也可以就在这个项目里实现，我下面在同一个项目中创建一个类HelloWorldCient/test/HelloWorldClient.java源码package test;import org.apache.cxf.jaxws.JaxWsProxyFactoryBean;import org.springframework.remoting.jaxws.JaxWsPortProxyFactoryBean;public class HelloWorldClient {public static void main(String[] args) {//创建一个JaxWs的代理工厂JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();//设置访问地址factory.setAddress("http://localhost:6666/MyCxfService");//设置接口类型factory.setServiceClass(HelloWorld.class);//获得代理类实例HelloWorld helloWorld = (HelloWorld) factory.create();//调用方法String str = helloWorld.sayHello("张三");System.out.println(str);}}运行客户端，会看到控制台，输出:hello,张三2 WSDL结构分析主要通过上一章生成的WSDL，来对WSDL语言的标签进行解释Web Services Description Language的缩写，是一个用来描述Web服务和说明如何与Web服务通信的XML 语言。
CXF开发指导
CXF开发指导目录1文档介绍 (3)2CXF介绍 (3)3CXF服务端开发 (3)3.1 运行环境 (3)3.2 项目结构和依赖 (3)3.3 编码配置 (4)3.3.1 Java编码 (4)3.3.2 web.xml配置 (6)3.3.3 Spring配置 (7)3.4 总结 (7)4CXF客户端开发 (8)4.1wsdl生成java代码 (8)4.2代码与CXF和Spring集成 (8)4.2.1 环境依赖 (9)4.2.2 Spring配置 (9)4.2.3 JAVA编码 (9)5CXF安全配置开发 (10)5.1接口调用安全 (11)5.1.1服务端安全开发 (11)5.1.2客户端安全开发 (13)5.2 数据传输安全 (16)5.2.1 服务端配置 (16)5.2.2 客户端配置 (17)6CXF与Struts2结合 (18)7总结 (18)1文档介绍本文档介绍了CXF的由来和特点、进行CXF开发的步骤和与struts框架结合的方法，还有CXF下如何保证安全的方案。
2CXF介绍Apache CXF = Celtix + XFire，开始叫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 框架，支持多种协议，比如：SOAP、XML/HTTP、RESTful HTTP 或者CORBA ，并且可以在多种传输协议上运行，比如：HTTP、JMS 或者JBI，CXF 大大简化了Services 的创建，同时它继承了XFire 传统，一样可以天然地和Spring 进行无缝集成。
cxf soapmessage 获取调用方法
cxf soapmessage 获取调用方法CXF是一个开源的Java Web服务框架，它提供了一种简单易用的方式来构建和部署SOAP和RESTful风格的Web服务。
CXF的核心功能是提供一个SOAP消息处理框架，可以通过SOAP消息来调用远程方法。
本文将介绍如何使用CXF来获取SOAP消息并调用相应的方法。
SOAP（Simple Object Access Protocol）是一种基于XML的协议，用于在网络中进行Web服务之间的通信。
SOAP消息由SOAP Envelope、Header和Body组成。
SOAP Envelope是SOAP消息的根元素，它包含了SOAP消息的头部和主体。
SOAP Header可包含一些可选的头部信息，而SOAP Body包含了实际的调用方法的信息。
在CXF中，可以通过实现自定义的SOAPHandler来获取SOAP消息并处理它。
SOAPHandler是一个接口，用于处理SOAP消息的拦截器。
在处理SOAP消息之前和之后，可以通过SOAPHandler来获取和修改SOAP消息。
首先，需要创建一个实现SOAPHandler接口的类。
可以通过实现SOAPHandler接口的handleMessage方法来处理SOAP消息。
handleMessage方法接收一个SoapMessage对象作为参数，该对象包含了完整的SOAP消息。
javapublic class MySOAPHandler implementsSOAPHandler<SOAPMessageContext> {@Overridepublic boolean handleMessage(SOAPMessageContext context) {获取SOAP消息SOAPMessage soapMessage = context.getMessage();处理SOAP消息return true;}其他方法被省略...}在handleMessage方法中，可以通过SoapMessage对象的getSOAPPart方法来获取SOAP消息的主体部分，即SOAP Body。
CXF简单实例
CXF简单实例官网下载地址：我下载的是最新版本：apache-cxf-2.7.8 IDE：springsource jdk：jdk1.7.0_17webservice服务端创建1、新建一个maven项目由于我使用的IED是springsource，支持maven。
所以新建项目就创建了一个maven项目，这样cxf的依赖包就不用手动导入，直接在pom文件中配置依赖即可。
cxf的maven的依赖配置可以上cxf官网的User Guide中查找，这个章节有maven依赖的说明。
若新建的项目不为maven项目，也可以将下载下来的cxf包中的apache-cxf-2.7.8\lib目录下的jar包导入到项目中。
添加完cxf依赖的pom文件如下：cxf-rt-transports-http-jetty这个jar包现在需要配置上，若创建的项目为web项目，最终要部署到web服务器上，这个依赖可以不配置。
[html]view plaincopy1.<project xmlns="/POM/4.0.0" xmlns:xsi="/2001/XMLSche ma-instance"2.xsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd">3.<modelVersion>4.0.0</modelVersion>4.<groupId>cxf</groupId>5.<artifactId>server</artifactId>6.<version>0.0.1-SNAPSHOT</version>7.<packaging>jar</packaging>8.<name>server</name>9.<url></url>10.<properties>11.<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>12.<cxf.version>2.7.8</cxf.version>13.</properties>14.<dependencies>15.<dependency>16.<groupId>junit</groupId>17.<artifactId>junit</artifactId>18.<version>4.10</version>19.<scope>test</scope>20.</dependency>21.<dependency>22.<groupId>org.apache.cxf</groupId>23.<artifactId>cxf-rt-frontend-jaxws</artifactId>24.<version>${cxf.version}</version>25.</dependency>26.<dependency>27.<groupId>org.apache.cxf</groupId>28.<artifactId>cxf-rt-transports-http</artifactId>29.<version>${cxf.version}</version>30.</dependency>31.<!-- Jetty is needed if you're are not using the CXFServlet -->32.<dependency>33.<groupId>org.apache.cxf</groupId>34.<artifactId>cxf-rt-transports-http-jetty</artifactId>35.<version>${cxf.version}</version>36.</dependency>37.</dependencies>38.<build>39.<plugins>40.<plugin>41.<artifactId>maven-compiler-plugin</artifactId>42.<configuration>43.<source>1.7</source>44.<target>1.7</target>45.</configuration>46.</plugin>47.</plugins>48.</build>49.</project>2、编写需要发布的服务接口新建一个实体类User[java]view plaincopy1.package com.service.entity;2.3.public class User4.{5.private String firstName;6.private String secondName;7.8.//此处省略getters and setters9.10.11.@Override12.public String toString() {13.return firstName + " " + secondName;14.}15.16.}新建一个接口，注意其中的注解。
cxf中构建xml字符串的方法
我们需要了解什么是CXF。
CXF是一个开源的Web服务框架，它是由Apache Software Foundation所支持的项目之一。
它提供了一种简单而强大的方式来开发基于SOAP和RESTful的Web服务应用程序。
CXF中的XML字符串构建是其中一个重要的功能，它可以帮助我们快速、高效地构建符合特定格式的XML字符串。
CXF中构建XML字符串的方法有很多种，这取决于我们的具体需求和应用场景。
接下来，我将介绍一些常用的方法和技巧，希望能对您有所帮助。
1. 使用JAXB在CXF中，我们可以使用JAXB（Java Architecture for XML Binding）来构建XML字符串。
JAXB是JavaEE的一部分，它可以帮助我们将Java对象映射到XML文档，从而实现XML的序列化和反序列化。
在CXF中，我们可以利用JAXB提供的注解和工具来快速地构建符合特定格式的XML字符串。
我们可以在Java对象的属性上使用XmlRootElement、XmlElement等注解来指定XML元素的名称和结构，然后利用JAXB提供的工具来自动生成对应的XML字符串。
2. 使用DOM除了JAXB，我们还可以使用DOM（Document Object Model）来构建XML字符串。
DOM是一种基于树形结构的XML文档表示方式，它可以帮助我们在内存中创建、修改和操作XML文档。
在CXF中，我们可以直接使用DOM提供的API来手动构建XML字符串，这个方法对于需要动态生成XML内容的场景非常有用。
我们可以通过创建Document对象、Element对象等来构建XML元素和节点，然后利用DOM提供的方法将它们组装成完整的XML字符串。
3. 使用StAX另外，我们还可以使用StAX（Streaming API for XML）来构建XML 字符串。
StAX是一种基于流的XML处理方式，它可以帮助我们逐行地读取和写入XML文档。
CXF配置和开发流程
CXF的配置和开发流程第一种方式配置信息如下1、cxf用的jar包/download.html可以下载到。
2、web.xml<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>/services/*</url-pattern></servlet-mapping>3、配置文件applicationContext-service.xml（注意红色部分为配置文件新加配置）<beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:jaxws="/jaxws"xmlns:jaxrs="/jaxrs"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd/jaxws/schemas/jaxws.xsd/jaxws/schemas/jaxws.xsd/jaxrs/schemas/jaxrs.xsd/transports/http/configuration/schemas/configuration/http-conf.xsd"><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" /><jaxws:endpoint id="method2"implementor="com.fxb.webservice.service.impl.HelloServiceImpl"address="/HelloWorldTwo"><jaxws:inInterceptors><beanclass="com.fxb.webservice.interceptor.MyInterceptor"></bean> </jaxws:inInterceptors><jaxws:outInterceptors><beanclass="com.fxb.webservice.interceptor.MyInterceptor"></bean> </jaxws:outInterceptors></jaxws:endpoint>配置文件applicationContext-client.xml注意applicationContext-service.xml配置文件中使用的是<jaxws:endpoint></jaxws:endpoint>标签4、服务类HelloService.java@WebServicepublic interface HelloService {public TestResponse hello(@WebParam(name="name")String name);}实现类HelloServiceImpl.javaTestResponse.java、TestList.java5、客户端类HelloClient.java6、拦截器MyInterceptor.java各部分代码如下Web.xml<?xml version="1.0"encoding="UTF-8"?><!DOCTYPE web-app PUBLIC"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN""/dtd/web-app_2_3.dtd"><web-app><context-param><param-name>contextConfigLocation</param-name><param-value>WEB-INF/classes/applicationContext.xml</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>/services/*</url-pattern></servlet-mapping><mime-mapping><extension>xsd</extension><mime-type>text/xml</mime-type></mime-mapping></web-app>applicationContext-service.xml<?xml version="1.0"encoding="UTF-8"?> <!-- START SNIPPET: beans --><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:jaxws="/jaxws"xmlns:jaxrs="/jaxrs"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd/jaxws /schemas/jaxws.xsd /jaxws /schemas/jaxws.xsd /jaxrs /schemas/jaxrs.xsd /transports/http/configuration/schemas/configuration/http-conf.xsd"><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"/><bean id="helloService"class="com.fxb.webservice.service.impl.HelloServiceImpl"></bean><jaxws:endpoint id="method2"implementor="com.fxb.webservice.service.impl.HelloServiceImpl"address="/HelloWorldTwo"><jaxws:inInterceptors><beanclass="com.fxb.webservice.interceptor.MyInterceptor"></bean> </jaxws:inInterceptors><jaxws:outInterceptors><beanclass="com.fxb.webservice.interceptor.MyInterceptor"></bean> </jaxws:outInterceptors></jaxws:endpoint></beans><!-- END SNIPPET: beans -->applicationContext-client.xml<?xml version="1.0"encoding="UTF-8"?><!-- START SNIPPET: beans --><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:jaxws="/jaxws"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd/jaxws /schema/jaxws.xsd"><bean id="client"class="com.fxb.webservice.client.HelloClient"factory-bean="clientFactory"factory-method="create"/><bean id="clientFactory"class="org.apache.cxf.jaxws.JaxWsProxyFactoryBean"><property name="serviceClass"value="com.fxb.webservice.service.HelloService"/><property name="address"value="http://localhost:8080/CXFSpring/services/HelloWorldTwo"/> </bean></beans><!-- END SNIPPET: beans -->HelloService.javapackage com.fxb.webservice.service;import javax.jws.WebParam;import javax.jws.WebService;import javax.jws.soap.SOAPBinding;import javax.jws.soap.SOAPBinding.Style;import com.fxb.webservice.bean.TestResponse;@WebServicepublic interface HelloService {public TestResponse hello(@WebParam(name="name")String name); }HelloServiceImpl.javapackage com.fxb.webservice.service.impl;import com.fxb.webservice.bean.TestList;import com.fxb.webservice.bean.TestResponse;import com.fxb.webservice.service.HelloService;public class HelloServiceImpl implements HelloService {public TestResponse hello(String name) {System.out.println(name);TestResponse testResponse = new TestResponse();TestList testList = new TestList();testList.setName("HelloServiceImpl");testResponse.setTestList(testList);return testResponse;}}TestResponse.java类package com.fxb.webservice.bean;import javax.xml.bind.annotation.XmlAccessType;import javax.xml.bind.annotation.XmlAccessorType;import javax.xml.bind.annotation.XmlRootElement;@XmlRootElement(name = "TestResponse")//设置一级子节点@XmlAccessorType(XmlAccessType.FIELD)public class TestResponse {protected TestList testList;public TestList getTestList() {return testList;}public void setTestList(TestList testList) { this.testList = testList;}}TestList.java类package com.fxb.webservice.bean;import javax.xml.bind.annotation.XmlAccessType; import javax.xml.bind.annotation.XmlAccessorType; import javax.xml.bind.annotation.XmlRootElement;@XmlRootElement(name = "TestList")//设置二级子节点@XmlAccessorType(XmlAccessType.FIELD)public class TestList {//类的属性为三级子节点protected String name;protected String age;public String getName() {return name;}public void setName(String name) { = name;}public String getAge() {return age;}public void setAge(String age) {this.age = age;}}MyInterceptor.javapackage com.fxb.webservice.interceptor;import org.apache.cxf.interceptor.Fault;import org.apache.cxf.message.Message;import org.apache.cxf.phase.AbstractPhaseInterceptor;import org.apache.cxf.phase.Phase;import org.apache.log4j.Logger;public class MyInterceptor extends AbstractPhaseInterceptor<Message> { private Logger log = Logger.getLogger(MyInterceptor.class);public MyInterceptor(String phase) {super(phase);}public MyInterceptor() {super(Phase.RECEIVE);}@SuppressWarnings("static-access")public void handleMessage(Message msg) throws Fault {String uri = String.valueOf(msg.get(msg.REQUEST_URI));StringBuffer bf = new StringBuffer(uri + ".xml");msg.put(msg.REQUEST_URI, String.valueOf(bf));System.out.println("in my intercetptor11111111111111111111");System.out.println(msg.get(msg.REQUEST_URI));("in my interceptor:");}@Overridepublic void handleFault(Message message) {super.handleFault(message);System.out.println("handleFault@@@@@@@@@@@@@@@@@@@@@2");}}HelloClient.javapackage com.fxb.webservice.client;import org.apache.cxf.jaxws.JaxWsProxyFactoryBean;importorg.springframework.context.support.ClassPathXmlApplicationContext; import com.fxb.webservice.bean.TestResponse;import com.fxb.webservice.service.HelloService;public class HelloClient {public static void main(String[] args) {ClassPathXmlApplicationContext context= new ClassPathXmlApplicationContext(new String[]{"com/fxb/webservice/client/applicationContext-client.xml"});HelloService client = (HelloService)context.getBean("client");TestResponse response = client.hello("Joe");System.out.println("Response: " +response.getTestList().getName());System.exit(0);}}通过客户端测试输出为Response: HelloServiceImpl通过http://localhost:8080/CXFSpring/services/HelloWorldTwo/hello输出为第二种方式配置信息如下1、cxf用的jar包/download.html可以下载到。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
CXF旨在为服务创建必要的基础设施，它的整体架构主要由以下几个部分组成：1.Bus它是C X F架构的主干，为共享资源提供了一个可配置的场所，作用非常类似于S p r i n g的ApplicationContext。
这些共享资源包括WSDL管理器、绑定工厂等。
通过对Bus进行扩展，可以方便地容纳自己的资源，或替换现有的资源。
默认Bus实现是基于Spring的，通过依赖注入，将运行时组件串起来。
Bus的创建由BusFactory负责，默认是 SpringBusFactory，对应于默认Bus实现。
在构造过程中，SpringBusFactory会搜索META-INF/cxf（就包含在 CXF的Jar中）下的所有Bean配置文件，根据它们构建一个ApplicationContext。
开发者也可提供自己的配置文件来定制Bus。
2.消息传递和拦截器（Interceptor）CXF建立于一个通用的消息层之上，主要由消息、拦截器和拦截器链（InterceptorChain）组成。
CXF是以消息处理为中心的，熟悉 JSP/Servlet的开发者可以将拦截器视为CXF架构中的“Filter”，拦截器链也与“FilterChain”类似。
通过拦截器，开发者可以方便地在消息传递、处理的整个过程中对CXF进行扩展。
拦截器的方法主要有两个：handleMessage和handleFault，分别对应消息处理和错误处理。
在开发拦截器的时候需要注意两点：拦截器不是线程安全的，不建议在拦截器中定义实例变量并使用它。
这一点跟JSP/Servlet中对于Filter的处理是一样的；不要调用下一个拦截器的handleMessage或handleFault，这个工作由InterceptorChain来完成。
3.前端（Front End）它为CXF提供了创建服务的编程模型，当前主要的前端就是JAX-WS。
4.服务模型CXF中的服务通过服务模型来表示。
它主要有两部分：ServiceInfo和服务本身。
ServiceInfo作用类似WSDL，包含接口信息、绑定、端点（EndPoint）等信息；服务则包含了ServiceInfo、数据绑定、拦截器和服务属性等信息。
可使用Java 类和WSDL来创建服务。
一般是由前端负责服务的创建，它通过ServiceFactory 来完成。
5.绑定（Binding）绑定提供了在传输之上映射具体格式和协议的方法，主要的两个类是Binding和BindingFactory。
BindingFactory负责创建Binding。
6.传输（Transport）为了向绑定和前端屏蔽传输细节，CXF提供了自己的传输抽象。
其中主要有两个对象：Conduit和Destination。
前者是消息发送的基础，后者则对应消息接收。
开发者还可以给Conduit和Destination注册MessageObserver，以便在消息发送和接收时获得通知。
开发方法CXF 可以创建的Web 服务应用有两种：服务提供者和服务消费者。
这种结构可类比客户端/ 服务器结构，服务消费者类似于客户端，服务提供者类似于服务器。
使用CXF 创建应用时，服务提供者和服务消费者并不需要同时出现，因为有可能应用只是作为服务提供者或服务消费者单独出现。
为了说明使用CXF 如何创建这两种类型的应用，本教程将同时给出它们的例子。
另外，由于Groovy在Java 世界中变得越来越流行，本教程会给出使用Groovy 的CXF 插件GroovyWS 的实现例子。
例子使用JDK 1.5.X 和Groovy 1.0 完成，包含以下几部分：er，用户对象，在消费者和提供者之间传递；erService，用户管理服务，它提供增加和获取所有用户的功能；3.Client，服务消费者，它向UserService发起服务请求。
Java 实现的步骤包括以下几点。
服务端包含UserService、UserServiceImpl和User。
其中，UserService是接口定义，UserServiceImpl是它的实现，并负责服务的发布，服务只有发布之后才能被消费。
例子使用了JAX-WS，它们的主要内容如下：UserService@ WebService中的serviceName、portName，分别指定了其产生的WSDL中的服务名和端口名。
endpointInterface为接口的类名。
服务发布代码也可以放在另一个类中。
User2.包中的对象。
注意，QName 的第一个参数指明了WSDL 的目标名字空间，可以通过“服务地址?wsdl”方式获取服务的WSDL，来查看服务的目标名字空间。
对于由CXF 创建的服务，目标名字空间的默认构造规则是：http:// 包名的倒序/。
即如果包名是a.b.c，那么名字空间就为http://c.b.a/ 。
GroovyWS 的实现步骤包括以下几点。
1.服务端包括：User、UserService、User.aegis.xml。
由于Groovy类包含一个metaClass属性，该属性不应该被序列化在服务端和客户端之间传递，User.aegis.xml用来指定将该属性忽略掉。
User注意它的发布。
Use.aegis.xml2.一样。
相关建议CXF 的功能特性非常多，要熟练使用它非得花些功夫才行。
笔者在此给出一些建议，期望能对读者在今后学习和使用CXF 的过程中有所帮助：1.熟悉工具涉及领域的协议是个不错的主意。
虽然CXF提供了简化服务创建的编程模型，但是如果不了解WS-*协议，在遇到问题调试时必然会花不少时间。
尤其是在SOA的环境中，客户端和服务不一定是使用同一语言、同一工具实现的情况下，互操作问题经常是由于对协议的不同支持造成的；2.作为CXF实现内容的一个重点，JAX-WS是值得关注的；3.在Java的环境中，Spring几乎已经成为开发服务器端应用的首选，应重点关注CXF和Spring的配合使用；4.近些年来，Java世界的动态语言旋风愈演愈烈。
Groovy由于其语法和Java兼容且提供了不少方便的语法，吸引了不少Java开发者。
更何况新兴的Grails 框架逐渐引人注目，其前途不可限量。
GroovyWS专为Groovy开发，且底层就是CXF，作为CXF的开发者，没有理由不去使用可以使自己生活过得舒适的工具；5.CXF携带了大量的例程，它们是熟悉和了解CXF的大门的；6.参与社区，参与讨论，往往比起自己单干要有用得多。
版本信息在官方网站上，CXF 公布了其2.0.4 版和2.1版的开发计划。
2.0.4 版于2008 年1 月15 日发布，2.1 版则是2 月28 日发布。
2.0.4 版的计划主要是修正2.0.3 版的错误，以及工具迁移的问题。
2.1 版则引入一些新特性，包括：1.支持JAX-WS2.1，包括JAXB 2.1、API中的WS-A、SEI接口方法的JAXB标注、WebServiceFeature标注；2.XmlBeans、JiBX数据绑定；3.新的java2ws工具；4.更好地支持REST（JSR-311）；5.支持js；6.OSGi bundling。
除了上述计划，有可能包含在2.1 版，但是肯定会在2.2 版的特性包括：1.通过继承Yoko 的代码来支持CORBA；2.更好地集成Acegi；3.WS-SecureConversation/Trust；4.其他WS-*协议。
社区视角在Celtix 和XFire 宣布合并的同年，另一个著名开源Web 服务框架Axis 的后继者Axis2 也诞生了。
Axis2 并非Axis 的2.0 版，而是完全重写了Axis 的新项目。
作为功能和背景都极其相似的两个项目，人们难免会将它们相提并论。
在著名的Java 企业开发站点TheServiceSide 上就有一篇名为“Axis, Axis2 and CXF: Survey theWS Landscape”（地址：/tt/articles/content/AxisAxis2andCXF/arti cle.html ）的文章对这两个项目进行了比较，主要内容如下。
1.在特性方面：C X F 支持W S - A d d r e s s i n g 、W S -Policy、WS-RM、WS-Security 和WS-I BasicProfile。
Axis2支持除了WSPolicy之外的所有这些标准，WS-Policy预计会在未来版本中得到支持；CXF可以方便地和Spring集成在一起，Axis2不行;Axis2支持范围更广的数据绑定，包括XMLBeans、JiBX、JaxMe、JaxBRI，以及它自己的数据绑定ADB。
在 Axis21.2 版中，JaxME和JaxBRI尚处于试验阶段。
目前，C X F只支持J A X B和Aegis，对XMLBeans、JiBX和Castor的支持将在CXF 2.1版中实现；Axis2支持多语言，除了Java版本，尚有C/C++版本。
2.在开发方面：Axis2更像一个微型服务器。
Axis2被打包成一个WAR，可部署到任何Servlet 容器中，为了更方便地在运行中管理和部署服务进行专门的设计。
CXF更专注于对开发人员友好及可嵌入性。
大部分配置只需使用API即可完成，与Spring紧密集成。
CXF强调代码优先的服务开发方式。
3.建议：如果需要多语言支持，那么就采用Axis2；如果考虑到使用Java、与Spring集成，或将服务嵌入到其他程序中，那么CXF更好。
当然，并不是所有人都说好。
例如，在国内的一些论坛上，就有开发者抱怨CXF 的入门比起XFire 来要复杂得多。
这是可以理解的，毕竟CXF本身也比XFire 要复杂得多。
为了帮助Celtix 和XFire 的开发者向新工具的迁移，其官方网站也提供了相应的迁移指南。
另外一个常见的问题是和Spring AOP 相关的（如事务、安全），这在官方网站的FAQ 中也有说明。