Spring IOC容器注解启动流程浅析_spring ioc容器基于注解的启动大概流程

前言

本次源码阅读的Spring版本为5.10.RELEASE。

启动Spring容器,本质上是创建并初始化一个具体的容器类的过程,以常见的容器类AnnotationConfigApplicationContext为例,启动一个Spring容器可以用以下代码表示

AnnotationConfigApplicationContext act = new AnnotationConfigApplicationContext(RootConfig.class);
1

尽管只有短短的一行代码,但已经创建并启动了一个Spring的IOC容器。

XML容器是ClassPathXmlApplicationContext

一、容器启动前的准备工作

为了后面更好的理解,先来看下AnnotationConfigApplicationContext的部分类继承结构

1、IOC容器核心DefaultListableBeanFactory在这边创建

public class GenericApplicationContext .... {

	private final DefaultListableBeanFactory beanFactory;
    ....
	public GenericApplicationContext() {
		this.beanFactory = new DefaultListableBeanFactory();
	}
	....
1
2
3
4
5
6
7
8

注意这时的DefaultListableBeanFactory还只是一个最基本的容器，只有储存功能。

2、这里先分析AnnotationConfigApplicationContext的无参构造器。register方法和refresh方法后面分析

public class AnnotationConfigApplicationContext extends GenericApplicationContext implements AnnotationConfigRegistry{
	
	public AnnotationConfigApplicationContext() {
        //完成spring内部BeanDefinition的定义
		this.reader = new AnnotatedBeanDefinitionReader(this);
		//一个可在类路径上检测候选bean的bean定义扫描器,
		this.scanner = new ClassPathBeanDefinitionScanner(this);
	}
    public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
		//生产bean工厂
		this();
		//将配置类注入bean工厂，下面分析
		register(annotatedClasses);
        //，下面分析
		refresh();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

其实this()中最重要的就是AnnotatedBeanDefinitionReader，他可以赋予容器基本功能

public class AnnotatedBeanDefinitionReader {

	private final BeanDefinitionRegistry registry;

	private BeanNameGenerator beanNameGenerator = new AnnotationBeanNameGenerator();

	private ScopeMetadataResolver scopeMetadataResolver = new AnnotationScopeMetadataResolver();

	private ConditionEvaluator conditionEvaluator;


	public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
		this(registry, getOrCreateEnvironment(registry));
	}
	public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
		Assert.notNull(environment, "Environment must not be null");
		this.registry = registry;
		this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
		//重要代码
		AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
	}
    
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

解析class成为RootBeanDefinition，注册到容器里面。

public abstract class AnnotationConfigUtils {
     ..........
    public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) {
		   registerAnnotationConfigProcessors(registry, null);
	 }
	   
   public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors( BeanDefinitionRegistry registry, Object source) {
        //获取对象
		DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
		
		if (beanFactory != null) {
			if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
				beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
			}
			if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
				beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
			}
		}

		Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
		
		/**********************************检查有没有，如果没有注册*************************/
		
         //org.springframework.context.annotation.internalConfigurationAnnotationProcessor。
         //@Configuration注解处理器
         //ConfigurationClassPostProcessor是一个BeanFactoryPostProcessor（BeanDefinitionRegistryPostProcessor）
		if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
		}
        //org.springframework.context.annotation.internalAutowiredAnnotationProcessor
        //@Autowired注解处理器
        //AutowiredAnnotationBeanPostProcessor是一个BeanPostProcessor
		if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		//org.springframework.context.annotation.internalCommonAnnotationProcessor
		//spring会检查是否支持JSR-250，如果存在，则添加CommonAnnotationBeanPostProcessor。
		if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		//org.springframework.context.annotation.internalCommonAnnotationProcessor
		// 检查JPA支持，如果存在，则添加PersistenceAnnotationBeanPostProcessor.
		if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition();
			try {
				def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
						AnnotationConfigUtils.class.getClassLoader()));
			}
			catch (ClassNotFoundException ex) {
				throw new IllegalStateException(
						"Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
			}
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
		}
        //org.springframework.context.event.internalEventListenerProcessor
        //@EventListener注解处理器
		if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
		}
        //org.springframework.context.event.internalEventListenerProcessor
        //内部管理的EventListenerFactory的bean名称
		if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
		}
		return beanDefs;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

1、设置bean排序处理器：AnnotationAwareOrderComparator

2、设置用于检查bean定义是否为自动连接候选项的解析器为：ContextAnnotationAutowireCandidateResolver

3、注册下面类的BeanDefinition到容器中

