欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

基于Spring + CXF框架的Web Service

程序员文章站 2022-04-28 09:50:29
...

1、用CXF编写基于Spring的Web service,也是需要分为Server服务器端、Client客户端的。

  1.1)、Server端,操作步骤,如下所示:

    第一步,创建spring的配置文件beans.xml,在其中配置SEI。
    第二步,在web.xml中,配置上CXF的一些核心组件。

  1.2、Client端,操作步骤,如下所示:

    第一步,生成客户端代码。
    第二步,创建客户端的spring配置文件beans-client.xml,并配置。
    第三步,编写测试类请求web service。

2、创建一个动态web工程,将apache-cxf-2.5.9\lib目录下面的包添加到此动态工程的lib目录下面,然后Build Path一下的哦。如果要看源代码,需要下载对应的src包的,不然无法进行查看源代码的。

创建web.xml配置文件,如下所示:

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
 3     xmlns="http://java.sun.com/xml/ns/javaee" 
 4     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
 5     http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" 
 6     id="WebApp_ID" version="2.5">
 7   <display-name>webServiceCxf_Spring</display-name>
 8   <welcome-file-list>
 9     <welcome-file>index.html</welcome-file>
10     <welcome-file>index.jsp</welcome-file>
11   </welcome-file-list>
12   
13   <!-- 配置beans.xml -->
14   <context-param>
15       <param-name>contextConfigLocation</param-name>
16       <param-value>classpath:beans.xml</param-value>
17    </context-param>
18    <!-- 应用启动的一个监听器 -->
19    <listener>
20       <listener-class>
21          org.springframework.web.context.ContextLoaderListener
22       </listener-class>
23    </listener>
24    
25    <!-- 所有请求都会先经过cxf框架 -->
26    <servlet>
27       <servlet-name>CXFServlet</servlet-name>
28       <servlet-class>
29          org.apache.cxf.transport.servlet.CXFServlet
30       </servlet-class>
31       <load-on-startup>1</load-on-startup>
32    </servlet>
33    <servlet-mapping>
34       <servlet-name>CXFServlet</servlet-name>
35       <url-pattern>/*</url-pattern>
36     </servlet-mapping>
37     
38 </web-app>

创建webservice的接口服务,如下所示:

 1 package com.bie.webservice.ws;
 2 
 3 import javax.jws.WebMethod;
 4 import javax.jws.WebService;
 5 
 6 import com.bie.webservice.bean.Order;
 7 
 8 /**
 9  * 
10  * @author
11  *
12  */
13 @WebService
14 public interface OrderWS {
15 
16     /**
17      * 根据订单号获取到订单信息
18      * 
19      * @param id
20      * @return
21      */
22     @WebMethod
23     public Order getOrderById(int id);
24 
25 }

创建webservice的接口服务实现类,如下所示:

 1 package com.bie.webservice.ws.impl;
 2 
 3 import javax.jws.WebService;
 4 
 5 import com.bie.webservice.bean.Order;
 6 import com.bie.webservice.ws.OrderWS;
 7 
 8 /**
 9  * 
10  * @author 项目部署的时候就创建好了webservice服务了。项目启动就自动部署了webservice了。
11  *
12  */
13 @WebService
14 public class OrderWSImpl implements OrderWS {
15 
16     /**
17      * 从对象什么时候创建呢,结论,项目部署的时候执行了
18      */
19     public OrderWSImpl() {
20         System.out.println("无参构造器执行,OrderWSImpl......");
21     }
22 
23     @Override
24     public Order getOrderById(int id) {
25         System.out.println("Server getOrderById() :  " + id);
26         return new Order(1, "大飞机", 999999999.00);
27     }
28 
29 }

