Spring读源码系列之AOP--07---aop自动代理创建器(拿下AOP的最后一击)

• 引子
• Spring中自动创建代理器（分类）
• 前提
• • ProxyProcessorSupport
  • SmartInstantiationAwareBeanPostProcessor
  • • 爷爷BeanPostProcessor
    • 爸爸InstantiationAwareBeanPostProcessor
    • 儿子SmartInstantiationAwareBeanPostProcessor
  • TargetSource
  • • TargetSource的实现类
  • TargetSourceCreator
  • • AbstractBeanFactoryBasedTargetSourceCreator
    • • QuickTargetSourceCreator
      • LazyInitTargetSourceCreator
• 正文
• • AbstractAutoProxyCreator---自动代理创建器抽象基类
  • • • BeanNameAutoProxyCreator---按照规定的beanName数组，对bean实施代理
      • • 简单使用
      • AbstractAdvisorAutoProxyCreator---getAdvicesAndAdvisorsForBean
      • • BeanFactoryAdvisorRetrievalHelper
        • DefaultAdvisorAutoProxyCreator---isEligibleAdvisorBean
        • InfrastructureAdvisorAutoProxyCreator----isEligibleAdvisorBean
        • AspectJAwareAdvisorAutoProxyCreator
        • • AnnotationAwareAspectJAutoProxyCreator
          • BeanFactoryAspectJAdvisorsBuilder

本系列列举的源码中，很多类没有展开讲，是因为之前的系列文章一直在对aop基础组件进行介绍，因此一定要按照顺序看本系列，否则观看本篇文章的时候，越往后看，越发觉得本文模糊不清，只会粘贴源码，实则不然，因为很多类前文已经讲过，如果本文再展开讲解，那么将无法突出重点

自动代理创建器是spring的aop体系中最重要的一环，也正是因为有他的存在，才让我们使用aop那么方便

先来看看自动代理创建器相关类藏在了哪里:

可以看出来，所有的创建器都是AbstractAutoProxyCreator该抽象类的子类~

当系统比较复杂，或者中需要进行aop进行织入的bean较多时，简单采用ProxyFacotryBean无疑会增加很多工作量（因为每个Bean都得手动写一个）。另外由于要从ProxyFactoryBean获得代理对象，也会使应用和Spring之间的耦合度增加，并且很多时候可维护性不强（我个人认为耦合这个不是最主要的原因，毕竟现在Spring已成为实际上的规范了）。

在内部，Spring使用BeanPostProcessor让自动生成代理。基于BeanPostProcessor的自动代理创建器的实现类，将根据一些规则在容器实例化Bean时为匹配的Bean生成代理实例。代理创建器可以分为三类：

• 基于Bean配置名规则的自动代理生成器：允许为一组特定配置名的Bean自动创建代理实例的代理创建器，实现类为BeanNameAutoProxyCreator
• 基于Advisor匹配机制的自动代理创建器它会对容器中的所有Advisor进行扫描，自动将这些切面应用到匹配的Bean中，实现类是DefaultAdvisorAutoProxyCreator（它也支持前缀匹配）
• 基于Bean中AspectJ注解的自动代理生成器：为包含AspectJ注解的切入的Bean自动创建代理实例

首先，单独看AbstractAutoProxyCreator的继承体系，分析可知，我们需要先去了解一下ProxyProcessorSupport干了啥(之前系列文章讲过，这里再重复一次)，和SmartInstantiationAwareBeanPostProcessor中相关回调接口的调用时机

在AbstractAutoProxyCreator类中，有这样一个属性，并且该属性很多地方用到了，因此这里还需求先科普一下TargetSourceCreator的作用，但是科普这个之前，我们还需要再来聊聊TargetSource

简单的说它就是提供为代理创建器提供了一些公共方法实现：

具有代理处理器通用功能的基类，特别是 ClassLoader 管理和 evaluateProxyInterfaces 算法。

@SuppressWarnings("serial")
public class ProxyProcessorSupport extends ProxyConfig implements Ordered, BeanClassLoaderAware, AopInfrastructureBean {

	
	private int order = Ordered.LOWEST_PRECEDENCE;
    