ConfigurationClassPostProcessor：它是一个BeanDefinitionRegistryPostProcessor，@Configuration注解处理器，

AutowiredAnnotationBeanPostProcessor：它是一个BeanPostProcessor，@Autowired注解处理器

CommonAnnotationBeanPostProcessor：注册条件：当前Spring支持JSR 250；它是一个BeanPostProcessor，@PreDestroy和@PostConstruct注解处理器

PersistenceAnnotationBeanPostProcessor：注册条件：当前Spring支持JPA；它是一个BeanPostProcessor，@PersistenceUnit和@PersistenceContext注解处理器

EventListenerMethodProcessor：它是一个BeanFactoryPostProcessor，@EventListener注解处理器

DefaultEventListenerFactory：：它是一个EventListenerFactory，内部管理的EventListenerFactory的bean名称

JPA（java persistence API）用于管理JavaEE和JavaSE环境中的持久化，以及对象/关系映射的JavaAPI
JSR 250是Java规范请求以发展为目标注解(即，关于不属于程序本身的软件程序的信息)JavaSE和JavaEE适用于各种不同技术的平台。据设想，各种JSR将使用注释来启用陈述式编程风格。在JavaEE组件JSR中保持一致性特别有价值，但允许JavaEE和JavaSE之间的一致性也是很有价值的。

二、注册配置类的BeanDefinition到容器中

下面开始分析这段代码register(annotatedClasses);

public class AnnotationConfigApplicationContext ...{

public void register(Class<?>... annotatedClasses) {
		Assert.notEmpty(annotatedClasses, "At least one annotated class must be specified");
		this.reader.register(annotatedClasses);
}
1
2
3
4
5
6

进入AnnotatedBeanDefinitionReader的register方法

public class AnnotatedBeanDefinitionReader {
    ....
    public void register(Class<?>... annotatedClasses) {
		for (Class<?> annotatedClass : annotatedClasses) {
			registerBean(annotatedClass);
		}
	}
	 public void registerBean(Class<?> annotatedClass) {
		doRegisterBean(annotatedClass, null, null, null);
	}

  <T> void doRegisterBean(Class<T> annotatedClass, Supplier<T> instanceSupplier, String name, Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {

		AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
		if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
			return;
		}

		abd.setInstanceSupplier(instanceSupplier);
		ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
		abd.setScope(scopeMetadata.getScopeName());
		String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));

		AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
		if (qualifiers != null) {
			for (Class<? extends Annotation> qualifier : qualifiers) {
				if (Primary.class == qualifier) {
					abd.setPrimary(true);
				}
				else if (Lazy.class == qualifier) {
					abd.setLazyInit(true);
				}
				else {
					abd.addQualifier(new AutowireCandidateQualifier(qualifier));
				}
			}
		}
		for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
			customizer.customize(abd);
		}

		BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
		definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
		// 注册配置类的beanDefinition到beanDefinitionMap中
		BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

• 作用：注册配置类的BeanDefinition到容器中

三、启动容器的真正入口refresh()

其方法内容如下