创建一个是实体类,如下所示:

 1 package com.bie.webservice.bean;
 2 
 3 /**
 4  * 
 5  * @author
 6  *
 7  */
 8 public class Order {
 9 
10     private int id;// 订单编号
11     private String name;// 订单名称
12     private Double price;// 订单价格
13 
14     public int getId() {
15         return id;
16     }
17 
18     public void setId(int id) {
19         this.id = id;
20     }
21 
22     public String getName() {
23         return name;
24     }
25 
26     public void setName(String name) {
27         this.name = name;
28     }
29 
30     public Double getPrice() {
31         return price;
32     }
33 
34     public void setPrice(Double price) {
35         this.price = price;
36     }
37 
38     @Override
39     public String toString() {
40         return "Order [id=" + id + ", name=" + name + ", price=" + price + "]";
41     }
42 
43     public Order(int id, String name, Double price) {
44         super();
45         this.id = id;
46         this.name = name;
47         this.price = price;
48     }
49 
50 }

创建beans.xml配置文件,如下所示:

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4     xmlns:jaxws="http://cxf.apache.org/jaxws"
 5     xsi:schemaLocation="http://www.springframework.org/schema/beans 
 6         http://www.springframework.org/schema/beans/spring-beans.xsd
 7         http://cxf.apache.org/jaxws 
 8         http://cxf.apache.org/jaxws">
 9     
10     <!-- 引cxf-2.5.9.jar此包下面的配置,这些配置不在此项目中,cxf的一些核心配置 -->
11     <import resource="classpath:META-INF/cxf/cxf.xml" />
12     <import resource="classpath:META-INF/cxf/cxf-extension-soap.xml" />
13     <import resource="classpath:META-INF/cxf/cxf-servlet.xml" />
14 
15     <!-- 
16         jaxws:endpoint标签配置终端。
17         implementor是实现类。
18         address是虚拟地址。
19      -->
20     <jaxws:endpoint id="orderWS"
21         implementor="com.bie.webservice.ws.impl.OrderWSImpl"
22         address="/orderws">
23         <!-- 
24             <jaxws:inInterceptors> 
25                 <bean class="com.bie.interceptor.CheckUserInterceptor"></bean> 
26             </jaxws:inInterceptors> 
27         -->
28     </jaxws:endpoint>
29 
30 </beans>

项目结构,如下所示:

基于Spring + CXF框架的Web Service

然后可以进行发布了,Run as -> Run on Server,启动项目,项目启动就自动部署了webservice了,可以进行访问,如下所示:

访问地址:http://localhost:8080/webServiceCxf_Spring/orderws?wsdl,其中项目名称后面的地址是beans.xml里面配置的address属性的值。

基于Spring + CXF框架的Web Service

可以使用eclipse自带的web service浏览器进行查看,如下所示:

基于Spring + CXF框架的Web Service

3、然后,创建一个客户端访问的动态web工程,将apache-cxf-2.5.9\lib目录下面的包添加到此动态工程的lib目录下面,然后Build Path一下的哦。如果要看源代码,需要下载对应的src包的,不然无法进行查看源代码的。此时,还是需要借助java自带的工具来生成客户端的代码,如下所示:

基于Spring + CXF框架的Web Service

刷新项目,就可以看到生成的代码了,如下所示:

基于Spring + CXF框架的Web Service

然后创建一个配置文件client-beans.xml,里面需要进行配置webservice的请求地址和所需要生成的动态代理对象。

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4     xmlns:jaxws="http://cxf.apache.org/jaxws"
 5     xsi:schemaLocation="http://www.springframework.org/schema/beans 
 6        http://www.springframework.org/schema/beans/spring-beans.xsd
 7     http://cxf.apache.org/jaxws http://cxf.apache.org/jaxws">
 8 
 9     <!-- 
10         客户端配置:
11         serviceClass根据此类动态产生接口的代理对象。
12         address是指的是webservice请求的地址。
13      -->
14     <jaxws:client id="orderClient"
15         serviceClass="com.bie.webservice.ws.OrderWS"
16         address="http://localhost:8080/webServiceCxf_Spring/orderws">
17 
18         <!-- <jaxws:outInterceptors>
19             <bean class="org.apache.cxf.interceptor.LoggingOutInterceptor" />
20             <bean
21                 class="com.bie.webservice.ws.interceptor.AddUserInterceptor">
22                 <constructor-arg name="name" value="张姗姗" />
23                 <constructor-arg name="password" value="123456" />
24             </bean>
25         </jaxws:outInterceptors> -->
26     </jaxws:client>
27 
28 </beans>

