Spring AOP面向切面编程

独自空忆成欢 提交于 2020-03-27 10:59:28
目录

1.AOP概览

AOP(Aspect Oriented Programming),什么是面向切面编程?

1)AOP是一种编程范式,不是编程语言

编程范式概览

  • 面向过程编程

  • 面向对象编程

  • 函数式编程

  • 事件驱动编程

  • 面向切面编程

 

2)AOP是为了解决特定问题,不是解决所有问题。AOP是OOP的补充,不是替代关系。

AOP的初衷是关注点隔离

切面隔离:将功能性需求和非功能性需求分离开来

做系统设计时,通常将大系统做分解,按业务功能分解成一个个低耦合、高内聚的模块。

分解后发现有趣的事情是,有些东西是公用的,或者跨越了多个模块。

  • 日志:对特定的操作输出日志来记录

  • 安全:在操作之前进行操作检查

  • 性能:统计每个方法的执行时间

  • 事务:方法开始前开始事务,方法结束后提交或回滚事务

我们可以将这些通用模块写好,在实现业务模块的时候去调用就好了。

但是,功能是实现了,但是业务代码中大部分都是日志、性能、事务等,几乎把真正的业务代码给淹没了!

最好的方法是将日志、安全、事务这样的代码和业务代码完全隔离开来,因为他们的关注点和业务代码的关注点完全不同。

他们之间的关系应该是正交的。如果把这个业务功能看成一层层面包的话, 这些日志/安全/事务 像不像一个个“切面”(Aspect) ?

如果我们能让这些“切面“能和业务独立,  并且能够非常灵活的“织入”到业务方法中, 那就实现了面向切面编程(AOP)!

 

 

 

 

AOP的应用场景

  • 审计日志:对特定的操作输出日志来记录

  • 权限控制:在操作之前进行操作检查

  • 性能监控:统计每个方法的执行时间

  • 事务控制:方法开始前开始事务,方法结束后提交或回滚事务

  • 缓存控制

  • 异常处理

 

根据织入时机的不同,AOP可以分为以下3种实现方式

1)编译期织入(AspectJ)

2)类加载时织入(AspectJ 5+)

3)运行时织入(Spring AOP)

 

2.Spring AOP的使用举例

Spring AOP实现权限控制:只有管理员可以进行修改操作

@Service
public class ProductService {
    public Product get(Long id) {
        System.out.println("get product id = " + id);
        return new Product(id, "aaa");
    }
    @AdminOnly
    public void insert(Product product) {
        System.out.println("insert product");
    }
​
    @AdminOnly
    public void delete(Long id) {
        System.out.println("delete product id = " + id);
    }
}
@Aspect  //1)表明这个是一个切面类
@Component
public class SecurityAspect {
    //2)切入点
    @Pointcut("@annotation(AdminOnly)")
    public void adminOnly() {
    }
    //3)通知
    @Before("adminOnly()")
    public void check() {
        String user = CurrentUserHolder.get();
        if (!"admin".equals(user)) {
            throw new RuntimeException("operation not allow");
        }
    }
}

 

PointCut切入点

PointCut(切入点):一个方法或一组方法(可以通过通配符支持)。

比如,“对于com.xxx这个包中所有类的execute方法” 。

Advice通知

Advice(通知):方法调用时需要做什么。比如,”在方法调用之前/之后 , 需要执行xxx操作“ 。

具体的通知类型包括:

  • before:前置通知,在方法调用前执行。

  • after returning:方法返回通知,在方法正常返回时执行。

  • throwing:方法异常通知,在方法抛出异常时执行。

  • after:方法结束通知,包含了方法正常返回和方法抛出异常两种情况。

  • around:环绕通知。

 

3.Spring AOP的实现原理

3.1运行时织入

根据织入时机的不同,AOP可以分为以下3种实现方式

1)编译期织入(AspectJ)

2)类加载时织入(AspectJ 5+)

3)运行时织入(Spring AOP)

Spring中的AOP实现是在运行时织入的。

运行时织入是如何实现的呢?通过动态代理的方式。

3.1.1代理模式

什么是代理模式

调用方Caller通过Proxy代理对象间接地与目标对象Target交互。

两个关键点:

1)Client客户端通过接口引用操作的对象Subject。且RealSubject真实对象和Proxy代理对象实现了同一个接口

2)Proxy代理对象会持有RealSubject真实对象的引用,真正要执行的方法委托给真实对象来执行,自己则执行一些额外的逻辑

