springboot-spring源码系列（七）

继续回到refresh()方法

6.registerBeanPostProcessors(beanFactory)

protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
	}
public static void registerBeanPostProcessors(
			ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
		/**
		 * 从beanDefinitionMap中拿到所有实现了beanPostProcessor的beanDefinition的beanName
		 */
		String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
        //拿到beanPostProcessor的数量(postProcessorNames + beanFactory中的beanPostProcessors)
		int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
 	    //添加了第三个后置处理器
        //负责检查单例池中，是否存在实现了后置处理器，但是没有执行的bean
		beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
		//存放实现了PriorityOrdered接口的beanPostProcessor的单例对象
		List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
        //存放实现了PriorityOrdered接口并且经过合成的beanPostProcessor的单例对象
		List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
        //存放实现了Ordered接口的beanPostProcessor的beanName
		List<String> orderedPostProcessorNames = new ArrayList<>();
        //存放没有实现Ordered和PriorityOrdered接口的beanPostProcessor的beanName
		List<String> nonOrderedPostProcessorNames = new ArrayList<>();
        //循环所有扫描出来的beanPostProcessor的beanName
		for (String ppName : postProcessorNames) {
        	//通过beanName找到类判断是否实现了PriorityOrdered接口
			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				//直接反射创建对象放入singeltonObjects中,并且返回该单例对象
				BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
				priorityOrderedPostProcessors.add(pp);
                //判断是否经过合成
				if (pp instanceof MergedBeanDefinitionPostProcessor) {
					internalPostProcessors.add(pp);
				}
             //判断是否实现了Order接口
			} else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			} else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}
        //首先对实现了priorityOrdered接口的beanPostProcessor进行排序
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		/**
		 *  往beanFactory中的beanPostProcessors添加了三个beanPostProcessor单例对象
		 *  1. CommonAnnotationBeanPostProcessor      解析方法上的通用注解
		 *  2. AutowiredAnnotationBeanPostProcessor   解析方法上的 @Autowired 注解
		 *  3. RequiredAnnotationBeanPostProcessor    解析方法上的 @Required  注解
         *  4. 还添加了你自己在配置类上开启的后置处理器 例如：@EnableAspectJAutoProxy(根据是否实现了Order和priorityOrdered接口,进入对应的循环)
		 *  5. 还添加了你自定义的后置处理器(根据是否实现了Order和priorityOrdered接口,进入对应的循环)
		 */
		registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
		//根据所有实现了Order接口的beanPostProcessor的beanName实例化对象,放入该List集合		
		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);
        //注册进beanFactory的beanPostProcessors集合
		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);
			}
		}
		registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

		//最后注册合成的beanPostProcessor
		sortPostProcessors(internalPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, internalPostProcessors);
		/**
		 * 添加了第七个后置处理器
		 * 该BeanPostProcessor检测那些实现了接口ApplicationListener的bean，在它们创建时初始化之后,将它们添加到应用上下文的事件多播器上
         * 在这些ApplicationListener bean销毁之前,将它们从应用上下文的事件多播器上移除
		 */
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
	}

7.initMessageSource();

protected void initMessageSource() {
   //获取Bean工厂，一般是DefaultListBeanFactory
   ConfigurableListableBeanFactory beanFactory = getBeanFactory();
   //首先判断是否已有xml文件定义了id为messageSource的bean对象
   if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
      //如果有，则从Bean工厂得到这个bean对象
      this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
      //当父类Bean工厂不为空，并且这个bean对象是HierarchicalMessageSource类型
      if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
         //为HierarchicalMessageSource的实现类
         HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
         //设置父类MessageSource，此处设置内部的parent messageSource
         if (hms.getParentMessageSource() == null) {
            hms.setParentMessageSource(getInternalParentMessageSource());
         }
      }
      if (logger.isTraceEnabled()) {
         logger.trace("Using MessageSource [" + this.messageSource + "]");
      }
   }
   else {
      //如果没有xml文件定义信息源对象，新建DelegatingMessageSource类作为messageSource的Bean
      //因为DelegatingMessageSource类实现了HierarchicalMessageSource接口，而这个接口继承了MessageSource这个类
      //因此实现了这个接口的类，都是MessageSource的子类，因此DelegatingMessageSource也是一个MessageSource
      DelegatingMessageSource dms = new DelegatingMessageSource();
      //给这个DelegatingMessageSource添加父类消息源
      dms.setParentMessageSource(getInternalParentMessageSource());
      this.messageSource = dms;
      //将这个messageSource实例注册到Bean工厂中
      beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
      if (logger.isTraceEnabled()) {
         logger.trace("No '" + MESSAGE_SOURCE_BEAN_NAME + "' bean, using [" + this.messageSource + "]");
      }
   }
}

8.initApplicationEventMulticaster();

protected void initApplicationEventMulticaster() {
		//拿到beanFactory
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
        //判断singeltonObjects中是否有 key = applicationEventMulticaster的bean
		if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
        	//如果有就把该bean设置给Context的applicationEventMulticaster属性
			this.applicationEventMulticaster =
					beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
			if (logger.isDebugEnabled()) {
				logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
			}
        //如果没有就创建一个SimpleApplicationEventMulticaster对象赋给applicationEventMulticaster属性
        //此时这个广播器只是进行了初始化,并没有添加广播器
		} else {
			this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
            //并且注册进beanFactory的singeltonObjects中
			beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
			if (logger.isDebugEnabled()) {
				logger.debug("Unable to locate ApplicationEventMulticaster with name '" +
						APPLICATION_EVENT_MULTICASTER_BEAN_NAME +
						"': using default [" + this.applicationEventMulticaster + "]");
			}
		}
	}

9.onRefresh();

