springboot-spring源码系列（五）当前方法结束后beanFactory中的一些重要属性 singleton

spring IOC中最重要的方法 refresh();

public void refresh() throws BeansException, IllegalStateException {
		// 来个锁，不然 refresh() 还没结束，你又来个启动或销毁容器的操作，那不就乱套了嘛
		synchronized (this.startupShutdownMonitor) {
			// 准备工作，记录下容器的启动时间、标记“已启动”状态、处理配置文件中的占位符
			prepareRefresh();
			/**
			 * 返回一个factory 为什么需要返回一个工厂
			 * 因为要对工厂进行初始化
			 */
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			/**
			 * 准备工厂 为beanFactory配置容器特性 例如类加载器、事件处理机制
			 */
			prepareBeanFactory(beanFactory);

			try {
				/**
				 *  目前该方法spring没有写 用于以后的扩展使用
				 */
				postProcessBeanFactory(beanFactory);
				/**
				 *
				 *   完成对自定义类的扫描以及 生成beadDefinition的对象  以及put进集合中
				 *   完成BeanFactoryRegisterPostProcessors的执行
				 * 	 完成BeanFactoryPostProcessors的执行
				 */
				invokeBeanFactoryPostProcessors(beanFactory);			
				/**
				 * 注册所有的beanBostProcessor 也就是后置处理器
				 */
				registerBeanPostProcessors(beanFactory);

				// 初始化信息源，和国际化相关
				initMessageSource();
				/**
				 * 初始化应用事件广播器
				 */
				initApplicationEventMulticaster();
				/**
				 * 空壳方法（调用子类的某些特殊bean的初始化方法）
                 * springboot在该方法进行了Tomcat的初始化
				 */
				onRefresh();
				/**
				 * 为事件传播器注册事件监听器
				 */
				registerListeners();
				/**
				 *   完成剩余Bean的装配,
				 */
				finishBeanFactoryInitialization(beanFactory);
				/**
				 * 初始化容器的生命周期事件处理器，并发布容器的生命周期事件
				 */
				finishRefresh();
			} catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}
				/**
				 * 如果上面的的那一步报错则销毁bean
				 */
				destroyBeans();
				/**
				 * 取消refreshc操作，重置容器的同步标识
				 */
				cancelRefresh(ex);
				throw ex;
			} finally {
				/**
				 * 清空所有缓存
				 */
				resetCommonCaches();
			}
		}
	}

refresh()方法典型的模板设计模式，其中我认为最重要的方式有三个 1.invokeBeanFactoryPostProcessors(beanFactory) 2.registerBeanPostProcessors(beanFactory); 3.finishBeanFactoryInitialization(beanFactory);

本篇文章将会深度讲解第一个方法

1.prepareRefresh()

该方法不重要，

protected void prepareRefresh() {
		//系统当前时间
		this.startupDate = System.currentTimeMillis();
		//设置当前为启用状态
		this.closed.set(false);
		this.active.set(true);

		if (logger.isInfoEnabled()) {
			logger.info("Refreshing " + this);
		}

		// 空壳方法
		initPropertySources();

		//验证标记为所需的所有属性是否可解析
        //spring容器启动时回去读取requiredProperties这个文件的所有key
        //根据这些key获取系统环境变量和进程环境变量，如果有一个为null则启动报错
		getEnvironment().validateRequiredProperties();

		//用来保存早期应用程序事件
		this.earlyApplicationEvents = new LinkedHashSet<>();
	}

2.obtainFreshBeanFactory();

拿到容器中的beanFactory

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
		/**
		 * 创建工厂
		 * 使用了委派的设计模式，父类只定义了抽象方法，在子类中进行具体实现
		 */
		refreshBeanFactory();
		//从容器中拿到beanFactory
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		if (logger.isDebugEnabled()) {
			logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
		}
		//把beanFactory返回
		return beanFactory;
	}

protected final void refreshBeanFactory() throws IllegalStateException {
		/**
         * 使用了CAS操作，感兴趣的同学可以自己去看
         * 这行代码保证了GenericApplicationContext只允许刷新一次 
         */
        if (!this.refreshed.compareAndSet(false, true)) {
			throw new IllegalStateException(
					"GenericApplicationContext does not support multiple refresh attempts: just call 'refresh' once");
		}
       //id为当前容器的全限定类名
       //id = org.springframework.context.annotation.AnnotationConfigApplicationContext@57829d67
       //作为beanFactory序列化唯一标识
		this.beanFactory.setSerializationId(getId());
	}