    //代理类的类加载器
	@Nullable
	private ClassLoader proxyClassLoader = ClassUtils.getDefaultClassLoader();
    
    //代理类的类加载器是否被手动配置了---即用户是否手动指定了类加载器
	private boolean classLoaderConfigured = false;

	public void setOrder(int order) {
		this.order = order;
	}

	@Override
	public int getOrder() {
		return this.order;
	}

	
	public void setProxyClassLoader(@Nullable ClassLoader classLoader) {
		this.proxyClassLoader = classLoader;
		//如果不为空，说明手动设置生效,打个标记
		this.classLoaderConfigured = (classLoader != null);
	}
	
	@Nullable
	protected ClassLoader getProxyClassLoader() {
		return this.proxyClassLoader;
	}
//因为继承了BeanClassLoaderAware,因此默认的代理类加载器就是beanFactory用来加载所有bean的beanClassLoader
	@Override
	public void setBeanClassLoader(ClassLoader classLoader) {
	//手动配置的优先级更高，无法覆盖
		if (!this.classLoaderConfigured) {
			this.proxyClassLoader = classLoader;
		}
	}


	
	protected void evaluateProxyInterfaces(Class beanClass, ProxyFactory proxyFactory) {
	//拿到目标类上的所有接口
		Class[] targetInterfaces = ClassUtils.getAllInterfacesForClass(beanClass, getProxyClassLoader());
		//是否存在合理的接口---可以决定是否采用jdk动态代理，如果为false则走cglib动态代理
		boolean hasReasonableProxyInterface = false;
		for (Class ifc : targetInterfaces) {
			if (
              //pass内部的回调接口
              !isConfigurationCallbackInterface(ifc) && 
               //pass内部语言接口
               !isInternalLanguageInterface(ifc) &&
					//当前接口内是否存在方法
					ifc.getMethods().length > 0) {
				hasReasonableProxyInterface = true;
				break;
			}
		}
		//如果存在合理的接口
		if (hasReasonableProxyInterface) {
			// Must allow for introductions; can't just set interfaces to the target's interfaces only.
			// 这里Spring的Doc特别强调了：不能值只把合理的接口设置进去，而是都得加入进去
			for (Class ifc : targetInterfaces) {
			//存在合理的接口，说明当前会采用jdk代理，并且代理类需要实现目标对象实现的所有接口
				proxyFactory.addInterface(ifc);
			}
		}
		else {
		// 这个很明显设置true，表示使用CGLIB得方式去创建代理了~~~~
		//proxyFactory继承了proxyConfig,这里调用的是proxyConfig的setProxyTargetClass方法
			proxyFactory.setProxyTargetClass(true);
		}
	}

	
	protected boolean isConfigurationCallbackInterface(Class ifc) {
		return (InitializingBean.class == ifc || DisposableBean.class == ifc || Closeable.class == ifc ||
				AutoCloseable.class == ifc || ObjectUtils.containsElement(ifc.getInterfaces(), Aware.class));
	}

	
	protected boolean isInternalLanguageInterface(Class ifc) {
		return (ifc.getName().equals("groovy.lang.GroovyObject") ||
				ifc.getName().endsWith(".cglib.proxy.Factory") ||
				ifc.getName().endsWith(".bytebuddy.MockAccess"));
	}

}

该类最重要的就是evaluateProxyInterfaces方法，来评估是该采用jdk还是cglib动态代理，该方法决定采用哪种代理方式后，会直接设置ProxyFactory的相关属性

AbstractAutoProxyCreator是对自动代理创建器的一个抽象实现。最重要的是，它实现了SmartInstantiationAwareBeanPostProcessor接口，因此会介入到Spring IoC容器Bean实例化的过程，因此由此为入口进行展开~

Initialization是初始化的意思，意味着该bean后置处理器接口中的两个方法会在bean的初始化前后被调用，这里初始化指的是bean的初始化方法被调用的前后，例如:init-method等

public interface BeanPostProcessor {
	@Nullable
	default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}

	@Nullable
	default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}

}

该后置处理器中的两个方法被调用的源码时机如下:

AbstractAutowireCapableBeanFactory

	protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged((PrivilegedAction