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

青旅半醒 2023-06-13 13:27 22阅读 0赞

### 文章目录 ###

*  doGetBean(name, null, null, false)
 *   *  createBean(beanName, mbd, args)
     *  切面信息的读取和缓存
     *   *  resolveBeforeInstantiation(beanName, mbdToUse)
         *   *  applyBeanPostProcessorsBeforeInstantiation(targetType, beanName)
             *  ibp.postProcessBeforeInstantiation(beanClass, beanName)
             *   *  shouldSkip(beanClass, beanName)
                 *  findCandidateAdvisors()
                 *   *  this.aspectJAdvisorsBuilder.buildAspectJAdvisors()
     *  生成动态代理对象
     *   *  doCreateBean(beanName, mbdToUse, args)
         *   *  initializeBean(beanName, exposedObject, mbd)
             *  applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName)
             *   *  processor.postProcessAfterInitialization(result, beanName)
                 *  wrapIfNecessary(bean, beanName, cacheKey)
                 *  createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean))
                 *  proxyFactory.getProxy(getProxyClassLoader())
                 *   *  createAopProxy()
                     *  createAopProxy().getProxy(classLoader)
     *  存储动态代理对象
     *   *  getSingleton(String beanName, ObjectFactory<?> singletonFactory)

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

[Spring Aop]: https://blog.csdn.net/qq_35620501/article/details/103436692