Spring源码（二）Spring容器初始化

了解专栏完整的内容，请点击跳转：
Spring framework专栏导航页

为了阐述得简要些，以下几篇内容都侧重于介绍注解方式的Spring容器，XML方式的略过。

什么是Spring容器

微观来说这个容器就是存储bean的Map，宏观来说（一般来说）是指ApplicationContext或者Spring框架的概念。

我们知道Spring是基于Ioc原理来管理我们的bean，让程序员解放双手，使对象的创建和使用不再犯难。
所以，Spring在启动的时候，会把我们用注解标识的bean都创建好并存起来，这个存的地方就是我们所说的容器，Spring的容器是用 Map结构来存我们的bean，为了解决bean之间创建时候可能有循环依赖问题，所以又加了两个Map结构，一共三个：

• Map singletonObjects // 一级缓存，存放的是已完全创建完的bean
• Map earlySingletonObjects // 二级缓存，存放的是已实例化但未进行属性赋值和初始化的bean
• Map> singletonFactories // 三级缓存，存放的value是一个函数接口 通过getObject获得bean

什么是BeanFactory

Spring有了容器，那就解决了存放的问题，那这么多奇奇怪怪的bean又该怎么创建呢？
Spring使用了简单工厂的设计模式，即用BeanFactory来生产我们的bean

什么是FactoryBean

他其实也是一种工厂，看一下这个接口就知道了。
最重要的就是getObject，可以拿到一个bean，和beanFactory功能一样。
可以供其他框架整合时候作为一个衔接纽带。

public interface FactoryBean {

	String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType";

	@Nullable
	T getObject() throws Exception;

	@Nullable
	Class getObjectType();

	default boolean isSingleton() {
		return true;
	}
}

什么是ApplicationContext

是一种特殊的BeanFactory，功能比BeanFactory强大

像Springboot启动类：

ConfigurableApplicationContext contxt = SpringApplication.run(Application.class, args)

还有AnnotationConfigApplicationContext

AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(MainConfig.class);

回归正题

好了，铺垫了一些概念，现在回到正题，Spring究竟是如何初始化的。

流程图如下：
Spring容器初始化

源码

完整代码点击这里,持续更新中

从这里开始

public class Application {

	public static void main(String[] args) {
		// 注解配置方式的spring容器 启动时候能完成单例bean的生产 供项目使用
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfig.class);
		MainConfig bean = context.getBean(MainConfig.class);
		System.out.println(bean);
	}
}

AnnotationConfigApplicationContext 构造器

	public AnnotationConfigApplicationContext(Class... componentClasses) {

		// 空参构造函数 （实例化bean工厂、创建bean定义读取器、创建bean定义扫描器）
		this();
		// 注册配置类（即自定义的配置类）到bean定义Map中
		register(componentClasses);
		// ioc容器刷新接口 这个是最重要的 前面都是准备工作 还没有一个bean完成创建
		refresh();
	}

空参构造函数

	public AnnotationConfigApplicationContext() {
		StartupStep createAnnotatedBeanDefReader = this.getApplicationStartup().start("spring.context.annotated-bean-reader.create");
		// 创建bean定义读取器
		this.reader = new AnnotatedBeanDefinitionReader(this);
		createAnnotatedBeanDefReader.end();
		//创建BeanDefinition扫描器
		// 这个扫描器是给程序员手动调用扫描器的 解析@ComponentScan时候，会再创建一个扫描器
		this.scanner = new ClassPathBeanDefinitionScanner(this);
	

AnnotatedBeanDefinitionReader核心代码

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
		Assert.notNull(environment, "Environment must not be null");
		//把ApplicationContext对象赋值给AnnotatedBeanDefinitionReader
		this.registry = registry;
		//用于处理条件注解 @Conditional
		this.conditionevaluator = new Conditionevaluator(registry, environment, null);
		//注册一些内置的后置处理器 用于解析@Component、@Configuration等
		AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
	}

注册配置类

public void register(Class... componentClasses) {
		Assert.notEmpty(componentClasses, "At least one component class must be specified");
		StartupStep registerComponentClass = this.getApplicationStartup().start("spring.context.component-classes.register")
				.tag("classes", () -> Arrays.toString(componentClasses));
		// 这里跟进去
		this.reader.register(componentClasses);

		registerComponentClass.end();
	}

配置类注册的核心代码

