webService CXF整合spring简易入门

1.webService简介

        webservice是多个系统之间通信的技术，类似技术：dubbo、dubbox、spring cloud。而CXF是实现其技术的框架，它是由Apache提供。

        webService-CXF开发主要分为两种服务提供方式，JAX-WS和JAX-RS。他们底层使用的通信协议不一样。

        JAX-WS全称是JavaTM API forXML-Based Web Services，传输的数据是XML格式，基于SOAP协议。

        JAX-RS全称是 JavaTM API forRESTful Web Services，传输的数据是XML格式或者JSON格式，基于HTTP协议，它是比较主流的RESTful架构风格。(对于JAX-WS和JAX-RW的详细介绍可以参考https://blog.csdn.net/dogiant/article/details/54907506)

2.JAX-WS服务的使用

        1.创建maven java工程

        2.导入cxf  jar包和spring依赖的支持

<!-- CXF WS开发  -->
  		<dependency>
			<groupId>org.apache.cxf</groupId>
			<artifactId>cxf-rt-frontend-jaxws</artifactId>
			<version>3.0.1</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>4.1.7.RELEASE</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-web</artifactId>
			<version>4.1.7.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-test</artifactId>
			<version>4.1.7.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
		</dependency>

        3.配置 web.xml

<!-- spring配置文件位置 -->
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>classpath:applicationContext.xml</param-value>
	</context-param>
	<!-- spring核心监听器 -->
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>
	<!-- CXF 基于 web 访问 -->
	<servlet>
		<servlet-name>CXFService</servlet-name>
		<servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>
		<load-on-startup>1</load-on-startup>
	</servlet>
	<servlet-mapping>
		<servlet-name>CXFService</servlet-name>
		<url-pattern>/services/*</url-pattern>
	</servlet-mapping>

        4.创建只有get和set方法的实体类

public class House {

	private Integer id;
	private String streetNumber;
	private Double price;
//get和set方法省略
}

public class User {
	private Integer id;
	private String username;
	private String city;
	private List<House> houses = new ArrayList<House>();
    //get和set方法省略
}

        5.编写服务

@WebService
public interface IUserService {
	@WebMethod
	public String sayHello(String name);

	@WebMethod
	public List<House> findHouseByUser(User user);
}

@WebService使用在类上，表示此类为服务提供对象

@WebMethod 使用在方法上面，是 WebService 服务提供方法

下面是接口实现类

@WebService(endpointInterface = "com.cz.service.IUserService", serviceName = "userService")
public class UserServiceImpl implements IUserService {

	// 简单参数传递
	public String sayHello(String name) {
		return "Hello," + name;
	}

	// 复杂参数传递
	public List<House> findHouseByUser(User user) {
		if ("cz".equals(user.getUsername())) {
			List<House> houses = new ArrayList<House>();
			House house1 = new House();
			house1.setId(1);
			house1.setStreetNumber("北京长安街");
			house1.setPrice(2000000d);
			houses.add(house1);

			House house2 = new House();
			house2.setId(2);
			house2.setStreetNumber("武汉光谷");
			house2.setPrice(170000d);
			houses.add(house2);

			return houses;
		} else {
			return null;
		}
	}
}

这里@WebService注解设置endpointInterface接口服务完整类名，servicename 服务名称。

        6.配置 spring cxf 服务发布

在applicationContext.xml文件中配置如下：

<?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"
	xsi:schemaLocation="
	http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
	http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd">
	<!-- 
		address 客户端访问服务路径 
		serviceClass 配置接口
		serviceBean 配置实现类 
	 -->
	<jaxws:server id="userService" address="/userService" serviceClass="com.cz.service.IUserService">
		<jaxws:serviceBean>
			<bean class="com.cz.service.UserServiceImpl" />
		</jaxws:serviceBean>
	</jaxws:server>
</beans>

       如上，需要引入名称空间

xmlns:jaxws="http://cxf.apache.org/jaxws"

http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd

       7.配置tomcat启动服务器

此时cxf服务器地址为根路径 + web.xml文件中cxf配置的url-pattern（这里配置的是<url-pattern>/services/*</url-pattern>）+ applicationContext.xml中配置的jaxws:server中的address + ?wsdl。所以这里地址为http://localhost:9001/cxf-ws-server-demo/services/userService?wsdl出现如下：

说明服务启动成功

        6.创建工程，编写客户端（可以在服务端编写测试类）

1)通过wsdl生成实体类和接口类

有两种方式：

           1.通过wsdl2java工具生成，可参考https://blog.csdn.net/dailywater/article/details/52796034

           2.通过jdk生成（可参考https://blog.csdn.net/wenzhi20102321/article/details/68484354），输入wsimport -keep -d d:\\ http://localhost:9001/cxf-ws-server-demo/services/userService?wsdl

如下：

这里生成的文件在d盘，这里没有指定包名，使用的就是根据WSDL文档里面的targetNamespace来命名包名

加入到工程：

编写main方法：

public class ClientMain {

	public static void main(String[] args) {
		// 编写客户端 调用发布WebService服务
		JaxWsProxyFactoryBean jaxWsProxyFactoryBean = new JaxWsProxyFactoryBean();
		jaxWsProxyFactoryBean.setServiceClass(IUserService.class);
		jaxWsProxyFactoryBean.setAddress("http://localhost:9001/userService");
		// 创建调用远程服务代理对象
		IUserService proxy = (IUserService) jaxWsProxyFactoryBean.create();
		// 调用代理对象 任何一个方法，都将通过网络 调用web服务
		System.out.println(proxy.sayHello("--------WebService-----------"));

		//User user = new User();
		//user.setUsername("cz");
		//System.out.println(proxy.findHouseByUser(user));
	}
}

        7.运行客户端代码，看到控制台如下：

这样就通信成功了

3.JAX-RS服务的使用

        1.restful风格简介

       restful是 一种软件架构风格、设计风格，而不是标准，只是提供了一组设计原则和约束条件。它主要用于客户端和服务器交互类的软件。基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制。基于这种风格架构，软件编写可以更简洁
基于 HTTP 协议， 支持多种消息格式，比如 XML 、JSON 更易于实现缓存机制（第一次访问资源 缓存，第二次访问资源，返回 304 客户端调用本地）。

        GET 请求方式访问 查询操作

        POST 请求方式访问 保存操作
        PUT 请求方式访问 修改操作
        DELETE 请求方式访问 删除操作

        2.创建JAX-RS服务工程，导入如下依赖

这里要导入的是rs的坐标和spring相关的包

<!-- cxf 进行rs开发 必须导入 -->
		<dependency>
			<groupId>org.apache.cxf</groupId>
			<artifactId>cxf-rt-frontend-jaxrs</artifactId>
			<version>3.0.1</version>
		</dependency>

		<!-- 日志引入 -->
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-log4j12</artifactId>
			<version>1.7.12</version>
		</dependency>
		<!-- spring 核心 -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>4.1.7.RELEASE</version>
		</dependency>

		<!-- spring web集成 -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-web</artifactId>
			<version>4.1.7.RELEASE</version>
		</dependency>

		<!-- spring 整合junit -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-test</artifactId>
			<version>4.1.7.RELEASE</version>
		</dependency>

		<!-- junit 开发包 -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
		</dependency>

        3.配置web.xml，和WS配置一样

<!-- spring配置文件位置 -->
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>classpath:applicationContext.xml</param-value>
	</context-param>
	<!-- spring核心监听器 -->
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>
<servlet>
		<servlet-name>CXFService</servlet-name>
		<servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>
		<load-on-startup>1</load-on-startup>
	</servlet>
	<servlet-mapping>
		<servlet-name>CXFService</servlet-name>
		<url-pattern>/services/*</url-pattern>
	</servlet-mapping>

        4.创建实体类

@XmlRootElement(name="House")
public class House {

	private Integer id;
	private String streetNumber;
	private Double price;
	public Integer getId() {

        这里要在实体类上加上@XmlRootElement注解，它的作用是转化成xml或json时指定序列化的名字。

        5.编写业务类

@Path("/userService")
@Produces("*/*")
public interface IUserService {
	@POST
	@Path("/user")
	@Consumes({ "application/xml", "application/json" })
	public void saveUser(User user);

	@PUT
	@Path("/user")
	@Consumes({ "application/xml", "application/json" })
	public void updateUser(User user);

	@GET
	@Path("/user")
	@Produces({ "application/xml", "application/json" })
	public List<User> findAllUsers();

	@GET
	@Path("/user/{id}")
	@Consumes("application/xml")
	@Produces({ "application/xml", "application/json" })
	public User finUserById(@PathParam("id") Integer id);

	@DELETE
	@Path("/user/{id}")
	@Consumes("application/xml")
	public void deleteUser(@PathParam("id") Integer id);
}

public class UserServiceImpl implements IUserService {

	public void saveUser(User user) {
		System.out.println("save user:" + user);
	}

	public void updateUser(User user) {
		System.out.println("update user:" + user);
	}

其中@Path是访问资源路径，如上如果要访问saveUser方法，它路径为/userService/user，一般情况下可以不配类上的@Path

@Produces指定返回值格式，例如如上findAllUsers()方法指定返回值格式为xml或json，当然如果没有返回值可以不用加此注解

@Consumes指定传递过来的数据格式，如上指定saveUser方法指定格式为xml或json

而@GET表示 查询， @PUT表示 修改， @POST表示 增加， @DELETE表示 删除

        6.配置applicationContext.xml

<?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:jaxrs="http://cxf.apache.org/jaxrs"
	xsi:schemaLocation="
	http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
	http://cxf.apache.org/jaxrs http://cxf.apache.org/schemas/jaxrs.xsd">

	<!-- 
		address 发布服务地址 
		servicesBeans 服务实现类 
	 -->
	<jaxrs:server id="myService" address="/myService" >
		<jaxrs:serviceBeans>
			<bean class="com.cz.service.UserServiceImpl" />
		</jaxrs:serviceBeans>
		<jaxrs:inInterceptors>
			<bean class="org.apache.cxf.interceptor.LoggingInInterceptor" />
		</jaxrs:inInterceptors>
		<jaxrs:outInterceptors>
			<bean class="org.apache.cxf.interceptor.LoggingOutInterceptor" />
		</jaxrs:outInterceptors>
	</jaxrs:server>
	
</beans>

        这里要引入入名称空间 xmlns:jaxrs="http://cxf.apache.org/jaxrs"
http://cxf.apache.org/jaxrs http://cxf.apache.org/schemas/jaxrs.xsd

此时服务路径为工程路径+web.xml+applicationContext.xml+接口+方法

        7.发布服务

浏览器输入http://localhost:9002/cxf-rs-server-demo/services/myService/userService/user，结果如下：

        6.编写客户端

        RS客户端编写有两种方式:

        1)使用 http client 工具 ，需要自己对 HTTP 协议内容进行定制和解析

        2)WebClient 工具类使用 （CXF 自带）

