week 7 CDI services

时间 2019-11-18

标签 week cdi services 繁體版

原文原文链接

.Decorators装饰器综述

拦截器是一种强大的方法在应用程序捕捉运行方法和解耦。拦截器能够拦截任何java类型的调用.
这使得拦截器适合解决事务管理,安全性,以及日记记录.
本质上说,拦截器并不知道他们截获的实际语义事件.所以,拦截器并非很适合和系统的业务挂钩.

而本章的装饰器,则又不同.
装饰器只截取调用某个Java接口,所以获知这个接口的全部语义链接。
decorator直接实现与业务语义操做,这也意味着装饰没有拦截器的通用性。
拦截器和修饰符,尽管在不少方面类似,是互补的。但decorator没法解决技术问题,横跨许多不一样的类型。

假设咱们有一个接口,表明帐户:php

public interface Account {

   public BigDecimal getBalance();
   public User getOwner();
   public void withdraw(BigDecimal amount);
   public void deposit(BigDecimal amount);
}

几种不一样的Bean在咱们系统实现帐户接口。css

然而,咱们有一个强制要求:任何类型的帐户,交易必须由系统日志进行记录.
这就是装饰器的一个工做.

用@Decorator标注一个bean(甚至多是一个抽象类),这样就代表此类是装饰器.java

@Decorator
public abstract class LargeTransactionDecorator implements Account {
   ...
}

装饰器的装修类型实现方法,可让他拦截他想要拦截的.spring

@Decorator
public abstract class LargeTransactionDecorator implements Account {

   @Inject @Delegate @Any Account account;

   @PersistenceContext EntityManager em;
    
   public void withdraw(BigDecimal amount) {
      ...
   }
 
   public void deposit(BigDecimal amount);
      ...
   }
}

须要注意的是,一个装饰器多是一个抽象类. 所以,某些状况下你可能不须要去实现方法.安全

2.Delegate object(委托对象)

decorator有特殊的注射点,称为委托注入点(delegate injection point),
其必须有一个delegate injection point,能够是一个构造函数参数,初始化方法参数或injected field.
服务器

@Decorator
public abstract class LargeTransactionDecorator implements Account {

   @Inject @Delegate @Any Account account;
   ...
}

像上面这段代码,装饰器将绑定到全部实现了Account的Bean上.app

若是是下面这段代码,@Foreign是咱们自定义.
那么装饰器将绑定到实现了Account的Bean而且qualifiers是@Foreign的Bean上.
框架

@Decorator
public abstract class LargeTransactionDecorator implements Account {

   @Inject @Delegate @Foreign Account account;
   ...
}

decorator可能调用委托对象,和拦截器调用InvocationContext.proceed() 有大体有相同的结果.但主要的区别在于装饰能够委托对象上调用任何业务方法。async

@Decorator
public abstract class LargeTransactionDecorator implements Account {

   @Inject @Delegate @Any Account account;

   @PersistenceContext EntityManager em;    

   public void withdraw(BigDecimal amount) {

      account.withdraw(amount);
      if ( amount.compareTo(LARGE_AMOUNT)>0 ) {
         em.persist( new LoggedWithdrawl(amount) );
      }
   }
    
   public void deposit(BigDecimal amount);

      account.deposit(amount);
      if ( amount.compareTo(LARGE_AMOUNT)>0 ) {

         em.persist( new LoggedDeposit(amount) );
      }
   }
}

3.Enabling decorators(启用装饰器)

默认状况下,全部装饰器都是禁用的.推荐用bean.xml进行开启.bean.xml是第一优先的.其次才是@Priority.
CDI 1.1之后的decorator可使用@Priority开启。@Priority定义了装饰器和拦截器的优先顺序,但仍是没bean.xml里直观.
ide

<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">

   <decorators>
         <class>org.mycompany.myapp.LargeTransactionDecorator</class>
   </decorators>
</beans>

注意:不要即在bean.xml配置又写@Priority.可能会出一些奇怪的问题.根本上,同时用这两种方式就是错误的.

Interceptors(拦截器)

1.拦截器综述

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

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

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

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

public class DependencyInjectionInterceptor {
   @PostConstruct 
   public void injectDependencies(InvocationContext ctx) { ... }
}

EJB超时时使用的拦截器

public class TimeoutInterceptor {

   @AroundTimeout 
   public Object manageTransaction(InvocationContext ctx) throws Exception { ... }
}

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

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封装了客户端所调用业务方法的一些信息。

getTarget() 指向被调用的bean实例
getMethod() 指向被拦截的业务方法getParameters

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;
}

() 获取被拦截业务方法的参数

setParameters() 设置被拦截业务方法的参数
getContextData() 返回一个Map对象，它在整个方法调用期间均可以被访问到。位于同一个方法调用内的不一样拦截器之间能够利用它来传递上下文相关的数据。

