4-BeanFactoryPostProcessor

BeanFactoryPostProcessor
BeanFactory 的 后置处理器

bean 创建之前执行

BeanDefinitionRegistryPostProcessor
执行时机，先执行 BeanDefinitionRegistryPostProcessor . postProcessBeanDefinitionRegistry

spring 容器的 refresh() 创建刷新

	1、prepareRefresh();
			1.initPropertySources(); 初始化属性设置，子类自定义个性化的属性设置方法
  		2.getEnvironment().validateRequiredProperties();校验相关属性的合法性
			3.this.earlyApplicationEvents = new LinkedHashSet<>(); 保存容器中的一些早期事件
  
  2、obtainFreshBeanFactory(); 获取 beanFactory实例
  		1.refreshBeanFactory() 刷新或创建 beanFactory；
      2.getBeanFactory();  将刚生成的 beanFactory 返回
	3、prepareBeanFactory(beanFactory);  beanFactory 预准备工作，（以上创建的 beanFactory 很多属性没值，只有一些默认的值）
			1.beanFactory.setBeanClassLoader(getClassLoader());设置 beanFactory 的类加载器、
			2.beanFactory.setBeanExpressionResolver(); 支持相关的表达式语言的解析
	      3.ignoreDependencyInterface  设置 忽略的的自动装配接口  EnvironmentAware、ApplicationEventPublisherAware、ApplicationContextAware
			4.beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
			5.beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this)); 添加部分BeanPostProcessor
			6.beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory); 注册可以解析的自动装配 ，我们能直接在任何组件中自动注入 ResourceLoader、ApplicationEventPublisher、 ApplicationContext
      7.beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this)); 添加监听检测的顺序
      8.添加 编译时的 AspectJ
      9.// Register default environment beans. 注册环境变量相关的bean 
				if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
					beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
				}
    4、postProcessBeanFactory(beanFactory); beanFactory 准备工作完成后进行的后置处理工作
    		1.子类通过重写这个方法来在 beanFactory 创建并预准备完成以后进一步的设置

----------------------------- beanFactory创建和预准备工作完成 ---------------------------------------      
      
     5、invokeBeanFactoryPostProcessors(beanFactory); 执行 BeanFactoryPostProcessors 的方法
     		beanFactory  标准初始化之后执行的。。
        两个接口 ： BeanDefinitionRegistryPostProcessor 、 BeanFactoryPostProcessor
        	先执行 BeanDefinitionRegistryPostProcessor 
           1、优先执行 实现了 PriorityOrdered 的
           2、获取 bean 
      6、registerBeanPostProcessors(beanFactory); 
      		拦截我们bean 的创建，用来对 单实例bean 的增强
        	InstantiationAwareBeanPostProcessor
      7、initMessageSource(); 标签国际化资源，初始化 MessageSource 组件（国际化功能：消息解析、消息绑定）
      		messageSource ： 判断容器中是否有 id 为 messageSource 的bean，没有就创建一个 new DelegatingMessageSource();
          并注册到 beanFactory ，beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
          其实就是把 bean put 到一个 name 为 singletonObjects 的 ConcurrentHashMap；
      8、initApplicationEventMulticaster(); 初始化 事件 派发器
      		获取 beanFactory
          判断 当前 beanFactory 中有没有一个名为 applicationEventMulticaster 的bean 
          没有就  new SimpleApplicationEventMulticaster(beanFactory);
      9、onRefresh(); 留给 子容器来扩展
      		子容器重写这个方法，在容器刷新时自定义逻辑
      10、registerListeners(); 给容器中将所有项目中的 ApplicationListener 注册进来
      		从我们容器中拿到所有的 ApplicationListener ，
      			getApplicationEventMulticaster().multicastEvent(earlyEvent); 事件派发
      11、finishBeanFactoryInitialization(beanFactory);所有单实例bean（非懒加载）创建
      			beanFactory.preInstantiateSingletons(); 初始化实例 bean 
            getMergedLocalBeanDefinition(beanName); 获取 bean 定义信息，依次创建和初始化
            getSingleton(beanName); 从 singletonObjects 中获取
            markBeanAsCreated(beanName); 标记 bean 已创建 this.alreadyCreated.add(beanName);
            mbd.getDependsOn(); 获取当前bean 依赖的其他bean 如果存在，getBean 从容器中拿出来
            Object bean = resolveBeforeInstantiation(beanName, mbdToUse); 让 beanPostProcess 尝试 返回一个代理对象，
            Object beanInstance = doCreateBean(beanName, mbdToUse, args);开始创建 bean 
            populateBean(beanName, mbd, instanceWrapper); 属性赋值
            	InstantiationAwareBeanPostProcessor . postProcessAfterInstantiation 后置处理
              applyPropertyValues(beanName, mbd, bw, pvs); 设值
            initializeBean(beanName, exposedObject, mbd); bean 初始化 前后增常，AOP动态代理的增强
      12、finishRefresh();
           clearResourceCaches(); 清除配置缓存
           initLifecycleProcessor();初始化生命周期
           publishEvent(new ContextRefreshedEvent(this)); 发布刷新完成的事件


BeanFactory -- getBean 单例模式
FactoryBean -- 工厂模式
Advisor -- 适配器模式 Adapter


生成容器  AnnotationConfigApplicationContext 父类的无参构造
public GenericApplicationContext() {
		this.beanFactory = new DefaultListableBeanFactory();
	}


public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");

			// 刷新的预处理
			prepareRefresh();

			// Tell the subclass to refresh the internal bean factory.
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// Prepare the bean factory for use in this context.
			prepareBeanFactory(beanFactory);

			try {
				// Allows post-processing of the bean factory in context subclasses.
				postProcessBeanFactory(beanFactory);

				StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
				// Invoke factory processors registered as beans in the context.
				invokeBeanFactoryPostProcessors(beanFactory);

				// Register bean processors that intercept bean creation.
				registerBeanPostProcessors(beanFactory);
				beanPostProcess.end();

				// Initialize message source for this context.
				initMessageSource();

				// Initialize event multicaster for this context.
				initApplicationEventMulticaster();

				// Initialize other special beans in specific context subclasses.
				onRefresh();

				// Check for listener beans and register them.
				registerListeners();

				// Instantiate all remaining (non-lazy-init) singletons.
				finishBeanFactoryInitialization(beanFactory);

				// Last step: publish corresponding event.
				finishRefresh();
			}

			catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}

				// Destroy already created singletons to avoid dangling resources.
				destroyBeans();

				// Reset 'active' flag.
				cancelRefresh(ex);

				// Propagate exception to caller.
				throw ex;
			}

			finally {
				// Reset common introspection caches in Spring's core, since we
				// might not ever need metadata for singleton beans anymore...
				resetCommonCaches();
				contextRefresh.end();
			}
		}
	}