Spring AOP

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {
    
    // 设置为true，表示代理对象的生成都是通过CGLIB方式
    boolean proxyTargetClass() default false;
    
    // 为了解决一些由于代理引发的切面失效问题，Spring AOP在Spring 4.3.1中引入了AopContext类来将处理类的引用存储在ThreadLocal中，通过AopContext可以快速获取当前类的代理类
    //默认为关闭，如果声明为true，即可使用AopContext获取代理类
    boolean exposeProxy() default false;
}

class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        // 向ioc容器中注册一个 AnnotationAwareAspectJAutoProxyCreator 后置处理器，它是用来生成代理对象的
        AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
        // 处理注解的两个属性
        AnnotationAttributes enableAspectJAutoProxy = AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
        if (enableAspectJAutoProxy != null) {
            // 如果proxyTargetClass设置为true，则强制指定AutoProxyCreator使用CGLIB进行代理
            if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
                AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
            }
            // 如果exposeProxy设置为true，则开启exposeProxy特性
            if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
                AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
            }
        }
    }
}

// 1.后置处理方法
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
    if (bean != null) {
        // 从BeanFactory中找到bean的key
        Object cacheKey = getCacheKey(bean.getClass(), beanName);
        // earlyProxyReferences 保存创建中的代理对象，如果bean跟缓存的对象不一致或者不存在，就开始生成代理对象
        if (this.earlyProxyReferences.remove(cacheKey) != bean) {
            // 生成代理对象
            return wrapIfNecessary(bean, beanName, cacheKey);
        }
    }
    return bean;
}
// 2.判断是否需要生成代理对象
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
    // 判断是否需要生成代理对象
    if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
        return bean;
    }
    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;
    }
    // 判断是否需要生成代理对象
    Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
    if (specificInterceptors != DO_NOT_PROXY) {// DO_NOT_PROXY = null
        this.advisedBeans.put(cacheKey, Boolean.TRUE);
        // 生成代理
        Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
        this.proxyTypes.put(cacheKey, proxy.getClass());
        return proxy;
    }
    this.advisedBeans.put(cacheKey, Boolean.FALSE);
    return bean;
}
// 3. 为当前bean实例生成代理对象
protected Object createProxy(Class<?> beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {
    if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
        AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
    }
    // 创建代理工厂
    ProxyFactory proxyFactory = new ProxyFactory();
    proxyFactory.copyFrom(this);

    if (proxyFactory.isProxyTargetClass()) {
        if (Proxy.isProxyClass(beanClass)) {
            for (Class<?> ifc : beanClass.getInterfaces()) {
                proxyFactory.addInterface(ifc);
            }
        }
    } else {
        if (shouldProxyTargetClass(beanClass, beanName)) {
            proxyFactory.setProxyTargetClass(true);
        } else {
            evaluateProxyInterfaces(beanClass, proxyFactory);
        }
    }
    // 所有aop的切面
    Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
    // 设置代理工厂
    // 1. 设置切面    
    proxyFactory.addAdvisors(advisors);			
    // 2. 设置目标对象
    proxyFactory.setTargetSource(targetSource);
    customizeProxyFactory(proxyFactory);

    proxyFactory.setFrozen(this.freezeProxy);
    if (advisorsPreFiltered()) {
        proxyFactory.setPreFiltered(true);
    }
    // 3.生成代码对象
    return proxyFactory.getProxy(getProxyClassLoader());
}

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
    // 1. 实例化对象
    // 反射生成对象 beanName -> BeanWrapper
    BeanWrapper instanceWrapper = createBeanInstance(beanName, mbd, args);
    // 获得原始对象  BeanWrapper ->  bean
    Object bean = instanceWrapper.getWrappedInstance();
    
    // 2.处理特殊的BeanPostProcessor，比如AutowiredAnnotationBeanPostProcessor，解析@Autowired的属性
    applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
    
    // 3.将创建中的对象，先保存到三级缓存中。判断条件： 单例 && 允许循环引用 && 对象正在创建中
    // 作用1：将单例对象缓存起来，目的是为了解决循环引用的问题（在允许循环引用的前提下，已经正在创建中的单例）
    // 作用2: 调用 getEarlyBeanReference 方法，对需要进行aop的对象生成 代理对象，不需要的还是原始对象。并将其封装为ObjectFactory对象。
    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName));
    if(earlySingletonExposure){
        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }
    // exposedObject 表示对外暴露的对象
    Object exposedObject = bean;
    // 4.自动装配Bean实例的属性
    populateBean(beanName, mbd, instanceWrapper);
    
    // 5.初始化对象，即调用init()，并且根据需要生成AOP的代理对象（如果在上面第3步的时候已经生成过AOP代理，此步不再生成）
    exposedObject = initializeBean(beanName, exposedObject, mbd);
    
    // 如果对象保存在三级缓存的话，在完成对象创建后，对依赖的对象进行处理
    if (earlySingletonExposure) {
        // 获得当前对象，getSingleton 将三级缓存转移到二级缓存中
        Object earlySingletonReference = getSingleton(beanName, false);
        if (earlySingletonReference != null) {
            if (exposedObject == bean) {
                exposedObject = earlySingletonReference;
            } else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
                // 如果bean创建的时候，有依赖的对象，这里需要判断所有依赖的对象是否也存在创建了
                String[] dependentBeans = getDependentBeans(beanName);
                Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
                for (String dependentBean : dependentBeans) {
                    if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                        actualDependentBeans.add(dependentBean);
                    }
                }
                // 有依赖没有创建就抛出异常
                if (!actualDependentBeans.isEmpty()){
                    throw new BeanCurrentlyInCreationException(beanName);
                }
            }
        }
    }
    return exposedObject;
}