示例:

//被拦截的方法
@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;
        } 
    }
}

@InterceptorBinding
@Target({METHOD, TYPE})
@Retention(RUNTIME)
public @interface Transactional {}

2.拦截器绑定(Interceptor bindings)

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

如今咱们能够很容易地指定类ShoppingCart是事务性对象:

@Transactional public class ShoppingCart { ... }

或者咱们能够指定一个

@Transactional @Interceptor
public class TransactionInterceptor {

   @AroundInvoke 
   public Object manageTransaction(InvocationContext ctx) throws Exception { ... }
}

器能够利用依赖注入:

@Transactional @Interceptor
public class TransactionInterceptor {

    @Resource UserTransaction transaction;

    @AroundInvoke 
    public Object manageTransaction(InvocationContext ctx) throws Exception { ... }
}

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

3.启用拦截器(Enabling interceptors) 默认状况下,全部拦截器被禁用.要使用拦截器.须要在bean.xml中进行配置,以启用.从CDI 1.1起拦截器可使用@Priority注释为整个应用程序启用。

<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中确保其肯定性行为
它让咱们在部署时启用或禁用拦截器类。

固然也能够配置启用多个拦截器

<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:

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

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

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

@InterceptorBinding
@Target({METHOD, TYPE})
@Retention(RUNTIME)
public @interface Transactional {

   boolean requiresNew() default false;
}

CDI将使用requiresNew的值选择两个不一样的拦截器,TransactionInterceptor和RequiresNewTransactionInterceptor

下面是requiresNew为true的拦截器

@Transactional(requiresNew = true) @Interceptor
public class RequiresNewTransactionInterceptor {

   @AroundInvoke 
   public Object manageTransaction(InvocationContext ctx) throws Exception { ... }
}

以下使用:

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

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

@InterceptorBinding
@Target({METHOD, TYPE})
@Retention(RUNTIME)
public @interface Secure {

   @Nonbinding String[] rolesAllowed() default {};
}

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

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

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

然而,在很是复杂的状况下,一个拦截器自己可能指定拦截器绑定类型:

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

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

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语言支持注解的一个限制就是缺少注解继承.注解应该重用内置已有的.就如同下面这段代码表达的意思

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

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

@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规范>.以下:

@Interceptors({TransactionInterceptor.class, SecurityInterceptor.class})
public class ShoppingCart {

   public void checkout() { ... }
}

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

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

所以仍是使用上面CDI的使用方式比较好.

CDI高级说明以及Producer methods

CDI是为解耦而生.如Spring主要用途是AOP.IOC(DI),而CDI除了DI外,AOP功能也是有的.从实际使用上来看,CDI比Spring功能更丰富,更灵活,其代价也是有的,学习成本相对spring较高.

1.CDI致力于松耦合,强类型.

实现松散耦合的三种方式:

部署时候的多态选择,@alternatives
producer methods在运行时的多态.
上下文相关的生命周期管理与bean生命周期解耦。

这些技术使客户端和服务器的松散耦合服务。客户端再也不是紧密地绑定到一个接口的一个实现,也不须要管理生命周期实现。这种方法容许有状态的对象看成服务交互。松散耦合使系统更具活力。在之前,框架老是牺牲了类型安全(尤为是经过使用XML描述符,Spring2.5)。

CDI提供了三个额外的重要措施,进一步松耦合:

在业务逻辑层用拦截器技术解耦.
修饰符(注解)能够用来分离一些业务问题
用CDI EVENT技术进行解耦事件生产者与消费者.

第二个CDI是强类型的.不管是依赖关系的信息,拦截器,修饰符的Bean,以及CDI event的生产者,消费者等的信息所有都是类型安全的.由编译器进行验证.
CDI是确确实实没String标识符,如xml配置什么的.好比Spring2.5用XML配置,其实都是字符串,以及"约定大于配置"的概念.在CDI里是没有的.CDI框架不是隐藏,而是没有.
这种方法的最明显好处就是任何IDE均可以提供自动完成,验证以及最重要的重构!(了解JPA的,能够对比安全类型的查询和JPQL.若是重构代码JPQL是很是麻烦的).
还有个好处就是你在识别不一样的对象,事件,拦截器能够经过注解而不是字符串名字,这样你能够提高代码质量.

CDI鼓励开发使用注解.如
@Asynchronous,
@Secure,
@Updated,
而不是使用复合名称,
asyncPaymentProcessor,
SecurityInterceptor
DocumentUpdatedEvent.
这也符合代码大全里的一些概念.只不过不用费尽心思考虑命名了,这样更简洁高效.
注释是可重用的。他们帮助描述系统的不一样部分的共同特质。他们帮助咱们分类和理解代码。他们帮助咱们应对常见问题的经常使用方法。他们使咱们的代码更简洁高效.

2.高级功能Producer methods

先贴一段代码,下面都用到

