前言：WebService就目前来讲已经是一种成熟的技术了，目前对WebService支持的框架也很多，虽然本人并没有对各框架做个测试，但分析比较各框架的优缺点(较为主观)，最后还是选择了CXF作为样例框架进行分析，主要是因为性能较佳，支持JAX-WS，Spring无缝集成，上手快等特点，本文旨在提供CXF基本入门demo，帮助快速入门了解CXF的使用。
本篇文章重点关注以下问题：
Apache CXF 是一个开源的 WebServices 框架，CXF 帮助您利用 Frontend 编程 API 来构建和开发 Services ，像 JAX-WS 。这些 Services 可以支持多种协议，比如：SOAP、XML/HTTP、RESTful HTTP 或者CORBA ，并且可以在多种传输协议上运行，比如：HTTP、JMS 或者 JBI，CXF 大大简化了 Services 的创建，同时它继承了 XFire 传统，一样可以天然地和 Spring 进行无缝集成。
CXF服务端、、客户端实现WebService服务的方式主要有两点：
调用原则如下图：
首先做两点说明，使用CXF发布一个服务于与Jax-Ws发布一个服务完全不同：
OK，废话不多说，直接上代码：
先定义对外发布服务的接口：
public interface IHelloService {
String sayHello(String name);
}
然后利用ServerFactoryBean对外发布服务：
/**
* 使用ServerFactoryBean发布CXF的Web服务
*/
public class HelloService implements IHelloService {
/**
* 对外发布的方法
* @param name
* @return
*/
public String sayHello(String name) {
System.err.println("hello, " + name);
return "hello, " + name;
}
public static void main(String[] args) {
ServerFactoryBean bean = new ServerFactoryBean();
// 服务的发布地址
bean.setAddress("http://localhost:9999/sayHello");
// 对外提供服务的类的类型，在面向接口编程时填写接口，否则写实现类
bean.setServiceClass(IHelloService.class);
// 对外提供服务的功能实现类
bean.setServiceBean(new HelloService());
// 发布服务 publish()...
bean.create();
System.out.println("服务已发布...");
}
}
使用CXF发布完此服务后，使用wsimport生成客户端一样可以成功调用此服务。最后废话一句，CXF要依赖的包太多了，当然也是我懒得去区分各个包的作用导致的。在浏览器中输入http://localhost:9999/sayHello?wsdl验证服务是否发布。
首先获取服务接口，有两种方式，如何可以直接联系服务方拿到定义的接口文件则可以拿过来直接使用，当然也可以利用wsimport获得接口文件来使用(此方法在java RMI一文中有阐述)。这里我就直接把服务端的接口文件直接拿过来用了。
直接上代码：
/**
* 使用ClientProxyFactoryBean调用CXF的Web服务(必须是使用ServerFactoryBean方式发布的)
*/
public class HelloServiceClient {
public static void main(String[] args) {
ClientProxyFactoryBean bean = new ClientProxyFactoryBean();
// 设置客户端需要使用服务的地址
bean.setAddress("http://localhost:9999/sayHello");
// 创建服务接口对象(接口对象用的仍是服务端的服务接口对象)
IHelloService helloService = (IHelloService) bean.create(IHelloService.class);
// 使用服务
String result = helloService.sayHello("熊燕子");
System.out.println(result);
}
}
当然，客户端既然用的仍然是CXF，那么还是需要导入那么多包的。
JaxWsServiceFactoryBean是ServerFactoryBean的子类，也是功能扩展类，此类必须要在被发布为服务的类的上添加@WebService注解，如果不加注解，虽然运行不会报错，但是也不会对外暴露任何方法。最重要的一点是，使用此类生成的wsdl文件更加规范。
先定义服务接口，直接上代码：
@WebService
@BindingType(value=SOAPBinding.SOAP12HTTP_BINDING)
/**
* 通过@BindingType(value=SOAPBinding.SOAP12HTTP_BINDING)转换为实现SOAP1.2
*/
public interface IHelloService {
public String sayHello(String name);
}
然后发布服务 ：
/**
* 使用JaxWsServerFactoryBean发布CXF的Web服务
* 注意：需要发布的服务接口必须加入WebService注解，如果不加，虽然不报错，但是所有的方法都暴露不出来
*/
public class HelloService implements IHelloService {
/**
* 对外发布的方法
* @param name
* @return
*/
@Override
public String sayHello(String name) {
System.err.println("hello, " + name);
return "hello, " + name;
}
public static void main(String[] args) {
JaxWsServerFactoryBean bean = new JaxWsServerFactoryBean();
// 设置服务的发布地址
bean.setAddress("http://localhost:9999/sayHello");
// 对外提供服务的类的类型，在面向接口编程时填写接口，否则写实现类
bean.setServiceClass(IHelloService.class);
// 对外提供服务的功能实现类
bean.setServiceBean(new HelloService());
// 发布服务 publish()...
bean.create();
System.out.println("服务已发布...");
}
}
使用CXF发布完此服务后，使用wsimport生成客户端一样可以成功调用此服务。与wsimport类似的还有CXF提供的wsdl2java命令，也同样可以生成客户端代码。此工具位于CXF_HOME/bin目录下，只是参数与wsimport有所不同，它包含以下常用参数：
用JaxWsServiceFactoryBean发布的服务，在客户端需要使用JaxWsProxyFactoryBean类进行调用，调用过程与前面的过程类似。
这里还是直接把服务端的服务接口文件IHelloService.javaz直接拷贝到客户端来使用。(当然，wsimport和wsdl2java都可以用来生成功能接口)
/**
* 利用JaxWsProxyFactoryBean进行WebService服务调用(只能调用JaxWsServerFactoryBean发布的服务)
*/
public class HelloServiceClient {
public static void main(String[] args) {
JaxWsProxyFactoryBean bean = new JaxWsProxyFactoryBean();
// 设置客户端需要使用服务的地址
bean.setAddress("http://localhost:9999/sayHello");
// 设置服务接口的类型
bean.setServiceClass(IHelloService.class);
// 创建服务接口对象
IHelloService helloService = (IHelloService) bean.create();
// 调用WebService服务
String ret = helloService.sayHello("aa");
System.out.println(ret);
}
}
利用wsdl2java命令生成客户端调用代码，进行客户端开发。
/**
* 通过wsdl2java生成客户端代码调用Webservice服务
*/
public class HelloServiceClient {
public static void main(String[] args) {
// 获取服务类对象
IHelloServiceService helloServiceService = new IHelloServiceService();
// 获取服务类对象的接口
IHelloService helloService = helloServiceService.getIHelloServicePort();
// 调用服务
String result = helloService.sayHello("熊燕子");
System.out.println(result);
}
}
可以发现wsdl2java不管是命令还是生成调用客户端代码，都与wsimport非常类似。
远程调用有可预见的失败概率，所以客户端需对服务请求超时做准备。CXF在调用WebService服务时，可以设置响应超时时间或读取超时时间，设置方式也比较简单。为验证客户端超时机制，前面的demo主要有两个地方需要修改：
/**
* 使用JaxWsServerFactoryBean发布CXF的Web服务
* 注意：方法的实现中增加了延迟5秒
*/
public class HelloService implements IHelloService {
/**
* 对外发布的方法
* @param name
* @return
*/
@Override
public String sayHello(String name) {
try {
Thread.sleep(5000); /* 服务端增加延迟，以在客户端验证超时机制. */
} catch (InterruptedException e) {
e.printStackTrace();
}
System.err.println("hello, " + name);
return "hello, " + name;
}
public static void main(String[] args) {
JaxWsServerFactoryBean bean = new JaxWsServerFactoryBean();
// 设置服务的发布地址
bean.setAddress("http://localhost:9999/sayHello");
// 对外提供服务的类的类型，在面向接口编程时填写接口，否则写实现类
bean.setServiceClass(IHelloService.class);
// 对外提供服务的功能实现类
bean.setServiceBean(new HelloService());
// 发布服务 publish()...
bean.create();
System.out.println("服务已发布...");
}
}
客户端采用JaxWsProxyFactoryBean进行客户端服务调用，与前面不同的加入了超时代理和超时机制：/**
* 利用JaxWsProxyFactoryBean进行WebService服务调用(只能调用JaxWsServerFactoryBean发布的服务)
* 中间部分增加了客户端超时机制
*/
public class HelloServiceClient {
public static void main(String[] args) {
JaxWsProxyFactoryBean bean = new JaxWsProxyFactoryBean();
// 设置客户端需要使用服务的地址
bean.setAddress("http://localhost:9999/sayHello");
// 设置服务接口的类型
bean.setServiceClass(IHelloService.class);
// 创建服务接口对象
IHelloService helloService = (IHelloService) bean.create();
/** 超时机制代码-------------begin------------ */
// 生成客户端代理对象(主要代理超时任务)
Client client = ClientProxy.getClient(helloService);
// 获取传输通道对象 --> 此对象关联超时策略
HTTPConduit conduit = (HTTPConduit) client.getConduit();
// 获取HttpClientd代理的策略对象，并设置代理的端口号、超时时间等信息
HTTPClientPolicy httpClientPolicy = new HTTPClientPolicy();
// 设置代理的IP和端口号
// httpClientPolicy.setProxyServer("");
// httpClientPolicy.setProxyServerPort(9999);
// 设置连接超时
httpClientPolicy.setConnectionTimeout(1000);
// 设置读取超时
httpClientPolicy.setReceiveTimeout(1000);
conduit.setClient(httpClientPolicy);
/** 超时机制代码------------ -end ------------ */
// 调用WebService服务
String ret = helloService.sayHello("熊燕子");
System.out.println(ret);
}
}
代码搭建完成后，可进行两方面的调试：
2. 测试服务调用超时(setReceiveTimeout)，即1秒之内要返回读取结果。
WebService服务主要用于远程调用，在进行不同系统之间对接时，必须考虑各系统的安全问题。因此，WebService服务一般都需要进行权限校验。如果用原生的JDK发布WebService服务，则程序员必须对每个SOAP消息进行解析，然后再判断权限。而CXF框架可以除了可以帮我们发布、调用WebService服务，还可以帮助我们进行SOAP消息的解析和生成，这样有助于开发效率的提升。
WebService分为入拦截器和出拦截器，无论是服务端和客户端都有这两种拦截器。 CXF 除了提供了一些默认的系统拦截器，如日志拦截器，还支持用于自定义拦截器。
4.1 CXF框架的系统拦截器 服务接口还是使用上面定义的IHelloService，这里只上拦截器使用的方法代码：
服务端增加日志拦截器：
/**
* 使用JaxWsServerFactoryBean发布CXF的Web服务
* 注意：服务端增加了系统拦截器，可用于日志记录
*/
public class HelloService implements IHelloService {
/**
* 对外发布的方法
* @param name
* @return
*/
@Override
public String sayHello(String name) {
System.err.println("hello, " + name);
return "hello, " + name;
}
public static void main(String[] args) {
JaxWsServerFactoryBean bean = new JaxWsServerFactoryBean();
// 设置服务的发布地址
bean.setAddress("http://localhost:9999/sayHello");
// 对外提供服务的类的类型，在面向接口编程时填写接口，否则写实现类
bean.setServiceClass(IHelloService.class);
// 对外提供服务的功能实现类
bean.setServiceBean(new HelloService());
/** 服务端加入拦截器. */
// 加入请求的入消息拦截器（日志拦截器）
bean.getInInterceptors().add(new LoggingInInterceptor());
// 加入请求的出消息拦截器（日志拦截器）
bean.getOutInterceptors().add(new LoggingOutInterceptor());
// 发布服务 publish()...
bean.create();
System.out.println("服务已发布...");
}
}
客户度增加日志拦截器：
/**
* 利用JaxWsProxyFactoryBean进行WebService服务调用(只能调用JaxWsServerFactoryBean发布的服务)
* 中间部分增加了客户端日志拦截器
*/
public class HelloServiceClient {
public static void main(String[] args) {
JaxWsProxyFactoryBean bean = new JaxWsProxyFactoryBean();
// 设置客户端需要使用服务的地址
bean.setAddress("http://localhost:9999/sayHello");
// 设置服务接口的类型
bean.setServiceClass(IHelloService.class);
// 创建服务接口对象
IHelloService helloService = (IHelloService) bean.create();
/** 加入客户端日志拦截器. */
// 获取Client代理对象
Client client = ClientProxy.getClient(helloService);
// 加入请求响应的入消息拦截器（日志拦截器）
client.getInInterceptors().add(new LoggingInInterceptor());
// // 加入请求的出消息拦截器（日志拦截器）
client.getOutInterceptors().add(new LoggingOutInterceptor());
// 调用WebService服务
String ret = helloService.sayHello("熊燕子");
System.out.println(ret);
}
}
服务端发布服务后，客户端进行调用，控制台打印分别为：
客户端：
服务端：
4.2 CXF框架自定义拦截器 此处以权限校验拦截器为例，介绍如何使用CXF框架对自定义拦截器的支持，实现权限控制。
CXF 中自定义拦截器，其实就是对SOAP 消息的封装和解析。这里对SOAP消息进行简单介绍：简单对象访问协议(SOAP)是交换数据的一种协议规范，是一种轻量的、简单的、基于XML的协议，它被设计成在WEB上交换结构化的和固化的信息。其格式如下：
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Header>
不是强制出现的， head 元素的内容由程序员控制添加， 主要用于携带一些其它的信息
</soap:Header>
<soap:Body>
body 元素的内容总是默认的，但是有两种情况
1. 当webService 正确交互时，Body元素内容由WSDL 控制
2. 当WebService 交互错误时，body元素的内容将是Fault 元素
</soap:Body>
</soap:Envelope>
是不是很类似html的定义！
步骤一：自定义权限拦截器
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Header>
<user>
<username>熊燕子</username>
<passwor>123456</passwor>
</user>
</soap:Header>
<soap:Body>
<ns2:sayHello xmlns:ns2="http://cxf4.wj.com/">
<arg0>熊燕子</arg0>
</ns2:sayHello>
</soap:Body>
</soap:Envelope>
步骤二：自定义客户端出拦截器
/**
* 客户端拦截器：拦截客户端发出的SOAP 消息，然后在<SOAP:Header> 标签中添加自定义xml元素
*/
public class UserOutInterceptor extends AbstractPhaseInterceptor<SoapMessage>{
private String username;
private String password;
public UserOutInterceptor(String username, String password) {
super(Phase.PRE_PROTOCOL);
this.username = username;
this.password = password;
}
@Override
public void handleMessage(SoapMessage soapMessage) throws Fault {
try {
//1. 用原生的w3c 的API 构建 <soap:header>中的一个 元素
DocumentBuilder documentBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
Document document = documentBuilder.newDocument();
Element userEle = document.createElement("user");
Element usernameEle = document.createElement("username");
Element passwordEle = document.createElement("password");
usernameEle.setTextContent(username);
passwordEle.setTextContent(password);
userEle.appendChild(usernameEle);
userEle.appendChild(passwordEle);
//2. 创建一个header，然后添加到当前的header列表中
Header header = new Header(new QName("user"),userEle);
soapMessage.getHeaders().add(header );
} catch (ParserConfigurationException e) {
e.printStackTrace();
}
}
}
步骤三：服务端加入拦截器进行权限校验
/**
* 服务器端拦截器：在消息到达服务器端时，拦截SOAP 消息，解析 <SOAP:Header> 元素中的指定元素
* 继承AbstractPhaseInterceptor
* 消息类型：SOAP 消息
*/
public class UserInInterceptor extends AbstractPhaseInterceptor<SoapMessage> {
public UserInInterceptor() {
super(Phase.PRE_PROTOCOL);
//准备协议化之前拦截
}
@Override
public void handleMessage(SoapMessage soapMessage) throws Fault {
String username;
String password;
//1. 解析用户名和密码，如果解析过程出错，证明请求参数格式不正确
try {
Header userHeader = soapMessage.getHeader(new QName("user"));
//必须是 org.w3c.dom.Element
Element userElement = (Element) userHeader.getObject();
username = userElement.getElementsByTagName("username").item(0).getTextContent();
password = userElement.getElementsByTagName("password").item(0).getTextContent();
} catch (Exception ex) {
throw new Fault(new RuntimeException("请求参数格式不正确"));
}
//2. 验证用户名和密码
if("熊燕子".equals(username) && "123456".equals(password)){
System.out.println("权限认证通过....");
}else{
throw new Fault(new RuntimeException("对不起，您的用户名或密码有误！"));
}
}
}
步骤四：服务端加入自定义权限拦截器，启动服务端
/**
* 使用JaxWsServerFactoryBean发布CXF的Web服务
* 注意：服务端增加了系统拦截器，可用于日志记录；加入了自定义权限拦截器进行权限控制
*/
public class HelloService implements IHelloService {
/**
* 对外发布的方法
* @param name
* @return
*/
@Override
public String sayHello(String name) {
System.err.println("hello, " + name);
return "hello, " + name;
}
public static void main(String[] args) {
JaxWsServerFactoryBean bean = new JaxWsServerFactoryBean();
// 设置服务的发布地址
bean.setAddress("http://localhost:9999/sayHello");
// 对外提供服务的类的类型，在面向接口编程时填写接口，否则写实现类
bean.setServiceClass(IHelloService.class);
// 对外提供服务的功能实现类
bean.setServiceBean(new HelloService());
/** 服务端加入拦截器. */
// 加入请求的入消息拦截器（日志拦截器）
bean.getInInterceptors().add(new LoggingInInterceptor());
/** 对所有SOAP消息进行权限校验 */
bean.getInInterceptors().add(new UserInInterceptor());
// 加入请求的出消息拦截器（日志拦截器）
bean.getOutInterceptors().add(new LoggingOutInterceptor());
// 发布服务 publish()...
bean.create();
System.out.println("服务已发布...");
}
}
步骤五：客户端加入拦截器，自动填充请求相关的权限信息，然后发送WebService请求
/**
* 利用JaxWsProxyFactoryBean进行WebService服务调用(只能调用JaxWsServerFactoryBean发布的服务)
* 中间部分增加了客户端日志拦截器, 自定义权限登录的拦截器
*/
public class HelloServiceClient {
public static void main(String[] args) {
JaxWsProxyFactoryBean bean = new JaxWsProxyFactoryBean();
// 设置客户端需要使用服务的地址
bean.setAddress("http://localhost:9999/sayHello");
// 设置服务接口的类型
bean.setServiceClass(IHelloService.class);
// 创建服务接口对象
IHelloService helloService = (IHelloService) bean.create();
/** 加入客户端日志拦截器. */
// 获取Client代理对象
Client client = ClientProxy.getClient(helloService);
// 加入请求响应的入消息拦截器（日志拦截器）
client.getInInterceptors().add(new LoggingInInterceptor());
// // 加入请求的出消息拦截器（日志拦截器）
client.getOutInterceptors().add(new LoggingOutInterceptor());
/** 在头字段中加入用户名、密码 */
client.getOutInterceptors().add(new UserOutInterceptor("熊燕子", "123456"));
// 调用WebService服务
String ret = helloService.sayHello("熊燕子");
System.out.println(ret);
}
}
步骤六：查看校验过程
5、CXF整合Spring发布 CXF与Spring联系紧密，这从CXF的依赖jar包中也可见一般，因此，CXF与Spring整合也很轻松简单。下面还是以发布、调用WebService服务为例来介绍其整合过程。
步骤一：准备工作
建立一个Web项目，并将CXF官方包lib目录下的所有jar包全部加入工程；
步骤二：配置Web,xml
<?xml version="1.0" encoding="UTF-8"?> <web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"> <!-- 通过上下文参数指定spring配置文件的位置 --> <context-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:cxf-servlet.xml</param-value> </context-param> <listener> <listener-class> org.springframework.web.context.ContextLoaderListener </listener-class> </listener> <!-- 配置CXF的核心Servlet --> <servlet> <servlet-name>cxf</servlet-name> <servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class> <!-- 通过初始化参数指定cxf配置文件的位置 --> <!-- <init-param> <param-name>config-location</param-name> <param-value>classpath:cxf-servlet.xml</param-value> </init-param> --> </servlet> <servlet-mapping> <servlet-name>cxf</servlet-name> <url-pattern>/cxf/*</url-pattern> </servlet-mapping> <welcome-file-list> <welcome-file>index.jsp</welcome-file> </welcome-file-list> </web-app>步骤三：创建spring的配置文件，命名spring-cxf.xml，此XML文件用于配置CXF相关信息
一般来说，Spring的一个基本原则就是面向接口编程，但是WebService也可进行简单发布，即不面向接口编程，两种形式有所不同，这里都做简要介绍。
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:jaxws="http://cxf.apache.org/jaxws"
xmlns:jaxrs="http://cxf.apache.org/jaxrs" xmlns:cxf="http://cxf.apache.org/core"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://cxf.apache.org/jaxrs http://cxf.apache.org/schemas/jaxrs.xsd
http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd
http://cxf.apache.org/core http://cxf.apache.org/schemas/core.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" />
<!-- 第一种发布方式：简单发布(没有接口的发布) -->
<!-- id:唯一标示 implementor：提供服务的类 address:服务的请求url-->
<jaxws:endpoint id="helloService" implementor="cn.itcast.cxf.HelloService" address="/hello">
<!-- 加入请求的消息拦截器 -->
<jaxws:inInterceptors>
<bean class="org.apache.cxf.interceptor.LoggingInInterceptor"></bean>
</jaxws:inInterceptors>
<!-- 加入响应的消息拦截器 -->
<jaxws:outInterceptors>
<bean class="org.apache.cxf.interceptor.LoggingOutInterceptor"></bean>
</jaxws:outInterceptors>
</jaxws:endpoint>
<!-- 第二种发布方式：带有接口的发布 -->
<!-- id:唯一标示 serviceClass：接口类型 address：服务的请求url-->
<jaxws:server id="hiService" serviceClass="cn.itcast.cxf.IHiService" address="/hi">
<jaxws:serviceBean>
<!-- 服务的实现类 -->
<bean class="cn.itcast.cxf.HiServiceImpl"></bean>
</jaxws:serviceBean>
<!-- 加入请求的消息拦截器 -->
<jaxws:inInterceptors>
<bean class="org.apache.cxf.interceptor.LoggingInInterceptor"></bean>
</jaxws:inInterceptors>
<!-- 加入响应的消息拦截器 -->
<jaxws:outInterceptors>
<bean class="org.apache.cxf.interceptor.LoggingOutInterceptor"></bean>
</jaxws:outInterceptors>
</jaxws:server>
<jaxws:server id="personService" serviceClass="cn.itcast.cxf.service.IPersonService" address="/person">
<jaxws:serviceBean>
<!-- 服务的实现类 -->
<bean class="cn.itcast.cxf.service.PersonServiceImpl"></bean>
</jaxws:serviceBean>
<!-- 加入请求的消息拦截器 -->
<jaxws:inInterceptors>
<bean class="org.apache.cxf.interceptor.LoggingInInterceptor"></bean>
</jaxws:inInterceptors>
<!-- 加入响应的消息拦截器 -->
<jaxws:outInterceptors>
<bean class="org.apache.cxf.interceptor.LoggingOutInterceptor"></bean>
</jaxws:outInterceptors>
</jaxws:server>
</beans>
步骤四：直接贴上服务类代码
首先是非面向接口编程的服务类：HelloService，对此实现类直接加注解发布，版本1.2；
@WebService
@BindingType(value=SOAPBinding.SOAP12HTTP_BINDING)
public class HelloService {
public String sayHello(String name){
return "hello, " + name;
}
}
面向接口编程，定义接口IHiService，对接口加注解发布，版本1.2：@WebService
@BindingType(value=SOAPBinding.SOAP12HTTP_BINDING)
public interface IHiService {
public String sayHi(String name);
}
服务接口实现类如下：
public class HiServiceImpl implements IHiService {
public String sayHi(String name) {
return "hi, " + name;
}
}
最后还有涉及具体对象的服务发布：
首先定义一个普通javaBean对象Person：
public class Person {
private String id;
private String name;
private String address;
public final String getId() { return id; }
public final String getName() { return name; }
public final String getAddress() { return address; }
public final void setId(String id) { this.id = id; }
public final void setName(String name) { this.name = name; }
public final void setAddress(String address) { this.address = address; }
}
涉及对象Person的服务接口，对接口加注解发布，版本1.2；
@WebService
@BindingType(value=SOAPBinding.SOAP12HTTP_BINDING)
public interface IPersonService {
public Person findPersonById(String id);
}
涉及对象Person对象的服务接口实现类如下：
public class PersonServiceImpl implements IPersonService {
public Person findPersonById(String id) {
Person p = new Person();
p.setId(id);
p.setAddress("江苏省南京市");
p.setName("熊燕子");
return p;
}
}
步骤五：启动发布，验证服务发布成功
如验证Hello服务发布成功，可在启动Tomcat后，在浏览器中输入：http://localhost:8080/Web_WebService_CXF_Server/cxf/，如出现wsdl描述信息，则说明发布成功：
5.2 CXF整合Spring之调用WebService最后在这一节中，面对上面整合Spring发布的三个服务，我使用三种方式进行调用：一是利用wsdl2java生成客户端代码，二是直接把服务端的服务类接口直接拿过来使用，三是利用Spring调用服务。
步骤一：利用wsdl2java命令和服务的wsdl地址生成客户端代码，如下图所示：
通过上述指令，可以生成如下代码：
步骤二：编写客户端调用服务的代码
/**
* 利用wsdl2java命令生成客户端代码，以便调用WebService服务
* @author Administrator
*
*/
public class HelloServiceClient {
public static void main(String[] args) {
HelloServiceService helloServiceService = new HelloServiceService();
HelloService helloService = helloServiceService.getHelloServicePort();
String result = helloService.sayHello("熊燕子");
System.out.println(result);
}
}
步骤三：查看调用结果(略)
步骤二：编写客户端调用代码
/**
* 直接拷贝服务功能接口至客户端，利用JaxWsProxyFactoryBean实现客户端
* @author Administrator
*/
public class HiServiceClient {
public static void main(String[] args) {
JaxWsProxyFactoryBean bean = new JaxWsProxyFactoryBean();
// 设置客户端需要使用服务的地址
bean.setAddress("http://localhost:8080/Web_WebService_CXF_Server/cxf/hi");
// 设置服务接口的类型
bean.setServiceClass(IHiService.class);
// 创建服务接口对象
IHiService hiService = (IHiService) bean.create();
// 调用WebService服务
String result = hiService.sayHi("熊燕子");
System.out.println(result);
}
}
步骤一：在Spring配置文件中配置服务
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:jaxws="http://cxf.apache.org/jaxws" xmlns:jaxrs="http://cxf.apache.org/jaxrs" xmlns:cxf="http://cxf.apache.org/core" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://cxf.apache.org/jaxrs http://cxf.apache.org/schemas/jaxrs.xsd http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd http://cxf.apache.org/core http://cxf.apache.org/schemas/core.xsd"> <jaxws:client id="personService" address="http://localhost:8080/Web_WebService_CXF_Server/cxf/person" serviceClass="com.wj.cxf.service.IPersonService"></jaxws:client> </beans>
步骤二：获取bean对象，调用服务
/**
* 利用Spring来调用服务
* @author Administrator
*/
public class PersonServiceClient {
public static void main(String[] args) {
ApplicationContext ctx = new ClassPathXmlApplicationContext("com/wj/cxf/ClientBeans.xml");
IPersonService s = (IPersonService) ctx.getBean("personService");
Person person = s.findPersonById("1223");
System.out.println("id :" + person.getId());
System.out.println("name :" + person.getName());
System.out.println("address :" + person.getAddress());
}
}
步骤三：查看结果：
代码地址：http://pan.baidu.com/s/1eSDx4bS，密码：qi1n
文章已被作者锁定，不允许评论。
相关推荐
实战Web Service 之 CXF 实战Web Service 之 CXF
实战Web Service with CXF cxf非常好的ppt教程
在Java世界中，Apache CXF是一个广泛使用的框架，它支持创建和消费Web服务。本篇将深入讲解如何利用Apache CXF实现一个简单的"Hello World" Web服务DEMO。 首先，我们需要了解Web服务的基本概念。Web服务是通过SOAP...
Apache CXF是一个开源的Java框架，它用于构建和开发Web服务。这个框架提供了一种灵活的方式来进行服务的创建、发布和调用。"Code-First"是CXF的一个重要概念，意味着开发者首先编写Java代码，然后CXF会自动生成相应...
CXF是一个流行的开源框架，专门用于开发和实现Web服务。CXF框架简化了Web服务的创建过程，提供了高度灵活且易于使用的API，使得开发者可以快速上手。 **CXF框架概述** CXF（Codehaus XFire的后继者）是一个Java库，...
在"Apache CXF开发Web Service理解CXF Frontends之Contract-First"的主题中，我们将深入探讨以下几个关键知识点： 1. **Web服务基础**：Web服务是一种通过网络进行通信的应用程序接口，使用标准协议如SOAP（简单...
1、解压cxf-spring-server文件后发布到tomcat服务器上（服务端） 2、解压cxf-spring-client文件后导入eclipse中运行...说明：在Web Server的服务端及客户端都添加了拦截器，模拟用户登录权限校验
【标题】中的"Apache CXF Web Service Development"指的是使用Apache CXF框架进行Web服务开发的过程。这通常包括了创建服务接口、实现服务逻辑、配置服务端点、以及发布和调用服务等步骤。源码部分可能包含了示例...
CXF是Apache组织提供的一款开源框架，专门用于构建和开发Web服务。本项目主要讲述了如何使用CXF框架来获取第三方天气数据。 首先，我们需要了解CXF的核心概念。CXF提供了一种简单的方式来创建和消费Web服务，支持...
标题"Web Service CXF Spring集成"表明我们将探讨如何在Spring环境中利用Apache CXF来创建和整合Web服务。首先，你需要在项目中引入CXF和Spring的相关依赖。通常，这可以通过在Maven或Gradle的配置文件中添加相应的...
提供的`cxf_service`文件可能包含了CXF运行时所需的集合，如JAXB绑定类、WSDL文件、XSD schema等。这些文件对于构建和运行Web服务至关重要。 **六、客户端调用** 使用Spring的JAX-WS客户端代理工厂...
本篇将深入探讨如何利用CXF来开发Web Service及其客户端，以及相关的重要知识点。 ### 1. CXF简介 Apache CXF是一个全面的服务框架，支持多种Web服务规范，如SOAP、RESTful API、WS-*（如WS-Security、WS-...
CXF提供了多种服务器实现，这些实现被称为CXF Webservers，它们使得部署和运行Web服务变得更加简单。在这个“CXF Webservers资源”中，我们可能涵盖了关于如何使用Apache CXF来搭建和管理Web服务服务器的相关知识。 ...
在"Web Service学习-CXF开发Web Service实例demo（一）"中，我们将专注于SOAP Web Service的实现。以下是一些关键步骤： 1. **创建服务接口**：首先，你需要定义一个Java接口，这个接口会成为你的Web Service接口。...