public interface Subject {
    void request() throws Exception;
}
public class RealSubject implements Subject {
​
    public void request() {
        System.out.println("RealSubject execute request()");
    }
}
public class Proxy implements Subject {
​
    private RealSubject realSubject;
​
    public Proxy(RealSubject realSubject) {
        this.realSubject = realSubject;
    }
    /**
    * 在真实对象request()方法之前或之后,可以执行一些额外的操作
    */
    public void request() throws Exception{
        System.out.println("before");
        try {
            realSubject.request();
        } catch (Exception e) {
            System.out.println("ex:" + e.getMessage());
            throw e;
        } finally {
            System.out.println("after");
        }
    }
}
public class Client {
​
    public static void main(String[] args) throws Exception{
        Subject subject = new Proxy(new RealSubject());
        subject.request();
    }
} 

运行结果

before
RealSubject execute request()
after

上面代码展示的是静态代理的实现。

静态代理有如下缺点:

1)假设真实对象有100方法,则代理对象需要对100个方法进行委托。

2)且在这100个方法中代理对象执行的额外逻辑是一样的。

就像下面代码展示的那样。

public interface Subject {
    void request() throws Exception;
    void request2() throws Exception;
    void request3() throws Exception;
    void request4() throws Exception;
 
public class RealSubject implements Subject {
​
    public void request() {
        System.out.println("RealSubject execute request()");
    }
​
    public void request2() {
        System.out.println("RealSubject execute request2()");
    }
​
    public void request3() {
        System.out.println("RealSubject execute request3()");
    }
​
    public void request4() {
        System.out.println("RealSubject execute request4()");
    }
}
public class Proxy implements Subject {
​
    private RealSubject realSubject;
​
    public Proxy(RealSubject realSubject) {
        this.realSubject = realSubject;
    }
​
    public void request() throws Exception{
        System.out.println("before");
        try {
            realSubject.request();
        } catch (Exception e) {
            System.out.println("ex:" + e.getMessage());
            throw e;
        } finally {
            System.out.println("after");
        }
    }
    //静态代理的缺点:
    //由于Subject添加了request2()、request3()、request4()方法,代理类中也要实现相应的方法
    //而且代理对象在request2()、request3()、request4()等方法中额外需要执行的逻辑都是一样的。
    public void request2() throws Exception{
        System.out.println("before");
        try {
            realSubject.request2();
        } catch (Exception e) {
            System.out.println("ex:" + e.getMessage());
            throw e;
        } finally {
            System.out.println("after");
        }
    }
​
    public void request3() throws Exception{
        System.out.println("before");
        try {
            realSubject.request3();
        } catch (Exception e) {
            System.out.println("ex:" + e.getMessage());
            throw e;
        } finally {
            System.out.println("after");
        }
    }
​
    public void request4() throws Exception{
        System.out.println("before");
        try {
            realSubject.request4();
        } catch (Exception e) {
            System.out.println("ex:" + e.getMessage());
            throw e;
        } finally {
            System.out.println("after");
        }
    }   
} 

由于静态代理有上面的缺点,就产生了动态代理技术。

动态代理有两种实现方式

1)基于接口实现:JDK动态代理

2)基于继承实现:cglib动态代理

3.1.2 JDK动态代理

将上面的静态代理实现,改为使用JDK动态代理后,代码如下。

public class JdkProxySubject implements InvocationHandler {
​
    private RealSubject realSubject;
​
    public JdkProxySubject(RealSubject realSubject) {
        this.realSubject = realSubject;
    }
​
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before");
        Object result = null;
        try {
           result = method.invoke(realSubject, args);
        } catch (Exception e) {
            throw e;
        } finally {
            System.out.println("after");
        }
        return result;
    }
}
public class Client {
​
    public static void main(String[] args) throws Exception {
        //通过调用Proxy.newProxyInstance生成代理对象
        //方法参数为:1)classLoader  2)要代理的接口 3)代理对象的InvocationHandler
        //(通过方法参数也可以看出来,JDK代理只能通过代理接口来来实现动态代理)
        Subject subject = (Subject) Proxy.newProxyInstance(Client.class.getClassLoader(),
                new Class[]{Subject.class}, new JdkProxySubject(new RealSubject()));
        //调用代理对象的request方法。
        //(根据InvocationHandler接口的定义,可以知道实际调用的是JdkProxySubject里的invoke方法)
        subject.request();
    }
}

 

3.1.3 cglib动态代理

将上面的静态代理实现,改为使用cglib动态代理后,代码如下。

public class DemoMethodInterceptor implements MethodInterceptor {
​
    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        System.out.println("before in cglib");
        Object result = null;
        try {
            //注意:调用的是proxy.invokeSuper来调用目标类的方法
            result = methodProxy.invokeSuper(o, args);
        } catch (Exception e) {
            System.out.println("ex:" + e.getMessage());
            throw e;
        } finally {
            System.out.println("after in cglib");
        }
        return null;
    }
}
public class Client {
​
    public static void main(String[] args) throws Exception {
        //创建一个增强器
        Enhancer enhancer = new Enhancer();
        //设置目标类
        enhancer.setSuperclass(RealSubject.class);
        //设置拦截对象
        enhancer.setCallback(new DemoMethodInterceptor());
        //生成代理对象
        Subject subject = (Subject) enhancer.create();
        //调用代理对象的request方法
        subject.request();
    }
}

 