/**
 * 将刚刚创建的对象放入缓存
 * 这里并不是直接将Bean放入缓存，而是包装成了ObjectFactory对象再放入
 */
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
    synchronized (this.singletonObjects) {
        if (!this.singletonObjects.containsKey(beanName)) {
            this.singletonFactories.put(beanName, singletonFactory);// 加入三级缓存
            this.earlySingletonObjects.remove(beanName);			// 保护性的从二级缓存删除
            this.registeredSingletons.add(beanName);
        }
    }
}
// 初始化bean
protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
   // 依次调用 BeanNameAware  BeanClassLoaderAware  BeanFactoryAware 的增强方法
   if (bean instanceof Aware) {
      if (bean instanceof BeanNameAware) {
       ((BeanNameAware) bean).setBeanName(beanName);
      }
      if (bean instanceof BeanClassLoaderAware) {
        ((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());
      }
      if (bean instanceof BeanFactoryAware) {
        ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
      }
   }
   // 调用BeanPostProcessor 的前置初始化方法
   Object wrappedBean = bean;
   if (mbd == null || !mbd.isSynthetic()) {
      wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
   }
   // 调用初始化方法
   // 调用 InitializingBean#afterPropertiesSet方法
   // 调用 xml配置的 init 方法  
   invokeInitMethods(beanName, wrappedBean, mbd);

   // 调用BeanPostProcessor 的后置初始化方法
   if (mbd == null || !mbd.isSynthetic()) {
      wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
   }
   return wrappedBean;
}

// 生成早期代理对象
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
   Object exposedObject = bean;
   if (bean != null && !mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
      for (BeanPostProcessor bp : getBeanPostProcessors()) {
         // 找到后置处理器中的 SmartInstantiationAwareBeanPostProcessor （也就是 AnnotationAwareAspectJAutoProxyCreator ）
         if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
            SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
            // 其实调用的是AbstractAutoProxyCreator#getEarlyBeanReference方法去创建代理对象
            exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
            if (exposedObject == null) {
                return null;
            }
         }
      }
   }
   // 代理对象或者原始对象
   return exposedObject;
}

public Object getProxy(@Nullable ClassLoader classLoader) {
    //1.createAopProxy()判断生成代理的方式: cglib或jdk
    //2.getProxy()生成代理对象
    return createAopProxy().getProxy(classLoader);
}