3.prepareBeanFactory(beanFactory);

对beanFactory进行初始化操作

	protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		//设置bean的加载器，通过super.getClassLoader()拿到
        //默认是Launcher&AppClassLoader
		beanFactory.setBeanClassLoader(getClassLoader());

       
		//设置bean表达式解释器 为容器添加SpEL支持
		beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
		//设置String和对象的转换器
		beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
		/**
		 * beanFactory中维护了一个 List 集合专门存放后置处理器
		 * 添加第一个后置处理器 作用是解析实现了Aware接口的实现类
		 */
		beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
        
		// beanFactory中维护了一个 Set 集合专门存放忽略的接口类
		//忽略给定接口的自动装配功能，也就是当有忽略的接口类，自动装配会忽略这部分类的初始化装配。
		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中维护了一个 Map 集合专门存放替代的接口类
		 * 如果你手动往beanFactory中注入了实现下面这几个接口的实现类 则用beanFactory或者Context替代 
		 */
		beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
		beanFactory.registerResolvableDependency(ResourceLoader.class, this);
		beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
		beanFactory.registerResolvableDependency(ApplicationContext.class, this);

		// 添加了第二个后置处理器
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
		/**
		 * 查看beanFactory的parent属性是否有值，如果有值才会执行
         * beanFactory的parent属性默认为null
         * 只有你自己通过api  beanFactory.setParent(xxxxxx);才会有值
		 */       
		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()));
		}

public boolean containsBean(String name) {
		//拿到beanFactory的别名如果没有返回loadTimeWeaver
		String beanName = transformedBeanName(name);
		if (containsSingleton(beanName) || containsBeanDefinition(beanName)) {
			return (!BeanFactoryUtils.isFactoryDereference(name) || isFactoryBean(name));
		}
		//拿到beanFactory的父beanFactory
		BeanFactory parentBeanFactory = getParentBeanFactory();
		return (parentBeanFactory != null && parentBeanFactory.containsBean(originalBeanName(name)));
	}


		/**
         * 下面这三个判断都会执行
         * registerSingleton()方法就是往beanFacotory中手动注册一个bean
         * 注意这个bean仅仅是一个对象，而没有经过生命周期的步骤，
         * 	1.容器的enviroment
         *	2.容器的enviroment中的系统的properties文件
         *	3.容器的enviroment中的系统的enviroment
         */
		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());
		}
	}

当前方法结束后beanFactory中的一些重要属性 singletonObjects这个Map就是我们通常说的spring单例池，用来存放bean。

4.postProcessBeanFactory(beanFactory);

空壳方法

5.invokeBeanFactoryPostProcessors(beanFactory);

两个重要的接口
1.BeanDefinitionRegistryPostProcesson
2.BeanDefinitionPostProcessor
BeanDefinitionRegistryPostProcesson是BeanDefinitionPostProcessor的子接口

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		//PostProcessorRegistrationDelegate的静态方法
		PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

		// Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
		// (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
		if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}
	}