3.1.4 Spring如何创建代理bean

动态代理有两种实现方式,JDK动态代理和cglib动态代理,那Spring是如何选择的?

 

ProxyFactoryBean的getObject()方法

@Override
  public Object getObject() throws BeansException {
    initializeAdvisorChain();
    //对singleton和prototype的类型进行区分,生成对应的proxy
    if (isSingleton()) {
      return getSingletonInstance();
    }
    else {
      if (this.targetName == null) {
        logger.warn("Using non-singleton proxies with singleton targets is often undesirable. " +
            "Enable prototype proxies by setting the 'targetName' property.");
      }
      return newPrototypeInstance();
    }
  }

 

getSingletonInstance()方法

  /**
   * Return the singleton instance of this class's proxy object,
   * lazily creating it if it hasn't been created already.
   * @return the shared singleton proxy
   */
  private synchronized Object getSingletonInstance() {
    if (this.singletonInstance == null) {
      this.targetSource = freshTargetSource();
      if (this.autodetectInterfaces && getProxiedInterfaces().length == 0 && !isProxyTargetClass()) {
        // Rely on AOP infrastructure to tell us what interfaces to proxy.
        Class<?> targetClass = getTargetClass();
        if (targetClass == null) {
          throw new FactoryBeanNotInitializedException("Cannot determine target class for proxy");
        }
        setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader));
      }
      // Initialize the shared singleton instance.
      super.setFrozen(this.freezeProxy);
      this.singletonInstance = getProxy(createAopProxy());
    }
    return this.singletonInstance;
  }

其中,生成代理实例的代码是这句。

this.singletonInstance = getProxy(createAopProxy());

可以将这句代码拆成下面两句。

1)aopProxy = createAopProxy()。

2)this.singletonInstance = getProxy(aopProxy) 。

createAopProxy()

createAopProxy()的方法如下。

protected final synchronized AopProxy createAopProxy() {
    if (!this.active) {
      activate();
    }
    return getAopProxyFactory().createAopProxy(this);
  }

其中getAopProxyFactory()返回一个AopProxyFactory。在这里,返回的是AopProxyFactory的默认实现DefaultAopProxyFactory。

DefaultAopProxyFactory的createAopProxy()方法

/**
 * Default {@link AopProxyFactory} implementation, creating either a CGLIB proxy
 * or a JDK dynamic proxy.
 *
 * <p>Creates a CGLIB proxy if one the following is true for a given
 * {@link AdvisedSupport} instance:
 * <ul>
 * <li>the {@code optimize} flag is set
 * <li>the {@code proxyTargetClass} flag is set
 * <li>no proxy interfaces have been specified
 * </ul>
 *
 * <p>In general, specify {@code proxyTargetClass} to enforce a CGLIB proxy,
 * or specify one or more interfaces to use a JDK dynamic proxy.
 */
@SuppressWarnings("serial")
public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {
​
  @Override
  public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
    //如果满足下面3个条件,将使用cglib动态代理
    if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
      Class<?> targetClass = config.getTargetClass();
      if (targetClass == null) {
        throw new AopConfigException("TargetSource cannot determine target class: " +
            "Either an interface or a target is required for proxy creation.");
      }
      //以下两种情况除外
      //targetClass是接口   或者  targetClass本身就是使用jdk动态代理的proxy
      if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
        return new JdkDynamicAopProxy(config);
      }
      return new ObjenesisCglibAopProxy(config);
    }
    //否则,使用jdk动态代理
    else {
      return new JdkDynamicAopProxy(config);
    }
  }
​
  /**
   * Determine whether the supplied {@link AdvisedSupport} has only the
   * {@link org.springframework.aop.SpringProxy} interface specified
   * (or no proxy interfaces specified at all).
   */
  private boolean hasNoUserSuppliedProxyInterfaces(AdvisedSupport config) {
    Class<?>[] ifcs = config.getProxiedInterfaces();
    return (ifcs.length == 0 || (ifcs.length == 1 && SpringProxy.class.isAssignableFrom(ifcs[0])));
  }
}
 

 

 

 

 

1)如果目标对象实现了接口,则默认采用JDK动态代理

2)如果目标对象没有实现接口,则采用cglib进行动态代理

3)如果目标对象实现了接口,且强制cglib代理,则使用cglib动态代理

getProxy(aopProxy)

protected Object getProxy(AopProxy aopProxy) {
    return aopProxy.getProxy(this.proxyClassLoader);
}

如果入参中的aopProxy是JdkDynamicAopProxy的实例的话,会调用JdkDynamicAopProxy类中的方法。

如果入参中的aopProxy是ObjenesisCglibAopProxy的实例的话,会调用ObjenesisCglibAopProxy类中的方法。