public void refresh() throws BeansException, IllegalStateException {
		//“刷新”和“销毁”的同步监视器
		synchronized (this.startupShutdownMonitor) {
			// 容器刷新前的准备，设置上下文状态，获取属性，验证必要的属性等
			prepareRefresh();

			// 获取beanFactory。注解启动可以认为，直接获取DefaultListableBeanFactory对象
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// 配置beanFactory的标准上下文特征
			prepareBeanFactory(beanFactory);

			try {
		//因为beanFactory都准备好了，子类可以自己去实现自己的逻辑。
		//比如一些web的ApplicationContext，就实现了自己的逻辑，做一些自己的web相关的事情
		postProcessBeanFactory(beanFactory);

		// 实例化并调用所有注册的beanFactory后置处理器（实现接口BeanFactoryPostProcessor的bean）。
		//在beanFactory标准初始化之后执行  例如：PropertyPlaceholderConfigurer(处理占位符)
		invokeBeanFactoryPostProcessors(beanFactory);

		// Register bean processors that intercept bean creation.
		//实例化和注册beanFactory中扩展了BeanPostProcessor的bean。
		//例如：
		//AutowiredAnnotationBeanPostProcessor(处理被@Autowired注解修饰的bean并注入)
		//RequiredAnnotationBeanPostProcessor(处理被@Required注解修饰的方法)
		//CommonAnnotationBeanPostProcessor(处理@PreDestroy、@PostConstruct、@Resource等多个注解的作用)等。
		registerBeanPostProcessors(beanFactory);

		//初始化国际化工具类MessageSource
		initMessageSource();

		//初始化事件广播器
		initApplicationEventMulticaster();

		//模板方法，在容器刷新的时候可以自定义逻辑（子类自己去实现逻辑），不同的Spring容器做不同的事情
		onRefresh();

		//注册监听器，并且广播early application events,也就是早期的事件
		registerListeners();

		//非常重要。。。实例化所有剩余的（非懒加载）单例Bean。（也就是我们自己定义的那些Bean们）
		//比如invokeBeanFactoryPostProcessors方法中根据各种注解解析出来的类，在这个时候都会被初始化  扫描的 @Bean之类的
		//实例化的过程各种BeanPostProcessor开始起作用~~~~~~~~~~~~~~
		finishBeanFactoryInitialization(beanFactory);

		// Last step: publish corresponding event.
		//refresh做完之后需要做的其他事情
		//清除上下文资源缓存（如扫描中的ASM元数据）
		//初始化上下文的生命周期处理器，并刷新（找出Spring容器中实现了Lifecycle接口的bean并执行start()方法）。
		//发布ContextRefreshedEvent事件告知对应的ApplicationListener进行响应的操作
		finishRefresh();
	}

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

		//如果刷新失败那么就会将已经创建好的单例Bean销毁掉
		destroyBeans();

		//重置context的活动状态 告知是失败的
		cancelRefresh(ex);

		//抛出异常
		throw ex;
	}

finally {
		// 失败与否，都会重置Spring内核的缓存。因为可能不再需要metadata给单例Bean了。
		resetCommonCaches();
	}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

通过上面的注释，已经能够比较宏观的了解到容器的一个初始化过程了，那么接下来，将针对每一个步骤，进行微观源码级别的解释说明。

1：容器刷新前的准备工作

• prepareRefresh()

protected void prepareRefresh() {
		//记录容器启动时间，然后设立对应的标志位
		this.startupDate = System.currentTimeMillis();
		this.closed.set(false);
		this.active.set(true);

		// 打印info日志：开始刷新this此容器了
		if (logger.isDebugEnabled()) {
			if (logger.isTraceEnabled()) {
				logger.trace("Refreshing " + this);
			}
			else {
				logger.debug("Refreshing " + getDisplayName());
			}
		}

		// 这是扩展方法，由AbstractApplicationContext的子类去实现，可以在验证之前为系统属性设置一些值可以在子类中实现此方法
		initPropertySources();

		//这里有两步，getEnvironment()，然后是是验证是否系统环境中有RequiredProperties参数值 如下详情
		// 然后管理Environment#validateRequiredProperties 后面在讲到环境的时候再专门讲解吧
		// 这里其实就干了一件事，验证是否存在需要的属性
		getEnvironment().validateRequiredProperties();

		// 创建存储应用程序侦听器的容器
		if (this.earlyApplicationListeners == null) {
			this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
		}
		else {
			// 将本地应用程序侦听器重置为预刷新状态。
			this.applicationListeners.clear();
			this.applicationListeners.addAll(this.earlyApplicationListeners);
		}

		// 初始化容器，用于装载早期的一些事件
		this.earlyApplicationEvents = new LinkedHashSet<>();
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

2、配置工厂的标准上下文特征

• prepareBeanFactory(beanFactory)

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		// 设置beanFactory的classLoader为当前context的classLoader
		beanFactory.setBeanClassLoader(getClassLoader());
		// 设置EL表达式解析器（Bean初始化完成后填充属性时会用到）
		// spring3增加了表达式语言的支持，默认可以使用#{bean.xxx}的形式来调用相关属性值
		beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
		//设置属性注册解析器PropertyEditor 这个主要是对bean的属性等设置管理的一个工具
		beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

		// 将当前的ApplicationContext对象交给ApplicationContextAwareProcessor类来处理，从而在Aware接口实现类中的注入applicationContext等等
		// 添加了一个处理aware相关接口的beanPostProcessor扩展，主要是使用beanPostProcessor的postProcessBeforeInitialization()前置处理方法实现aware相关接口的功能
		// 类似的还有ResourceLoaderAware、ServletContextAware等等等等
		beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
		// 下面是忽略的自动装配（也就是实现了这些接口的Bean，不要Autowired自动装配了）
		// 默认只有BeanFactoryAware被忽略,所以其它的需要自行设置
		// 因为ApplicationContextAwareProcessor把这5个接口的实现工作做了（具体你可参见源码） 所以这里就直接忽略掉
		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的类，就注册beanFactory
		//  如果是ResourceLoader、ApplicationEventPublisher、ApplicationContext等等就注入当前对象this(applicationContext对象)

		// 此处registerResolvableDependency()方法注意：它会把他们加入到DefaultListableBeanFactory的resolvableDependencies字段里面缓存这，供后面处理依赖注入的时候使用 DefaultListableBeanFactory#resolveDependency处理依赖关系
		// 这也是为什么我们可以通过依赖注入的方式，直接注入这几个对象比如ApplicationContext可以直接依赖注入
		// 但是需要注意的是：这些Bean，Spring的IOC容器里其实是没有的。beanFactory.getBeanDefinitionNames()和beanFactory.getSingletonNames()都是找不到他们的，所以特别需要理解这一点
		// 至于容器中没有，但是我们还是可以@Autowired直接注入的有哪些，请看下图：
		beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
		beanFactory.registerResolvableDependency(ResourceLoader.class, this);
		beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
		beanFactory.registerResolvableDependency(ApplicationContext.class, this);

		// 注册这个Bean的后置处理器：在Bean初始化后检查是否实现了ApplicationListener接口
		// 是则加入当前的applicationContext的applicationListeners列表 这样后面广播事件也就方便了
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

		// 检查容器中是否包含名称为loadTimeWeaver的bean，实际上是增加Aspectj的支持
		// AspectJ采用编译期织入、类加载期织入两种方式进行切面的织入
		// 类加载期织入简称为LTW（Load Time Weaving）,通过特殊的类加载器来代理JVM默认的类加载器实现
		if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			// 添加BEAN后置处理器：LoadTimeWeaverAwareProcessor
			// 在BEAN初始化之前检查BEAN是否实现了LoadTimeWeaverAware接口，
			// 如果是，则进行加载时织入，即静态代理。
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			// Set a temporary ClassLoader for type matching.
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}

		// 注入一些其它信息的bean，比如environment、systemProperties、SystemEnvironment等
		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());
		}
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

