前言：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
文章已被作者锁定，不允许评论。
相关推荐
本文档详细介绍了如何使用Eclipse IDE结合CXF进行Web Service开发，从环境配置到创建并部署HelloWorld示例，再到客户端的开发，涵盖了一系列关键步骤。 ### 环境配置 1. **Eclipse的安装**：首先需要下载并安装...
【XFire建立Webservice实例详解】对于初学者来...虽然XFire目前已经不再是最主流的Web Service框架，但它提供了一个简洁的学习入口，帮助初学者理解Web Service的核心概念，为后续学习其他框架如Axis2、CXF等奠定基础。
首先，Web Service的实现框架众多，如AXIS、CXF、JAX-RPC（JAX）、XFire等。这些框架都能根据WSDL（Web Service Description Language）文件自动生成服务端和客户端的代码，使得开发更加便捷。WSDL文件定义了服务的...
- **创建Webservice项目**：在Myeclipse中，可以通过新建一个动态Web项目，然后选择“New -> Web Service”来创建Webservice。你需要选择服务实现类（一个包含了业务逻辑的方法的Java类）和相应的服务端口。 - **...
stm32+esp8266+mqtt/onenet智能家居
Android开发不用存储权限进行拍照，得到拍照后的图片效果。有一点难度，关键是存储路径的定义。
j
反向Lora提高画面细节。
小秘书（凤凰电话管理系统）【纽曼声卡版小秘书】，主要用来做为来电自动录音功能。
基于SpringBoot的疫情居家检测管理系统，系统包含三种角色：管理员、用户、医生，主要功能如下。 【用户功能】 1. 首页：获取系统信息。 2. 论坛：参与居民讨论和分享信息。 3. 公告：查看社区发布的各类公告。 4. 医保信息：了解医疗保障相关信息。 5. 个人中心：管理个人信息，查看预约和就诊历史。 【管理员功能】 1. 首页：查看系统整体。 2. 个人中心：管理管理员的个人信息。 3. 管理员管理：维护系统管理员的账户信息。 4. 医生管理：添加、编辑和删除医生信息。 5. 用户管理：查看和管理系统用户的信息。 6. 预约管理：审核和管理用户对医生的预约服务。 7. 就诊历史管理：查看和管理用户的就诊历史记录。 8. 健康信息管理：记录和查看用户的健康信息。 9. 药品管理：管理系统内的药品种类。 10. 药品入库管理：记录和管理药品的入库情况。 11. 药品使用管理：记录和管理药品的使用情况。 12. 医保信息管理：管理医保相关信息。 13. 论坛管理：审核和回复用户在论坛上的帖子。 14. 公告管理：发布、编辑和管理公告信息。 15. 基础数据管理：管理系统的基础数据。 16. 轮播图信息：管理系统首页的轮播图展示。 【医生功能】 1. 首页：查看医生个人信息。 2. 个人中心：管理医生的个人信息。 3. 预约管理：查看和管理用户对医生的预约服务。 4. 就诊历史管理：查看和管理用户的就诊历史记录。 5. 健康信息管理：记录和查看用户的健康信息。 6. 药品管理：管理系统内的药品种类。 7. 药品入库管理：记录和管理药品的入库情况。 8. 药品使用管理：记录和管理药品的使用情况。 9. 医保信息管理：管理医保相关信息。 10. 论坛管理：审核和回复用户在论坛上的帖子。 11. 公告管理：发布、编辑和管理公告信息。 12. 轮播图信息：管理系统首页的轮播
基于python的Opencv项目实战.zip
鸿蒙开发画廊效果功能，中间大，两边小的浏览效果，难度不小，进行了一定的封装。很好看的画廊效果
win32汇编环境,网络编程入门之十九
linux
【HD-RK3576-PI】定制用户升级固件
内容概要：本文是关于大规模L1正则化线性分类优化方法和软件比较的补充材料，由台湾大学计算机科学系的研究团队撰写。文章详细介绍了GLMNET算法的核心公式推导及其具体实现步骤，包括如何计算L¯j(0; X˜)，以及如何维护关键变量以减少计算量。此外，文中对比了多种求解器（如CDN、IPM、TRON等）在不同数据集上的性能，涵盖达到特定停止准则所需时间、迭代次数及每次迭代的平均成本。研究结果显示，在大多数数据集上，CDN方法表现最优，但在极严格的条件下，IPM方法表现更好。对于L1和L2正则化的逻辑回归，文中指出L1正则化在某些数据类型上可能提供更好的准确性，但训练时间较长，因此推荐先尝试L2正则化用于分类任务，而L1正则化更适合特征选择。 适合人群：对机器学习算法尤其是正则化技术有一定了解的数据科学家和研究人员。 使用场景及目标：①需要进行大规模线性分类问题的优化；②比较不同优化方法和工具包在实际应用中的效果；③理解L1和L2正则化在逻辑回归中的区别及其适用情况。 其他说明：本文提供了详细的数学推导和实验结果分析，有助于深入理解各种优化方法的工作原理及其优劣。读者可以通过这些内容选择最适合自身需求的算法和工具包。
西电A测或通院微控温度仿真控制系统的proteus文件
华为ONT使能2.0工具
basalt_top
无极调速数控车床主轴箱装配CAD图.rar