AOP

https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#aop

根据 Spring 源码，再 Spring 完成 bean 的生命周期回调之后，开始进行 AOP 代理，所调用的就是 BeanPostProcessor 的 postProcessAfterInitialization 方法

@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
    throws BeansException {
    Object result = existingBean;
    // 执行直接实现了 BeanPostProcessor 的类的 postProcessAfterInitialization 方法
    for (BeanPostProcessor processor : getBeanPostProcessors()) {
        Object current = processor.postProcessAfterInitialization(result, beanName);
        if (current == null) {
            return result;
        }
        result = current;
    }
    return result;
}

既然知道了原理，我么也可以实现了一个 AOP，我们使用 @Import 注解导入的方式（方便扩展）

@Service
public class UserService {
    public void testAop() {
        System.out.println("UserService test aop");
    }
}
public class CustomAopBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof UserService) {
            bean = CglibUtils.getProxy(bean.getClass(), new MethodInterceptor() {
                @Override
                public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                    System.out.println("aop ----------");
                    Object result = methodProxy.invokeSuper(o, args);
                    return result;
                }
            });
        }
        return bean;
    }
}
@Configuration
@ComponentScan("org.wesoft.spring.aop")
@EnableAspectJAutoProxy
@Import(CustomAopBeanPostProcessor.class)
public class AppConfig {
}
public class App {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext();
        ac.register(AppConfig.class);
        ac.refresh();
        ac.getBean(UserService.class).testAop();
    }
}
// 运行结果
aop ----------
UserService test aop

什么是 AOP

与 OOP 对比，面向切面，传统的 OOP 开发中的代码逻辑是自上而下的，而这些过程会产生一些横切性问题，这些横切性问题和我们的业务关系不大，这些横切问题不会影响到主逻辑的实现，但是会散落到代码的各个部分，难以维护，AOP 是处理一些横切性的问题，AOP 的编程思想就是把这些问题和主业务逻辑分开，达到与主业务逻辑解耦的目的。使代码的重用性和开发效率更高

应用场景

• 日志记录
• 权限验证
• 效率检查
• 事务管理
• 异常处理

相关概念

• Aspect: 切面，一个综合体.
• Join point: 连接点，如方法的执行和异常的处理，在 Spring AOP 中，指的是方法的执行.
  
• Advice: 通知，包括“around”, “before” and “after” 通知
  
• Pointcut: 匹配连接点，是一段表达式，一个集合.
  
• Introduction: 代表类型声明其他方法或字段
• Target object: 目标对象.
  
• AOP proxy: 代理对象
  
• Weaving: 将通知应用到切点的过程

通知类型

• Before advice: Advice that runs before a join point but that does not have the ability to prevent execution flow proceeding to the join point (unless it throws an exception).
  
• After returning advice: Advice to be run after a join point completes normally (for example, if a method returns without throwing an exception).
  
• After throwing advice: Advice to be executed if a method exits by throwing an exception.
  
• After (finally) advice: Advice to be executed regardless of the means by which a join point exits (normal or exceptional return).
  
• Around advice: Advice that surrounds a join point such as a method invocation. This is the most powerful kind of advice. Around advice can perform custom behavior before and after the method invocation. It is also responsible for choosing whether to proceed to the join point or to shortcut the advised method execution by returning its own return value or throwing an exception.

execution

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern?name-pattern(param-pattern)
                throws-pattern?)

Spring 第一次调用后置处理器

在 createBean 中，第一次调用后置处理器时，完成了，是否要代理 Bean 的逻辑

try {
    // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
    // 给 BeanPostProcessors 来返回代理对象 代替 目标对象
    // ★★★ 第一次调用后置处理器---在 bean 被实例化之前调用
    // 此处调用的目的是，判断当前的 bean 将来是否能够被代理，
    // 实例化之前解析 bean，来判断这个 bean 是不是需要代理
    // 这里会将可能会被代理的类，放入 advisedBeans（Map）中，其中 key 为 bean 的名字，value 为 是否需要被代理
    Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
    if (bean != null) {
        return bean;
    }
}
@Nullable
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
    Object bean = null;
    // 判断 实例化处理器是否已经开始工作
    if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
        // Make sure bean class is actually resolved at this point.
        // 是否不是一个合成类
        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            Class<?> targetType = determineTargetType(beanName, mbd);
            if (targetType != null) {
                // 判断是否需要被代理
                bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                if (bean != null) {
                    bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
                }
            }
        }
        mbd.beforeInstantiationResolved = (bean != null);
    }
    return bean;
}
@Nullable
protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
    for (BeanPostProcessor bp : getBeanPostProcessors()) {
        if (bp instanceof InstantiationAwareBeanPostProcessor) {
            InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
            // 调用后置处理器，如果开启了 @EnableAspectJAutoProxy
            // 就会调用 AnnotationAwareAspectJAutoProxyCreator 的 postProcessBeforeInstantiation
            Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
            if (result != null) {
                return result;
            }
        }
    }
    return null;
}