/**
 * 获取动态代理生成器
 */
protected final synchronized AopProxy createAopProxy() {
    if (!this.active) {
        activate();
    }
    return getAopProxyFactory().createAopProxy(this);
}

public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
    // 如果没有用户接口的话，那就使用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.");
        }
        if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
            return new JdkDynamicAopProxy(config);
        }
        return new ObjenesisCglibAopProxy(config);
    } else {
        // 有接口就通过JDK的动态代理
        return new JdkDynamicAopProxy(config);
    }
}

// 接口
public interface IFun{
    
} 
// 实现类
@Service
public class FunImpl implements IFun {
    
}
// 注入实现类， spring 项目中会因为找不到fun报错了。而spring boot项目中可以找到
@Service
public class Demo {
    @Autowrite
    private FunImpl fun;
}

public class ReflectiveMethodInvocation implements ProxyMethodInvocation, Cloneable {
   // 代理对象 
   protected final Object proxy;
   // 目标原始对象
   protected final Object target;
   // 需要调用的方法
   protected final Method method;
   // 目标类型
   private final Class<?> targetClass;
   // 需要执行的功能责任链，比如事务的 TransactionInterceptor、CacheInterceptor....
   protected final List<?> interceptorsAndDynamicMethodMatchers;
   // 责任链执行的位置，从0开始依次执行
   private int currentInterceptorIndex = -1;

   public Object proceed() throws Throwable {
      // 1. 依次执行责任链中的功能，当没有 interceptor 都执行完之后，我们就通过反射调用目标对象
      if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
         return invokeJoinpoint();
      }
      // 2. 找到需要执行的 interceptor
      Object interceptorOrInterceptionAdvice = this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
      
      // 3. 调用 interceptor
      if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
         InterceptorAndDynamicMethodMatcher dm = (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
         Class<?> targetClass = (this.targetClass != null ? this.targetClass : this.method.getDeclaringClass());
         if (dm.methodMatcher.matches(this.method, targetClass, this.arguments)) {
            return dm.interceptor.invoke(this);
         } else {
            return proceed();
         }
      } else {
         // 正常的时候，都调用这个，MethodInterceptor 对象在执行自己的功能后，
         // 都会调用 invocation.proceed(),继续执行责任链的 interceptor
         return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
      }
   }
   //通过反射调用目标对象
   protected Object invokeJoinpoint() throws Throwable {
      return AopUtils.invokeJoinpointUsingReflection(this.target, this.method, this.arguments);
   }
}

// 1. 异步调用
public class AsyncExecutionInterceptor extends AsyncExecutionAspectSupport implements MethodInterceptor, Ordered {

   public Object invoke(final MethodInvocation invocation) throws Throwable {
      Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);
      Method specificMethod = ClassUtils.getMostSpecificMethod(invocation.getMethod(), targetClass);
      final Method userDeclaredMethod = BridgeMethodResolver.findBridgedMethod(specificMethod);

      AsyncTaskExecutor executor = determineAsyncExecutor(userDeclaredMethod);
      if (executor == null) {
         throw new IllegalStateException("No executor specified and no default executor set on AsyncExecutionInterceptor either");
      }
      // 创建一个回调函数，里面调用 invocation.proceed()，并把任务提交到线程池  
      Callable<Object> task = () -> {
         try {
            Object result = invocation.proceed();
            if (result instanceof Future) {
               return ((Future<?>) result).get();
            }
         } catch (ExecutionException ex) {
            handleError(ex.getCause(), userDeclaredMethod, invocation.getArguments());
         } catch (Throwable ex) {
            handleError(ex, userDeclaredMethod, invocation.getArguments());
         }
         return null;
      };

      return doSubmit(task, executor, invocation.getMethod().getReturnType());
   }
}
// 2.事务
public class TransactionInterceptor extends TransactionAspectSupport implements MethodInterceptor, Serializable {
   public Object invoke(MethodInvocation invocation) throws Throwable {
      Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);
      // 开启事务后，调用 invocation.proceed()
      return invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed);
   }
}