最后搞一个客户端的访问类,就可以进行运行了,如下所示:

 1 package com.bie.webservice.ws.client;
 2 
 3 import org.springframework.context.support.ClassPathXmlApplicationContext;
 4 
 5 import com.bie.webservice.ws.Order;
 6 import com.bie.webservice.ws.OrderWS;
 7 
 8 /**
 9  * 
10  * @author 客户端访问webservice的代码
11  *
12  */
13 public class ClientCxfSpring {
14 
15     public static void main(String[] args) {
16         ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(
17                 new String[] { "client-beans.xml" });
18         OrderWS orderWS = (OrderWS) context.getBean("orderClient");
19         Order order = orderWS.getOrderById(1);
20         System.out.println(order);
21     }
22 
23 }

4、如何在此基础上添加自定义拦截器,步骤如下所示:

第一步,Server端,在beans.xml中,在endpoint中配置上入拦截器。

 1 package com.bie.webservice.interceptor;
 2 
 3 import javax.xml.namespace.QName;
 4 
 5 import org.apache.cxf.binding.soap.SoapMessage;
 6 import org.apache.cxf.headers.Header;
 7 import org.apache.cxf.interceptor.Fault;
 8 import org.apache.cxf.phase.AbstractPhaseInterceptor;
 9 import org.apache.cxf.phase.Phase;
10 import org.w3c.dom.Element;
11 import org.w3c.dom.Node;
12 
13 /**
14  * 查检用户的拦截器
15  * 
16  * @author
17  *
18  */
19 
20 public class CheckUserInterceptor extends AbstractPhaseInterceptor<SoapMessage> {
21 
22     private static final String name = "张姗姗";
23     private static final String password = "123456";
24     
25     public CheckUserInterceptor() {
26         super(Phase.PRE_PROTOCOL);
27         System.out.println("CheckUserInterceptor()");
28     }
29 
30     /**
31      * 请求体,服务器端需要解析请求头信息
32      * 
33      * <soap:Envelope> 
34      *     <head>
35      *         <zhangsansan>
36      *             <name>zhangsansan</name>
37      *             <password>123456</password>
38      *         </zhangsansan>
39      *  </head>
40      *     <Body> 
41      *         <sayHello> 
42      *             <arg0>张姗姗</arg0> 
43      *         </sayHello> 
44      *     </Body>
45      * </soap:Envelope>
46      */
47     @Override
48     public void handleMessage(SoapMessage soapMessage) throws Fault {
49         // 获取到请求头的信息
50         QName qName = QName.valueOf("zhangsansan");
51         // 获取到请求头
52         Header header = soapMessage.getHeader(qName);
53         // 判断是否为空
54         if(header != null) {
55             // 获取到对象,强转为w3c的元素标签
56             Element element = (Element) header.getObject();
57             // 获取到name标签的值
58             Node nameNode = element.getElementsByTagName("name").item(0);
59             // 获取到name的值
60             String nameValue = nameNode.getTextContent();
61             // 获取到pasword标签的值
62             Node passwordNode = element.getElementsByTagName("password").item(0);
63             // 获取到pasword的值
64             String paswordValue = passwordNode.getTextContent();
65             // 开始进行判断
66             if(CheckUserInterceptor.name.equals(nameValue) && CheckUserInterceptor.password.equals(paswordValue)) {
67                 System.out.println("Server 通过拦截器......");
68                 return;
69             }
70         }
71         // 如果不能通过
72         System.out.println("Sorry Server 不通过拦截器......");
73         // 抛出异常信息
74         throw new Fault(new RuntimeException("账号密码错误......"));
75     }
76 
77 }