import javax.enterprise.inject.Produces;

@SessionScoped
public class Preferences implements Serializable {

   private PaymentStrategyType paymentStrategy;

   ...

   @Produces @Preferred 
   public PaymentStrategy getPaymentStrategy() {
       switch (paymentStrategy) {
           case CREDIT_CARD: return new CreditCardPaymentStrategy();
           case CHECK: return new CheckPaymentStrategy();
           case PAYPAL: return new PayPalPaymentStrategy();
           default: return null;
       } 
   }
}
//注入一个Producer methods
@Inject @Preferred PaymentStrategy paymentStrategy;

A:Producer methods的Scope

Producer methods的默认范围是@Dependent.
从上面代码咱们能够思考一种场景,那就是一个用户会话中有多个PaymentStrategy对象的实例.若是想改变,咱们能够在Producer方法上添加一个@SessionSciped注解.
如今,若是一个用户调用了这个Producer methods,那么返回的这个PaymentStrategy对象的实例将绑定到会话的上下文.Producer methods不会再实例化另外一个出来.

@Produces @Preferred @SessionScoped
public PaymentStrategy getPaymentStrategy() {
   ...
}

注意:Producer methods不继承声明此Producer methods的Bean的Scope.
其实这里有2个不一样的Bean:Producer methods(至关于一个Bean)以及声明这个生产方法的Bean.

B: Injection into producer methods

在Producer methods一开始的实例有一个潜在的问题
CreditCardPaymentStrategy 的实现使用 Java new 运算符来实例化。

private PaymentStrategyType paymentStrategy;

而producer methods应该理解为一个独立的Bean,而paymentStrategy是从Preferences 中用new实例化的.因此咱们应该使用下面这种方式来使用producer methods方法.

@Produces @Preferred @SessionScoped
public PaymentStrategy getPaymentStrategy(CreditCardPaymentStrategy ccps,
                                          CheckPaymentStrategy cps,
                                          PayPalPaymentStrategy ppps) {

   switch (paymentStrategy) {
      case CREDIT_CARD: return ccps;
      case CHEQUE: return cps;
      case PAYPAL: return ppps;
      default: return null;
   } 
}

这里会有问题,若是CreditCardPaymentStrategy 是一个@RequestScope,那这里必然是要发生错误的.由于注入的 CreditCardPaymentStrategy Bean实例是request,在@SessionScoped使用前容器就会进行销毁.那么就出错了.

这是个问题,因此咱们有3种处理方案.

producer method to @Dependent or @RequestScoped.<最好的方式>
CreditCardPaymentStrategy 更改Scope,但这可能会影响其余的地方,不是很好.
~~使用@New限定符,但在CDI 1.1 @New限定符被弃用。CDI鼓励应用程序注入@Dependent范围bean。~~

C:Use of @New with producer methods<不推荐>

~~Consider the following producer method:~~

@Produces @Preferred @SessionScoped public PaymentStrategy getPaymentStrategy(@New CreditCardPaymentStrategy ccps, @New CheckPaymentStrategy cps, @New PayPalPaymentStrategy ppps) { switch (paymentStrategy) { case CREDIT_CARD: return ccps; case CHEQUE: return cps; case PAYPAL: return ppps; default: return null; } }

~~这将会建立一个新的CreditCardPaymentStrategy依赖实例,传递到生产方法,依赖对象不会被摧毁,直到会话结束。~~

~~在CDI 1.1 @New限定符被弃用。CDI鼓励应用程序注入@Dependent范围bean。~~

D:Disposer methods

一些Procucer methods返回的对象须要显式的破坏。例如,有人须要关闭这个JDBC链接:

@Produces @RequestScoped 
Connection connect(User user) {

   return createConnection(user.getId(), user.getPassword());
}

而在一个相同的类中,disposer method能够进行匹配.

void close(@Disposes Connection connection) {

   connection.close();
}

说明:在同一个类中,disposer method能够进行匹配类型为Connection 的Procucer methods,从而在 Procucer methods周期结束后进行jdbc的连接关闭.

以下面这个:

import javax.enterprise.context.RequestScoped;
import javax.enterprise.inject.Disposes;
import javax.enterprise.inject.Produces;
import javax.enterprise.inject.spi.InjectionPoint;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.PersistenceUnit;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Resources {

    @PersistenceUnit
    private EntityManagerFactory entityManagerFactory;

    @Produces
    @RequestScoped
    protected EntityManager createEntityManager() {

        return entityManagerFactory.createEntityManager();
    }

    //参数必须对应上面方法的返回值
    protected void closeEntityManager(@Disposes EntityManager entityManager) {

        if ( entityManager.isOpen() )
        {
            entityManager.close();
        }
    }
}

参考：https://my.oschina.net/zhaoqian/blog/264604

https://www.jianshu.com/p/5d2bd9369134