CXF拦截器（Interceptor）LoggingInInterceptor

Interceptor是CXF架构中一个重要的功能。你可以在不对核心模块进行修改的情况下，动态添加很多功能（你可以想象Struts2拦截器的优点）。这对于CXF这个以处理消息为中心的服务框架来说是非常有用的，CXF通过在Interceptor中对消息进行特殊处理，实现了很多重要功能模块，例如：日志记录，Soap消息处理，消息的压缩处理。

CXF已经实现了很多种拦截器，很多已经在发布、访问Web 服务时已经默认添加到拦截器链。一般情况下， 我们自己的拦截器只要继承AbstractPhaseInterceptor<T extends org.apache.cxf.message.Message>类即可，这个类可以指定继承它的拦截器在什么阶段被启用，阶段属性可以通过org.apache.cxf.phase.Phase 中的常量指定值。

下面简单通过实例来表述一下CXF拦截器功能；

一、拦截器实现

1、拦截器的代码实现

1. public class HelloInInterceptor extends AbstractPhaseInterceptor<Message> {
2. public HelloInInterceptor(String phase) {
3. super(phase);
4. }
5. public HelloInInterceptor() {
6. super(Phase.RECEIVE);
7. }
8. /** <功能详细描述>
9. * 创 建 人:  XX
10. * 创建时间:  2012-9-28 下午02:34:07
11. * @param arg0
12. * @throws Fault
13. * @see [类、类#方法、类#成员]
14. */
15. public void handleMessage(Message message) throws Fault {
16. System.out.println("*********In****Helloworld******");
17. }
18. }

注意：你要注意CXF 中的拦截器编写时不要只针对服务端或者客户端，应该是两者均可使用，另外名字要见名知意。例如：使用In、Out 标注这是一个输入时起作用还是输出时起作用的拦截器。上面的HelloInInterceptor由于在构造方法中指定在接收消息阶段有效，所以即使你把它注册到OutInterceptor 的集合中也无效。

2、在spring对自定义拦截器的配置

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. xmlns:jaxrs="http://cxf.apache.org/jaxrs"
6. xsi:schemaLocation=" http://www.springframework.org/schema/beans
7. http://www.springframework.org/schema/beans/spring-beans.xsd
8. http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd
9. http://cxf.apache.org/jaxrs http://cxf.apache.org/schemas/jaxrs.xsd">
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. <bean id="inMessageInterceptor" class="org.apache.cxf.interceptor.LoggingInInterceptor" />
14. <bean id="outMessageInterceptor" class="org.apache.cxf.interceptor.LoggingOutInterceptor"/>
15. <bean id="helloInInterceptor" class="com.exp.service.outer.interceptor.HelloInInterceptor"/>
16. <!--id:名称(随意配)，implementor:指定接口具体实现类，address:随意配-->
17. <jaxws:endpoint id="helloWorld"  implementor="#HelloWorldImpl" address="/HelloWorld"  >
18. <!-- 输入日志拦截器 -->
19. <jaxws:inInterceptors>
20. <ref bean="inMessageInterceptor"/>
21. <ref bean="helloInInterceptor"/>
22. </jaxws:inInterceptors>
23. <!-- 输出日志拦截器 -->
24. <jaxws:outInterceptors>
25. <ref bean="outMessageInterceptor"/>
26. </jaxws:outInterceptors>
27. <jaxws:properties>
28. <entry key="mtom_enabled" value="true"></entry>
29. </jaxws:properties>
30. <!--
31. <jaxws:features>
32. <bean class="com.exp.service.outer.interceptor.HelloWorldFeature"></bean>
33. </jaxws:features> -->
34. </jaxws:endpoint>
35. <jaxrs:server id="rest_HelloWorld" address="/">
36. <jaxrs:inInterceptors>
37. <ref bean="inMessageInterceptor"/>
38. </jaxrs:inInterceptors>
39. <jaxrs:outInterceptors>
40. <ref bean="outMessageInterceptor"/>
41. </jaxrs:outInterceptors>
42. <jaxrs:serviceBeans>
43. <ref bean="rest_HelloWorldImpl" />
44. </jaxrs:serviceBeans>
45. <jaxrs:extensionMappings>
46. <entry key="json" value="application/json" />
47. <entry key="xml" value="application/xml" />
48. </jaxrs:extensionMappings>
49. <jaxrs:languageMappings>
50. <entry key="en" value="en-gb" />
51. </jaxrs:languageMappings>
52. </jaxrs:server>
53. <!-- WebService 客户端 spring 配置文件cxf与Spring集成，cxf里提供了一个工厂类org.apache.cxf.jaxws.JaxWsProxyFactoryBean，
54. 可以方便实现的调用WebService。serviceClass属性是接口类，address是webService的路径在其他bean里如果要调用webservice，
55. 只要将client这个bean注入到需要使用的bean里。-->
56. <bean id="client" class="com.exp.service.outer.HelloWorld" factory-bean="clientFactory" factory-method="create" />
57. <bean id="clientFactory" class="org.apache.cxf.jaxws.JaxWsProxyFactoryBean">
58. <property name="serviceClass" value="com.exp.service.outer.HelloWorld" />
59. <property name="address" value="http://localhost:8080/demo/webservice/HelloWorld" />
60. </bean>
61. </beans>