然后在服务器端的beans.xml进行配置,如下所示:

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4    xmlns:jaxws="http://cxf.apache.org/jaxws"
 5    xsi:schemaLocation="http://www.springframework.org/schema/beans 
 6    http://www.springframework.org/schema/beans/spring-beans.xsd
 7         http://cxf.apache.org/jaxws http://cxf.apache.org/jaxws">
 8     
 9     <!-- 引cxf-2.5.9.jar此包下面的配置,这些配置不在此项目中,cxf的一些核心配置 -->
10     <import resource="classpath:META-INF/cxf/cxf.xml" />
11     <import resource="classpath:META-INF/cxf/cxf-extension-soap.xml" />
12     <import resource="classpath:META-INF/cxf/cxf-servlet.xml" />
13 
14     <!-- 
15         jaxws:endpoint标签配置终端。
16         implementor是实现类。
17         address是虚拟地址。
18      -->
19     <jaxws:endpoint id="orderWS"
20         implementor="com.bie.webservice.ws.impl.OrderWSImpl"
21         address="/orderws">
22             <!-- 服务器端配置入拦截器 -->
23             <jaxws:inInterceptors> 
24                 <!-- 配置自定义的拦截器,注入到ioc容器中 -->
25                 <bean class="com.bie.webservice.interceptor.CheckUserInterceptor"></bean> 
26             </jaxws:inInterceptors> 
27     </jaxws:endpoint>
28 
29 </beans>

如果开发完毕,重启项目,报下面的错误,我的操作是clean项目,清空tomcat下面的项目,清空tomcat,重启项目解决的。

1 cvc-complex-type.2.4.c: 通配符的匹配很全面, 但无法找到元素 'context:property-placeholder' 的声明

