Spring 系列篇之彻底了解AOP

本篇文章主要介绍如何快速使用Spring AOP,以及Spring AOP的一个基本原理。
首先我们在介绍如何使用XML格式来使用Spring AOP。

1. 概念

在使用AOP之前我们简单来介绍一下，不得不提的几个重要概念，官网也有说明

• Aspect 切面(包括Advice,Pointcut)，通常指一个类
• Join point 连接点，通常指类中需要被代理的方法
• Advice 通知(建议)，通常指需要增强的代码。分为(戳我查看详细)：前，后，环绕，返回，抛异常
• Pointcut 切入点，通常指通知与连接点的关联，也就是定义连接点的表达式。语法戳这里

2. 使用

搞清楚概念之后，我们在来实际操作，我来做几个例子。我们先定义以下几个类

Person and Animal

Person

public interface Person {
    void run();
    int getMoney();
}

Man

public class Man implements Person {
    @Override
    public void run() {
        System.out.println("by car");
    }

    @Override
    public int getMoney() {
        return 1-000-000-000;
    }
}

Animal

public class Animal {
    public void run(){
        System.out.println("四条腿跑");
    }
    public void say(){
        int i = 1 / 0;
    }
}

2.2 XML方式使用AOP

定义好后我们接下来我们想把 run方法添加一个环绕通知，getMoney添加一个返回通知，say添加一个异常通知。那么接下来我们来创建一个切面Aspect

@Component
public class AspectBean {
    public void before(JoinPoint point){
        System.out.println("this is before");
    }
    public void after(JoinPoint point) throws Throwable{
        System.out.println("this is after +" + point);
    }
    public void afterReturn(JoinPoint point,Object aa){
        System.out.println("this is afterReturn +" + point);
    }
    public void round(JoinPoint point) throws Throwable{
        System.out.println("this is round before +" + point);
        ((ProceedingJoinPoint)point).proceed();
        System.out.println("this is round after +" + point);
    }
    public void throwException(JoinPoint point,Throwable exs){
        System.out.println("error +" + point);
    }
}

创建好切面后。我先来看看用XML配置方式,因为这里只测试切面相关的XML配置,其它Bean注入此处省略。

上面介绍的是用在注入我们的切面。其实我们还可以用，如下：

不过用这个时，我们的通知需要实现Advice接口，如上面的aroundAdvice,afterReturnAdvice定义分别如下：

public class AroundAdvice implements MethodInterceptor {
    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        return invocation.proceed();
    }
}

public class AfterReturnAdvice implements AfterReturningAdvice {
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("afterReturning");
    }
}

2.2 Annotation方式使用AOP

以上就是用XML格式使用了我们的Spring AOP，接下来我们在用注解方式实现一遍，注意Spring AOP的注解是支
持 AspectJ的。所以我们用AspectJ的注解。在使用注解之前我们需要先开启支持注解，开启方式也有两种,XML 和 Annotation @EnableAspectJAutoProxy。
以下Annotation事例功能等同于上面,这里需要注意的就是@Component需要和@Aspect一起使用。

@Component
@Aspect
public class AspectJBean {
    @AfterReturning(value = "execution(* com.lykos.aop..*.getMoney(..))",returning = "xx")
    public void afterReturn(JoinPoint point,Object aa){
        System.out.println("this is afterReturn +" + point);
    }

    /**
     * 这里用pointcut修饰方法，以便在@Around上直接使用
     */
    @Pointcut("execution(* com.lykos.aop..*.run(..))")
    public void aroundPointcut(){}


    @Around("aroundPointcut()")
    public void round(JoinPoint point) throws Throwable{
        System.out.println("this is round before +" + point);
        ((ProceedingJoinPoint)point).proceed();
        System.out.println("this is round after +" + point);
    }
    @AfterThrowing(value = "execution(* com.lykos.aop..*.say(..))",throwing = "ex")
    public void throwException(JoinPoint point,Throwable ex){
        System.out.println("error +" + point);
    }
}

3. 原理

Spring AOP是支持JDK动态代理和Cglib动态代理的，默认只要类有实现接口就是用的JDK动态代理，如果没有实现任何接口则使用Cglib动态代理。

