spring 源码笔记 spring启动过程(概括篇)

何为spring容器

理论级别解释：由多个spring组件组成的应用程序叫spring容器。
代码级别解释：所有实现ApplicationContext接口的类都是spring容器。
如何得到一个普通对象
简单描述：.java —> class —> object
详细描述：创建.java文件 —> 编译得到.class文件 —> JVM加载到方法区得到class对象 —> 初始化(或反射)得到object对象。
如何得到一个spring Bean对象
简单描述：.java —> class —> BeanDefinition —> Bean
详细描述：创建.java文件 —> 编译得到.class文件 —> JVM加载到方法区得到class对象 —> spring容器扫描、解析、验证并生成BeanDefinition —> spring容器执行Bean生命周期并put到单例池 —> 通过context.getBean()得到spring Bean对象。

spring容器核心组件

spring容器

XML风格：ClassPathXmlApplicationContext
annotation风格 & java config风格：AnnotationConfigApplicationContext

Bean工厂：DefaultListableBeanFactory

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
	// beanDefinition缓存
	private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);
	// beanDefinition缓存名单
	private volatile List<String> beanDefinitionNames = new ArrayList<>(256);
}

DefaultSingletonBeanRegistry

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
	// 一级缓存：单例池
	private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
	// 二级缓存，用于解决循环依赖中的AOP问题
	private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
	// 三级缓存，用于解决循环依赖问题
	private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
}

BeanFactory后置处理器(扩展点)

BeanFactoryPostProcessor

public interface BeanFactoryPostProcessor {
	void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
}

BeanDefinitionRegistryPostProcessor

public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {
	void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;
}

内置BeanFactory后置处理器ConfigurationClassPostProcessor

public class ConfigurationClassPostProcessor implements BeanDefinitionRegistryPostProcessor, PriorityOrdered, ResourceLoaderAware, BeanClassLoaderAware, EnvironmentAware {
	// 扫描、解析、验证并生成BeanDefinition，注册到BeanDefinition缓存
	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
		...
	}
	// 为全配置类生成代理
	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		...
	}
}

Bean后置处理器(扩展点)

InstantiationAwareBeanPostProcessor

public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {
	default Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException;
	// 为什么要传beanName？方便单个控制
	default boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException;
	default PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException;
	default PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException;
}

SmartInstantiationAwareBeanPostProcessor

public interface SmartInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessor {
	default Class<?> predictBeanType(Class<?> beanClass, String beanName) throws BeansException;
	default Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName) throws BeansException;
	default Object getEarlyBeanReference(Object bean, String beanName) throws BeansException;
}

MergedBeanDefinitionPostProcessor

public interface MergedBeanDefinitionPostProcessor extends BeanPostProcessor {
	void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName);
	default void resetBeanDefinition(String beanName);
}

BeanPostProcessor

public interface BeanPostProcessor {
	default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;
	default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
}

启动spring容器(annotation风格)

build.gradle添加依赖

    compile(project(":spring-context"))

配置类AppConfig

@Configuration
@ComponentScan("com.tbryant.springtest")
public class AppConfig {
}

测试类AnnotationConfigApplication

public class AnnotationConfigApplication {
	public static void main(String[] args) {
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();// 第一步
		context.register(AppConfig.class);// 第二步
		context.refresh();
	}
}

refresh()

	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			prepareRefresh();// 第三步
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();// 第四步
			prepareBeanFactory(beanFactory);// 第五步
			postProcessBeanFactory(beanFactory);// 第六步
			invokeBeanFactoryPostProcessors(beanFactory);// 第七步
			registerBeanPostProcessors(beanFactory);// 第八步
			initMessageSource();// 第九步
			initApplicationEventMulticaster();// 第十步
			onRefresh();// 第十一步
			registerListeners();// 第十二步
			finishBeanFactoryInitialization(beanFactory);// 第十三步
			finishRefresh();// 第十四步
		}
	}

第一步：new AnnotationConfigApplicationContext()

实例化spring容器。

1. 调用父类GenericApplicationContext无参构造函数，实例化Bean工厂。
2. 实例化并初始化解析器。
3. 实例化并初始化扫描器。

第二步：register(AppConfig.class)

注册AppConfig.class。
解析AppConfig.class，生成BeanDefinition(AnnotatedGenericBeanDefinition)，注册到context.beanFactory.beanDefinitionMap。
为什么AppConfig.class需要手动注册
因为spring启动依赖AppConfig.class类，所以需要在容器初始化之前手动注册到容器。

第三步：prepareRefresh()

准备刷新此上下文。

第四步：obtainFreshBeanFactory()

告诉子类刷新内部Bean工厂。

第五步：prepareBeanFactory(beanFactory)

准备Bean工厂以供在此上下文中使用。

第六步：postProcessBeanFactory(beanFactory)

允许在上下文子类中对Bean工厂进行后处理。

第七步：invokeBeanFactoryPostProcessors(beanFactory)

（重要）调用上下文中注册为Bean的工厂处理器。

1. 执行程序员通过API：context.addBeanFactoryPostProcessor()添加的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法
2. 执行实现PriorityOrdered接口的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法
3. 执行实现Ordered接口的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法
4. 执行其他所有(自定义)BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法
5. 执行其他所有(自定义)BeanDefinitionRegistryPostProcessor的postProcessBeanFactory方法
6. 执行程序员通过API：context.addBeanFactoryPostProcessor()添加的BeanFactoryPostProcessors的postProcessBeanFactory方法
7. 执行实现PriorityOrdered接口的BeanFactoryPostProcessor的postProcessBeanFactory方法
8. 执行实现Ordered接口的BeanFactoryPostProcessor的postProcessBeanFactory方法
9. 执行其他所有BeanFactoryPostProcessor的postProcessBeanFactory方法

更多内容请参考spring 源码笔记 启动过程(七) invokeBeanFactoryPostProcessors(beanFactory)

第八步：registerBeanPostProcessors(beanFactory);

注册拦截Bean创建的Bean后置处理器。

第九步：initMessageSource()

初始化此上下文的消息源。

第十步：initApplicationEventMulticaster()

为此上下文初始化事件多主机。

第十一步：onRefresh()

初始化特定上下文子类中的其他特殊Bean。

第十二步：registerListeners()

检查侦听器Bean并注册它们。

第十三步：finishBeanFactoryInitialization(beanFactory)

（重要）实例化所有剩余的（非延迟初始化）单例。
第一次调用Bean后置处理器：判断Bean是否需要代理
InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation
第二次调用Bean后置处理器：推断构造方法
SmartInstantiationAwareBeanPostProcessor.determineCandidateConstructors
第三次调用Bean后置处理器：合并父子BeanDefinition
MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition
第四次调用Bean后置处理器：提前暴露工厂，为了解决循环依赖
SmartInstantiationAwareBeanPostProcessor.getEarlyBeanReference
第五次调用Bean后置处理器：判断属性是否需要注入
InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation
第六次调用Bean后置处理器：完成属性注入
InstantiationAwareBeanPostProcessor.postProcessProperties
第七次调用Bean后置处理器：执行初始化生命周期回调
BeanPostProcessor.postProcessBeforeInitialization
第八次调用Bean后置处理器：给需要代理的类生成代理
BeanPostProcessor.postProcessAfterInitialization
更多内容请参考spring 源码笔记 启动过程(十三) finishBeanFactoryInitialization(beanFactory)

第十四步：finishRefresh()

最后一步：发布对应的事件。