JdkDynamicAopProxy.getProxy()方法

final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {
  @Override
  public Object getProxy(ClassLoader classLoader) {
    if (logger.isDebugEnabled()) {
      logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());
    }
    Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
    findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
    return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
  }
}
 

可以看到JdkDynamicAopProxy实现了InvocationHandler接口,并通过Proxy.newProxyInstance(classLoader, proxiedInterfaces, this)生成代理对象。

ObjenesisCglibAopProxy.getProxy()方法

与下面代码逻辑类似。

        Enhancer enhancer = new Enhancer();
        //设置目标类
        enhancer.setSuperclass(RealSubject.class);
        //设置拦截对象
        enhancer.setCallback(new DemoMethodInterceptor());
        //生成代理对象
        Subject subject = (Subject) enhancer.create();
        //调用代理对象的request方法
        subject.request();

 

4.Spring AOP的实现原理

4.1 链式调用

多个AOP 切面是如何叠加起作用的?

public class Proxy implements Subject {
​
    private RealSubject realSubject;
​
    public Proxy(RealSubject realSubject) {
        this.realSubject = realSubject;
    }
    /**
    * realSubject.request()是目标方法
    * 在目标方法调用前、调用后、发生异常时,都需要被拦截
    * aop是如何实现将这些调用串起来的?
    */
    public void request() throws Exception{
        //before
        //记录调用次数
        //权限控制,仅管理员可以操作
        //开启事务
        System.out.println("before:记录调用次数"); 
        System.out.println("before:进行权限控制,仅管理员可以进行后续操作");
        System.out.println("before:开启事务");
        try {
            realSubject.request();
        } catch (Exception e) {
            //afterThrowing
            //事务失败,回滚操作
            System.out.println("afterThrowing:事务失败,回滚操作 ex:" + e.getMessage());
            throw e;
        } finally {
            //afterReturning
            //事务成功,提交操作
            System.out.println("afterReturning:事务成功,提交操作");
        }
    }
}

 

4.1.1 职责链模式

4.1.1.1 V1

 

 

 

public abstract class Handler {
​
    private Handler successor;
​
    public Handler getSuccessor() {
        return successor;
    }
​
    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }
​
    //对外暴露的方法
    public void execute() {
        handleProcess();
        if (successor != null) {
            successor.execute();
        }
    }
​
    // 需要子类实现
    protected abstract void handleProcess();
}
public class Client {
​
    static class HandlerA extends Handler {
​
        @Override
        protected void handleProcess() {
            System.out.println("handle by a");
        }
    }
​
    static class HandlerB extends Handler {
​
        @Override
        protected void handleProcess() {
            System.out.println("handle by b");
        }
    }
​
    static class HandlerC extends Handler {
​
        @Override
        protected void handleProcess() {
            System.out.println("handle by c");
        }
    }
    //缺点:各个handler之间的顺序需要显式指定
    //handlerA.setSuccessor(handlerB);
    //handlerB.setSuccessor(handlerC);
    public static void main(String[] args) {
        HandlerA handlerA = new HandlerA();
        HandlerB handlerB = new HandlerB();
        HandlerC handlerC = new HandlerC();
​
        handlerA.setSuccessor(handlerB);
        handlerB.setSuccessor(handlerC);
​
        handlerA.execute();
    }
}

运行结果

handle by a
handle by b
handle by c

 

4.1.1.2 V2

public abstract class ChainHandler {
​
    public void execute(Chain chain) {
        handleProcess();
        chain.proceed();
    }
​
    protected abstract void handleProcess();
}
public class Chain {
    //将各个handler保存在handlers这个list中
    //各个handler之间的执行顺序由chain来维持
    private List<ChainHandler> handlers;
    private int index = 0;
​
    public Chain(List<ChainHandler> handlers) {
        this.handlers = handlers;
    }
​
    public void proceed() {
        if (index >= handlers.size()) {
            return;
        }
        handlers.get(index++).execute(this);
    }
}
public class ChainClient {
    static class ChainHandlerA extends ChainHandler {
        @Override
        protected void handleProcess() {
            System.out.println("handle by a");
        }
    }
    static class ChainHandlerB extends ChainHandler {
        @Override
        protected void handleProcess() {
            System.out.println("handle by b");
        }
    }
    static class ChainHandlerC extends ChainHandler {
        @Override
        protected void handleProcess() {
            System.out.println("handle by c");
        }
    }
​
    public static void main(String[] args) {
        /**
        在list中的顺序决定了handler的执行顺序
        */
        List<ChainHandler> handlers = Arrays.asList(
                new ChainHandlerA(),
                new ChainHandlerB(),
                new ChainHandlerC()
        );
​
        Chain chain = new Chain(handlers);
        chain.proceed();
    }
}

运行结果

handle by a
handle by b
handle by c

 