3.2 启用流程

3.2.1 @EnableAspectJAutoProxy 启动流程

前面我们讲过，要使用AOP我们需要使用@EnableAspectJAutoProxy,接下来我们看看@EnableAspectJAutoProxy为我们做了什么。根据定义我们发现帮我们引入了AspectJAutoProxyRegistrar

@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {
    boolean proxyTargetClass() default false;
    boolean exposeProxy() default false;

}

3.2.1.1 AspectJAutoProxyRegistrar

AspectJAutoProxyRegistrar是实现了ImportBeanDefinitionRegistrar接口，其定义如下

public interface ImportBeanDefinitionRegistrar {
    void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry);
}

可以发现他就是一个注册Bean的接口，并且还可以实EnvironmentAware,BeanFactoryAware ,BeanClassLoaderAware,ResourceLoaderAware接口，也就是说我们在使用registerBeanDefinitions方法做Bean注册时可以拿到以上列的相关对象。而他通常和@Import一起使用。类似@Import(AspectJAutoProxyRegistrar.class)。那么到这里我们知道AspectJAutoProxyRegistrar是注册Bean的类，接下来我们看看他到底注册的哪个Bean

class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        // (1) 注册 AnnotationAwareAspectJAutoProxyCreator
        AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
        AnnotationAttributes enableAspectJAutoProxy = AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
        // (2)获取EnableAspectJAutoProxy 属性值
        if (enableAspectJAutoProxy != null) {
            if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
                AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
            }
            if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
                AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
            }
        }
    }

}

3.2.1.1.1 (1) 注册 AnnotationAwareAspectJAutoProxyCreator

AnnotationAwareAspectJAutoProxyCreator最终是实现了BeanPostProcessor接口中的postProcessAfterInitialization方法，通过Spring 系列篇之后置处理器我们知道postProcessAfterInitialization是可以改变我们Bean的实际返回值的。那么重点来了，Spring AOP就是在这里帮我们做的代理。

@Override
    public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
        if (bean != null) {
            Object cacheKey = getCacheKey(bean.getClass(), beanName);
            if (this.earlyProxyReferences.remove(cacheKey) != bean) {
                return wrapIfNecessary(bean, beanName, cacheKey);
            }
        }
        return bean;
    }

上面会走wrapIfNecessary -> AbstractAutoProxyCreator.createProxy
AbstractAutoProxyCreator.createProxy

protected Object createProxy(Class beanClass, @Nullable String beanName,
        @Nullable Object[] specificInterceptors, TargetSource targetSource) {
    if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
        AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
    }
    ProxyFactory proxyFactory = new ProxyFactory();
    proxyFactory.copyFrom(this);
    //判断是否强制走Cglib代理
    if (!proxyFactory.isProxyTargetClass()) {
        if (shouldProxyTargetClass(beanClass, beanName)) {
            proxyFactory.setProxyTargetClass(true);
        }
        else {
            //分析需要代理的对象是否实现了接口，如果实现了接口，则使用Jdk 动态代理
            evaluateProxyInterfaces(beanClass, proxyFactory);
        }
    }
    //此处获取到的Advisor 来源在 【4. Advice】 提到
    Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
    proxyFactory.addAdvisors(advisors);
    proxyFactory.setTargetSource(targetSource);
    customizeProxyFactory(proxyFactory);
    proxyFactory.setFrozen(this.freezeProxy);
    if (advisorsPreFiltered()) {
        proxyFactory.setPreFiltered(true);
    }
    //会创建AopProxy对象，并使用他为我们创建实际代理对象
    return proxyFactory.getProxy(getProxyClassLoader());
}

上面我们需要关注两个信息。

• 第一个是proxyTargetClass这个属性，如果为ture代表强制使用Cglib做代理，如果不是就会调用 evaluateProxyInterfaces分析是否有实现接口，如果有则使用JDK动态代理。
• 第二个是proxyFactory.getProxy这个方法会先帮我们创建一个AopProxy对象，然后使用他创建实际的代理对象。其实AopProxy是一个接口，真正实现他的，如图：
  
  AopProxy
  
  无论是JdkDynamicAopProxy还是CglibAopProxy都会在其代理的方法上使用
  List