专栏首页Java建设者读源码,我们可以从第一行读起

读源码,我们可以从第一行读起

在前面的文章中,我们已经完成了《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);
}

它主要做了两件事

  1. 创建一个AnnotatedBeanDefinitionReader
  2. 创建一个ClassPathBeanDefinitionScanner

本文的重点就是分析第一行代码,也就是创建AnnotatedBeanDefinitionReader的过程。在分析代码前,我们首先应该搞懂一件事情,就是创建的这个AnnotatedBeanDefinitionReader到底是什么呢?

AnnotatedBeanDefinitionReader是什么?

这个类的主要作用就是注册BeanDefinition,与之相类似的功能的类还有一个就是ClassPathBeanDefinitionScanner。它们最大的不同在于AnnotatedBeanDefinitionReader支持注册单个的BeanDefinition,而ClassPathBeanDefinitionScanner会一次注册所有扫描到的BeanDefinition。关于ClassPathBeanDefinitionScanner本文不专门做过多解释,只要能看懂这篇文章ClassPathBeanDefinitionScanner自然就懂了。 如果对于BeanDefinition不了解的推荐先阅读: Spring官网阅读(四)BeanDefinition(上) Spring官网阅读(五)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、ScopedProxyCreator.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件事,接下来我们就详细看看

  1. 指定容器使用的比较器,通过这个比较器能够解析@Order注解以及Ordered接口

指定容器中使用的比较器为AnnotationAwareOrderComparator,这个比较器继承了OrderComparatorOrderComparator自身提供了对Ordered接口的处理功能,而AnnotationAwareOrderComparator进一步做了扩展,除了会处理Ordered接口外还会处理@Order注解,但是接口的优先级高于注解。”

  1. 指定容器使用的AutowireCandidateResolver

参考我之前的文章:Spring中的AutowireCandidateResolver 这个类主要是在依赖注入期间起作用

  • 判断一个bean的类型是否符合依赖的条件
  • 处理@Vlaue注解
  • 处理@Qualifier注解
  • 处理@Lazy注解为延迟注入的依赖生成代理

  1. 注册ConfigurationClassPostProcessor

这个类是Spring启动过程中非常重要的一个后置处理器,它完成了对配置类的解析,并根据配置类上的配置信息去进行扫描并将扫描得到的bd注册到容器中,之后又会去解析注册到容器中的bd(因为在前一次扫描中可能会注册新的配置类),重复上面的操作确保所有的配置类都被解析处理完成。 这个类的源码之后单独用一篇文章分析,本文就不过多介绍了。 只要记住一点,Spring在构建Reader对象时就已经将这个后置处理器添加到容器中了,这个后置处理器属于**“开天辟地”**的那一类Bean”

  1. 注册AutowiredAnnotationBeanPostProcessor

这个后置处理器主要工作于依赖注入阶段,专门用于处理@Autowired注解”

  1. 如果支持JSR-250,注册CommonAnnotationBeanPostProcessor

这个后置处理器也是工作于依赖注入阶段,专门用于处理@Inject注解”

  1. 如果支持jpa,注册PersistenceAnnotationBeanPostProcessor

提供了JPA的支持,不是重点,了解即可”

  1. 注册EventListenerMethodProcessor,用于处理@EventListener注解

在Spring完成Bean的创建后,会调用这个处理器的afterSingletonsInstantiated,在这个方法中会完成@EventListener注解的解析,将所有的@EventListener注解标注的方法通过后面注册的DefaultEventListenerFactory转换成为ApplicationListener并注册到容器中”

  1. 注册DefaultEventListenerFactory

将@EventListener标注的方法转换成ApplicationListener


至此,整个AnnotatedBeanDefinitionReader创建完成。

总结

本文作为Spring源码阅读系列的第一篇,主要介绍了整个AnnotatedBeanDefinitionReader的创建过程。我们从AnnotatedBeanDefinitionReader是什么开始,详细介绍了Spring的第一行代码到底干了什么。

可以看到,Spring在创建AnnotatedBeanDefinitionReader的过程中,还往容器中添加了开天辟地用的几个后置处理器,关于这几个后置处理器我将会在后面的文章中做详细的介绍。

源码的学习过程是枯燥的,这一系列的文章的目的一方面是总结自己在阅读Spring的源码过程中一些心得,朝着精通Spring的方向发展,一方面也希望能帮助到那些跟我一样正在学习Spring的同学可以减少一些源码阅读过程中的困扰。

给自己加油,也给在学习过程中的你们加油~!

码字不易,有喜欢的同学记得点个赞呀!

我叫DMZ,一个在学习路上匍匐前行的小菜鸟!

本文分享自微信公众号 - Java建设者(javajianshe)

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2020-06-23

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • Spring 的 @EnableCaching 注解

    @EnableCaching注解是spring framework中的注解驱动的缓存管理功能。自spring版本3.1起加入了该注解。如果你使用了这个注解,那么...

    cxuan
  • 硬肝 Linux 系列汇总

    Linux,全称 GNU/Linux,是一套免费使用和自由传播的类 UNIX 操作系统。我在开发之前只知道 Windows 操作系统,所以我就以为世界上只有一种...

    cxuan
  • Spring Aop 扫盲

    面向切面编程(Aspect-oriented Programming,俗称AOP)提供了一种面向对象编程(Object-oriented Programming...

    cxuan
  • 利用Androidstudio开发Java工程图文详解

    作为一名安卓开发工作者,有时候希望可以借助简单的Java程序来验证或测试一些代码,目前Androidstudio开发工具越来越火,但是很遗憾在使用了as一年后才...

    fanfan
  • 什么叫代码的可读性?为什么说Kotlin的可读性比Java好?

    不久之前,我看了一篇文章,大意是Kotlin与Java之间的对比,像这种文章,我一般是直接忽略的,但是那天我还是打开了,然后就看到一个非常吃惊的结果。 里面有一...

    企鹅号小编
  • SpringBoot使用事务

    dalaoyang
  • 哈哈哈哈,「00 后黑话破解器」火爆 GitHub,这波操作我给满分!

    起初咋看一下,还以为又是一篇上怼天,下怼地的键盘侠文章,没想到,点进去后发现竟然是一个颇有意思的开源项目,下面小 G 就来跟大家聊聊,这是项目到底是干啥用的。

    GitHubDaily
  • 无人机质量滑坡,中国智造为何频现一锤子买卖?

    从人们手腕上的智能手环到共享单车上的智能锁,从农田上空撒种子、喷农药的无人机到餐厅中“萌萌哒”的机器人服务员,随着大众创业、万众创新的兴起和中国经济结构转型的深...

    机器人网
  • LeetCode98题 验证二叉搜索树(Validate Binary Search Tree)

    https://leetcode-cn.com/problems/validate-binary-search-tree/

    code随笔
  • 自动返回笑话接口调用之微信公众平台(二)

    在InputStreamReader(InputStream in, Charset cs) 中,将编码设置为“UTF-8”即可

    lpe234

扫码关注云+社区

领取腾讯云代金券