4.1.2 Spring内部实现

以JDK动态代理为例,调用目标对象的方法时,实际上调用的是代理对象的invoke方法。

JdkDynamicAopProxy的invoke方法

 
 
/**
 * Implementation of {@code InvocationHandler.invoke}.
 * <p>Callers will see exactly the exception thrown by the target,
 * unless a hook method throws an exception.
 */
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
MethodInvocation invocation;
Object oldProxy = null;
boolean setProxyContext = false;
​
TargetSource targetSource = this.advised.targetSource;
Class<?> targetClass = null;
Object target = null;
​
try {
if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
// The target does not implement the equals(Object) method itself.
return equals(args[0]);
}
else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
// The target does not implement the hashCode() method itself.
return hashCode();
}
else if (method.getDeclaringClass() == DecoratingProxy.class) {
// There is only getDecoratedClass() declared -> dispatch to proxy config.
return AopProxyUtils.ultimateTargetClass(this.advised);
}
else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
method.getDeclaringClass().isAssignableFrom(Advised.class)) {
// Service invocations on ProxyConfig with the proxy config...
return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
}
​
Object retVal;
​
if (this.advised.exposeProxy) {
// Make invocation available if necessary.
oldProxy = AopContext.setCurrentProxy(proxy);
setProxyContext = true;
}
​
// May be null. Get as late as possible to minimize the time we "own" the target,
// in case it comes from a pool.
target = targetSource.getTarget();
if (target != null) {
targetClass = target.getClass();
}
​
// Get the interception chain for this method.
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
​
// Check whether we have any advice. If we don't, we can fallback on direct
// reflective invocation of the target, and avoid creating a MethodInvocation.
if (chain.isEmpty()) {
// We can skip creating a MethodInvocation: just invoke the target directly
// Note that the final invoker must be an InvokerInterceptor so we know it does
// nothing but a reflective operation on the target, and no hot swapping or fancy proxying.
Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
}
else {
// We need to create a method invocation...
invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
// Proceed to the joinpoint through the interceptor chain.
retVal = invocation.proceed();
}
​
// Massage return value if necessary.
Class<?> returnType = method.getReturnType();
if (retVal != null && retVal == target && returnType.isInstance(proxy) &&
!RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
// Special case: it returned "this" and the return type of the method
// is type-compatible. Note that we can't help if the target sets
// a reference to itself in another returned object.
retVal = proxy;
}
else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
throw new AopInvocationException(
"Null return value from advice does not match primitive return type for: " + method);
}
return retVal;
}
finally {
if (target != null && !targetSource.isStatic()) {
// Must have come from TargetSource.
targetSource.releaseTarget(target);
}
if (setProxyContext) {
// Restore old proxy.
AopContext.setCurrentProxy(oldProxy);
}
}
}

JdkDynamicAopProxy的invoke方法核心代码如下:

      //1).得到目标方法的拦截器链
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
      //2). 调用拦截器链
      //如果chain是空的,直接调用target对象的method
if (chain.isEmpty()) {
Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
}
      //如果chain不是空的,进行拦截器链的调用
else {
invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
// Proceed to the joinpoint through the interceptor chain.
retVal = invocation.proceed();
}

1)拦截器链是如何生成的

我们顺着this.advised.getInterceptorsAndDynamicInterceptionAdvice往下走。

/**
 * Determine a list of {@link org.aopalliance.intercept.MethodInterceptor} objects
 * for the given method, based on this configuration.
 * @param method the proxied method
 * @param targetClass the target class
 * @return List of MethodInterceptors (may also include InterceptorAndDynamicMethodMatchers)
 */
public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Method method, Class<?> targetClass) {
MethodCacheKey cacheKey = new MethodCacheKey(method);
List<Object> cached = this.methodCache.get(cacheKey);
if (cached == null) {
cached = this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(
this, method, targetClass);
this.methodCache.put(cacheKey, cached);
}
return cached;
} 

上面的this.advisorChainFactory其实是DefaultAdvisorChainFactory。

