文章目录
在前面的文章中，我们已经完成了《Spring官网阅读》，有了上面的基础，那么源码的阅读也就不会太难了，从今天开始我们一步步走进Spring的源码。我们整个源码的解析将以下面这句代码为入口：
AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(Config.class);下面就跟着我来看看，Spring第一行代码到底干了什么！
本系列文章对应
Spring版本为5.x。
上面这行代码就是执行了AnnotationConfigApplicationContext中的一个构造函数，其代码如下：
public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
// 1.调用了AnnotationConfigApplicationContext的空参构造方法
this();
// 2.将配置类注册到容器中
register(annotatedClasses);
// 3.刷新容器
refresh();
}
找到第一行代码
我们继续查看AnnotationConfigApplicationContext的空参构造
其代码如下：
public AnnotationConfigApplicationContext() {
// 1.1 构造一个reader对象
this.reader = new AnnotatedBeanDefinitionReader(this);
// 1.2 构造一个scanner对象
this.scanner = new ClassPathBeanDefinitionScanner(this);
}
它主要做了两件事
- 创建一个
AnnotatedBeanDefinitionReader - 创建一个
ClassPathBeanDefinitionScanner
本文的重点就是分析第一行代码，也就是创建AnnotatedBeanDefinitionReader的过程。在分析代码前，我们首先应该搞懂一件事情，就是创建的这个AnnotatedBeanDefinitionReader到底是什么呢？
AnnotatedBeanDefinitionReader是什么？
这个类的主要作用就是注册
BeanDefinition，与之相类似的功能的类还有一个就是ClassPathBeanDefinitionScanner。它们最大的不同在于AnnotatedBeanDefinitionReader支持注册单个的BeanDefinition，而ClassPathBeanDefinitionScanner会一次注册所有扫描到的BeanDefinition。关于ClassPathBeanDefinitionScanner本文不专门做过多解释，只要能看懂这篇文章ClassPathBeanDefinitionScanner自然就懂了。如果对于
BeanDefinition不了解的推荐先阅读：
AnnotatedBeanDefinitionReader源码解析
// 这里只保留了这个类中的部分代码，其余不重要我都没有放出来
public class AnnotatedBeanDefinitionReader {
// 上面我们已经说了，这个reader对象主要的工作就是注册BeanDefinition，那么将BeanDefinition注册到哪里去呢？所以它内部就保存了一个BeanDefinition的注册表。对应的就是我们代码中的AnnotationConfigApplicationContext
private final BeanDefinitionRegistry registry;
// 见名知意，Bean名称的生成器，生成BeanName
private BeanNameGenerator beanNameGenerator = new AnnotationBeanNameGenerator();
// 解析@Scope注解
private ScopeMetadataResolver scopeMetadataResolver = new AnnotationScopeMetadataResolver();
// 解析@Conditional注解
private ConditionEvaluator conditionEvaluator;
// 将解析指定的类成为BeanDefinition并注册到容器中
public void registerBean(Class<?> annotatedClass, String name, Class<? extends Annotation>... qualifiers) {
doRegisterBean(annotatedClass, null, name, qualifiers);
}
// 真正的执行注册的方法
<T> void doRegisterBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
@Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {
// Spring在这里写死了，直接new了一个AnnotatedGenericBeanDefinition，也就是说通过reader对象注册的BeanDefinition都是AnnotatedGenericBeanDefinition。
AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
// 调用conditionEvaluator的shouldSkip方法
// 判断当前的这个bd是否需要被注册
if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
return;
}
// 在注册时可以提供一个instanceSupplier
abd.setInstanceSupplier(instanceSupplier);
// 解析@Scope注解，得到一个ScopeMetadata
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
// 将@Scope注解中的信息保存到bd中
abd.setScope(scopeMetadata.getScopeName());
// 调用beanNameGenerator生成beanName
// 所谓的注册bd就是指定将bd放入到容器中的一个beanDefinitionMap中
// 其中的key就是beanName,value就是解析class后得到的bd
String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
// 这句代码将进一步解析class上的注解信息，Spring在创建这个abd的信息时候就已经将当前的class放入其中了，所有这行代码主要做的就是通过class对象获取到上面的注解（包括@Lazy，@Primary，@DependsOn注解等等），然后将得到注解中对应的配置信息并放入到bd中的属性中
AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
// 下面的这段不用过多关注，为了文章的完整性我这里还是说说我的理解
// 正常的容器启动阶段qualifiers肯定等于null
// 我能想到的不为空的方法就是直接在外部调用了register方法并且出入了qualifiers参数
// 就是说我们手动直接注册了一个类，但是我们没有在类上添加@Lazy，@Primary注解，但是我们又希望能将其标记为Primary为true/LazyInit为true,这个时候就手动传入Primary.class跟Lazy.class即可。
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));
}
}
}
// 我们注册时，我们可以传入一些回调方法，在解析得到bd后调用
for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
customizer.customize(abd);
}
// bd中是没有beanName属性的，BeanDefinitionHolder中就是保存了beanName以及对应的BeanDefinition
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
// 这个地方主要是解析Scope中的ProxyMode属性，默认为no，不生成代理对象
// 后文做详细分析
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
// 注册bd到容器中，实际上最终就是将bd放到了beanFactory中的一个map里（beanDefinitionMap）
// key为beanName,value为bd
BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}
}
applyScopedProxyMode做了什么？
上面的代理有一个地方没有将清楚，就是AnnotationConfigUtils.applyScopedProxyMode到底做了什么？
带着这个问题，我们继续看看这个方法的代码
1、applyScopedProxyMode
// 这个方法名称直译过来就是----应用Scoped中的ProxyMode属性
// 这个属性有什么用呢？
// ProxyMode属性一共有下面几种取值
// 1.DEFAULT:默认值，默认情况下取no
// 2.NO:不开启代理
// 3.INTERFACES:使用jdk动态代理
// 4.TARGET_CLASS:使用cglib代理
// 假设我们有一个单例的对象A，其中有一个属性B，B的作用域是session的，这个时候容器在启动时创建A的过程中需要为A注入属性B，但是属性B的作用域为session,这种情况下注入必定会报错的
// 但是当我们将ProxyMode属性配置为INTERFACES/TARGET_CLASS时，它会暴露一个代理对象，ProxyMode可以配置代理对象的生成策略是使用jdk动态代理还是生成cglib动态代理,那么当我们在创建A时，会先注入一个B的代理对象而不是直接报错
static BeanDefinitionHolder applyScopedProxyMode(
ScopeMetadata metadata, BeanDefinitionHolder definition, BeanDefinitionRegistry registry) {
// 根据scopedProxyMode进行判断，如果是NO，直接返回原有的bd并添加到容器的bdMap中
ScopedProxyMode scopedProxyMode = metadata.getScopedProxyMode();
if (scopedProxyMode.equals(ScopedProxyMode.NO)) {
return definition;
}
// 是否采用cglib代理
boolean proxyTargetClass = scopedProxyMode.equals(ScopedProxyMode.TARGET_CLASS);
// 调用ScopedProxyCreator的createScopedProxy，创建代理对象对应的bd
return ScopedProxyCreator.createScopedProxy(definition, registry, proxyTargetClass);
}
2、ScopedProxyUtils.createScopedProxy
public static BeanDefinitionHolder createScopedProxy(
BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry, boolean proxyTargetClass) {
// 继续调用ScopedProxyUtils的方法
return ScopedProxyUtils.createScopedProxy(definitionHolder, registry, proxyTargetClass);
}
3、ScopedProxyUtils.createScopedProxy
// 根据目标对象的bd生成代理对象的bd,并且会将目标对象的bd注册到容器中
public static BeanDefinitionHolder createScopedProxy(BeanDefinitionHolder definition,
BeanDefinitionRegistry registry, boolean proxyTargetClass) {
// 目标对象的名称
String originalBeanName = definition.getBeanName();
// 目标对象的bd
BeanDefinition targetDefinition = definition.getBeanDefinition();
// 将来会将目标对象的bd注册到容器中，targetBeanName作为注册时的key
// targetBeanName = "scopedTarget."+originalBeanName
String targetBeanName = getTargetBeanName(originalBeanName);
// 创建代理对象的bd,可以看到代理对象会是一个factoryBean的介绍请参考《》，关于factoryBean的介绍请参考我的Spring官网阅读系列第七篇，这里不做过多介绍
RootBeanDefinition proxyDefinition = new RootBeanDefinition(ScopedProxyFactoryBean.class);
// 代理对象所装饰的bd就是目标对象的bd
// 拷贝了部分目标对象bd中的属性到代理对象的bd中
proxyDefinition.setDecoratedDefinition(new BeanDefinitionHolder(targetDefinition, targetBeanName));
proxyDefinition.setOriginatingBeanDefinition(targetDefinition);
proxyDefinition.setSource(definition.getSource());
proxyDefinition.setRole(targetDefinition.getRole());
proxyDefinition.getPropertyValues().add("targetBeanName", targetBeanName);
if (proxyTargetClass) {
targetDefinition.setAttribute(AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE, Boolean.TRUE);
// ScopedProxyFactoryBean's "proxyTargetClass" default is TRUE, so we don't need to set it explicitly here.
}
else {
proxyDefinition.getPropertyValues().add("proxyTargetClass", Boolean.FALSE);
}
// Copy autowire settings from original bean definition.
proxyDefinition.setAutowireCandidate(targetDefinition.isAutowireCandidate());
proxyDefinition.setPrimary(targetDefinition.isPrimary());
if (targetDefinition instanceof AbstractBeanDefinition) {
proxyDefinition.copyQualifiersFrom((AbstractBeanDefinition) targetDefinition);
}
// The target bean should be ignored in favor of the scoped proxy.
targetDefinition.setAutowireCandidate(false);
targetDefinition.setPrimary(false);
// 这一步会将原始的bd注册到容器中，其中的key="scopedTarget."+originalBeanName
registry.registerBeanDefinition(targetBeanName, targetDefinition);
// 返回这个用于创建代理对象的bd
return new BeanDefinitionHolder(proxyDefinition, originalBeanName, definition.getAliases());
}
从上面的代码可以看出，当我们选择在@Scope注解中配置了proxyMode属性时（INTERFACES/TARGET_CLASS），那么Spring会在注册bd时，在容器中注册一个代理的bd，这个bd是一个ScopedProxyFactoryBean类型的bd，并且没有特别指定它的作用域，所以它是单例的，并且这个FactoryBean返回就是对应的目标对象的代理对象。基于此，Spring就可以利用这个bd来完成在启动阶段对session/request域对象的注入。
创建AnnotatedBeanDefinitionReader的过程中做了什么?
现在我们已经知道了这个reader对象有什么用，那么接下来我们就一起分析下Spring在创建这个对象的过程中还做了什么，也就是reader对象在执行构造函数时还完成了什么事情
1、创建environment
// 第一步：调用了第一个构造函数，在这个过程中创建了environment，关于environment可以参考我的《Spring官网阅读（十一）ApplicationContext详细介绍（上）》
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
// 这个environment实际上就是包含了系统环境变量以及JVM启动参数
this(registry, getOrCreateEnvironment(registry));
}
2、对属性进行赋值，并注册容器需要的bd
// 第二步：进一步调用构造函数
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
// 为read对象中的属性赋值
this.registry = registry;
this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
// 从这个方法可以看出，Spring在创建reader对象的时候就开始注册bd了，那么Spring注册了哪些bd呢？注册的bd有什么用呢？我们接着往下看
AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}
3、注册容器需要的bd
public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
BeanDefinitionRegistry registry, @Nullable Object source) {
DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
if (beanFactory != null) {
// 1.指定容器使用的比较器，通过这个比较器能够解析@Order注解以及Ordered接口
if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
}
// 2.指定容器使用的AutowireCandidateResolver
if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
}
}
Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
// 3.注册ConfigurationClassPostProcessor
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));
}
// 4.注册AutowiredAnnotationBeanPostProcessor
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));
}
// 5.如果支持JSR-250，注册CommonAnnotationBeanPostProcessor
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));
}
// 6.如果支持jpa,注册PersistenceAnnotationBeanPostProcessor
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));
}
// 7.注册EventListenerMethodProcessor，用于处理@EventListener注解
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));
}
// 8.注册DefaultEventListenerFactory，用于将@EventListener所标注的方法转换成EventListener对象
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;
}
上面这段代码，主要做了8件事，接下来我们就详细看看
- 指定容器使用的比较器，通过这个比较器能够解析@Order注解以及Ordered接口
指定容器中使用的比较器为
AnnotationAwareOrderComparator,这个比较器继承了OrderComparator。
OrderComparator自身提供了对Ordered接口的处理功能，而AnnotationAwareOrderComparator进一步做了扩展，除了会处理Ordered接口外还会处理@Order注解，但是接口的优先级高于注解。
- 指定容器使用的
AutowireCandidateResolver
参考我之前的问题：Spring中的AutowireCandidateResolver
这个类主要是在依赖注入期间起作用
- 判断一个bean的类型是否符合依赖的条件
- 处理
@Vlaue注解- 处理
@Qualifier注解- 处理
@Lazy注解为延迟注入的依赖生成代理
- 注册
ConfigurationClassPostProcessor
这个类是Spring启动过程中非常重要的一个后置处理器，它完成了对配置类的解析，并根据配置类上的配置信息去进行扫描并将扫描得到的bd注册到容器中，之后又会去解析注册到容器中的bd（因为在前一次扫描中可能会注册新的配置类），重复上面的操作确保所有的配置类都被解析处理完成。
这个类的源码之后单独用一篇文章分析，本文就不过多介绍了。
只要记住一点，Spring在构建Reader对象时就已经将这个后置处理器添加到容器中了，这个后置处理器属于**“开天辟地”**的那一类Bean
- 注册
AutowiredAnnotationBeanPostProcessor
这个后置处理器主要工作于依赖注入阶段，专门用于处理
@Autowired注解
- 如果支持
JSR-250，注册CommonAnnotationBeanPostProcessor
这个后置处理器也是工作于依赖注入阶段，专门用于处理
@Inject注解
- 如果支持
jpa,注册PersistenceAnnotationBeanPostProcessor
提供了
JPA的支持，不是重点，了解即可
- 注册
EventListenerMethodProcessor，用于处理@EventListener注解
在Spring完成Bean的创建后，会调用这个处理器的
afterSingletonsInstantiated,在这个方法中会完成@EventListener注解的解析，将所有的@EventListener注解标注的方法通过后面注册的DefaultEventListenerFactory转换成为ApplicationListener并注册到容器中
- 注册
DefaultEventListenerFactory
将
@EventListener标注的方法转换成ApplicationListener
至此，整个AnnotatedBeanDefinitionReader创建完成。
总结
本文作为Spring源码阅读系列的第一篇，主要介绍了整个AnnotatedBeanDefinitionReader的创建过程。我们从AnnotatedBeanDefinitionReader是什么开始，详细介绍了Spring的第一行代码到底干了什么。
可以看到，Spring在创建AnnotatedBeanDefinitionReader的过程中，还往容器中添加了开天辟地用的几个后置处理器，关于这几个后置处理器我将会在后面的文章中做详细的介绍。
源码的学习过程是枯燥的，这一系列的文章的目的一方面是总结自己在阅读Spring的源码过程中一些心得，朝着精通Spring的方向发展，一方面也希望能帮助到那些跟我一样正在学习Spring的同学可以减少一些源码阅读过程中的困扰。
给自己加油，也给在学习过程中的你们加油~！
码字不易，有喜欢的同学记得点个赞呀！
