Spring源码剖析之IOC容器创建流程

ApplicationContextConfiguration为核心配置类

 ApplicationContext applicationContext =
                new AnnotationConfigApplicationContext(ApplicationContextConfiguration.class);

1、this(), 实例化IOC容器，定义BeanDefinition读取器，读取注解定义的Bean。定义类路径下的BeanDefinition扫描器，扫描定义的Bean

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
		this();   // 实例化IOC容器
		register(annotatedClasses);
		refresh();
	}

2、register方法，获取核心配置类注解，获取注解元数据，封装成BeanDefinition，放入IOC容器

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
		this();   // 实例化IOC容器
		// 获取核心配置类注解，获取注解元数据，封装成BeanDefinition，放入IOC容器
		register(annotatedClasses);
		refresh();
	}

定义的BeanDefinitionReader，调用doRegisterBean

1、通过class.getAnnotations,获取核心配置类上的所有注解
2、解析核心配置类上的注解元数据，判断是singleton还是prototype
3、判断是否需要scope代理
4、将核心配置类，封装成的BeanDefinition，注册到IOC容器的BeanDefinitionMap中

<T> void doRegisterBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
			@Nullable 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);
		BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
	}

3、refresh方法， 实例化默认，自定义组件BeanFactoryPostProcessor并调用，实现核心配置类解析，自定义包组件扫描成BeanDefinition。实例化默认，自定义组件BeanPostProcessor，在Bean实例化，属性赋值后，init-method前后调用，实现动态代理等。定义监听器，实现整个应用上下文监听。实例化所有剩余的Bean，通过三级缓存解决循环依赖。

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
		this();   // 实例化IOC容器
		register(annotatedClasses);
		refresh();
	}

调用refresh方法

1、刷新前预处理
2、获取之前创建的BeanFactory，默认实现DefaultListableBeanFactory
3、BeanFactory的预准备⼯作（BeanFactory进⾏⼀些设置，设置类加载器，默认的BeanPostProcess，环境等等。

4、invokeBeanFactoryPostProcessors(beanFactory); 实例化并调用默认配置，和自定义的BeanFactoryPostProcessor,实现核心配置类解析，包组件扫描封装BeanDefinition.

4.1、调用ConfigurationClassPostProcessor，处理@Configuration 定义的类，
注意：此时IOC容器的BeanDefinitionMap中只有核心配置类ApplicationContextConfiguration标识了@Configuration，因为首先识别的是核心配置类，因此以核心配置类为起点，进行解析。
（调用实现了PriorityOrdered的BeanDefinitionRegistryPostProcessors，例如ConfigurationClassPostProcessor）

4.1.1、@Configuration配置类解析流程

• 递归解析，核心配置类以及其父类。
• 解析@PropertySource，加载外部配置文件
• 解析@ComponentScan ，获取注解属性，对单个属性一一解析，例如basePackage，通过类路径下的BeanDefinitionScanner对指定包极其子包进行扫描，实际上扫描到的就是对应的.class文件，然后将他们封装为一个个的BeanDefinition，放入IOC容器的B、BeanDefinitionMap中
• 解析@Import，加载其它配置类
• 解析@Bean，获取@Configuration类所有@Bean对应的方法，getAnnotatedMethods(Bean.class.getName());

4.2、调用实现了Order的BeanDefinitionRegistryPostProcessors

4.3、调用实现剩余的其它全部BeanDefinitionRegistryPostProcessors

4.4、获取所有实现了BeanFactoryPostProcessor的后置处理器，通过PriorityOrdered-》Order-》Other 依次调用（先反射实例化，放入Spring一级缓存池中（单例池），然后调用对应的方法）

而我们自己实现BeanFactoryPostProcessor，在这里被实例化，并调用

5、registerBeanPostProcessors(beanFactory); 注册默认的，自定义的BeanPostProcessor，实现Bean-init前后的调用。注册顺序PriorityOrdered-》Order-》Other

6、initMessageSource(); 初始化MessageSource组件（做国际化功能；消息绑定，消息解析）

7、initApplicationEventMulticaster(); 初始化事件派发器

8、onRefresh(); ⼦类重写这个⽅法，在容器刷新的时候可以⾃定义逻辑

9、registerListeners(); 注册监听器，就是注册实现了ApplicationListener接⼝的监听器

10、finishBeanFactoryInitialization(beanFactory); 实例化所有单例bean，放入一级缓存池中

11、finishRefresh(); 完成context的刷新。主要是调⽤LifecycleProcessor的onRefresh()⽅法，并且发布事件（ContextRefreshedEvent）

public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// 刷新前预处理
			prepareRefresh();

			// 获取之前创建的BeanFactory，默认实现DefaultListableBeanFactory
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// BeanFactory的预准备⼯作（BeanFactory进⾏⼀些设置，设置类加载器，环境等等。
			prepareBeanFactory(beanFactory);

			try {
				// Allows post-processing of the bean factory in context subclasses.
				postProcessBeanFactory(beanFactory);
				
				//  实例化并调用默认配置，和自定义的BeanFactoryPostProcessor,实现核心配置类解析，包组件扫描封装BeanDefinition.
				invokeBeanFactoryPostProcessors(beanFactory);

				// 注册默认配置的和自定义的BeanPostProcessor , 实现bean创建赋值之后 init 方法前后调用
				registerBeanPostProcessors(beanFactory);

				// 初始化MessageSource组件，实现 国际化功能，消息绑定，消息解析
				initMessageSource();

				// 初始化应用事件派发器
				initApplicationEventMulticaster();

				// 子类重写
				onRefresh();

				// 注册实现了ApplicationListener接⼝的监听器
				registerListeners();

				// 实例化剩下的所有单例bean
				finishBeanFactoryInitialization(beanFactory);

				// 发布事件，交由其它组件触发对应响应，例如springMVC初始化
				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();
			}
		}
	}

总结

1、创建IOC容器，并实例化BeanDefinitionReader，BeanDefinitionScanner
2、通过BeanDefinitionReader，简单解析核心配置类，注册到IOC容器的BeanDefiniton中
3、调用refresh方法

• 实例化并调用系统默认，自定义的BeanFactoryPostProcessor，实现核心配置类解析，包组件扫描成BeanDefinition
• 注册实例化系统默认的，自定义的BeanPostProcessor，用于bean init前后调用
• 初始化MessageSource实现消息绑定，国际化。实例化监听器，实现上下文监听
• 实例化剩下的所有单例Bean，加入Spring一级缓存池，SingletonObjects。