public class DefaultAdvisorChainFactory implements AdvisorChainFactory, Serializable {
​
@Override
public List<Object> getInterceptorsAndDynamicInterceptionAdvice(
Advised config, Method method, Class<?> targetClass) {
​
// This is somewhat tricky... We have to process introductions first,
// but we need to preserve order in the ultimate list.
List<Object> interceptorList = new ArrayList<Object>(config.getAdvisors().length);
Class<?> actualClass = (targetClass != null ? targetClass : method.getDeclaringClass());
boolean hasIntroductions = hasMatchingIntroductions(config, actualClass);
AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();
    //遍历config.getAdvisors
for (Advisor advisor : config.getAdvisors()) {
if (advisor instanceof PointcutAdvisor) {
// Add it conditionally.
PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;
if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(actualClass)) {
          //调用registry.getInterceptors得到advisor的MethodInterceptor
MethodInterceptor[] interceptors = registry.getInterceptors(advisor);
          //调用pointcutAdvisor.getPointcut().getMethodMatcher()得到pointcut的MethodMatcher
MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();
          //调用interceptorList.add将拦截器加入到拦截器链中
if (MethodMatchers.matches(mm, method, actualClass, hasIntroductions)) {
if (mm.isRuntime()) {
// Creating a new object instance in the getInterceptors() method
// isn't a problem as we normally cache created chains.
for (MethodInterceptor interceptor : interceptors) {
interceptorList.add(new InterceptorAndDynamicMethodMatcher(interceptor, mm));
}
}
else {
interceptorList.addAll(Arrays.asList(interceptors));
}
}
}
}
else if (advisor instanceof IntroductionAdvisor) {
IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
if (config.isPreFiltered() || ia.getClassFilter().matches(actualClass)) {
Interceptor[] interceptors = registry.getInterceptors(advisor);
interceptorList.addAll(Arrays.asList(interceptors));
}
}
else {
Interceptor[] interceptors = registry.getInterceptors(advisor);
interceptorList.addAll(Arrays.asList(interceptors));
}
}
​
return interceptorList;
}
​
/**
 * Determine whether the Advisors contain matching introductions.
 */
private static boolean hasMatchingIntroductions(Advised config, Class<?> actualClass) {
for (int i = 0; i < config.getAdvisors().length; i++) {
Advisor advisor = config.getAdvisors()[i];
if (advisor instanceof IntroductionAdvisor) {
IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
if (ia.getClassFilter().matches(actualClass)) {
return true;
}
}
}
return false;
}
}

List<Object> getInterceptorsAndDynamicInterceptionAdvice(Advised config, Method method, Class<?> targetClass)

其实这里的config就是ProxyFactoryBean的实例。(config传入了个AdvisedSupport实例,ProxyFactoryBean继承了AdvisedSupport)

继续找ProxyFactoryBean的代码。

ProxyFactoryBean的getObject方法调用时,会对adviceChain进行初始化(如果未初始化的话)。

 
@Override
public Object getObject() throws BeansException {
    //adviceChain拦截器链的初始化
initializeAdvisorChain();
if (isSingleton()) {
return getSingletonInstance();
}
else {
if (this.targetName == null) {
logger.warn("Using non-singleton proxies with singleton targets is often undesirable. " +
"Enable prototype proxies by setting the 'targetName' property.");
}
return newPrototypeInstance();
}
}

initializeAdvisorChain的内部实现:

因为ProxyFactoryBean实现了BeanFactoryAware接口,因此可以拿到当前的容器实例beanFactory。

通过调用this.beanFactory.get(beanName)方法将各个advice bean拿出来,然后加入到list中。

initializeAdvisorChain的具体内部实现如下。

/**
 * Create the advisor (interceptor) chain. Advisors that are sourced
 * from a BeanFactory will be refreshed each time a new prototype instance
 * is added. Interceptors added programmatically through the factory API
 * are unaffected by such changes.
 */
private synchronized void initializeAdvisorChain() throws AopConfigException, BeansException {
if (this.advisorChainInitialized) {
return;
}
​
if (!ObjectUtils.isEmpty(this.interceptorNames)) {
if (this.beanFactory == null) {
throw new IllegalStateException("No BeanFactory available anymore (probably due to serialization) " +
"- cannot resolve interceptor names " + Arrays.asList(this.interceptorNames));
}
​
// Globals can't be last unless we specified a targetSource using the property...
if (this.interceptorNames[this.interceptorNames.length - 1].endsWith(GLOBAL_SUFFIX) &&
this.targetName == null && this.targetSource == EMPTY_TARGET_SOURCE) {
throw new AopConfigException("Target required after globals");
}
​
// Materialize interceptor chain from bean names.
for (String name : this.interceptorNames) {
if (logger.isTraceEnabled()) {
logger.trace("Configuring advisor or advice '" + name + "'");
}
​
if (name.endsWith(GLOBAL_SUFFIX)) {
if (!(this.beanFactory instanceof ListableBeanFactory)) {
throw new AopConfigException(
"Can only use global advisors or interceptors with a ListableBeanFactory");
}
addGlobalAdvisor((ListableBeanFactory) this.beanFactory,
name.substring(0, name.length() - GLOBAL_SUFFIX.length()));
}
​
else {
// If we get here, we need to add a named interceptor.
// We must check if it's a singleton or prototype.
Object advice;
if (this.singleton || this.beanFactory.isSingleton(name)) {
// Add the real Advisor/Advice to the chain
advice = this.beanFactory.getBean(name);
}
else {
// It's a prototype Advice or Advisor: replace with a prototype.
// Avoid unnecessary creation of prototype bean just for advisor chain initialization.
advice = new PrototypePlaceholderAdvisor(name);
}
addAdvisorOnChainCreation(advice, name);
}
}
}
​
this.advisorChainInitialized = true;
}

