1、CXF框架的深入使用，CXF的拦截器，为什么设计CXF拦截器？
答：为了在webservice请求过程中，能动态操作请求和响应数据,，CXF设计了拦截器。
2、CXF的拦截器分类：
1）、按所处的位置分：服务器端拦截器，客户端拦截器。
2）、按消息的方向分：入拦截器，出拦截器。
3）、按定义者分：系统拦截器，自定义拦截器。
3、使用拦截器就可以不适用tcp/ip监控的工具了，因为此监控工具还需要将wsdl文件下载到本地，然后修改端口才能进行监控。
将apache-cxf-2.5.9\lib里面的包导入到项目中，然后编写SEI(Service Endpoint Interface)，SEI在webservice中称为portType，在java中就是普通接口。
1 package com.bie.webservice.sei;
2
3 import javax.jws.WebMethod;
4 import javax.jws.WebService;
5
6 /**
7 *
8 * @author
9 * 编写SEI(Service Endpoint Interface)，SEI在webservice中称为portType，在java中就是普通接口 。
10 *
11 * 1、第一步，开发服务器端，Web Service编码。
12 * –@WebService(SEI和SEI的实现类)，该注解用来定义SEI和SEI的实现类。
13 * –@WebMethod(SEI中的所有方法)，该注解用来定义SEI里面的方法。
14 * 2、第二步，发布Web Service，–Endpoint(终端, 发布webservice)。
15 */
16 @WebService
17 public interface HelloWebServiceSEI {
18
19 @WebMethod
20 public String sayHello(String name);
21
22 }
然后编写SEI实现类，如下所示：
1 package com.bie.webservice.sei.impl;
2
3 import javax.jws.WebService;
4
5 import com.bie.webservice.sei.HelloWebServiceSEI;
6
7 /**
8 *
9 * @author
10 *
11 * 1、SEI实现类
12 *
13 *
14 */
15 @WebService // SEI实现类也要使用此注解
16 public class HelloWebServiceSEIImpl implements HelloWebServiceSEI {
17
18 @Override
19 public String sayHello(String name) {
20 System.out.println("Service server sayHello() : " + name);
21 return "hello " + name;
22 }
23
24 }
发布WebService，Endpoint(终端, 发布webservice)，可以在服务器端编写拦截器，此拦截器可以替换掉tcp/ip监控工具。
1 package com.bie.webservice.endpoint;
2
3 import java.util.List;
4
5 import javax.xml.ws.Endpoint;
6
7 import org.apache.cxf.interceptor.Interceptor;
8 import org.apache.cxf.interceptor.LoggingInInterceptor;
9 import org.apache.cxf.interceptor.LoggingOutInterceptor;
10 import org.apache.cxf.jaxws22.EndpointImpl;
11 import org.apache.cxf.message.Message;
12
13 import com.bie.webservice.sei.HelloWebServiceSEI;
14 import com.bie.webservice.sei.impl.HelloWebServiceSEIImpl;
15
16 /**
17 *
18 * @author 1、发布WebService，Endpoint(终端, 发布webservice)。
19 *
20 */
21 public class WebServiceEndpoint {
22
23 public static void main(String[] args) {
24 // 使用Endpoint发布webservice
25 // 参数一，url地址
26 String address = "http://localhost:8888/webservice/hello";
27 // 参数二，是SEI实现类对象
28 HelloWebServiceSEI implementor = new HelloWebServiceSEIImpl();
29 // 终端
30 Endpoint endpoint = Endpoint.publish(address, implementor);
31 System.out.println(endpoint.toString());
32
33 // 将Endpoint转换为EndpointImpl，使用更多的实现方法
34 EndpointImpl endpointImpl = (EndpointImpl) endpoint;
35 // 如果要添加拦截器，是使用终端Endpoint来添加拦截器的，这里使用EndpointImpl来添加拦截器
36 // 添加服务器端的入拦截器
37 List<Interceptor<? extends Message>> inInterceptors = endpointImpl.getInInterceptors();
38 // 向拦截器集合中添加拦截器，添加服务器端的日志入拦截器
39 inInterceptors.add(new LoggingInInterceptor());
40
41 // 添加服务器端的日志出拦截器
42 List<Interceptor<? extends Message>> outInterceptors = endpointImpl.getOutInterceptors();
43 // 向拦截器集合中添加拦截器，添加服务器端的日志出拦截器
44 outInterceptors.add(new LoggingOutInterceptor());
45
46 System.out.println("使用Endpoint发布webservice,发布成功Success......");
47 }
48
49 }
可以使用eclipse的web service浏览器进行测试，查看入拦截器和出拦截器的请求和相应参数是什么，如下所示：
输入请求参数之后，就可以在控制台查看请求信息和响应信息，如下所示：
同样，在客户端也可以进行入拦截器和出拦截器的配置，客户端的代码可以使用java的工具脚本wsimport自动生成的，这里省略了，同样，需要将apache-cxf-2.5.9\lib里面的包导入到客户端项目中，如下所示：
1 package com.bie.webservice.sei.client;
2
3 import java.util.List;
4
5 import org.apache.cxf.endpoint.Client;
6 import org.apache.cxf.frontend.ClientProxy;
7 import org.apache.cxf.interceptor.Interceptor;
8 import org.apache.cxf.interceptor.LoggingInInterceptor;
9 import org.apache.cxf.interceptor.LoggingOutInterceptor;
10 import org.apache.cxf.message.Message;
11
12 import com.bie.webservice.sei.HelloWebServiceSEI;
13 import com.bie.webservice.sei.impl.HelloWebServiceSEIImplService;
14
15 public class WebServiceCxfClient {
16
17 public static void main(String[] args) {
18 // 根据标签进行创建类<wsdl:service name="HelloWebServiceSEIImplService">
19 HelloWebServiceSEIImplService factory = new HelloWebServiceSEIImplService();
20 // 根据绑定的type为返回类型，<wsdl:binding name="HelloWebServiceSEIImplServiceSoapBinding"
21 // type="ns1:HelloWebServiceSEI">
22 HelloWebServiceSEI helloWebServiceSEI = factory.getHelloWebServiceSEIImplPort();
23
24 // 服务器端使用的是终端EndPoint来进行添加拦截器的
25 // 客户端是是使用的ClientProxy来获取到Client，Client即发送请求的客户端对象
26 Client client = ClientProxy.getClient(helloWebServiceSEI);
27 // 客户端的日志出拦截器
28 List<Interceptor<? extends Message>> outInterceptors = client.getOutInterceptors();
29 // 向集合中添加出拦截器
30 outInterceptors.add(new LoggingOutInterceptor());
31
32 // 客户端的日志入拦截器
33 List<Interceptor<? extends Message>> inInterceptors = client.getInInterceptors();
34 // 向集合中添加入拦截器
35 inInterceptors.add(new LoggingInInterceptor());
36
37 // 调用业务方法
38 String sayHello = helloWebServiceSEI.sayHello("张姗姗");
39 System.out.println("client : " + sayHello);
40 }
41
42 }
客户端请求，入拦截器和出拦截器，已经请求方法返回信息打印的结果，如下所示：
4、CXF的拦截器API。
1）、Interceptor(拦截器接口)。
2）、AbstractPhaseInterceptor(自定义拦截器从此继承)。
3）、LoggingInInterceptor(系统日志入拦截器类)。使用日志拦截器，可以实现日志记录，日志拦截器有LoggingInInterceptor，LoggingOutInterceptor。
4）、LoggingOutInterceptor(系统日志出拦截器类)。使用日志拦截器，可以实现日志记录，日志拦截器有LoggingInInterceptor，LoggingOutInterceptor。
5、使用自定义拦截器，实现用户名与密码的检验，对于客户端的出拦截器，入拦截器，服务器端的入拦截器，出拦截器如何进行添加拦截器进行账号密码校验呢？
答：需要在服务器端的in拦截器，客户端的out拦截器添加拦截器进行校验。
首先搞一个客户端的出拦截器，进行拦截，如下所示：
1 package com.bie.webservice.sei.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 }
40
41 /**
42 * 请求体
43 *
44 * <soap:Envelope>
45 * <head>
46 * <zhangsansan>
47 * <name>zhangsansan</name>
48 * <password>123456</password>
49 * </zhangsansan>
50 * </head>
51 * <Body>
52 * <sayHello>
53 * <arg0>张姗姗</arg0>
54 * </sayHello>
55 * </Body>
56 * </soap:Envelope>
57 */
58 @Override
59 public void handleMessage(SoapMessage soapMessage) throws Fault {
60 // 获取到头信息，向头部信息设置值
61 List<Header> headers = soapMessage.getHeaders();
62 // 此时需要构造这种结构的数据
63 // <zhangsansan>
64 // <name>zhangsansan</name>
65 // <password>123456</password>
66 // </zhangsansan>
67
68 // 第一步：初始化一个XML解析工厂
69 DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
70 // 第二步：创建一个DocumentBuilder实例
71 DocumentBuilder builder = null;
72 try {
73 builder = factory.newDocumentBuilder();
74 } catch (ParserConfigurationException e) {
75 // TODO Auto-generated catch block
76 e.printStackTrace();
77 }
78 // 第三步：构建一个Document实例
79 Document doc = builder.newDocument();
80 // standalone用来表示该文件是否呼叫其它外部的文件。若值是 ”yes” 表示没有呼叫外部文件
81 doc.setXmlStandalone(true);
82 // 第四步：创建一个根节点，名称为root，并设置一些基本属性，创建标签
83 Element rootElement = doc.createElement("zhangsansan");
84 // 设置节点属性
85 // rootElement.setAttribute("attr", "root");
86 // 设置标签之间的内容
87 // rootElement.setTextContent("root attr");
88
89 // 开始设置<zhangsansan>下面的标签<name>zhangsansan</name>
90 Element nameElement = doc.createElement("name");
91 nameElement.setTextContent(this.name);
92 // 第五步：把节点添加到Document中，再创建一些子节点加入，将子标签添加到父标签中
93 rootElement.appendChild(nameElement);
94
95 // 开始设置<zhangsansan>下面的标签<name>zhangsansan</name>
96 Element passwordElement = doc.createElement("password");
97 passwordElement.setTextContent(this.password);
98 // 第五步：把节点添加到Document中，再创建一些子节点加入，将子标签添加到父标签中
99 rootElement.appendChild(passwordElement);
100
101 // 第六步：把构造的XML结构，写入到具体的文件中
102 // 参数一QName起一个唯一的名字，这个名称必须和rootElement标签的值必须一样
103 // 参数二就是rootElement根节点
104 Header header = new Header(new QName("zhangsansan"), rootElement);
105 // 将此请求体和构建的请求头发送给服务器端
106 headers.add(header);
107
108 System.out.println("Client handleMessage Interceptor......");
109
110 // DOMHelper.createDocument()方法过期了
111 // Document createDocument = DOMHelper.createDocument();
112 }
113
114 }
然后在客户端新增自定义的出拦截器，验证账号密码信息，如下所示：
1 package com.bie.webservice.sei.client;
2
3 import java.util.List;
4
5 import org.apache.cxf.endpoint.Client;
6 import org.apache.cxf.frontend.ClientProxy;
7 import org.apache.cxf.interceptor.Interceptor;
8 import org.apache.cxf.message.Message;
9
10 import com.bie.webservice.sei.HelloWebServiceSEI;
11 import com.bie.webservice.sei.impl.HelloWebServiceSEIImplService;
12 import com.bie.webservice.sei.interceptor.ClientValidateUserInterceptor;
13
14 public class WebServiceCxfClient2 {
15
16 public static void main(String[] args) {
17 // 根据标签进行创建类<wsdl:service name="HelloWebServiceSEIImplService">
18 HelloWebServiceSEIImplService factory = new HelloWebServiceSEIImplService();
19 // 根据绑定的type为返回类型，<wsdl:binding name="HelloWebServiceSEIImplServiceSoapBinding"
20 // type="ns1:HelloWebServiceSEI">
21 HelloWebServiceSEI helloWebServiceSEI = factory.getHelloWebServiceSEIImplPort();
22
23 // 服务器端使用的是终端EndPoint来进行添加拦截器的
24 // 客户端是是使用的ClientProxy来获取到Client，Client即发送请求的客户端对象
25 Client client = ClientProxy.getClient(helloWebServiceSEI);
26 // 账号密码的校验，要使用的是客户端的出拦截器
27 List<Interceptor<? extends Message>> outInterceptors = client.getOutInterceptors();
28 // 向集合中添加自定义的出拦截器
29 String name = "张姗姗";
30 String password = "123456";
31 outInterceptors.add(new ClientValidateUserInterceptor(name, password));
32
33 // 调用业务方法
34 String sayHello = helloWebServiceSEI.sayHello("张姗姗");
35 System.out.println("client : " + sayHello);
36 }
37
38 }
然后搞一个服务器端的入拦截器，验证账号密码是否正常，如下所示：
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 * @author 服务器端的自定义入拦截器
16 *
17 */
18 public class ServerValidateUserInterceptor extends AbstractPhaseInterceptor<SoapMessage> {
19
20 private static final String name = "张姗姗";
21 private static final String password = "123456";
22
23 public ServerValidateUserInterceptor() {
24 // 准备协议化的时候进行拦截调用
25 super(Phase.PRE_PROTOCOL);
26 }
27
28 /**
29 * 请求体，服务器端需要解析请求头信息
30 *
31 * <soap:Envelope>
32 * <head>
33 * <zhangsansan>
34 * <name>zhangsansan</name>
35 * <password>123456</password>
36 * </zhangsansan>
37 * </head>
38 * <Body>
39 * <sayHello>
40 * <arg0>张姗姗</arg0>
41 * </sayHello>
42 * </Body>
43 * </soap:Envelope>
44 */
45 @Override
46 public void handleMessage(SoapMessage soapMessage) throws Fault {
47 // 获取到请求头的信息
48 QName qName = QName.valueOf("zhangsansan");
49 // 获取到请求头
50 Header header = soapMessage.getHeader(qName);
51 // 判断是否为空
52 if(header != null) {
53 // 获取到对象，强转为w3c的元素标签
54 Element element = (Element) header.getObject();
55 // 获取到name标签的值
56 Node nameNode = element.getElementsByTagName("name").item(0);
57 // 获取到name的值
58 String nameValue = nameNode.getTextContent();
59 // 获取到pasword标签的值
60 Node passwordNode = element.getElementsByTagName("password").item(0);
61 // 获取到pasword的值
62 String paswordValue = passwordNode.getTextContent();
63 // 开始进行判断
64 if(ServerValidateUserInterceptor.name.equals(nameValue) && ServerValidateUserInterceptor.password.equals(paswordValue)) {
65 System.out.println("Server 通过拦截器......");
66 return;
67 }
68 }
69 // 如果不能通过
70 System.out.println("Sorry Server 不通过拦截器......");
71 // 抛出异常信息
72 throw new Fault(new RuntimeException("账号密码错误......"));
73 }
74
75 }
然后在服务器端添加自定义的入拦截器，如下所示：
1 package com.bie.webservice.endpoint;
2
3 import java.util.List;
4
5 import javax.xml.ws.Endpoint;
6
7 import org.apache.cxf.interceptor.Interceptor;
8 import org.apache.cxf.jaxws22.EndpointImpl;
9 import org.apache.cxf.message.Message;
10
11 import com.bie.webservice.interceptor.ServerValidateUserInterceptor;
12 import com.bie.webservice.sei.HelloWebServiceSEI;
13 import com.bie.webservice.sei.impl.HelloWebServiceSEIImpl;
14
15 /**
16 *
17 * @author 1、发布WebService，Endpoint(终端, 发布webservice)。
18 *
19 */
20 public class WebServiceEndpoint2 {
21
22 public static void main(String[] args) {
23 // 使用Endpoint发布webservice
24 // 参数一，url地址
25 String address = "http://localhost:8888/webservice/hello";
26 // 参数二，是SEI实现类对象
27 HelloWebServiceSEI implementor = new HelloWebServiceSEIImpl();
28 // 终端
29 Endpoint endpoint = Endpoint.publish(address, implementor);
30 System.out.println(endpoint.toString());
31
32 // 将Endpoint转换为EndpointImpl，使用更多的实现方法
33 EndpointImpl endpointImpl = (EndpointImpl) endpoint;
34 // 如果要添加拦截器，是使用终端Endpoint来添加拦截器的，这里使用EndpointImpl来添加拦截器
35 // 添加服务器端的入拦截器
36 List<Interceptor<? extends Message>> inInterceptors = endpointImpl.getInInterceptors();
37 // 向拦截器集合中添加拦截器，添加服务器端的账号密码验证的入拦截器
38 inInterceptors.add(new ServerValidateUserInterceptor());
39
40 System.out.println("使用Endpoint发布webservice,发布成功Success......");
41 }
42
43 }
启动服务器端服务，然后启动客户端服务，分别输入正确的账号密码，和错误的账号密码进行验证。