Spring 源码阅读 一

其他 2019-10-14 23:04:30 阅读次数: 0

终于,有一天我也来看Spring的源码了,看了一阵之后感觉心情那叫一个舒畅,对Spring底层的实现也有了进一步的了解, 最直观的感受就是Spring的命名风格很赞,很长,真的长到使人见名知意, 闲言少叙,开始整理笔记了

程序的入口

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfig.class);

跟进这个AnnotationConfigApplicationContext()程序的启动入口, 注解配置的应用上下文.主要做了下面的三件事

  • 调用本类无参构造方法
  • 调用register(annotatedClasses) 将我们传递进来的配置类注册进BeanFactory的BeanDefinitionMap
  • 刷新容器
    public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
        this();
        register(annotatedClasses);
        refresh();
    }

创建BeanFactory

https://img2018.cnblogs.com/blog/1496926/201910/1496926-20191014223256299-675993675.png

首先调用本类的无参构造方法,,通过上图,可以看到,AnnotationConfigAllicationContext的父类是GenericApplicationContext但是,在执行本类的无参构造方法时会先执行父类的无参构造方法.它父类的无参构造方法我贴在下面,就做了一件事,初始化了Spring的BeanFactory,没错就是Spring的Bean工厂,由于两者的继承关系,我们就任务,AnnotationConfigApplicationContext的Bean工厂被初始化了

    public GenericApplicationContext() {
        this.beanFactory = new DefaultListableBeanFactory();
    }

创建AnnotatedBeanDefinitionReader加载

接着回到这个构造方法的源码我贴在下面, 这个构造方法主要做了两件事

  • 为应用的上下文创建reader读取器, 读取被添加了注解的类信息
  • 实例化了一个Scanner, 这个Scanner可以用去做包扫描的工作,但是Spring根据我们的配置信息去进行包扫描的工作时,并没有使用这个扫描器,而是自己new 了一个,当前的扫描器可以理解成是方便程序员使用而创建的
    public AnnotationConfigApplicationContext() {
        this.reader = new AnnotatedBeanDefinitionReader(this); 
        this.scanner = new ClassPathBeanDefinitionScanner(this);
    }

下面跟进AnnotatedBeanDefinitionReader扫描器的创建过程,经过几个没有重要逻辑的方法,我们会进入registerAnnotationConfigProcessors(BeanDefinitionRegistry registry, @Nullable Object source),下面是源码： 这算是Spring初始化的一个小高潮了!!!,为啥这样说呢? 因下面的逻辑中,为Spring初始化过程中,构建BeanFactory提供了几个开天辟地性质的RootBeanDefinition``

  • 首先是在为BeanFactory添加了两个大组件
    • AnnotationAwareOrderComparator用于解析@Order 和 @Priorty注解
    • ContextAnnotationAutowireCandidateResolver 提供了懒加载的支持
  • 然后就是往BeanFactory中的BeanDefinitionMap中添加了6个RootBeanDefinition
    • ConfigurationClassPostProcessor
    • AutowiredAnnotationBeanPostProcessor
    • ...
public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
        BeanDefinitionRegistry registry, @Nullable Object source) {

    //   得到bean工厂
    DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
    if (beanFactory != null) {
        if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
            //  给Bean工厂添加原材料
            //  AnnotationAwareOrderComparator 主要能解析@Order注解和@Priority
            beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
        }
        if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
            //  ContextAnnotationAutowireCandidateResolver 提供处理懒加载(Lazy)相关的功能
            beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
        }
    }
    //   作用是方便传递参数BeanDefinitionHolder
    Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
    // BeanDefinition的注册，这里很重要，需要理解注册每个bean的类型
    //   就是判断工厂中有没有包含 CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME 名称的bean, Spring在启动时,工厂肯定是空的返回false , 加上! 表示ture
    if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {//configuration_annotation_processor_bean_name
        //   注意: 下面的ConfigurationClassPostProcessor实现了BeanDefinitionRegistryPostProcessor,间接实现了 BeanFactoryPostProcessor bean工厂的后置处理器
        //   RootBeanDefinition可以理解成 描述Spring内部类的Definition

        //   除了通过AnnotationedBeanDefinitionReader把 加上了注解的类加载成bean,下面的第二种方式, 通过new RootBeanDefinition, 进而将 XXX.class起来注册进bean工厂
        //   这是使用第二种方式, 通过new Spring自己实现的BeanDefinition接口的类,将java转换成 Bean 然后put进BeanFactory的BeanDefinitionMap中
        //   下面的111-666 就是最先放置进去的6个Spring的RootBean对象
        //   ---111---------------------------
        RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
        def.setSource(source);
        //   跟进去 registerPostProcessor
        beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
    }

    if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        //AutowiredAnnotationBeanPostProcessor 实现了 MergedBeanDefinitionPostProcessor
        //MergedBeanDefinitionPostProcessor 最终实现了 BeanPostProcessor
        //   ---222---------------------------
        RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
    }

    if (!registry.containsBeanDefinition(REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        //   ---333---------------------------
        RootBeanDefinition def = new RootBeanDefinition(RequiredAnnotationBeanPostProcessor.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
    }

    // Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
    if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {

        //   ---444---------------------------
        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.
    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));
    }

    if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
        //   ---555---------------------------

        RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
    }

    if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
        //   ---666---------------------------
        RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
    }

    return beanDefs;
}