总结,在ProxyFactoryBean的getObject方法中,会初始化拦截器链,相关的bean是通过调用beanFactory.get(beanName)方法得到的。

 

2)拦截器链是如何链式调用的

ReflectiveMethodInvocation.proceed执行拦截器链的调用。

下面摘录了ReflectiveMethodInvocation的部分代码。

 
//ReflectiveMethodInvocation实现了接口ProxyMethodInvocation,而ProxyMethodInvocation是MethodInvocation的子接口。
//因此,ReflectiveMethodInvocation实现了MethodInvocation接口。
public class ReflectiveMethodInvocation implements ProxyMethodInvocation, Cloneable {
​
protected final Object proxy;
​
protected final Object target;
​
protected final Method method;
​
protected Object[] arguments;
​
private final Class<?> targetClass;
​
/**
 * List of MethodInterceptor and InterceptorAndDynamicMethodMatcher
 * that need dynamic checks.
 */
  //拦截器列表
protected final List<?> interceptorsAndDynamicMethodMatchers;
​
/**
 * Index from 0 of the current interceptor we're invoking.
 * -1 until we invoke: then the current interceptor.
 */
private int currentInterceptorIndex = -1;
​
@Override
public Object proceed() throws Throwable {
//We start with an index of -1 and increment early.
    //如果拦截器list到了最后了,运行目标方法
if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
return invokeJoinpoint();
}
//根据currentInterceptorIndex得到list中的拦截器
Object interceptorOrInterceptionAdvice =
this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
    //1.如果拦截器中不仅有Interceptor,还需要进行动态方法匹配DynamicMethodMatcher
    //InterceptorAndDynamicMethodMatcher包含了Interceptor和DynamicMethodMatcher,
    //其中DynamicMethodMatcher用于运行时检查,用于在运行时判断方法是否需要拦截
    //(说明:MethodMatcher方法匹配分静态和动态两种
    //个人理解:
    //静态检查:比如你要拦截的方法名是精确的,就是某个类的某个方法,可以在程序非运行时,就可判断是否需要拦截
    //动态检查:比如你要拦截的某个方法,且要求入参为“aaa”,这种肯定需要运行时判断)
if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
// Evaluate dynamic method matcher here: static part will already have
// been evaluated and found to match.
InterceptorAndDynamicMethodMatcher dm =
(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
      //1.1 如果匹配上了,调用interceptor的invoke方法
if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
        //如果匹配上了,调用拦截器方法
        //注意:interceptor.invoke(this)传入的是this。
        //而ReflectiveMethodInvocation实现了MethodInvocation接口
        //因此,传入的是一个MethodInvocation实例。
return dm.interceptor.invoke(this);
}
      //1.2 如果没有匹配上,
else {
// Dynamic matching failed.
// Skip this interceptor and invoke the next in the chain.
return proceed();
}
}
    //2. 如果拦截器就是个interceptor,调用invoker方法
else {
// It's an interceptor, so we just invoke it: The pointcut will have
// been evaluated statically before this object was constructed.
return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
}
}
}
public interface MethodInterceptor extends Interceptor {
​
/**
 * Implement this method to perform extra treatments before and
 * after the invocation. Polite implementations would certainly
 * like to invoke {@link Joinpoint#proceed()}.
 * @param invocation the method invocation joinpoint
 * @return the result of the call to {@link Joinpoint#proceed();
 * might be intercepted by the interceptor
 * @throws Throwable if the interceptors or the target object
 * throws an exception
 */
Object invoke(MethodInvocation invocation) throws Throwable;
} 

MethodBeforeAdviceInterceptor:会在目标方法运行之前进行拦截。

public class MethodBeforeAdviceInterceptor implements MethodInterceptor, Serializable {
private MethodBeforeAdvice advice;
/**
 * Create a new MethodBeforeAdviceInterceptor for the given advice.
 * @param advice the MethodBeforeAdvice to wrap
 */
public MethodBeforeAdviceInterceptor(MethodBeforeAdvice advice) {
Assert.notNull(advice, "Advice must not be null");
this.advice = advice;
}
​
@Override
public Object invoke(MethodInvocation mi) throws Throwable {
this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis() );
return mi.proceed();
}
} 

AfterReturningAdviceInterceptor:会在目标方法返回后进行拦截

public class AfterReturningAdviceInterceptor implements MethodInterceptor, AfterAdvice, Serializable {
private final AfterReturningAdvice advice;
/**
 * Create a new AfterReturningAdviceInterceptor for the given advice.
 * @param advice the AfterReturningAdvice to wrap
 */
public AfterReturningAdviceInterceptor(AfterReturningAdvice advice) {
Assert.notNull(advice, "Advice must not be null");
this.advice = advice;
}
​
@Override
public Object invoke(MethodInvocation mi) throws Throwable {
Object retVal = mi.proceed();
this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());
return retVal;
}
}

 

