spring容器初始化过程笔记（三）给Aware 类型的bean 塞入 applicationContext、Environment 等的时间

结论

传入值的时间为Bean初始化过程中 doCreateBean 中的 initializeBean(beanName, exposedObject, mbd);
执行bean后置处理器内的postProcessAfterInitialization

结论为什么时候这样呢

initializeBean(beanName, exposedObject, mbd); 内会执行以下步骤：
1.invokeAwareMethods 调用AwareMethod
2. applyBeanPostProcessorsBeforeInitialization 执行Bean后置处理器postProcessBeforeInitialization 方法
3. 调用invokeInitMethods 调用初始化方法
4. applyBeanPostProcessorsAfterInitialization 请求spring内所有的bean后置处理器 postProcessAfterInitialization 方法

其中第四步是关键步骤：

第4步 执行所有的bean后置处理器方法 ，会执行到ApplicationContextAwareProcessor 后置处理器的postProcessAfterInitialization ，下面是 applyBeanPostProcessorsAfterInitialization 和 ApplicationContextAwareProcessor后置处理器的源码：

initializeBean(beanName, exposedObject, mbd); 内 applyBeanPostProcessorsAfterInitialization 源码为：

@Override
	public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
			throws BeansException {

		Object result = existingBean;
        // 循环遍历Bean后置处理器，执行BeanPostProcessor子类postProcessBeforeInitialization方法
        // 在这里BeanPostProcessor包括 sprig内置的 用户自定义的
        // 笔者这里 使用注解AnnotationConfigApplicationContext 初始化spring容器
        // 内置的bean后置处理器为：1.ApplicationContextAwareProcessor 2. ApplicationListenerDetector  3. ConfigurationClassPostProcessor$ImportAwareBeanPostProcessor
		for (BeanPostProcessor processor : getBeanPostProcessors()) {
// 循环遍历Bean后置处理器，执行BeanPostProcessor子类postProcessBeforeInitialization 方法dd
			Object current = processor.postProcessBeforeInitialization(result, beanName);
			if (current == null) {
				return result;
			}
			result = current;
		}
		return result;
	}

ApplicationContextAwareProcessor后置处理器的源码：

class ApplicationContextAwareProcessor implements BeanPostProcessor {

	private final ConfigurableApplicationContext applicationContext;

	private final StringValueResolver embeddedValueResolver;


	/**
	 * Create a new ApplicationContextAwareProcessor for the given context.
	 */
	public ApplicationContextAwareProcessor(ConfigurableApplicationContext applicationContext) {
		this.applicationContext = applicationContext;
		this.embeddedValueResolver = new EmbeddedValueResolver(applicationContext.getBeanFactory());
	}

	@Override
	@Nullable
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		// 判断Bean类型 如果不是EnvironmentAware 、EmbeddedValueResolverAware等 子类 ，直接返回Bean
		if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
				bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
				bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)){
			return bean;
		}

		AccessControlContext acc = null;
		// Java安全管理器。
		if (System.getSecurityManager() != null) {
			acc = this.applicationContext.getBeanFactory().getAccessControlContext();
		}

		if (acc != null) {
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				// 调用 ApplicationContextAwareProcessor.invokeAwareInterfaces 接口方法
				invokeAwareInterfaces(bean);
				return null;
			}, acc);
		}
		else {
			// ApplicationContextAwareProcessor.invokeAwareInterfaces 接口方法 把上下文、上下文环境set进去
			invokeAwareInterfaces(bean);
		}

		return bean;
	}

	private void invokeAwareInterfaces(Object bean) {
		if (bean instanceof EnvironmentAware) {
			((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
		}
		if (bean instanceof EmbeddedValueResolverAware) {
			((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
		}
		if (bean instanceof ResourceLoaderAware) {
			((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
		}
		if (bean instanceof ApplicationEventPublisherAware) {
			((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
		}
		if (bean instanceof MessageSourceAware) {
			((MessageSourceAware) bean).setMessageSource(this.applicationContext);
		}
		if (bean instanceof ApplicationContextAware) {
			((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
		}
	}

}

ApplicationContextAwareProcessor bean后置处理器什么时候初始化的

我们知道refresh() 内 registerBeanPostProcessors(beanFactory); 会注册bean后后置处理器，但是ApplicationContextAwareProcessor 后置处理器实例化 在spring容器初始过程中 refresh() 内 prepareBeanFactory(beanFactory); 内

关键代码：

beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));

prepareBeanFactory 源码：

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		// Tell the internal bean factory to use the context's class loader etc.
		beanFactory.setBeanClassLoader(getClassLoader());
		if (!shouldIgnoreSpel) {
			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.ignoreDependencyInterface(ApplicationStartup.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 (!IN_NATIVE_IMAGE && 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());
		}
		if (!beanFactory.containsLocalBean(APPLICATION_STARTUP_BEAN_NAME)) {
			beanFactory.registerSingleton(APPLICATION_STARTUP_BEAN_NAME, getApplicationStartup());
		}
	}