注意：修改的代码如下：

1. <jaxws:endpoint id="helloWorld"  implementor="#HelloWorldImpl" address="/HelloWorld"  >
2. <!-- 输入日志拦截器 -->
3. <jaxws:inInterceptors>
4. <ref bean="inMessageInterceptor"/>
5. <ref bean="helloInInterceptor"/>
6. </jaxws:inInterceptors>
7. <!-- 输出日志拦截器 -->
8. <jaxws:outInterceptors>
9. <ref bean="outMessageInterceptor"/>
10. </jaxws:outInterceptors>
11. <jaxws:properties>
12. <entry key="mtom_enabled" value="true"></entry>
13. </jaxws:properties>
14. <!--
15. <jaxws:features>
16. <bean class="com.exp.service.outer.interceptor.HelloWorldFeature"></bean>
17. </jaxws:features> -->
18. </jaxws:endpoint>

二、多拦截器的捆绑

由于不光CXF内置有拦截器，而且还可以自定义拦截器。这样WebServcie的SEI可能配置多个、一大堆拦截器，这样很不方便。在Struts2中可以自定义拦截器，他还提供了自定义拦截器堆栈的功能，将多个拦截器捆绑在一起使用。这样不必要一个一个的去注册拦截器。在CXF中也有类似功能，可以将拦截器捆绑在一起，你就可以将它注册到你要使用的地方，而不必一个一个拦截器的注册使用。

实现拦截器的捆绑过程非常的简单，继承AbstractFeature 类来实现一个新的特征， 只需要覆盖initializeProvider 方法即可。其实Feature 就是将一组拦截器放在其中，然后一并注册使用。

具体实现如下：

1、

1. public class HelloWorldFeature extends AbstractFeature {
2. @Override
3. protected void initializeProvider(InterceptorProvider provider, Bus bus) {
4. provider.getInInterceptors().add(new LoggingInInterceptor());
5. provider.getInInterceptors().add(new HelloInInterceptor());
6. provider.getOutInterceptors().add(new LoggingOutInterceptor());
7. }
8. }

注意：能够看到通过HelloWorldFeature.Java捆绑了三个拦截器。

2、在Spring对捆绑拦截器的配置

1. <jaxws:endpoint id="helloWorld" implementor="#HelloWorldImpl" address="/HelloWorld" >
2. <jaxws:features>
3. <bean class="com.exp.service.outer.interceptor.HelloWorldFeature"></bean>
4. lt;/jaxws:features>
5. <jaxws:properties>
6. <entry key="mtom_enabled" value="true"></entry>
7. </jaxws:properties>
8. t;/jaxws:endpoint>

看到这里省掉了很多拦截器的配置代码，只需要一个 <jaxws:features>就搞定