private  void doRegisterBean(Class beanClass, @Nullable String name,
			@Nullable Class[] qualifiers, @Nullable Supplier supplier,
			@Nullable BeanDefinitionCustomizer[] customizers) {

		//存储@Configuration注解注释的类
		AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);
		//判断是否需要跳过注解，spring中有一个@Condition注解，当不满足条件，这个bean就不会被解析
		if (this.conditionevaluator.shouldSkip(abd.getmetadata())) {
			return;
		}

		abd.setInstanceSupplier(supplier);
		//解析bean的作用域，如果没有设置的话，默认为单例
		Scopemetadata scopemetadata = this.scopemetadataResolver.resolveScopemetadata(abd);
		abd.setScope(scopemetadata.getScopeName());
		//获得beanName
		String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
		//解析通用注解，填充到AnnotatedGenericBeanDefinition，解析的注解为Lazy，Primary，DependsOn，Role，Description
		AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
		if (qualifiers != null) {
			for (Class qualifier : qualifiers) {
				if (Primary.class == qualifier) {
					abd.setPrimary(true);
				}
				else if (Lazy.class == qualifier) {
					abd.setLazyInit(true);
				}
				else {
					abd.addQualifier(new AutowireCandidateQualifier(qualifier));
				}
			}
		}
		if (customizers != null) {
			for (BeanDefinitionCustomizer customizer : customizers) {
				customizer.customize(abd);
			}
		}

		BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
		definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopemetadata, definitionHolder, this.registry);
		//注册，最终会调用DefaultListableBeanFactory中的registerBeanDefinition方法去注册，
		//DefaultListableBeanFactory维护着一系列信息，比如beanDefinitionNames，beanDefinitionMap
		//beanDefinitionNames是一个List,用来保存beanName
		//beanDefinitionMap是一个Map,用来保存beanName和beanDefinition
		BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
	}

回到AnnotationConfigApplicationContext 构造器

	public AnnotationConfigApplicationContext(Class... componentClasses) {

		// 空参构造函数 （实例化bean工厂、创建bean定义读取器、创建bean定义扫描器）
		this();
		// 注册配置类（即自定义的配置类）到bean定义Map中
		register(componentClasses);
		// ioc容器刷新接口 这个是最重要的 前面都是准备工作 还没有一个bean完成创建
		refresh();
	}

refresh()

@Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");

			// 准备工作 1.设置一些标志信息 2.设置环境属性 3.设置一些集合
			// Prepare this context for refreshing.
			prepareRefresh();

			// 获取一个bean工厂 不同工厂不同实现
			// xml方式解析bean的话这里会去创建工厂 耦合度大 注解方式的工厂只是设置一下id
			// Tell the subclass to refresh the internal bean factory.
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// 准备bean工厂 初始化bean工厂的一些属性值 注册了一个解析接口方式的监听器
			// Prepare the bean factory for use in this context.
			prepareBeanFactory(beanFactory);

			try {
				// bean工厂后续的扩展 空实现 比如web容器会在这里注册servletContext
				// Allows post-processing of the bean factory in context subclasses.
				postProcessBeanFactory(beanFactory);

				StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");

				// 调用bean工厂后置处理类  ConfigurationClassPostProcessor会被调用
				// 后置处理器、配置类、普通bean都被解析成bean定义
				// beanFactoryPostProcessor可以获得beanFactory进而获得bean定义 可以对其进行修改
				// Invoke factory processors registered as beans in the context.
				invokeBeanFactoryPostProcessors(beanFactory);

				// bean的后置处理器实例化
				// Register bean processors that intercept bean creation.
				registerBeanPostProcessors(beanFactory);
				beanPostProcess.end();

				// 初始化国际化处理
				// Initialize message source for this context.
				initMessageSource();

				// 初始化程序的多播器 管理所有的监听器 负责调用事件对应的监听器
				// Initialize event multicaster for this context.
				initApplicationEventMulticaster();

				// 刷新 没做什么 其他容器可扩展
				// Initialize other special beans in specific context subclasses.
				onRefresh();

				// 注册接口方式的监听器 其实只是注册监听器名字
				// 防止懒加载监听器漏掉
				// 事件发布时候 会再根据这里注册的名字 把懒加载的bean进行实例化 然后再发布事件
				// Check for listener beans and register them.
				registerListeners();

				// bean的实例化
				// 所有非懒加载的单例bean在这里实例化
				// Instantiate all remaining (non-lazy-init) singletons.
				finishBeanFactoryInitialization(beanFactory);

				// Last step: publish corresponding event.
				finishRefresh();
			}

			catch (BeansException ex) {
				......
			}

			finally {
				......
			}
		}
	}

refresh().prepareBeanFactory()

