（Spring源码分析）Spring Aop生成动态代理源码

Spring Aop的核心就是 生成动态代理和 动态代理织入，本篇主要讲 Spring Aop生成动态代理， Spring Aop动态代理织入在 Spring Aop动态代理织入博文中

Spring Aop生成动态代理出现在创建bean时，主要使用了工厂模式、动态代理模式、享元模式等设计模式。Aop首先调用AbstractBeanFactory#doGetBean()方法创建来bean

doGetBean(name, null, null, false)

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType, @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

  // 这一大段代码省略
  ......
    
  // 真正创建bean
  return createBean(beanName, mbd, args);
  
  // 这一大段代码省略
  ......
}

createBean(beanName, mbd, args)

/**
 * Spring Aop功能是使用Spring提供的扩展点BeanPostProcessor后置处理器来实现对切面信息的读取和缓存
 */
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
  // 这一大段代码省略
  ......
    
  // 主要是来执行实现了InstantiationAwareBeanPostProcessor接口的BeanPostProcesser
  // AOP核心方法，用来处理使用@Aspect注解标识的切面bean，读取切面bean中的信息，添加到advisorsCache缓存中，以便后面生成动态代理
  Object bean = resolveBeforeInstantiation(beanName, mbdToUse);

  // 实例化bean
  Object beanInstance = doCreateBean(beanName, mbdToUse, args);
  
  // 这一大段代码省略
  ......
}

切面信息的读取和缓存

resolveBeforeInstantiation(beanName, mbdToUse)

/**
 * AOP核心方法，用来处理使用@Aspect注解标识的切面bean，读取切面bean中的信息，添加到advisorsCache缓存中，以便后面生成动态代理
 */
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
  Object bean = null;
  // 检测是否被解析过
  if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
    // hasInstantiationAwareBeanPostProcessors()是来判断容器中是否有InstantiationAwareBeanPostProcessor的实现bean
    // AOP切面后置处理器AspectJAwareAdvisorAutoProxyCreator就实现了InstantiationAwareBeanPostProcessor接口
    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
      Class<?> targetType = determineTargetType(beanName, mbd); // 获取bean的目标类型
      if (targetType != null) {
        // 执行实现了InstantiationAwareBeanPostProcessor接口的BeanPostProcessor中的前置处理方法postProcessBeforeInstantiation方法
        bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
        if (bean != null) {
          // 执行实现了InstantiationAwareBeanPostProcessor接口的BeanPostProcessor中的后置处理方法postProcessAfterInitialization方法
          bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
        }
      }
    }
    mbd.beforeInstantiationResolved = (bean != null);
  }
  return bean;
}

applyBeanPostProcessorsBeforeInstantiation(targetType, beanName)

protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
  for (BeanPostProcessor bp : getBeanPostProcessors()) {
    if (bp instanceof InstantiationAwareBeanPostProcessor) {
      InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
      // 调用实现InstantiationAwareBeanPostProcessor接口的方法
      Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
      if (result != null) {
        return result;
      }
    }
  }
  return null;
}

ibp.postProcessBeforeInstantiation(beanClass, beanName)

public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
  Object cacheKey = getCacheKey(beanClass, beanName);

  if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
    if (this.advisedBeans.containsKey(cacheKey)) {
      return null;
    }
    
    // shouldSkip(beanClass, beanName)中
    if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
      this.advisedBeans.put(cacheKey, Boolean.FALSE);
      return null;
    }
  }

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

shouldSkip(beanClass, beanName)

protected boolean shouldSkip(Class<?> beanClass, String beanName) {
  // 找到我们的切面
  List<Advisor> candidateAdvisors = findCandidateAdvisors();
  
  for (Advisor advisor : candidateAdvisors) {
    if (advisor instanceof AspectJPointcutAdvisor &&
        ((AspectJPointcutAdvisor) advisor).getAspectName().equals(beanName)) {
      return true;
    }
  }
  return super.shouldSkip(beanClass, beanName);
}

findCandidateAdvisors()

protected List<Advisor> findCandidateAdvisors() {
  // 第一次调用AbstractAutoProxyCreator实现类AnnotationAwareAspectJAutoProxyCreator中实现的方法postProcessBeforeInstantiation时进行初始化切面信息，并添加到advisorsCache缓存中
		
  // 这是事务的切面
  List<Advisor> advisors = super.findCandidateAdvisors();

  // 这是AspectJ的切面
  if (this.aspectJAdvisorsBuilder != null) {
    advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
  }
  return advisors;
}