// 空壳方法,
// AbstractApplicationContext对象中没有实现,他的子类webContext在这个方法中完成了springMVC九大组件的初始化
// springboot在这个方法中完成Tomcat的初始化

10.registerListeners();

protected void registerListeners() {
		//尝试从Context的applicationListeners属性中拿监听器,通过api手动注入的
		for (ApplicationListener<?> listener : getApplicationListeners()) {
        	//注册进广播器
			getApplicationEventMulticaster().addApplicationListener(listener);
		}
        //尝试从beanDefinitionMap中拿到实现了ApplicationListener接口的beanDefinition的beanName集合
		String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
        //注册进广播器
		for (String listenerBeanName : listenerBeanNames) {
			getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
		}
		//从earlyApplicationEvents集合中拿到在此之前需要执行的监听事件
		Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
        //将earlyApplicationEvents集合设为null
		this.earlyApplicationEvents = null;
        //如果存在监听事件,则广播器根据事件类型让对应的监听器执行事件
        //对于如何分发监听事件的有兴趣的同学自己看,springboot中的重点就是广播器和监听器
		if (earlyEventsToProcess != null) {
			for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
				getApplicationEventMulticaster().multicastEvent(earlyEvent);
			}
		}
	}

11.finishBeanFactoryInitialization(beanFactory);

• 这个方法太重要了下篇文章单独讲

12.finishRefresh();

protected void finishRefresh() {
		//清除上下文级资源缓存（例如扫描中的ASM元数据）。
		clearResourceCaches();
		//往beanFactory的singletonObjects中注册一个key为lifecycleProcessor的bean
        //lifecycleProcessor可以理解为生命周期处理器
		initLifecycleProcessor();
        //如果一个类实现了lifecycle接口,那么在容器进行start或者stop的时候会通过LifecycleProcessor这个后置处理器执行这些类的start和stop方法
		//当容器启动时调用lifecycleProcessor的onRefresh()方法
        //调容器销毁时调用lifecycleProcessor的onClose()方法
		getLifecycleProcessor().onRefresh();
		//发布最后一个事件容器启动成功
		publishEvent(new ContextRefreshedEvent(this));
		//尝试从properties文件中拿key为spring.liveBeansView.mbeanDomain的值,如果拿到了添加进LiveBeansView的属性中
        //至于做什么的不理解
		LiveBeansView.registerApplicationContext(this);
	}
public void onRefresh() {
		startBeans(true);
        //表示当前容器处于运行状态
		this.running = true;
	}
private void startBeans(boolean autoStartupOnly) {
		//从容其中拿到实现了Lifecycle接口的beanDefinition的beanName,放入singletonObjects中
		//返回单例对象不是DefaultLifecycleProcessor类型的对象集合
		Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans();
         // key:如果实现了SmartLifeCycle，则为其getPhase方法返回的值，如果只是实现了Lifecycle，则返回0
    	 // value:相同phase的Lifecycle的集合，并将其封装到了一个LifecycleGroup中
		Map<Integer, LifecycleGroup> phases = new HashMap<>();
        //只有实现了SmartLifecycle接口的类才会执行
		lifecycleBeans.forEach((beanName, bean) -> {
         	// 我们可以看到autoStartupOnly这个变量在上层传递过来的
       	    // 这个参数意味着是否只启动“自动”的Bean,这是什么意思呢？就是说，不需要手动调用容器的start方法
      	    // 从这里可以看出，实现了SmartLifecycle接口的类并且其isAutoStartup如果返回true的话，会在容器启动过程中自动调用，而仅仅实现了Lifecycle接口的类并不会被调用。
            // 如果我们去阅读容器的start方法的会发现，当调用链到达这个方法时，autoStartupOnly这个变量写死的为false
			if (!autoStartupOnly || (bean instanceof SmartLifecycle && ((SmartLifecycle) bean).isAutoStartup())) {
               // 获取这个Bean执行的阶段，实际上就是调用SmartLifecycle中的getPhase方法
               // 如果没有实现SmartLifecycle，而是单纯的实现了Lifecycle，那么直接返回0
				int phase = getPhase(bean);
				LifecycleGroup group = phases.get(phase);
				if (group == null) {
                  // LifecycleGroup构造函数需要四个参数
                  // phase：代表这一组lifecycleBeans的执行阶段
                  // timeoutPerShutdownPhase：因为lifecycleBean中的stop方法可以在另一个线程中运行，所以为了确保当前阶段的所有lifecycleBean都执行完，Spring使用了CountDownLatch，而为了防止无休止的等待下去，所有这里设置了一个等待的最大时间，默认为30秒
                  // lifecycleBeans：所有的实现了Lifecycle的Bean
                  // autoStartupOnly: 手动调用容器的start方法时，为false。容器启动阶段自动调用时为true,详细的含义在上面解释过了
					group = new LifecycleGroup(phase, this.timeoutPerShutdownPhase, lifecycleBeans, autoStartupOnly);
					phases.put(phase, group);
				}
				group.add(beanName, bean);
			}
		});
		if (!phases.isEmpty()) {
			List<Integer> keys = new ArrayList<>(phases.keySet());
            //排序
			Collections.sort(keys);
			for (Integer key : keys) {
              // 获取每个阶段下所有的lifecycleBean，然后调用其start方法
				phases.get(key).start();
			}
		}
	}   

13.resetCommonCaches();

	protected void resetCommonCaches() {
    	//清除内部方法/字段缓存。
		ReflectionUtils.clearCache();
        //清除内部ResolvableType和serializabletypwrapper的缓存。
		ResolvableType.clearCache();
        /**
		 * 清除给定类加载器的自省缓存
         * 删除该类加载器下所有类的自省结果
	     * 以及从类加载器列表中删除子类加载器
         */
		CachedIntrospectionResults.clearClassLoader(getClassLoader());
	}