最近工作之余有时间和精力，加上平时对源码比较感兴趣，就开始啃起了Spring源码。为加深印象写了这篇博客，如有错误，望各位大佬不吝指正。
我看的是Spring5的源码，从同性社区download下来后编译，然后看源码、写注释、一步一步debug，理论指导实践，实践再反作用于理论。
因为基于注解的开发是现在比较主流的开发模式，所以就从 AnnotationConfigApplicationContext 开始啃了。
因为代码过多，执行流程过于复杂，就拆成了三篇来解析。
下面就从这个类开始探究Spring上下文的初始化。
这里需要留意 AnnotationConfigApplicationContext 继承了 GenericApplicationContext
public class GenericApplicationContext extends AbstractApplicationContext implements BeanDefinitionRegistry {
private final DefaultListableBeanFactory beanFactory;
/**
* 注意这个无参构造函数
*
* 这个初始化的DefaultListableBeanFactory就是Spring的Bean工厂
*/
public GenericApplicationContext() {
this.beanFactory = new DefaultListableBeanFactory();
}
}再来看看 AnnotationConfigApplicationContext 这个类
public class AnnotationConfigApplicationContext extends GenericApplicationContext implements AnnotationConfigRegistry {
/**
* 定义一个读取注解的 BeanDefinition 读取器
* 这个类在构造方法中被实例化
*/
private final AnnotatedBeanDefinitionReader reader;
/**
* 定义一个扫描类路径下加了注解的 BeanDefinition 扫描器
* 这个类在构造方法中被实例化
*/
private final ClassPathBeanDefinitionScanner scanner;
public AnnotationConfigApplicationContext() {
// 实例化 BeanDefinition 读取器
/**
* 注册所有注解相关的后置处理器
* 最重要的一个后置处理器 ConfigurationClassPostProcessor
* BeanName 是 internalConfigurationAnnotationProcessor
*/
this.reader = new AnnotatedBeanDefinitionReader(this);
// 实例化 BeanDefinition 扫描器
// 但是实际上扫描包的工作并不是 scanner 这个对象来完成的，是 Spring 自己创建的一个新的 ClassPathBeanDefinitionScanner
// 这里的 scanner 仅仅是为了程序员能够在外部调用 AnnotationConfigApplicationContext 对象的 scanner 方法
this.scanner = new ClassPathBeanDefinitionScanner(this);
}
public AnnotationConfigApplicationContext(DefaultListableBeanFactory beanFactory) {
// 调用父类的构造方法，初始化 DefaultListableBeanFactory 的 Bean 工厂
super(beanFactory);
// 实例化该读取器
this.reader = new AnnotatedBeanDefinitionReader(this);
// 实例化该扫描器
this.scanner = new ClassPathBeanDefinitionScanner(this);
}
/**
* 这个构造方法需要传入一个 @Configuration 注解配置类
* 通过注解读取器读取并解析
*/
public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
/**
* 由于继承了父类，这里会先去调用父类的构造方法，然后调用自身的构造方法
*
* this.beanFactory = new DefaultListableBeanFactory();
*
* 其实就是初始化一个 DefaultListableBeanFactory
*/
this();
/**
* 将传入的 @Configuration 配置类转换为 BeanDefinition
* 并添加到 DefaultListableBeanFactory 工厂的 BeanDefinitionMap 中
*/
register(annotatedClasses);
/**
* 1、准备刷新山下文
* 2、通知子类刷新内部的 bean 工厂，得到创建的 DefaultListableBeanFactory 工厂
* 3、配置工厂的标准上下文特征
* 4、允许在上下文子类中对 bean 工厂进行后置处理
* 5、在上下文中调用工厂处理器方法，注册为 bean
* 6、注册 BeanPostProcessor
* 7、初始化此上下文的消息源
* 8、初始化应用事件广播器【SpringBoot 的启动源码中与该方法有很大关系】
* 9、在特定的上下文子类中初始化其他特殊 bean
* 10、检查监听器 bean 并注册它们
* 11、实例化所有剩余（非延迟初始化）单例
* 12、发布相应的事件
*/
refresh();
}
public AnnotationConfigApplicationContext(String... basePackages) {
/**
* 由于继承了父类，这里会先去调用父类的构造方法，然后调用自身的构造方法
*
* this.beanFactory = new DefaultListableBeanFactory();
*
* 其实就是初始化一个 DefaultListableBeanFactory
*/
this();
scan(basePackages);
refresh();
}
} 这里还要注意一下AnnotatedBeanDefinitionReader的实例化，代码跟进去发现调用了 AnnotationConfigUtils 的 registerAnnotationConfigProcessors 方法，Spring在初始化上下文时，在Bean工厂中添加了很多辅助其初始化的类
public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
BeanDefinitionRegistry registry, @Nullable Object source) {
// 获取 Bean 工厂
DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
if (beanFactory != null) {
if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
// AnnotationAwareOrderComparator 主要能解析 @Order 注解和 @Priority 注解
beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
}
if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
// ContextAnnotationAutowireCandidateResolver 提供处理延迟加载的功能
beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
}
}
/**
* 存放所有辅助类的信息
*/
Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
/**
* BeanDefinition 的注册，很重要，需要理解注册的每个 Bean 的类型和作用
*
* Spring 在初始化 ApplicationContext 和 Bean 工厂时，在 Bean 工厂中添加了很多辅助初始化 Bean 工厂的类
*
* 1.ConfigurationClassPostProcessor 类型是 BeanFactoryPostProcessor
* 2.AutowiredAnnotationBeanPostProcessor 类型是 BeanPostProcessor
* 3.CommonAnnotationBeanPostProcessor 类型是 BeanPostProcessor
* 4.PersistenceAnnotationBeanPostProcessor 类型是 BeanPostProcessor
* 5.EventListenerMethodProcessor 类型是 BeanFactoryPostProcessor
* 6.DefaultEventListenerFactory 类型是 EventListenerFactory
*/
/**
* BeanName 是否包含 org.springframework.context.annotation.internalConfigurationAnnotationProcessor
* BeanClass 是 ConfigurationClassPostProcessor，类型是 BeanFactoryPostProcessor
*/
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));
}
/**
* BeanName 是否包含 org.springframework.context.annotation.internalAutowiredAnnotationProcessor
* BeanClass 是 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));
}
// Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
/**
* BeanName 是否包含 org.springframework.context.annotation.internalCommonAnnotationProcessor
* BeanClass 是 CommonAnnotationBeanPostProcessor，类型是 BeanPostProcessor
*/
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));
}
// Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
/**
* 检查 JPA 支持，如果存在，则添加 PersistenceAnnotationBeanPostProcessor
*
* BeanName 是否包含 org.springframework.context.annotation.internalPersistenceAnnotationProcessor
* BeanClass 是 PersistenceAnnotationBeanPostProcessor，类型是 BeanPostProcessor
*/
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));
}
/**
* BeanName 是否包含 org.springframework.context.event.internalEventListenerProcessor
* BeanClass 是 EventListenerMethodProcessor，类型是 BeanFactoryPostProcessor
*/
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));
}
/**
* BeanName 是否包含 org.springframework.context.event.internalEventListenerFactory
* BeanClass 是 DefaultEventListenerFactory，类型是 EventListenerFactory
*/
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;
}这个方法执行完后，可以看到 DefaultListableBeanFactory 中的 beanDefinitionMap 中已经有数据了，如果支持 JPA 则有6个元素，没有则有5个。分别是 ConfigurationClassPostProcessor、AutowiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor、EventListenerMethodProcessor、DefaultEventListenerFactory，支持 JPA 的是 PersistenceAnnotationBeanPostProcessor。
这里实例化的 ClassPathBeanDefinitionScanner 仅仅是为了让程序员能够在外部调用 AnnotationConfigApplicationContext 对象的 scanner 方法。Spring 在后面又重新初始化了一个 ClassPathBeanDefinitionScanner，用新的 ClassPathBeanDefinitionScanner 进行扫描。
回到一开始，我这里是传了一个@Configuration的配置类，所以从register方法往下跟，最后调用的是 AnnotatedBeanDefinitionReader 的 doRegisterBean 方法
/**
* 将给定的 bean 类注册为 bean，从类声明的注释中派生其元数据
*/
private <T> void doRegisterBean(Class<T> annotatedClass, @Nullable String name,
@Nullable Class<? extends Annotation>[] qualifiers,
@Nullable Supplier<T> supplier, @Nullable BeanDefinitionCustomizer[] customizers) {
// 根据指定的 bean 创建一个 AnnotatedGenericBeanDefinition
AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
// 若这个类是需要跳过解析的类，则返回
if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
return;
}
// 指定创建 bean 实例的回调方法，此时为 null
abd.setInstanceSupplier(supplier);
// 解析类的作用域元数据
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
// 添加类的作用域元数据
abd.setScope(scopeMetadata.getScopeName());
/**
* 生成 BeanName
* 调用 AnnotationBeanNameGenerator.generateBeanName()
*/
String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
/**
* 处理类当中的通用注解
* 主要处理 @Lazy @DependsOn @Primary @Role @Description 等注解
* 处理完成之后将值赋给到 AnnotatedGenericBeanDefinition 对应的属性中
*/
AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
/**
* 如果在向容器注册注解 BeanDefinition 时，使用了额外的限定符注解则解析
* byName 和 qualifiers 变量是 Annotation 类型的数组，里面不仅存了 @Qualifier 注解
* 所以 Spring 遍历这个数组判断是否加了指定注解
*
* 此时 qualifiers 为 null，if 语句不执行
*/
if (qualifiers != null) {
for (Class<? extends Annotation> qualifier : qualifiers) {
if (Primary.class == qualifier) {
// 设置 primary 属性值
abd.setPrimary(true);
} else if (Lazy.class == qualifier) {
// 设置 lazyInit 属性值
abd.setLazyInit(true);
} else {
/**
* 如果使用了除 @Primary 和 @Lazy 以外的其他注解
* 则为该 Bean 添加一个根据名字自动装配的限定符
*/
// 向 Map<String, AutowireCandidateQualifier> qualifiers 集合中添加值
abd.addQualifier(new AutowireCandidateQualifier(qualifier));
}
}
}
/**
* 如果存在一个或多个用于自定义工厂的回调
*
* 此时 customizers 为 null，if 语句不执行
*/
if (customizers != null) {
for (BeanDefinitionCustomizer customizer : customizers) {
customizer.customize(abd);
}
}
/**
* 获取 BeanDefinitionHolder 持有者容器
* 里面包含的属性值有 String beanName，BeanDefinition beanDefinition 和 String[] aliases 别名集合
*/
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
/**
* 解析代理模型
*/
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
/**
* 将最终获取到的 BeanDefinitionHolder 持有者容器中包含的信息注册给 BeanDefinitionRegistry
*
* AnnotationConfigApplicationContext 在初始化的时候通过调用父类的构造方法，实例化了一个 DefaultListableBeanFactory
* 这一步就是把 BeanDefinitionHolder 这个数据结构中包含的信息注册到 DefaultListableBeanFactory 中
*
* DefaultListableBeanFactory 实现了 BeanDefinitionRegistry
*
* 此时传入的 @Configuration 配置类已经注册到 DefaultListableBeanFactory 工厂中
*/
BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}这里比较重要的是最后一行代码，进行注册操作，代码如下：
public static void registerBeanDefinition(
BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
throws BeanDefinitionStoreException {
// Register bean definition under primary name.
// 用类的主要名称注册 BeanDefinition
String beanName = definitionHolder.getBeanName();
/**
* 将 beanName 注册到 DefaultListableBeanFactory 工厂中
*/
registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
// Register aliases for bean name, if any.
// 如果有别名则为 BeanName 注册别名
String[] aliases = definitionHolder.getAliases();
if (aliases != null) {
for (String alias : aliases) {
/**
* 注册别名
*/
registry.registerAlias(beanName, alias);
}
}
}public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException {
if (beanDefinition instanceof AbstractBeanDefinition) {
try {
((AbstractBeanDefinition) beanDefinition).validate();
} catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
"Validation of bean definition failed", ex);
}
}
// 先从 Map<String, BeanDefinition> beanDefinitionMap 中获取一次
BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
// 已注册过则进行逻辑校验
if (existingDefinition != null) {
// 是否允许 BeanDefinition 覆盖
if (!isAllowBeanDefinitionOverriding()) {
// 不允许则抛异常
throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
}
// 已存在的角色是否小于传入的 beanDefinition 角色
else if (existingDefinition.getRole() < beanDefinition.getRole()) {
// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
if (logger.isInfoEnabled()) {
logger.info("Overriding user-defined bean definition for bean '" + beanName +
"' with a framework-generated bean definition: replacing [" +
existingDefinition + "] with [" + beanDefinition + "]");
}
}
// 如果传入的 beanDefinition 和已存在的不相等
else if (!beanDefinition.equals(existingDefinition)) {
if (logger.isDebugEnabled()) {
logger.debug("Overriding bean definition for bean '" + beanName +
"' with a different definition: replacing [" + existingDefinition +
"] with [" + beanDefinition + "]");
}
} else {
if (logger.isTraceEnabled()) {
logger.trace("Overriding bean definition for bean '" + beanName +
"' with an equivalent definition: replacing [" + existingDefinition +
"] with [" + beanDefinition + "]");
}
}
// 重新存入 Map<String, BeanDefinition> beanDefinitionMap 中
this.beanDefinitionMap.put(beanName, beanDefinition);
}
// 不存在
else {
// 是否已经启动 bean 创建
if (hasBeanCreationStarted()) {
// Cannot modify startup-time collection elements anymore (for stable iteration)
synchronized (this.beanDefinitionMap) {
// 注册到 Map<String, BeanDefinition> beanDefinitionMap 集合中
this.beanDefinitionMap.put(beanName, beanDefinition);
// 用新的 beanDefinitionNames 替换旧的
List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
updatedDefinitions.addAll(this.beanDefinitionNames);
updatedDefinitions.add(beanName);
this.beanDefinitionNames = updatedDefinitions;
// 从集合中移除该 bean 名称
removeManualSingletonName(beanName);
}
}
// 还未启动 bean 创建，即仍在启动注册阶段
else {
// 注册到 Map<String, BeanDefinition> beanDefinitionMap 集合中
this.beanDefinitionMap.put(beanName, beanDefinition);
// 添加 bean 名称到 beanDefinitionNames 数据集合中
this.beanDefinitionNames.add(beanName);
// 从集合中移除该 bean 名称
removeManualSingletonName(beanName);
}
this.frozenBeanDefinitionNames = null;
}
if (existingDefinition != null || containsSingleton(beanName)) {
resetBeanDefinition(beanName);
}
}register 方法执行完成，此时传入的 @Configuration 配置类已经注册到 DefaultListableBeanFactory 工厂中
那这一篇就先到这里，有问题或者错误欢迎大家沟通交流
下一篇从 refresh 方法开始往下跟代码