这里提下ApplicationContextAwareProcessor，他是用来注入springIOC资源的，其源码如下

class ApplicationContextAwareProcessor implements BeanPostProcessor {

    ......

	public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException {
		AccessControlContext acc = null;

		if (System.getSecurityManager() != null &&
				(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
						bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
						bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)) {
			acc = this.applicationContext.getBeanFactory().getAccessControlContext();
		}

		if (acc != null) {
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				invokeAwareInterfaces(bean);
				return null;
			}, acc);
		}
		else {
			invokeAwareInterfaces(bean);
		}

		return bean;
	}

	private void invokeAwareInterfaces(Object bean) {
		if (bean instanceof Aware) {
			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);
			}
		}
	}

	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) {
		return bean;
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

3、模版方法

• postProcessBeanFactory(beanFactory)

这是一个模版方法。因为beanFactory都准备好了，子类可以自己去实现自己的逻辑。

在这里我们以AbstractRefreshableWebApplicationContext的postProcessBeanFactory方法为例子

protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		//注册ServletContextAwareProcessor 这样任意Bean都可以很方便的获取到ServletContext了  
		//同时忽略另外两个，因为ServletContextAwareProcessor 都把事情都做了
		beanFactory.addBeanPostProcessor(new ServletContextAwareProcessor(this.servletContext, this.servletConfig));
		beanFactory.ignoreDependencyInterface(ServletContextAware.class);
		beanFactory.ignoreDependencyInterface(ServletConfigAware.class);

	   //注册ServletRequest，ServletResponse，HttpSession，WebRequest到resolvableDependencies中
		WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, this.servletContext);
		//注册servletContext、contextParamters、contextAttributes  、servletConfig单例bean到singletonObjects中
		WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext, this.servletConfig);
	}
1
2
3
4
5
6
7
8
9
10
11
12

这里提下ServletContextAwareProcessor，他是用来注入springMVC资源的，其源码如下

public class ServletContextAwareProcessor implements BeanPostProcessor {

	.........
	
	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		if (getServletContext() != null && bean instanceof ServletContextAware) {
			((ServletContextAware) bean).setServletContext(getServletContext());
		}
		if (getServletConfig() != null && bean instanceof ServletConfigAware) {
			((ServletConfigAware) bean).setServletConfig(getServletConfig());
		}
		return bean;
	}

	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) {
		return bean;
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

4、实例化并调用BeanFactoryPostProcessors

• invokeBeanFactoryPostProcessors

实例化并调用所有注册的beanFactory后置处理器（实现接口BeanFactoryPostProcessor的bean）

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

		//这里就是定制：如果loadTimeWeaver这个Bean存在，那么就会配置上运行时织入的处理器LoadTimeWeaverAwareProcessor
		if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}
	}