上面的代码中有来如下两个亮点:

亮点1:RootBeanDefinition

首先涉及到的知识点就是,Spring有哪几种方式将对象转成BeanDefinition? 其实是有两种,第一种就是让Spring通过Scanner去扫描包解析程序员提供的添加了注解的类,这是个自动完成的过程,第二种就是Spring通过new RootBeanDefinition等诸多的BeanDefinition接口的实现类, 然后将Spring原生的对象当成参数传递进去进而转换成BeanDefinition, 当然,Spring在这里选择的就是第二种方法

亮点2:ConfigurationClassPostProcessor

这个类很牛,为什么这么说呢? 先看一下他的继承类图

https://img2018.cnblogs.com/blog/1496926/201910/1496926-20191014223255758-1792965804.png

没错,他是6个RootBeanDefinition中唯一的一个实现BeanFactoryPostProcessor的,其他的五个RootBeanDifinition实现的都是BeanPostProcessor, 其实也不用懵逼,只要我们整明白这里说的BeanPostProcessor和BeanFactoryPostProcessor的作用就好了,然后在这里我用下面的两个模块解释

BeanPostProcessor

接口的抽象方法源码如下:

public interface BeanPostProcessor {

@Nullable
    default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
@Nullable
    default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
}

两个方法名,见名知意: 第一个会在 对象的 constructor 之后,init()方法之前调用

第二个会在init()方法之后调用

但是,大家可以发现,它的调用时机都是在构造方法执行之后进行拦截,这时候BeanDefinition已经被实例化了

BeanFactoryPostProcessor

@FunctionalInterface
public interface BeanFactoryPostProcessor {

    void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;

}

它就比较厉害了, 这也是Spring牛的地方,它不仅仅会替我们维护这些Bean,而且还通过当前的BeanFactoryPostProcessor,为程序员开放一个缺口,让程序员可以参与到Bean的创建过程中来,为什么这样说呢, 其实大家可以看到,它唯一的抽象方法中的入参位置上是谁? 没错,就是BeanFactory, Bean工厂都给我们了,那不是想干啥干啥?

其次,它的作用时机是执行Bean的构造方法之前

最直接的应用场景: 当一个单例的Bean依赖 多例的Bean时,我们多次通过 应用的上下文获取出来的单例bean的hashcode都是唯一的这没错,但是紧接着打印它依赖的多例对象的hashcode同样是相同的,这种单例失效的问题,就可以根据这个知识点从容解决

前面说的ConfigurationClassPostProcessor就是BeanFactoryPostProcessor的实现类,并且它也不辱使命, 完美的使用作用时机不同的特点,在程序员提供的配置类的构造方法调用之前,就先入为主,围棋生成了 cglib代理对象

接着看代码,回到上面的代码,我们看如何将RootBeanDefinition注册进BeanFactory, 我从上面截取一行代码放在这里

    //   跟进去 registerPostProcessor
        beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));

跟进这个registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)

private static BeanDefinitionHolder registerPostProcessor(
        BeanDefinitionRegistry registry, RootBeanDefinition definition, String beanName) {

    definition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    //   registerBeanDefinition()
    registry.registerBeanDefinition(beanName, definition);
    return new BeanDefinitionHolder(definition, beanName);
}

我们关注这个registry.registerBeanDefinition(beanName, definition); , 可以看到,其实这个registerBeanDefinition()是BeanDefinitionRegistry的抽象方法,我们要找的是它的实现类,那问题来了, 是谁实现他呢? 可以回到博客顶部,看看第一个图,没错Spring的BeanFactory,也就是DefualtListableBeanFactory实现了这个接口,虽然有点意外,一个工厂竟然还是一个注册器,但是这也是事实情况, 看看这个工厂是如何做的吧 .原函数很长,我截取了部分源码如下: 它的解释我写在源码的下面

