zoukankan      html  css  js  c++  java

  • CDI services--interceptors(拦截器)

    1.拦截器综述

    拦截器的功能是定义在Java拦截器规范。

    拦截器规范定义了三种拦截点: 

    1. 业务方法拦截,
    2. 生命周期回调侦听,
    3. 超时拦截(EJB)方法。

    在容器的生命周期中进行拦截 

    1
    2
    3
    4
    public class DependencyInjectionInterceptor {
       @PostConstruct
       public void injectDependencies(InvocationContext ctx) { ... }
    }

    EJB超时时使用的拦截器 

    1
    2
    3
    4
    5
    public class TimeoutInterceptor {
     
       @AroundTimeout
       public Object manageTransaction(InvocationContext ctx) throws Exception { ... }
    }

    在业务上,对某一个Bean的方法进行拦截 

    1
    2
    3
    4
    5
    public class TransactionInterceptor {
     
       @AroundInvoke
       public Object manageTransaction(InvocationContext ctx) throws Exception { ... }
    }

    @AroundInvoke注释指定了要用作拦截器的方法，拦截器方法与被拦截的业务方法执行同一个java调用堆栈、同一个事务和安全上下文中。用@AroundInvoke注释指定的方法必须遵守以下格式：public Object XXX(javax.interceptor.InvocationContext ctx) throws Exception 

    下面是javax.interceptor.InvocationContext封装了客户端所调用业务方法的一些信息。 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    package javax.interceptor;
    public interface InvocationContext{
        public Object getTarget();
        public Method getMethod();
        public Ojbect[] getParameters();
        public void setParameters(Object[] newArgs);
        public java.util.Map<String, Ojbect> getContextData();
        public Object proceed() throws Exception;
    }
    • getTarget() 指向被调用的bean实例
    • getMethod() 指向被拦截的业务方法
    • getParameters() 获取被拦截业务方法的参数
    • setParameters() 设置被拦截业务方法的参数
    • getContextData() 返回一个Map对象，它在整个方法调用期间都可以被访问到。位于同一个方法调用内的不同拦截器之间可以利用它来传递上下文相关的数据。

    示例: 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    //被拦截的方法
    @Interceptors(HelloInterceptor.class)
    public class HelloChinaBean {
        public String SayHello(String name) {
            return name +"Hello World.";
        }
    }
    //拦截器定义
    public class HelloInterceptor {
        @AroundInvoke
        public Object log(InvocationContext ctx) throws Exception {
            
            try{
                if (ctx.getMethod().getName().equals("SayHello")){
                    System.out.println("Holle World!!!" );
                }           
                return ctx.proceed();
            }catch (Exception e) {
                throw e;
            }
        }
    }

    2.拦截器绑定(Interceptor bindings)

    假设我们想要申明一些bean的事务。我们先要的是一个拦截器绑定类型来指定哪些bean我们要申明. 
    首先定义一个注解 

    1
    2
    3
    4
    @InterceptorBinding
    @Target({METHOD, TYPE})
    @Retention(RUNTIME)
    public @interface Transactional {}

    现在我们可以很容易地指定类ShoppingCart是事务性对象: 

    1
    2
    @Transactional
    public class ShoppingCart { ... }

    或者我们可以指定一个方法的事务 

    1
    2
    3
    public class ShoppingCart {
       @Transactional public void checkout() { ... }
    }

    2.拦截器实现(Implementing interceptors)

    我们实际上要实现提供了这种事务管理方面的拦截器,所以我们需要做的是创建一个标准的拦截,并配上@Interceptor和@transactional注解. 

    1
    2
    3
    4
    5
    6
    @Transactional @Interceptor
    public class TransactionInterceptor {
     
       @AroundInvoke
       public Object manageTransaction(InvocationContext ctx) throws Exception { ... }
    }

    拦截器可以利用依赖注入: 

    1
    2
    3
    4
    5
    6
    7
    8
    @Transactional @Interceptor
    public class TransactionInterceptor {
     
        @Resource UserTransaction transaction;
     
        @AroundInvoke
        public Object manageTransaction(InvocationContext ctx) throws Exception { ... }
    }

    多个拦截器可以使用相同的拦截器绑定类型。

    @Resource和@Inject的区别:

    3.启用拦截器(Enabling interceptors)

    默认情况下,所有拦截器被禁用.要使用拦截器.需要在bean.xml中进行配置,以启用.从CDI 1.1起拦截器可以使用@Priority注释为整个应用程序启用。 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    <beans
       xmlns="http://xmlns.jcp.org/xml/ns/javaee"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
          http://xmlns.jcp.org/xml/ns/javaee
          http://xmlns.jcp.org/xml/ns/javaee/beans_1_1.xsd">
       <interceptors>
          <class>org.mycompany.myapp.TransactionInterceptor</class>
       </interceptors>
    </beans>

    这样有2个好处:

    • 拦截器比较重要,在XML中确保其确定性行为
    • 它让我们在部署时启用或禁用拦截器类。

    当然也可以配置启用多个拦截器

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    <beans
       xmlns="http://xmlns.jcp.org/xml/ns/javaee"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
          http://xmlns.jcp.org/xml/ns/javaee
          http://xmlns.jcp.org/xml/ns/javaee/beans_1_1.xsd">
       <interceptors>
          <class>org.mycompany.myapp.SecurityInterceptor</class>
          <class>org.mycompany.myapp.TransactionInterceptor</class>
       </interceptors>
    </beans>

    拦截器毕竟比较重要,不推荐使用@Priority启用.
    在CDI中,XML配置的优先级高于@Priority.
    关于@Priority可以参考下列:

    public static class Interceptor.Priority
    extends Object
    Priorities that define the order in which interceptors are invoked. These values should be used with the Priority annotation.

    Interceptors defined by platform specifications should have priority values in the range PLATFORM_BEFORE up until LIBRARY_BEFORE, or starting at PLATFORM_AFTER.
    Interceptors defined by extension libraries should have priority values in the range LIBRARY_BEFORE up until APPLICATION, or LIBRARY_AFTER up until PLATFORM_AFTER.
    Interceptors defined by applications should have priority values in the range APPLICATION up until LIBRARY_AFTER.
    An interceptor that must be invoked before or after another defined interceptor can choose any appropriate value.

    Interceptors with smaller priority values are called first. If more than one interceptor has the same priority, the relative order of these interceptor is undefined.

    For example, an extension library might define an interceptor like this:

    1
    2
    3
    @Priority(Interceptor.Priority.LIBRARY_BEFORE+10)
     @Interceptor
     public class ValidationInterceptor { ... }

    4.Interceptor bindings with members(拦截器注解属性)

    假设我们想要添加一些额外的信息给我们的@transactional注解: 

    1
    2
    3
    4
    5
    6
    7
    @InterceptorBinding
    @Target({METHOD, TYPE})
    @Retention(RUNTIME)
    public @interface Transactional {
     
       boolean requiresNew() default false;
    }
    CDI将使用requiresNew的值选择两个不同的拦截器,TransactionInterceptor和RequiresNewTransactionInterceptor 


    下面是requiresNew为true的拦截器

    1
    2
    3
    4
    5
    6
    @Transactional(requiresNew = true) @Interceptor
    public class RequiresNewTransactionInterceptor {
     
       @AroundInvoke
       public Object manageTransaction(InvocationContext ctx) throws Exception { ... }
    }

    如下使用:

    1
    2
    @Transactional(requiresNew = true)
    public class ShoppingCart { ... }

    但是如果我们只有一个拦截器,我们希望容器拦截器绑定时忽略requiresNew的值,也许这些信息只用于拦截器实现。我们可以使用@Nonbinding注释: 

    1
    2
    3
    4
    5
    6
    7
    @InterceptorBinding
    @Target({METHOD, TYPE})
    @Retention(RUNTIME)
    public @interface Secure {
     
       @Nonbinding String[] rolesAllowed() default {};
    }

    5.Multiple interceptor binding annotations(多重拦截器绑定注解)

    通常我们使用拦截器绑定的组合类型绑定多个拦截器bean。例如,下面的声明将用于绑定TransactionInterceptor和SecurityInterceptor这2个拦截器到ShoppingCart.

    1
    2
    @Secure(rolesAllowed="admin") @Transactional
    public class ShoppingCart { ... }

    然而,在非常复杂的情况下,一个拦截器本身可能指定拦截器绑定类型:

    1
    2
    @Transactional @Secure @Interceptor
    public class TransactionalSecureInterceptor { ... }

    那么这个拦截器可以绑定到checkout() 方法,以下任何组合都可使用:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    public class ShoppingCart {
       @Transactional @Secure public void checkout() { ... }
    }
    @Secure
    public class ShoppingCart {
     
       @Transactional public void checkout() { ... }
    }
    @Transactional
    public class ShoppingCart {
     
       @Secure public void checkout() { ... }
    }
    @Transactional @Secure
    public class ShoppingCart {
     
       public void checkout() { ... }
    }

    6. Interceptor binding type inheritance(拦截器绑定类型继承)

    Java语言支持注解的一个限制就是缺乏注解继承.注解应该重用内置已有的.就如同下面这段代码表达的意思

    1
    2
    //实际没这写法
    public @interface Action extends Transactional, Secure { ... }

    幸运的是,CDI围绕Java没有的这个特性开展了一些工作. 
    我们会标注一个拦截器绑定类型,其有其他拦截器的绑定类型,(称为元注解) 
    表述起来有点费劲,就如同下面代码这样.

    1
    2
    3
    4
    5
    @Transactional @Secure
    @InterceptorBinding
    @Target(TYPE)
    @Retention(RUNTIME)
    public @interface Action { ... }

    现在任何Bean绑定 Action这个注解 ,其实就是绑定到了@Transactional @Secure.(就是拦截器TransactionInterceptor和拦截器SecurityInterceptor). (甚至TransactionalSecureInterceptor,如果它存在.)

    7.Use of @Interceptors(同时用多个拦截器)

    这个注解@Interceptors是拦截器规范定义的,cdi是支持的<使用托管bean和EJB规范>.如下:

    1
    2
    3
    4
    5
    @Interceptors({TransactionInterceptor.class, SecurityInterceptor.class})
    public class ShoppingCart {
     
       public void checkout() { ... }
    }

    但缺点也很明显,不推荐使用.缺点如下:

    1. 拦截器在代码中是硬编码.
    2. 拦截器在部署时不好更改.
    3. 拦截器命令是非全局的——它是在类级别由拦截器的顺序列出.

    因此还是使用上面CDI的使用方式比较好.
  • 相关阅读:
    linux常用命令
    Win10正式版快捷键大全,Win10快捷组合键汇总
    cmd命令大全
    Wordpress目录结构
    dedecms目录结构，非常全
    wordpress文件系统结构
    WordPress数据库及各表结构
    网站跳转代码的实现途径
    主机屋----常用程序安装链接数据库教程
    CMS问答错误提示 ----------Deprecated: Function set_magic_quotes_runtime() is deprecated in D:wwwrootxianfanetwwwrootaskincludecommon.inc.php on line 15
  • 原文地址：https://www.cnblogs.com/formyfish/p/10752012.html
Copyright © 2011-2022 走看看