第二步,Client端,通过Client对象设置出拦截器。

  1 package com.bie.webservice.ws.interceptor;
  2 
  3 import java.util.List;
  4 
  5 import javax.xml.namespace.QName;
  6 import javax.xml.parsers.DocumentBuilder;
  7 import javax.xml.parsers.DocumentBuilderFactory;
  8 import javax.xml.parsers.ParserConfigurationException;
  9 
 10 import org.apache.cxf.binding.soap.SoapMessage;
 11 import org.apache.cxf.headers.Header;
 12 import org.apache.cxf.interceptor.Fault;
 13 import org.apache.cxf.phase.AbstractPhaseInterceptor;
 14 import org.apache.cxf.phase.Phase;
 15 import org.apache.xml.utils.DOMHelper;
 16 import org.w3c.dom.Document;
 17 import org.w3c.dom.Element;
 18 
 19 /**
 20  * 
 21  * @author 拦截的是某一个消息,所以泛型是SoapMessage
 22  *
 23  */
 24 public class ClientValidateUserInterceptor extends AbstractPhaseInterceptor<SoapMessage> {
 25 
 26     private String name;// 账号
 27     private String password;// 密码
 28 
 29     /**
 30      * 此构造器是关键点,决定了什么时候拦截器会拦截到消息
 31      * 
 32      * @param phase
 33      */
 34     public ClientValidateUserInterceptor(String name, String password) {
 35         // 准备协议化的时候进行拦截调用
 36         super(Phase.PRE_PROTOCOL);
 37         this.name = name;
 38         this.password = password;
 39         System.out.println("Client 客户端,拦截器初始化......");
 40     }
 41 
 42     /**
 43      * 请求体
 44      * 
 45      * <soap:Envelope> 
 46      *     <head>
 47      *         <zhangsansan>
 48      *             <name>zhangsansan</name>
 49      *             <password>123456</password>
 50      *         </zhangsansan>
 51      *  </head>
 52      *     <Body> 
 53      *         <sayHello> 
 54      *             <arg0>张姗姗</arg0> 
 55      *         </sayHello> 
 56      *     </Body>
 57      * </soap:Envelope>
 58      */
 59     @Override
 60     public void handleMessage(SoapMessage soapMessage) throws Fault {
 61         // 获取到头信息,向头部信息设置值
 62         List<Header> headers = soapMessage.getHeaders();
 63         // 此时需要构造这种结构的数据
 64 //        <zhangsansan>
 65 //            <name>zhangsansan</name>
 66 //            <password>123456</password>
 67 //        </zhangsansan>
 68         
 69         // 第一步:初始化一个XML解析工厂
 70         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
 71         // 第二步:创建一个DocumentBuilder实例
 72         DocumentBuilder builder = null;
 73         try {
 74             builder = factory.newDocumentBuilder();
 75         } catch (ParserConfigurationException e) {
 76             // TODO Auto-generated catch block
 77             e.printStackTrace();
 78         }
 79         // 第三步:构建一个Document实例
 80         Document doc = builder.newDocument();
 81         // standalone用来表示该文件是否呼叫其它外部的文件。若值是 ”yes” 表示没有呼叫外部文件
 82         doc.setXmlStandalone(true);
 83         // 第四步:创建一个根节点,名称为root,并设置一些基本属性,创建标签
 84         Element rootElement = doc.createElement("zhangsansan");
 85         // 设置节点属性
 86         // rootElement.setAttribute("attr", "root");
 87         // 设置标签之间的内容
 88         // rootElement.setTextContent("root attr");
 89         
 90         // 开始设置<zhangsansan>下面的标签<name>zhangsansan</name>
 91         Element nameElement = doc.createElement("name");
 92         nameElement.setTextContent(this.name);
 93         // 第五步:把节点添加到Document中,再创建一些子节点加入,将子标签添加到父标签中
 94         rootElement.appendChild(nameElement);
 95         
 96         // 开始设置<zhangsansan>下面的标签<name>zhangsansan</name>
 97         Element passwordElement = doc.createElement("password");
 98         passwordElement.setTextContent(this.password);
 99         // 第五步:把节点添加到Document中,再创建一些子节点加入,将子标签添加到父标签中
100         rootElement.appendChild(passwordElement);
101         
102         // 第六步:把构造的XML结构,写入到具体的文件中
103         // 参数一QName起一个唯一的名字,这个名称必须和rootElement标签的值必须一样
104         // 参数二就是rootElement根节点
105         Header header = new Header(new QName("zhangsansan"), rootElement);
106         // 将此请求体和构建的请求头发送给服务器端
107         headers.add(header);
108         
109         System.out.println("Client handleMessage Interceptor......");
110         
111         // DOMHelper.createDocument()方法过期了
112         // Document createDocument = DOMHelper.createDocument();
113     }
114 
115 }

然后在客户端的beans.xml进行配置,如下所示:

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4     xmlns:jaxws="http://cxf.apache.org/jaxws"
 5     xsi:schemaLocation="http://www.springframework.org/schema/beans 
 6        http://www.springframework.org/schema/beans/spring-beans.xsd
 7     http://cxf.apache.org/jaxws http://cxf.apache.org/jaxws">
 8 
 9     <!-- 
10         客户端配置:
11         serviceClass根据此类动态产生接口的代理对象。
12         address是指的是webservice请求的地址。
13      -->
14     <jaxws:client id="orderClient"
15         serviceClass="com.bie.webservice.ws.OrderWS"
16         address="http://localhost:8080/webServiceCxf_Spring/orderws">
17 
18         <!-- 客户端配置出拦截器类 -->
19         <jaxws:outInterceptors>
20             <!-- <bean class="org.apache.cxf.interceptor.LoggingOutInterceptor" /> -->
21             <bean
22                 class="com.bie.webservice.ws.interceptor.ClientValidateUserInterceptor">
23                 <!-- 通过构造参数传递给客户端拦截器类 -->
24                 <constructor-arg name="name" value="张姗姗" />
25                 <constructor-arg name="password" value="123456" />
26             </bean>
27         </jaxws:outInterceptors>
28     </jaxws:client>
29 
30 </beans>

使用tomcat启动服务端,然后客户端访问服务端,效果如下所示:

基于Spring + CXF框架的Web Service