编写客户端第一步：

1)创建工程，导入如下包：

<!-- 使用rs客户端 -->
		<dependency>
			<groupId>org.apache.cxf</groupId>
			<artifactId>cxf-rt-rs-client</artifactId>
			<version>3.0.1</version>
		</dependency>

2)编写客户端代码：

public class ClientMain {

	public static void main(String[] args) {
		// create 建立与调用 服务资源路径 连接
		// type 发送给服务器数据格式 --- @Consumes
		// accept 接收服务器传输数据格式 ---- @Produces
		// 采用HTTP协议哪种方式访问服务器
		Collection<? extends User> collection = WebClient
			.create("http://localhost:9002/cxf-rs-server-demo/services/myService/userService/user")
			.accept(MediaType.APPLICATION_JSON)//接受json格式
			.getCollection(User.class);
		System.out.println(collection);

	}
}

运行发现结果如下：

Exception in thread "main" javax.ws.rs.client.ResponseProcessingException: No message body reader has been found for class java.util.Collection, ContentType: application/json
    at org.apache.cxf.jaxrs.impl.ResponseImpl.reportMessageHandlerProblem(ResponseImpl.java:433)...

这是因为需要在项目中引入 json 转换器

添加如下依赖:

<!-- 扩展json提供者 -->
		<dependency>
			<groupId>org.apache.cxf</groupId>
			<artifactId>cxf-rt-rs-extension-providers</artifactId>
			<version>3.0.1</version>
		</dependency>
		<!-- 转换json工具包，被extension providers 依赖 -->
		<dependency>
			<groupId>org.codehaus.jettison</groupId>
			<artifactId>jettison</artifactId>
			<version>1.3.7</version>
		</dependency>

再次运行将能在控制台看到结果。

添加User:

// 增加用户
		User user1 = new User();
		user1.setUsername("小明");
		user1.setId(100);
		user1.setCity("武汉");
		WebClient.create("http://localhost:9002/cxf-rs-server-demo/services/myService/userService/user")
			.type("application/xml;charset=utf-8")
			.post(user1);

因为是发送给服务端的数据，这里要用type方法，post方法表示添加，相应的还有put和delete方法。

运行，可以看到服务端控制台如下：

注意点：实体类上要加上@XmlRootElement(name="xxx")注解