1
2
3
4
5
6
7
8
9

这篇文章对这里有详细对分析 SpringBean注册之后置处理器BeanFactoryPostProcessor和BeanDefinitionRegistryPostProcessor

5、实例化和注册BeanPostProcessor

• registerBeanPostProcessors(beanFactory)

• 这一步：我们从所有的@Bean定义中抽取出来了BeanPostProcessor然后都注册进去，等待后面的的顺序调用

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

详细分析见SpringBean实例化之后置处理器BeanPostProcessor

6、初始化消息源

• initMessageSource()

若用户自己定义了这个名为messageSource的MessageSource类型Bean，就以用户的为准。
否则注册一个系统默认的消息源DelegatingMessageSource，其名字是messageSource

protected void initMessageSource() {
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		// 判断是否已经存在名为“messageSource”的Bean了（一般情况下，我们都是没有的）
		if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
			// 注册messageSource，并从容器里拿出这个messageSource
			this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
			// 设置父属性。
			if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
				HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
				if (hms.getParentMessageSource() == null) {
					//仅当没有父消息源时才将父上下文设置为父消息源
                    hms.setParentMessageSource(getInternalParentMessageSource());
				}
			}
			if (logger.isTraceEnabled()) {
				logger.trace("Using MessageSource [" + this.messageSource + "]");
			}
		}
		else {
			//使用空的MessageSource可以接受getMessage调用。
			DelegatingMessageSource dms = new DelegatingMessageSource();
			// 其实就是获取到父容器的messageSource字段（否则就是getParent()上下文自己）
			dms.setParentMessageSource(getInternalParentMessageSource());
			// 给当前的messageSource赋值
			this.messageSource = dms;
			// 把messageSource作为一个单例的Bean注册进beanFactory工厂里面
			beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
			if (logger.isTraceEnabled()) {
				logger.trace("No '" + MESSAGE_SOURCE_BEAN_NAME + "' bean, using [" + this.messageSource + "]");
			}
		}
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

7、初始化事件广播器

• initApplicationEventMulticaster()

若用户自己定义了这个名为applicationEventMulticaster的ApplicationEventMulticaster类型Bean，就以用户的为准。
否则注册一个系统默认的事件广播器SimpleApplicationEventMulticaster，其名字是applicationEventMulticaster

protected void initApplicationEventMulticaster() {
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		//如果容器中包含applicationEventMulticaster
		if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
			//赋值当前存在的事件广播器
			this.applicationEventMulticaster =
					beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
			if (logger.isTraceEnabled()) {
				logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
			}
		}
		//如果容器中不包含applicationEventMulticaster
		else {
			//注册一个系统默认的SimpleApplicationEventMulticaster
			this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
			beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
			if (logger.isTraceEnabled()) {
				logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +
						"[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
			}
		}
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

8、模版方法

• onRefresh()

模板方法，在容器刷新的时候可以自定义逻辑（子类自己去实现逻辑），不同的Spring容器做不同的事情
下面是AbstractRefreshableWebApplicationContext的onRefresh方法

protected void onRefresh() {
		this.themeSource = UiApplicationContextUtils.initThemeSource(this);
	}
1
2
3

9、注册监听器

• registerListeners()

protected void registerListeners() {
		// 这一步和手动注册BeanDefinitionRegistryPostProcessor一样，可以自己通过set手动注册监听器  
		//然后是最先执行的（显然此处我们无自己set）
		for (ApplicationListener<?> listener : getApplicationListeners()) {
			// 把手动注册的监听器绑定到广播器
			getApplicationEventMulticaster().addApplicationListener(listener);
		}

		// 取到容器里面的所有的监听器的名称，绑定到广播器  后面会广播出去这些事件的
		// 同时提醒大伙注意：此处并没有说到ApplicationListenerDetector这个东东，下文会分解
		String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
		for (String listenerBeanName : listenerBeanNames) {
			getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
		}

		// 这一步需要注意了：如果存在早期应用事件，这里就直接发布了(同时就把earlyApplicationEvents该字段置为null)
		Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
		this.earlyApplicationEvents = null;
		if (earlyEventsToProcess != null) {
			for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
				getApplicationEventMulticaster().multicastEvent(earlyEvent);
			}
		}
	}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

