Spring源码——容器创建

Spring5.0.2

准备

public class Blue {
    public Blue() {
        System.out.println("Blue---Constructor");
    }
}

@ComponentScan("cn.example.ext")
@Configuration
public class ExtConfig {
    @Bean
    public Blue blue() {
        return new Blue();
    }
}

public class Test01 {
    @Test
    public void test01() {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(ExtConfig.class);
        applicationContext.close();
    }
}

分析

容器创建首先会进入AnnotationConfigApplicationContext中：

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
	this();
	register(annotatedClasses);
	/*
		1. 从refresh()开始
	*/
	refresh();
}

@Override
public void refresh() throws BeansException, IllegalStateException {
	synchronized (this.startupShutdownMonitor) {
		// Prepare this context for refreshing.
		/* 
			2. 容器刷新前的预处理工作
			   进入这个方法中，可以看到进行了属性合法性校验、
			   保存容器的一些早期事件（别忘了这个早期事件哦！后面会提到它的派发时机）等工作
		*/
		prepareRefresh();

		// Tell the subclass to refresh the internal bean factory.
		/*
			3. 获取BeanFactory
		*/
		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

		// Prepare the bean factory for use in this context.
		/*
			4. BeanFactory的预准备工作：
				设置BeanFactory的类加载器
				往BeanFactory中注册了一些后置处理器（后置处理器用来在组件创建前进行拦截）
				添加编译时的AspectJ支持
				往BeanFactory中注册了一些组件（环境变量、系统属性、系统的环境信息）
		*/
		prepareBeanFactory(beanFactory);
		
		try {
			// Allows post-processing of the bean factory in context subclasses.
			/*
				默认是空的，留给子类
			*/
			postProcessBeanFactory(beanFactory);
			/*
			    =========至此，BeanFactory的准备工作就完成了=========
		    */
			// Invoke factory processors registered as beans in the context.
			/*
				5. BeanFactory的后置处理器，以上过程是BeanFactory的标准初始化工作，
				这个方法中就是在这个工作之后执行
				BeanFactoryPostProcessors有两大子接口：BeanFactoryPostProcessor和BeanDefinitionRegistryPostProcessor
				我们自定义的类可以实现这两个接口，获取BeanFactory信息，以及往BeanFactory中
				注入组件
			*/
			invokeBeanFactoryPostProcessors(beanFactory);

			// Register bean processors that intercept bean creation.
			/*
				6. 注册Bean的后置处理器（实现了BeanPostProcessor的接口）,
				我们可以自定义实现这个接口的类。
				这个后置处理器就很厉害了，而且又很多，用于在Bean创建之前进行拦截，比如它的子接口
				AutowiredAnnotationBeanPostProcessor，就完成了Autowired注解的任务；
				再比如AnnotationAwareAspectJAutoProxyCreator，就完成了AOP代理对象的任务
			*/
			registerBeanPostProcessors(beanFactory);

			// Initialize message source for this context.
			/*
				7. 初始化并注册MessageSource组件，主要做些国际化功能
			*/
			initMessageSource();

			// Initialize event multicaster for this context.
			/*
				8. 初始化事件派发器，和事件监听、发布相关
				比如我们可以自定义实现ApplicationListener接口的类，监听系统事件以及自己发布的事件
			*/
			initApplicationEventMulticaster();

			// Initialize other special beans in specific context subclasses.
			/*
				默认是空的，留给子类
			*/
			onRefresh();

			// Check for listener beans and register them.
			/*
				9. 将所有的（系统的、自定义的）
				 ApplicationListener类注册到容器中，将每个监听器添加到事件派发器中，
				 并派发第2步中提到的早期事件，默认没有事件				 
			*/
			registerListeners();

			// Instantiate all remaining (non-lazy-init) singletons.
			/*
				10. 初始化所有剩下的单实例Bean（不包括懒加载的Bean，因为它是第一次使用才会创建）
				Bean的创建过程：
					1）先从缓存中或者这个单实例Bean，能获取到说明之前已经创建过了，获取不到则继续（保存单实例Bean用的是CurrentHashMap）
					2）先把当前Bean标记为已经被创建（防止多线程情况下Bean被多次创建）
					3）获取Bean的定义信息（包括是否是抽象类、Scope作用域、Bean的类信息、自定义初始化方法名、自定义销毁方法名等）
					4）获取它所依赖的Bean（就是创建这个Bean之前，要创建哪些Bean），如果有，则先创建依赖的Bean
					5）开始创建当前Bean，此时在第6步注册的Bean的后置处理器就开始工作了（很多后置处理器，系统的、自定义的，不同的后置处理器，执行时机也不同）
					创建Bean的细节看下面的小节部分
			*/
			finishBeanFactoryInitialization(beanFactory);
			/*
				11.完成BeanFactory的初始化创建工作，IOC容器的创建也就完成了，IOC容器就是很多个Map集合，key是Bean的ID、Value是Bean的对象信息
			*/
			// Last step: publish corresponding event.
			finishRefresh();
		}

		//....省略
	}
}

完成创建的BeanFactory

到达第11步：

单实例Bean的创建流程

这里继续深入上面第10步中第5小步开始的Bean创建过程

先说下前边的函数调用链，IDEA最下面显示的就是当前所属类的方法，从refresh()开始一次调用每个方法中的下一个方法，下面都有显示：


在这之前会判断是不是工厂Bean，不是就会进入getBean()方法中


doGetBean()方法：

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
			@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

		   //......省略

			if (!typeCheckOnly) {
			   // 把当前Bean标记为已创建
				markBeanAsCreated(beanName);
			}

			try {
				// 获取Bean的定义信息
				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				checkMergedBeanDefinition(mbd, beanName, args);

				// Guarantee initialization of beans that the current bean depends on.
				// 获取Bean所依赖的Bean
				String[] dependsOn = mbd.getDependsOn();
				if (dependsOn != null) {
					for (String dep : dependsOn) {
						if (isDependent(beanName, dep)) {
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
						}
						// 先注册并创建Bean所依赖的Bean
						registerDependentBean(dep, beanName);
						getBean(dep);
					}
				}

				// Create bean instance.
				if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, () -> {
						try {
						    // 这里开始就是第10步第5小步开始的地方，真正创建当前Bean
						    // 这个创建好的Bean返回之后，就保存在了一个单实例Bean的集合中
							return createBean(beanName, mbd, args);
						}
				//......省略		
	}

createBean()方法->doCreateBean()方法：

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
			throws BeanCreationException {
		// ....省略

		// Initialize the bean instance.
		Object exposedObject = bean;
		try {
		    // 10.5.1 进行Bean的属性的赋值
			populateBean(beanName, mbd, instanceWrapper);
			// 10.5.2 初始化Bean
			// 1）这个方法中会调用invokeAwareMethods()方法，执行BeanNameAware、BeanClassLoaderAware、BeanFactoryAware，这三个Aware类，是Bean生命周期中很重要的三个类
			// 2）对这个Bean执行所有的后置处理器的postProcessBeforeInitialization()方法
			// 3）如果这个Bean实现了InitializingBean接口，则执行重写的初始化方法
			// 4）如果这个Bean有自定义初始化方法，则执行
			// 5）对这个Bean执行所有的后置处理器的postProcessAfterInitialization()方法
			exposedObject = initializeBean(beanName, exposedObject, mbd);
		}
		//....省略
		//===============至此，这个Bean就可以使用了=============
		// Register bean as disposable.
		try {
			// 注册销毁方法，如果这个Bean实现了DisposableBean 接口
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
		}

		return exposedObject;
	}