this.aspectJAdvisorsBuilder.buildAspectJAdvisors()

public List<Advisor> buildAspectJAdvisors() {
  List<String> aspectNames = this.aspectBeanNames;

  // aspectNames用来存储切面bean的beanName
  if (aspectNames == null) {
    synchronized (this) {
      aspectNames = this.aspectBeanNames;
      if (aspectNames == null) {
        List<Advisor> advisors = new ArrayList<>();
        aspectNames = new ArrayList<>();

        // 获取BeanDefinitionMap中所有类型为Object的的beanName
        String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
          this.beanFactory, Object.class, true, false);

        // 遍历所有的bean
        for (String beanName : beanNames) {
          if (!isEligibleBean(beanName)) {
            continue;
          }
          Class<?> beanType = this.beanFactory.getType(beanName);
          if (beanType == null) {
            continue;
          }

          // 只对bean类型为Aspect的进行处理
          if (this.advisorFactory.isAspect(beanType)) {
            aspectNames.add(beanName);

            // AspectMetadata对象是用来包装Aspect切面类的信息
            AspectMetadata amd = new AspectMetadata(beanType, beanName);

            if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {

              // 将切面实例封装为切面实例工厂
              MetadataAwareAspectInstanceFactory factory =
                new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);

              // 根据实例工厂获取切面中的顾问Advisor对象
              List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);

              // 判断bean是否是单例的，如果是单例的，将切面bean的切面信息放入advisorsCache切面缓存中，方面后面后置处理器进行生成动态代理对象
              if (this.beanFactory.isSingleton(beanName)) {
                this.advisorsCache.put(beanName, classAdvisors);
              }
              else {
                this.aspectFactoryCache.put(beanName, factory);
              }
              advisors.addAll(classAdvisors);
            }
            else {
              // Per target or per this.
              if (this.beanFactory.isSingleton(beanName)) {
                throw new IllegalArgumentException("Bean with name '" + beanName + "' is a singleton, but aspect instantiation model is not singleton");
              }
              MetadataAwareAspectInstanceFactory factory =
                new PrototypeAspectInstanceFactory(this.beanFactory, beanName);
              this.aspectFactoryCache.put(beanName, factory);
              advisors.addAll(this.advisorFactory.getAdvisors(factory));
            }
          }
        }
        this.aspectBeanNames = aspectNames;
        return advisors;
      }
    }
  }

  // 这一大段代码省略
  ......
  
  return advisors;
}

生成动态代理对象

doCreateBean(beanName, mbdToUse, args)

/**
 * 实例化bean对象
 */
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
  throws BeanCreationException {
  // 这一大段代码省略
  ......

  // 初始化bean实例
  exposedObject = initializeBean(beanName, exposedObject, mbd);

  // 这一大段代码省略
  ......

  return exposedObject;
}

initializeBean(beanName, exposedObject, mbd)

/**
 * 初始化bean实例
 */
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
  // 这一大段代码省略
  ......

  // 在bean初始化之后调用BeanPostProcessor后置处理器中的postProcessAfterInitialization方法
  wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);

  return wrappedBean;
}

applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName)

/**
 * BeanPostProcessor后置处理器中的postProcessAfterInitialization实现方法
 */
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException {
	Object result = existingBean;
  for (BeanPostProcessor processor : getBeanPostProcessors()) {
	// 当processor的实现类是AbstractAutoProxyCreator时将会调用AbstractAutoProxyCreator对postProcessAfterInitialization方法的实现
    Object current = processor.postProcessAfterInitialization(result, beanName);
    if (current == null) {
      return result;
    }
    result = current;
  }
  return result;
}

processor.postProcessAfterInitialization(result, beanName)

/**
 * BeanPostProcessor接口的实现抽象类AbstractAutoProxyCreator对postProcessAfterInitialization方法的实现
 */
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) throws BeansException {
  if (bean != null) {
    Object cacheKey = getCacheKey(bean.getClass(), beanName);
    if (this.earlyProxyReferences.remove(cacheKey) != bean) {
      // 生成动态代理对象
      return wrapIfNecessary(bean, beanName, cacheKey);
    }
  }
  return bean;
}