// 准备bean工厂 初始化bean工厂的一些属性值 注册了一个解析接口方式的监听器
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		//设置bean工厂的类加载器为当前application应用的加载器
		// Tell the internal bean factory to use the context's class loader etc.
		beanFactory.setBeanClassLoader(getClassLoader());
		//为bean工厂设置我们标准的SPEL表达式解析器对象StandardBeanexpressionResolver
		if (!shouldIgnoreSpel) {
			beanFactory.setBeanexpressionResolver(new StandardBeanexpressionResolver(beanFactory.getBeanClassLoader()));
		}
		//为我们的bean工厂设置了一个propertityEditor 属性资源编辑器对象(用于后面的给bean对象赋值使用)
		beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

		//注册了一个完整的ApplicationContextAwareProcessor 后置处理器用来处理ApplicationContextAware接口的回调方法
		// Configure the bean factory with context callbacks.
		beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));

		
		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.ignoreDependencyInterface(ApplicationStartupAware.class);

		
		// BeanFactory interface not registered as resolvable type in a plain factory.
		// MessageSource registered (and found for autowiring) as a bean.
		beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
		beanFactory.registerResolvableDependency(ResourceLoader.class, this);
		beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
		beanFactory.registerResolvableDependency(ApplicationContext.class, this);

		//注册了一个事件监听器探测器后置处理器接口
		// 解析接口方式的监听器 又往多播器里注册监听器
		// 在此前还有一个注册的地方 不过那里是注册名字 这里是注册bean 因为懒加载的监听器在容器初始化时候不会初始化 只会把名字注册进去
		// Register early post-processor for detecting inner beans as ApplicationListeners.
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

		// 处理aspectj的
		// Detect a LoadTimeWeaver and prepare for weaving, if found.
		if (!NativeDetector.inNativeImage() && 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()));
		}

		//注册了bean工厂的内部的bean
		// Register default environment beans.
		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());
		}
		if (!beanFactory.containsLocalBean(APPLICATION_STARTUP_BEAN_NAME)) {
			beanFactory.registerSingleton(APPLICATION_STARTUP_BEAN_NAME, getApplicationStartup());
		}
	}

refresh().finishBeanFactoryInitialization()

// bean的实例化
// 所有非懒加载的单例bean在这里实例化
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {

		......

		// 重点！！！实例化bean
		// Instantiate all remaining (non-lazy-init) singletons.
		beanFactory.preInstantiateSingletons();
	}

finishBeanFactoryInitialization().preInstantiateSingletons()

@Override
	public void preInstantiateSingletons() throws BeansException {
		if (logger.isTraceEnabled()) {
			logger.trace("Pre-instantiating singletons in " + this);
		}

		// Iterate over a copy to allow for init methods which in turn register new bean definitions.
		// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
		List beanNames = new ArrayList<>(this.beanDefinitionNames);

		// Trigger initialization of all non-lazy singleton beans...
		for (String beanName : beanNames) {
			// 合并bean定义 转换为统一的RootBeanDefinition 方便后续处理
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			// 根据bean定义判断是不是抽象的 && 不是单例的 && 不是懒加载的
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {

				// 如果是工厂bean
				if (isFactoryBean(beanName)) {
					// 是factoryBean会先生成实际的bean  &beanName 是用来获取实际bean的
					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
					if (bean instanceof FactoryBean) {
						FactoryBean factory = (FactoryBean) bean;
						boolean isEagerInit;
						if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
							isEagerInit = AccessController.doPrivileged(
									(PrivilegedAction) ((SmartFactoryBean) factory)::isEagerInit,
									getAccessControlContext());
						}
						else {
							isEagerInit = (factory instanceof SmartFactoryBean &&
									((SmartFactoryBean) factory).isEagerInit());
						}
						if (isEagerInit) {
							getBean(beanName);
						}
					}
				}
				else {
					// 实际实例化的方法！！
					getBean(beanName);
				}
			}
		}

		// 所有bean都创建完了 可以实现SmartInitializingSingleton来做扩展
		// 解析注解方式监听器就是在这里进行的
		// Trigger post-initialization callback for all applicable beans...
		for (String beanName : beanNames) {
			Object singletonInstance = getSingleton(beanName);
			if (singletonInstance instanceof SmartInitializingSingleton) {
				StartupStep smartInitialize = this.getApplicationStartup().start("spring.beans.smart-initialize")
						.tag("beanName", beanName);
				SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
				if (System.getSecurityManager() != null) {
					AccessController.doPrivileged((PrivilegedAction