`

CXF之四(拦截器(Interceptor)

    博客分类:
  • SOA
阅读更多

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

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

 

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

 

一、拦截器实现

 

1、拦截器的代码实现

 

 

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

 

 

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

 

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

 

 

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

 

 

注意:修改的代码如下:

 

Java代码  收藏代码
  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.        <!--   
  16.        <jaxws:features>  
  17.             <bean class="com.exp.service.outer.interceptor.HelloWorldFeature"></bean>  
  18.         </jaxws:features> -->  
  19.           
  20.     </jaxws:endpoint>  

 

 

 

二、多拦截器的捆绑

 

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

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

 

具体实现如下:

1、

 

 

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

 

 

 

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

 

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

 

 

Java代码  收藏代码
  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.   
  6.  <jaxws:properties>  
  7.     <entry key="mtom_enabled" value="true"></entry>  
  8.  </jaxws:properties>  
  9.    
  10. t;/jaxws:endpoint>  

 

 

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

分享到:
评论

相关推荐

Global site tag (gtag.js) - Google Analytics