这里调用了 AbstractAutoProxyCreator 的 postProcessBeforeInstantiation 方法，其中 this.advisedBeans 中存放了是否需要代理的 bean，其中 key = beanName，value = boolean，表示是否需要被代理

@Override
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
    // 获取 bean 的名字，如果是 FactoryBean 的话，给他的前面加一个 & 符号
    Object cacheKey = getCacheKey(beanClass, beanName);
    if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
        // 判断 advisedBeans 是否是包含不需要被代理的类
        // advisedBeans 存放着两种 bean
        // 1、不能被代理，比如 切面（Aspect），配置类（AppConfig），后置处理器（BeanPostProcessor），这些都是不能被代理的类
        // 2、已经被代理的被，因为不需要继续被代理
        if (this.advisedBeans.containsKey(cacheKey)) {
            return null;
        }
        // 判断是不是不需要被代理的类，如果是，则放到 advisedBeans 中
        // 先判断是不是基础 Bean 或者 prototype 类型的 bean
        if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return null;
        }
    }
    // Create proxy here if we have a custom TargetSource.
    // Suppresses unnecessary default instantiation of the target bean:
    // The TargetSource will handle target instances in a custom fashion.
    TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
    if (targetSource != null) {
        if (StringUtils.hasLength(beanName)) {
            this.targetSourcedBeans.add(beanName);
        }
        Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
        Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
        this.proxyTypes.put(cacheKey, proxy.getClass());
        return proxy;
    }
    return null;
}

Spring 开始创建 AOP 代理对象

if (mbd == null || !mbd.isSynthetic()) {
    // ★★★ 开始执行对象的代理（AOP）
    wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
    throws BeansException {
    Object result = existingBean;
    // 执行直接实现了 BeanPostProcessor 的类的 postProcessAfterInitialization 方法
    for (BeanPostProcessor processor : getBeanPostProcessors()) {
        Object current = processor.postProcessAfterInitialization(result, beanName);
        if (current == null) {
            return result;
        }
        result = current;
    }
    return result;
}
@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;
}

Spring 会先判断这个 bean 是否在 advisedBeans 中，在判断 bean 的类型，是否时不需要被代理的类型，然后找出我们提供的切面，在检查我们提供 bean 是否符合这个切面

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
    if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
        return bean;
    }
    // 判断 在不在 advisedBeans 里
    if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
        return bean;
    }
    if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
    }
    // Create proxy if we have advice.
    // ★ 判断这个 bean 是否符合我们提供的切面规则
    Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
    if (specificInterceptors != DO_NOT_PROXY) {
        // 需要被代理的类
        this.advisedBeans.put(cacheKey, Boolean.TRUE);
        // ★★★ 关键代码：开始创建代理
        Object proxy = createProxy(
            bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
        this.proxyTypes.put(cacheKey, proxy.getClass());
        return proxy;
    }
    // 代理完成，将这个对象放入 advisedBeans，并标记为 不需要被代理
    this.advisedBeans.put(cacheKey, Boolean.FALSE);
    return bean;
}

Spring 开始创建代理对象

if (mbd == null || !mbd.isSynthetic()) {
    // ★★★ 开始执行对象的代理（AOP）
    wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
    throws BeansException {
    Object result = existingBean;
    // 执行直接实现了 BeanPostProcessor 的类的 postProcessAfterInitialization 方法
    for (BeanPostProcessor processor : getBeanPostProcessors()) {
        Object current = processor.postProcessAfterInitialization(result, beanName);
        if (current == null) {
            return result;
        }
        result = current;
    }
    return result;
}
@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;
}
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
    if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
        return bean;
    }
    // 判断 在不在 advisedBeans 里
    if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
        return bean;
    }
    if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
    }
    // Create proxy if we have advice.
    // ★ 判断这个 bean 是否符合我们提供的切面规则
    Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
    if (specificInterceptors != DO_NOT_PROXY) {
        // 需要被代理的类
        this.advisedBeans.put(cacheKey, Boolean.TRUE);
        // ★★★ 关键代码：开始创建代理
        Object proxy = createProxy(
            bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
        this.proxyTypes.put(cacheKey, proxy.getClass());
        return proxy;
    }
    // 代理完成，将这个对象放入 advisedBeans，并标记为 不需要被代理
    this.advisedBeans.put(cacheKey, Boolean.FALSE);
    return bean;
}