Spring之实例化AOP标签的后置处理器流程

在上一篇文章中我们讲述了Spring是如何解析aop标签的，关键点是解析器把<aop:config/>的定义和他的子元素的定义通过parseContext利用栈把他们绑定到了一起。在这篇文章中我们就要看一下有关aop的后置处理器如何被实例化的，再来看一下配置文件的内容:

ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

这行代码是我们上篇文章中解析过的，接下来从他下面的代码开始。

prepareBeanFactory(beanFactory);

这行代码的意思是准备bean factory，以便在此上下文中使用，我们走进去看一下:

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		// Tell the internal bean factory to use the context's class loader etc.
		beanFactory.setBeanClassLoader(getClassLoader());
		beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
		beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

		// Configure the bean factory with context callbacks.
		beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
		beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
		beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
		beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
		beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

		// BeanFactory interface not registered as resolvable type in a plain factory.
		// MessageSource registered (and found for autowiring) as a bean.
		beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
		beanFactory.registerResolvableDependency(ResourceLoader.class, this);
		beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
		beanFactory.registerResolvableDependency(ApplicationContext.class, this);

		// Register early post-processor for detecting inner beans as ApplicationListeners.
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

		// Detect a LoadTimeWeaver and prepare for weaving, if found.
		if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			// Set a temporary ClassLoader for type matching.
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}

		// Register default environment beans.
		if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
			beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
		}
		if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
			beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
		}
		if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
			beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
		}
	}

大体上一看就是设置类加载器，解析器这些配置，在这就不仔细分析了。

postProcessBeanFactory(beanFactory);

接着就是用户自定义的处理器。

invokeBeanFactoryPostProcessors(beanFactory);

这行代码的意思是调用上下文中注册为bean的工厂处理器。我们在配置文件中没有配置这些处理器，所以目前来说这个方法对我们也没有用处。

registerBeanPostProcessors(beanFactory);

注册拦截bean创建的bean处理器。我们进入这个方法看一下：

protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
	}

实例化并调用所有已注册的bean后处理器bean，尊重明确的秩序：