3)Spring使用职责链模式实现拦截器链链式调用

将上面调用拦截器链的简化下,如下。

public interface MethodInterceptor {
​
    Object invoke(MethodInvocation mi);
}
public class MethodBeforeInterceptor implements MethodInterceptor {
​
    @Override
    public Object invoke(MethodInvocation mi) {
        before();
        return mi.proceed();
    }
​
    private void before() {
        System.out.println("Method before");
    }
}
public class AfterReturningInterceptor implements MethodInterceptor {
​
    @Override
    public Object invoke(MethodInvocation mi) {
        Object retVal = mi.proceed();
        afterReturning();
        return retVal;
    }
​
    private void afterReturning() {
        System.out.println("afterReturning");
    }
}
public interface MethodInvocation {
​
    Object proceed();
}
public class ReflectiveMethodInvocation implements MethodInvocation{
​
    private List<MethodInterceptor> interceptors;
​
    public ReflectiveMethodInvocation(List<MethodInterceptor> interceptors) {
        this.interceptors = interceptors;
    }
​
    private int currentInterceptorIndex = -1;
​
    public Object proceed() {
        if (currentInterceptorIndex == interceptors.size() - 1) {
            System.out.println("invoke target method");
            return "obj after invoke target method";
        }
        return interceptors.get(++currentInterceptorIndex).invoke(this);
    }
}
public class Client {
​
    public static void main(String[] args) {
        List<MethodInterceptor> interceptors = Arrays.asList(
                new AfterReturningInterceptor(),
                new MethodBeforeInterceptor()
        );
        ReflectiveMethodInvocation invocation = new ReflectiveMethodInvocation(interceptors);
        invocation.proceed();
    }
}

结果如下:

Method before
invoke target method
afterReturning

(这里抛个思考题:

运行结果与List<MethodInterceptor>中interceptor的顺序有关吗?

把new AfterReturningInterceptor()和new MethodBeforeInterceptor()换下顺序,结果会不同吗?

答案:无关,不会。

 

5. ProxyFactory实现AOP

通过配置的方式使用AOP时,是通过ProxyFactoryBean的getObject()方法得到代理对象的。

Spring 提供ProxyFactory类,可以通过编写代码的方式创建代理对象。

        TargetImpl target = new TargetImpl();
        ProxyFactory proxyFactory = new ProxyFactory(target);
        proxyFactory.addAdvisor(yourAdvisor);
        proxyFactory.addAdvice(yourAdvice);
        TargetImpl targetProxy = (TargetImpl)proxyFactory.getProxy();

ProxyFactory类提供的方法如下。

/**
 * Factory for AOP proxies for programmatic use, rather than via a bean
 * factory. This class provides a simple way of obtaining and configuring
 * AOP proxies in code.
 *
 * @author Rod Johnson
 * @author Juergen Hoeller
 * @author Rob Harrop
 * @since 14.03.2003
 */
@SuppressWarnings("serial")
public class ProxyFactory extends ProxyCreatorSupport {

    /**
     * Create a new ProxyFactory.
     */
    public ProxyFactory() {
    }
  
    public ProxyFactory(Object target) {
        setTarget(target);
        setInterfaces(ClassUtils.getAllInterfaces(target));
    }

    public ProxyFactory(Class<?>... proxyInterfaces) {
        setInterfaces(proxyInterfaces);
    }

    public ProxyFactory(Class<?> proxyInterface, Interceptor interceptor) {
        addInterface(proxyInterface);
        addAdvice(interceptor);
    }

    public ProxyFactory(Class<?> proxyInterface, TargetSource targetSource) {
        addInterface(proxyInterface);
        setTargetSource(targetSource);
    }

    public Object getProxy() {
        return createAopProxy().getProxy();
    }

    public Object getProxy(ClassLoader classLoader) {
        return createAopProxy().getProxy(classLoader);
    }

    @SuppressWarnings("unchecked")
    public static <T> T getProxy(Class<T> proxyInterface, Interceptor interceptor) {
        return (T) new ProxyFactory(proxyInterface, interceptor).getProxy();
    }

    @SuppressWarnings("unchecked")
    public static <T> T getProxy(Class<T> proxyInterface, TargetSource targetSource) {
        return (T) new ProxyFactory(proxyInterface, targetSource).getProxy();
    }

    public static Object getProxy(TargetSource targetSource) {
        if (targetSource.getTargetClass() == null) {
            throw new IllegalArgumentException("Cannot create class proxy for TargetSource with null target class");
        }
        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.setTargetSource(targetSource);
        proxyFactory.setProxyTargetClass(true);
        return proxyFactory.getProxy();
    }
}

 

 

 

易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!