public static void invokeBeanFactoryPostProcessors(
			ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

		//存储所有已经执行过的BeanDefinitionRegistryPostProcessor实现类的名字！
		Set<String> processedBeans = new HashSet<>();

		//beanFactory实现了BeanDefinitionRegistry的接口，所以 99%为true
		if (beanFactory instanceof BeanDefinitionRegistry) {
			BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
			//存放所有自己添加的实现了beanDefinitionPostProccessor的对象
			List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<>();
			//存放所有已经执行过的实现了beanFactoryRegisterPostProcessor的接口的对象
			List<BeanDefinitionRegistryPostProcessor> registryProcessors = new LinkedList<>();

			/**
             * 循环所有beanFactoryPostProcessors中的实现类，从源码可以看到此时并没有往beanFactoryPostProcessors添加过任何类
			 * 因为spring允许用户通过api自己往beanFactory中的BeanFactoryPostProcessor的List集合添加对象
			 * 所以他会先去找已经添加进去的
			 * 如果该对象实现了beanFactoryRegisterPostProcessor接口，就会执行他的postProcessBeanDefinitionRegistry()方法，然后添加进registryProcessors集合中
			 * 如果该对象没有实现了beanFactoryRegisterPostProcessorr接口，只会添加进regularPostProcessors集合
			 * 为什么spring可以让用户自己添加。因为如果你想在扫描之前通过后置处理器执行方法，比如说对beanDefinitionMap修改，那么这个方法就可行
			 */
			for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
				if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
					BeanDefinitionRegistryPostProcessor registryProcessor =
							(BeanDefinitionRegistryPostProcessor) postProcessor;
					registryProcessor.postProcessBeanDefinitionRegistry(registry);
					registryProcessors.add(registryProcessor);
				} else {
					regularPostProcessors.add(postProcessor);
				}
			}

			/**
			 * 存储的是当前正在执行的BeanDefinitionRegistryPostProcessor的实现类，执行完成后remove掉
			 */
			List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

			/**
			 *  第一次执行getBeanNamesForType()方法，从beanDefinition拿到所有实现了BeanDefinitionRegistryPostProcessor的类，该方法后面回细讲！          
			 *  只有一个ConfigutionClassPostProcessor这个beanDefinition
             *	为什么此时只有一个，因为并没有扫开始描自己的bean
			 */	
			String[] postProcessorNames =
					beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);

             
			for (String ppName : postProcessorNames) {
            	//先判断是否实现了PriorityOrdered.class这个接口，如果实现了就不会在此处执行
				if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
					//添加到正在执行实现类的集合中去 并且是通过getBean(),也就是说直接放到SingoletonObjects中了,这个getBean()方法到后面在细讲
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					//添加到已经执行完毕实现类的集合中
					processedBeans.add(ppName);
				}
			}
			//排序
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			//合并
			registryProcessors.addAll(currentRegistryProcessors);
			/**
             * 重点！！我会在最后进行该方法的详解
             * 执行方法 完成了扫描配置类，生成beanDefinition，放入集合的的一系列操作   
             */
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			//清空正在执行的集合
			currentRegistryProcessors.clear();

			/**
			 * 第二次执行实现order接口的自定义BeanDefinitionRegistryPostProcessor的实现类
             * 此时我们自己的类已经被扫描出来，注册进beanDefinitionMap中
             * 第二次拿到beanDefinitionMap中所有实现了BeanDefinitionRegistryPostProcessor的beanDefinition  
			 */
			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            //大体步骤和第一次一样
			for (String ppName : postProcessorNames) {
				//判断是否已经执行过了 && 判断是否实现了Ordered.class这个接口
				if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
				}
			}
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			registryProcessors.addAll(currentRegistryProcessors);
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			currentRegistryProcessors.clear();

			/**
			 * 最后一次执行没有实现order接口的BeanDefinitionRegistryPostProcessor实现类
             * 为什么这里要用reiterate做一个标识符，并且在执行完之后还会再执行一遍
             * 因为你可能通过BeanDefinitionRegistryPostProcessors()这个方法，手动往beanDefinition中注册实现了BeanDefinitionRegistryPostProcessor的beanDefinition
             * spring为了防止漏掉这种情况，会多进行一次循环，如果全部执行过了则结束本次循环
			 */
			boolean reiterate = true;
			while (reiterate) {
				reiterate = false;
                //第三次拿到拿到beanDefinitionMap中所有实现了BeanDefinitionRegistryPostProcessor的beanDefinition  
				postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
				for (String ppName : postProcessorNames) {
                //只判断是否已经执行过了
					if (!processedBeans.contains(ppName)) {
						currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
						processedBeans.add(ppName);
						reiterate = true;
					}
				}
				sortPostProcessors(currentRegistryProcessors, beanFactory);
				registryProcessors.addAll(currentRegistryProcessors);
				invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
				currentRegistryProcessors.clear();
			}
			/**
			 *  上述代码完成了所有实现了BeanDefinitionRegistryPostProcessor的类的特定方法的执行和该类的bean的生命周期
			 */


			/**
			 * 开始执行实现BeanFactoryPostProcessors的接口的类
			 */
             
			/**
			 *  首先执行的是registryProcessors这个集合中已经完成执行的实现了BeanDefinitionRegistryPostProcessor的类
			 *  为什么，因为BeanDefinitionRegistryPostProcessor是BeanDefinitionPostProcessor的子类
			 *  同样实现了BeanDefinitionPostProcessor接口中的方法
			 *  这个方法也很重要！！
             *  ConfigutionClassPostProcessor这个接口的postProcessBeanFactory完成了对配置类的动态代理
             *  最后会详细讲！！
			 */
			invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
			/**
			 * 接着因为程序员自己通过api注入的实现BeanDefinitionPostProcessor的类一开始缓存起来了
			 * 所以直接执行regularPostProcessors中的实现类
			 */
			invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
		} else {
			invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
		}

		/**
		 * 第四次调用getBeanNamesForType方法，只不过此时传入的Class变成了BeanFactoryPostProcessor
         * 但是他还是能够找到实现了BeanDefinitionRegisterPostProcessor的beanDefinition
		 */
		String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

		/**
		 * 存放的是所有实现了beanDefinitionPostProcessor和priorityOrdered接口的类的对象
		 */
		List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
		/**
		 * 存放的是所有实现了beanDefinitionPostProcessor和ordered接口的类的名字
		 */
		List<String> orderedPostProcessorNames = new ArrayList<>();
		/**
		 * 存放的没是实现beanDefinitionPostProcessor和ordered接口的类的名字
		 */
		List<String> nonOrderedPostProcessorNames = new ArrayList<>();
		
        //根据判断添加进不同的List集合
		for (String ppName : postProcessorNames) {
			//判断是否已经执行过了
			if (processedBeans.contains(ppName)) {
				//判断是否实现了PriorityOrdered接口
			} else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
				//判断是否实现了Ordered接口
			} else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			} else {
				//都不满足
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

		/**
		 * 排序、执行priorityOrderedPostProcessors集合中的对象
		 */
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

		/**
		 * 根据orderedPostProcessorNames中的beanName拿到对应的beanDefinition进行生命周期实例化 
		 */
		List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
		for (String postProcessorName : orderedPostProcessorNames) {
			orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		//排序且执行
		sortPostProcessors(orderedPostProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
		/**
		 * 根据nonOrderedPostProcessorNames中的beanName拿到对应的beanDefinition进行生命周期实例化 
		 */
		List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
		for (String postProcessorName : nonOrderedPostProcessorNames) {
			nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
        //执行
		invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
		//清除元数据缓存
		beanFactory.clearMetadataCache();
	}

最后总结一下执行顺序

1.通过api手动注册的实现了BeanDefinitionRegistryPostProcessor接口的类的postProcessBeanDefinitionRegistry方法
2.spring内置的实现了BeanDefinitionRegistryPostProcessor接口的类的postProcessBeanDefinitionRegistry方法
3.扫描出来的实现了Order和BeanDefinitionRegistryPostProcessor接口的类的postProcessBeanDefinitionRegistry方法
4.扫描出来的没有实现Order实现了BeanDefinitionRegistryPostProcessor接口的类的postProcessBeanDefinitionRegistry方法
5.所有实现了BeanDefinitionRegistryPostProcessor接口的类的postProcessBeanFactory方法
6.通过api手动注册的实现了BeanFactoryPostProcessor接口的类的postProcessBeanFactory方法
7.扫描出来的实现了Order和BeanFactoryPostProcessor接口的类的postProcessBeanFactory方法
8.扫描出来的没有实现Order和BeanFactoryPostProcessor接口的类的postProcessBeanFactory方法

剩下的三个重点方法下篇文章在讲

下篇结束后invokeBeanFactoryPostProcessors(beanFactory);这个方法就结束了
源码到这里已经开始接触到了beanPostProcessor以及他的子类，这个接口到底干了什么。已经他的实现类到底做了什么
我会专门出一篇文章讲明白，最后再看一眼此时beanFactory中的重要属性
除了我自己用来测试的类，重点关注其他spring内置的beanDefinition

//记录一下还没讲到的重点！！！！
ConfigurationClassPostProcessor.postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)
ConfigurationClassPostProcessor.postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
DefaultListableBeanFactory.getBeanNamesForType(@Nullable Class<?> type, boolean includeNonSingletons, boolean allowEagerInit)