public static void registerBeanPostProcessors(
			ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
		//根据类型获得后置处理器
		String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

		//获得所有初始化bean的后置处理器
		int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
		//添加一个记录了有关bean的后置处理器的个数的类
		beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

		// 将后置处理器分类
		List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
		List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
		List<String> orderedPostProcessorNames = new ArrayList<>();
		List<String> nonOrderedPostProcessorNames = new ArrayList<>();
		//将后置处理器按不同类型分类
		for (String ppName : postProcessorNames) {
			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				//实例化处理器
				BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
				//添加实例化的处理器
				priorityOrderedPostProcessors.add(pp);
				if (pp instanceof MergedBeanDefinitionPostProcessor) {
					internalPostProcessors.add(pp);
				}
			}
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

		// 给Priority处理器排序并注册到IOC中
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

		// Next, register the BeanPostProcessors that implement Ordered.
		List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
		for (String ppName : orderedPostProcessorNames) {
			//实例化处理器
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			//将实例化的处理器添加到列表中
			orderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		//给当前处理器列表排序
		sortPostProcessors(orderedPostProcessors, beanFactory);
		//将处理器注册到IOC中
		registerBeanPostProcessors(beanFactory, orderedPostProcessors);

		// 注册常规的处理器
		List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
		for (String ppName : nonOrderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			nonOrderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		//将实例化的处理器注册到IOC中
		registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

		// 给所有的处理器排序并注册到IOC容器中
		sortPostProcessors(internalPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, internalPostProcessors);

		//将检测内部bean的后处理器重新注册为applicationlistener，
		//将其移动到处理器链的末端(用于获取代理等)。
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
	}

这个方法主要就是得到各种处理器并将他们分类，按顺序实例化并添加到IOC中，在我们的配置文件中只有一个后置处理器org.springframework.aop.config.internalAutoProxyCreator，所以接下来我们来看他具体是怎么被实例化的：

public <T> T getBean(String name, @Nullable Class<T> requiredType) throws BeansException {
		return doGetBean(name, requiredType, null, false);
	}

这次是根据指定的类型和指定的名字来创建bean实例:

sharedInstance = getSingleton(beanName, () -> {
						try {
							return createBean(beanName, mbd, args);
						}
					...

容器第一次启动是没有该处理器的实例的，所以要先创建:

singletonObject = singletonFactory.getObject();

要通过回调函数创建一个bean实例:

Object beanInstance = doCreateBean(beanName, mbdToUse, args);

进入createBean()方法之后，程序执行到了这个方法，和以往创建bean一样，进入这个方法:

		BeanWrapper instanceWrapper = null;
		//如果要实例的bean是单例，那么就要从实例的缓存中移除它
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
			//如果封装对象是null，就要创建一个对象
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		//得到实例化后的bean
		final Object bean = instanceWrapper.getWrappedInstance();
		//得到要实例化的bean的class对象
		Class<?> beanType = instanceWrapper.getWrappedClass();
		if (beanType != NullBean.class) {
			mbd.resolvedTargetType = beanType;
		}

这段代码的功能是创建了一个封装了实例化的bean，bean的定义，和参数的对象，接下来具体看一下这个对象是如何被创建出来的,进入createBeanInstance方法:

Class<?> beanClass = resolveBeanClass(mbd, beanName);

先获取到了实例化的class对象

...
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
...

这一步是确定要为给定bean使用的候选构造函数，检查所有已注册的构造函数

return instantiateBean(beanName, mbd);

使用无参构造函数去实例化这个对象:

protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
		try {
			Object beanInstance;
			final BeanFactory parent = this;
			...
			//采用cglib的策略来创建bean实例
			beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
			//创建封装对象
			BeanWrapper bw = new BeanWrapperImpl(beanInstance);
			//初始化封装对象
			initBeanWrapper(bw);
			return bw;
		}
		...
	}

这个方法就做了三件事，在注释中已经详细说明了，接下来就看看每个方法是怎么实现的:

public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
		// 如果没有重写，不要用CGLIB重写类。
		if (!bd.hasMethodOverrides()) {
		//获得一个可以使用的构造方法
			Constructor<?> constructorToUse;
			synchronized (bd.constructorArgumentLock) {
				constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
				if (constructorToUse == null) {
					final Class<?> clazz = bd.getBeanClass();
					if (clazz.isInterface()) {
						throw new BeanInstantiationException(clazz, "Specified class is an interface");
					}
					try {
						if (System.getSecurityManager() != null) {
							constructorToUse = AccessController.doPrivileged(
									(PrivilegedExceptionAction<Constructor<?>>) () -> clazz.getDeclaredConstructor());
						}
						else {
							constructorToUse =	clazz.getDeclaredConstructor();
						}
						bd.resolvedConstructorOrFactoryMethod = constructorToUse;
					}
					catch (Throwable ex) {
						throw new BeanInstantiationException(clazz, "No default constructor found", ex);
					}
				}
			}
			//利用构造方法实例化对象
			return BeanUtils.instantiateClass(constructorToUse);
		}
		else {
			// Must generate CGLIB subclass.
			return instantiateWithMethodInjection(bd, beanName, owner);
		}
	}

这个方法寻找了一个用来实例化对象的构造方法，实例化的任务交给了下一个方法:

public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
		Assert.notNull(ctor, "Constructor must not be null");
		try {
			//跳过语法检查，防止构造方法是private
			ReflectionUtils.makeAccessible(ctor);
			//通过反射实例化bean
			return (KotlinDetector.isKotlinType(ctor.getDeclaringClass()) ?
					KotlinDelegate.instantiateClass(ctor, args) : ctor.newInstance(args));
		}
		...
	}

这个方法一开始设定了跳过语法检查，目的就是为了防止选择的构造方法万一是private修饰的，接着利用反射来实例化bean，这个方法执行完，这个处理器就实例化结束了，我们来看下面的工作：

BeanWrapper bw = new BeanWrapperImpl(beanInstance);

封装一个对象，没什么好说的，继续:

protected void initBeanWrapper(BeanWrapper bw) {
		bw.setConversionService(getConversionService());
		registerCustomEditors(bw);
	}

使用注册的自定义编辑器初始化给定的bean包装器这家工厂。调用将创建的BeanWrappers并填充bean实例。
接着我们返回到这个doCreateBean方法中，执行到了下面这个方法：

applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);

我们进入看看到底是做什么的:

protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) {
		for (BeanPostProcessor bp : getBeanPostProcessors()) {
			if (bp instanceof MergedBeanDefinitionPostProcessor) {
				MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
				bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
			}
		}
	}

其实就是遍历所有的有关bean的后置处理器，将mergedbeandefinitionpostprocessor应用到指定的bean定义，

boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			..
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}

接着，后置处理器就被实例化好了，被放到了三级缓存中，剩下的就是填充属性了，我们看看和之前实例化bean有什么区别：

PropertyValues: length=1; bean property 'order'

里面只有一个属性需要注入，没有其他操作了。到这一个后置处理器就创建结束了，被添加到了IOC中。