wrapIfNecessary(bean, beanName, cacheKey)

/**
 * 生成动态代理对象
 */
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;
  }
  // isInfrastructureClass(bean.getClass())：判断这个bean是不是有没有实现Advice、PuintCut、Advisor、AopInfrastructureBean接口
  // shouldSkip(bean.getClass(), beanName)：应不应该跳过
  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) {
    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;
}

createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean))

/**
 * 真正的创建动态代理对象
 */
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);

  if (!proxyFactory.isProxyTargetClass()) {
    if (shouldProxyTargetClass(beanClass, beanName)) {
      proxyFactory.setProxyTargetClass(true);
    }
    else {
      evaluateProxyInterfaces(beanClass, proxyFactory);
    }
  }

  // 获取Advisor顾问对象
  Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
  proxyFactory.addAdvisors(advisors);
  proxyFactory.setTargetSource(targetSource);
  customizeProxyFactory(proxyFactory);

  proxyFactory.setFrozen(this.freezeProxy);
  if (advisorsPreFiltered()) {
    proxyFactory.setPreFiltered(true);
  }

  // 从动态代理工厂中获取代理对象
  return proxyFactory.getProxy(getProxyClassLoader());
}

proxyFactory.getProxy(getProxyClassLoader())

/**
 * 从动态代理工厂中获取代理对象
 */
public Object getProxy(@Nullable ClassLoader classLoader) {
  return createAopProxy().getProxy(classLoader);
}

createAopProxy()

/**
 * 创建Aop动态代理
 */
protected final synchronized AopProxy createAopProxy() {
  if (!this.active) {
    activate();
  }
  return getAopProxyFactory().createAopProxy(this);
}

getAopProxyFactory().createAopProxy(this)

/**
 * 创建Aop动态代理的真正实现
 */
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
  // config.isProxyTargetClass()默认值为false
  // hasNoUserSuppliedProxyInterfaces(config)判断该bean是否是接口，如果是接口，直接使用JDK动态代理
  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.");
    }

    // ProxyTargetClass为true时使用Cglib动态代理
    if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
      return new JdkDynamicAopProxy(config);
    }

    // 否则为JDK动态代理
    return new ObjenesisCglibAopProxy(config);
  }

  // 当ProxyTargetClass为false 或者 该bean时接口时 使用JDK动态代理
  else {
    return new JdkDynamicAopProxy(config);
  }
}

hasNoUserSuppliedProxyInterfaces(config)

/**
 * 判断该bean是否是接口
 */
private boolean hasNoUserSuppliedProxyInterfaces(AdvisedSupport config) {
  Class<?>[] ifcs = config.getProxiedInterfaces();
  return (ifcs.length == 0 || (ifcs.length == 1 && SpringProxy.class.isAssignableFrom(ifcs[0])));
}

createAopProxy().getProxy(classLoader)

/**
 * 从创建的动态代理中生成代理对象（这里是使用JDK动态的）
 */
public Object getProxy(@Nullable 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);

  // 调用Proxy.newProxyInstance()方法生成JDK动态代理对象并返回
  return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
}

存储动态代理对象

在经过Object beanInstance = doCreateBean(beanName, mbdToUse, args);获取了bean实例，将其返回给方法调用的createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)方法，然后再返回给调用的getSingleton(String beanName, ObjectFactory<?> singletonFactory)方法

getSingleton(String beanName, ObjectFactory<?> singletonFactory)

/**
 * 获取单例的bean实例，如果bean实例不存在的话就创建
 * 从addSingleton(beanName, singletonObject)可以看出，最后生成的代理对象和普通bean一样被添加到singletonObjects单例池(一级缓存)中
 */
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
  Assert.notNull(beanName, "Bean name must not be null");
  synchronized (this.singletonObjects) {
    
    // 这一大块代码省略
    ......
    
    // 调用ObjectFactory接口实现类中的getObject()方法，这里是使用lambad表达式来进行重新getObject()方法的
    singletonObject = singletonFactory.getObject();
 
    // 这一大块代码省略
    ......
    
    // 将singletonObject添加到singletonObjects一级缓存中，同时将二级、三级缓存中的bean删除
    addSingleton(beanName, singletonObject);

    return singletonObject;
  }
}