public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
            throws BeanDefinitionStoreException {
            ...
            else {
                //   添加进入容器中, 最终的结果就是,这个map中存在哪些类,Spring的IOC中就有哪些类
                // Still in startup registration phase
                this.beanDefinitionMap.put(beanName, beanDefinition);
                //   单独使用一个list存放名字
                this.beanDefinitionNames.add(beanName);

                this.manualSingletonNames.remove(beanName);
            }
            this.frozenBeanDefinitionNames = null;
        }

        if (existingDefinition != null || containsSingleton(beanName)) {
            resetBeanDefinition(beanName);
        }

可以看到,他将一开始的6个RootBeanDefinition全都都put进了一个map中, 下面这个map

private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

key就是beanName, value就是BeanDefinition

这也是迄今为止我们遇到的第一个map, 这个map是BeanFactory的一个组件,但是它可不是传说中的IOC容器,大家也看到了它里面存放的是BeanDefinition,而不是Bean

将配置类注册进BeanFactory

回到一开始AnnotationConfigApplicationContext的register(annotatedClasses);方法,然后一路往下跟,会经过几个没有什么重要逻辑的方法, 然后来到这里

public void register(Class<?>... annotatedClasses) {
    for (Class<?> annotatedClass : annotatedClasses) {
        //  继续跟进去
        registerBean(annotatedClass);
    }
}

通过上面的代码,我们可以回想,annotatedClasses这个可变长度的参数,其实就是我们在AnnotationConfigApplicationContext中传递进来的主配置类MainConfig, 也就是说,这个主配置类是可以存在多个的

接着往下跟

<T> void doRegisterBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
            @Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {
        // 可以将当前类理解成一个方便参数传递的封装类
        // 意为: 被加上注解的通用的BD
        // 将传递进来的 主配置类封装进 这个AnnotatedGenericBeanDefinition
        AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);

        if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
            return;
        }

        abd.setInstanceSupplier(instanceSupplier);

        // 解析出它的元数据
        ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
        // 设置它的作用域
        abd.setScope(scopeMetadata.getScopeName());
        // 名称生成器, 目的是为BeanDefinition取个名字,因为这个BD最终被存放到一个map中,
        // 默认情况下@Configuration(value = "XXX") 这个value有值,就是使用这个当成名字
        // 都这就使用 类名首字母小写当成名字
        String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));

        // 处理bean上的通用注解, @Lazy  @Dependon @Primary role等
        AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);

        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));
                }
            }
        }

        for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
            customizer.customize(abd);
        }
        // 理解成方便参数传递的封装类
        BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd,beanName);
  
        definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
        // 我们关注的重点, 注册BeanDefinition
        BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
    }

上面的函数的主要作用如下: 将我们通过AnnotationConfigApplicationContext构造函数传递进来的主配置类封装进了AnnotatedGenericBeanDefinition中,然后解析它身上的其他注解完成属性的赋值

接着跟进registerBeanDefinition()方法

    public static void registerBeanDefinition(
            BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
            throws BeanDefinitionStoreException {

        //   再来这个方法之前封装了一个 difinitionHolder , 然后在这里又把它拆分开传递给了下面的函数
        // Register bean definition under primary name.
        String beanName = definitionHolder.getBeanName();
        //   在当前的BeanDefinitionReaderUtils中使用
        registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

        // Register aliases for bean name, if any.
        String[] aliases = definitionHolder.getAliases();
        if (aliases != null) {
            for (String alias : aliases) {
                registry.registerAlias(beanName, alias);
            }
        }
    }

继续跟进

    registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

于是有回到了上面注册6大RootBeanDefinition的逻辑中,将我们的主配置类注册进BeanFactory的BeanDefinitionMap中

未完待续...

猜你喜欢

转载自www.cnblogs.com/ZhuChangwu/p/11674684.html
今日推荐
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
OOP第二次作业
java web 乱码问题
android 禁止scrollview 因控件变化自动滚动到底的方法
mysql服务解压版的安装(5.7)
centos7 nginx+tomcat配置https 安装免费SSL Let’s Encrypt
使用Mosquitto遗嘱机制实现感知客户端上下线功能的方法
面向对象之------多态与多态性
开发Teams Tabs应用程序
C# 希尔排序
第2章 Jupyter Notebooks
每日归档
更多
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022