10、注册和初始化容器内所有的单例Bean

• finishBeanFactoryInitialization(beanFactory)

11、refresh做完之后需要做的其他事情

• finishRefresh()

1、清除上下文资源缓存（如扫描中的ASM元数据）
2、初始化上下文的生命周期处理器，并刷新（找出Spring容器中实现了Lifecycle接口的bean并执行start()方法）。
3、发布ContextRefreshedEvent事件告知对应的ApplicationListener进行响应的操作

protected void finishRefresh() {
		// 表示清除一些resourceCaches，这个resourceCaches就是一个map,如doc说的  清楚context级别的资源缓存，比如ASM的元数据
		clearResourceCaches();

		// 初始化所有的LifecycleProcessor
		initLifecycleProcessor();

		// 上面注册好的处理器，这里就拿出来，调用它的onRefresh方法了
		getLifecycleProcessor().onRefresh();

		// 发布容器刷新的事件：
		publishEvent(new ContextRefreshedEvent(this));

		// 和MBeanServer和MBean有关的。相当于把当前容器上下文，注册到MBeanServer里面去。
		// 这样子，MBeanServer持久了容器的引用，就可以拿到容器的所有内容了，也就让Spring支持到了MBean的相关功能
		LiveBeansView.registerApplicationContext(this);
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

初始化上下文的生命周期处理器

若用户自己定义了这个名为lifecycleProcessor的LifecycleProcessor类型Bean，就以用户的为准。
否则注册一个系统默认的上下文的生命周期处理器DefaultLifecycleProcessor，其名字是LifecycleProcessor

protected void initLifecycleProcessor() {
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		//如果容器中存在lifecycleProcessor
		if (beanFactory.containsLocalBean(LIFECYCLE_PROCESSOR_BEAN_NAME)) {
			//使用当前的bean
			this.lifecycleProcessor =
					beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class);
			if (logger.isTraceEnabled()) {
				logger.trace("Using LifecycleProcessor [" + this.lifecycleProcessor + "]");
			}
		}
		//如果容器中不存在lifecycleProcessor
		else {
			DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();
			defaultProcessor.setBeanFactory(beanFactory);
			this.lifecycleProcessor = defaultProcessor;
			beanFactory.registerSingleton(LIFECYCLE_PROCESSOR_BEAN_NAME, this.lifecycleProcessor);
			if (logger.isTraceEnabled()) {
				logger.trace("No '" + LIFECYCLE_PROCESSOR_BEAN_NAME + "' bean, using " +
						"[" + this.lifecycleProcessor.getClass().getSimpleName() + "]");
			}
		}
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

通知上下文刷新

• getLifecycleProcessor().onRefresh()

public class DefaultLifecycleProcessor implements LifecycleProcessor, BeanFactoryAware{
@Override
	public void onRefresh() {
		startBeans(true);
		this.running = true;
	}
1
2
3
4
5
6

private void startBeans(boolean autoStartupOnly) {
		 //拿到所有的实现了Lifecycle/SmartLifecycle的  已经在IOC容器里面的单例Bean们（备注：不包括自己this，也就是说处理器自己不包含进去）
		// 这里若我们自己没有定义过实现Lifecycle的Bean，这里就是空的
		Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans();
		Map<Integer, LifecycleGroup> phases = new HashMap<>();
		lifecycleBeans.forEach((beanName, bean) -> {
			// 若Bean实现了SmartLifecycle 接口并且标注是AutoStartup  或者  强制要求自动自行的autoStartupOnly = true
			if (!autoStartupOnly || (bean instanceof SmartLifecycle && ((SmartLifecycle) bean).isAutoStartup())) {
				int phase = getPhase(bean);
				LifecycleGroup group = phases.get(phase);
				if (group == null) {
					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) {
				phases.get(key).start();
			}
		}
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

就这样，实现了Lifecycle接口的Bean start方法什么时候调用就有门路了。

从上面的源码中，我们能够读出什么异常的地方呢？我们发现Lifecycle这个接口并不能直接使用。
因为DefaultLifecycleProcessor的onRefresh方法传值为autoStartupOnly=true：表示只有实现了SmartLifecycle的Bean才会调用start方法，因为实现了SmartLifecycle接口会有一个phase值，根据上面源码会根据此值分组执行。
autoStartupOnly=false则只要是Lifecycle 的实现既可以被调用，我们会给其默认的phase。

所以，我们要想要这个功能，请实现SmartLifecycle，而不是Lifecycle接口