四.Spring源码剖析-基于注解的IOC启动流程

本文涉及的产品
云解析 DNS,旗舰版 1个月
全局流量管理 GTM,标准版 1个月
公共DNS(含HTTPDNS解析),每月1000万次HTTP解析
简介: 前面章节我们已经分析了XML配置的IOC的启动流程,这章节来分析一下基于注解配置的IOC启动流程,有了前面的铺垫,这章分析起来将会比较简单。

前言

前面章节我们已经分析了XML配置的IOC的启动流程,这章节来分析一下基于注解配置的IOC启动流程,有了前面的铺垫,这章分析起来将会比较简单。

Spring的注解编程

相信比较老的程序员是体验过使用Spring的xml配置来开发项目,大量繁杂复杂的配置增加了开发的繁琐性。Spring在 2.0 以后就引入了注解编程来代替复杂成XML配置-即JavaConfig,Spring框架内部也是大量使用注解代替XML配置,对于新的程序员可能都是直接使用SpringBoot开发项目,SpringBoot本身就是基于Spring封装推荐使用全注解编程的快速开发框架。比如:在SpringBoot中,以前的XML配置已经变成了注解了@Configuration 的配置类 ,下面我们来入门一个简单的基于注解的IOC

第一步:创建一个类

public class MyBean {
   
   
}

第二步:定义一个基于注解的配置

//定义一个基于注解的Spring配置类,相当于是Spring的xml配置
@Configuration
public class AppConfig {
   
   

    //向容器中注册一个Bean
    @Bean
    public MyBean myBean(){
   
   
        return new MyBean();
    }
}

第三步:使用 AnnotationConfigApplicationContext容器工厂加载位置

public class MyBeanTest {
   
   

    @Test
    public void testMyBean(){
   
   
        //通过容器工厂:AnnotationConfigApplicationContext 加载配置
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
        //通过容器工厂获取MyBean
        MyBean myBean = applicationContext.getBean(MyBean.class);
        //打印myBean
        System.out.println(myBean);
    }
}

容器工厂:AnnotationConfigApplicationContext

AnnotationConfigApplicationContext是一个基于注解的IOC容器工厂,以注解了@Configuration的配置类作为输入。它继承了 GenericApplicationContext 容器工厂,和AnnotationConfigRegistry 注解配置注册器,源码如下:

public class AnnotationConfigApplicationContext extends GenericApplicationContext implements AnnotationConfigRegistry {
   
   

    //基于注解方式的Bean的注册器,提供了注册Bean的方法
    private final AnnotatedBeanDefinitionReader reader;

    //bean 定义扫描器,它检测类路径上的 bean ,使用给定的注册器注册相应的 bean 定义。
    //通过可配置的类型过滤器检测候选类。 默认过滤器包括使用 Spring 的@Component 、 @Repository 、 @Service或@Controller型注释的@Component 。
    private final ClassPathBeanDefinitionScanner scanner;


    /**
     * Create a new AnnotationConfigApplicationContext that needs to be populated
     * through {@link #register} calls and then manually {@linkplain #refresh refreshed}.
     */
    //创建Bean的注册器  和 Bean的扫描器
    public AnnotationConfigApplicationContext() {
   
   
        this.reader = new AnnotatedBeanDefinitionReader(this);
        this.scanner = new ClassPathBeanDefinitionScanner(this);
    }
    //根据class注册一个类
    @Override
    public void register(Class<?>... componentClasses) {
   
   
        Assert.notEmpty(componentClasses, "At least one component class must be specified");
        this.reader.register(componentClasses);
    }

    //扫描一个包,注册多个类
    @Override
    public void scan(String... basePackages) {
   
   
        Assert.notEmpty(basePackages, "At least one base package must be specified");
        this.scanner.scan(basePackages);
    }

下面是继承体系:
在这里插入图片描述

AnnotatedBeanDefinitionReader

AnnotatedBeanDefinitionReader 是基于注解方式的Bean的注册器,它负责把传入类的class封装成BeanDefinition ,并解析类的注解:@Scope,@Lazy,@Primary等等,然后使用BeanDefinitionRegistry 注册Bean。

public class AnnotatedBeanDefinitionReader {
   
   
    //Bean的注册器
    private final BeanDefinitionRegistry registry;
    //Bean的名字生成器
    private BeanNameGenerator beanNameGenerator = new AnnotationBeanNameGenerator();
    //Scope元注解解析器
    private ScopeMetadataResolver scopeMetadataResolver = new AnnotationScopeMetadataResolver();
    //根据多个class注册Bean
    public void register(Class<?>... componentClasses) {
   
   
        for (Class<?> componentClass : componentClasses) {
   
   
            registerBean(componentClass);
        }
    }
    //根据class注册一个 Bean
    public void registerBean(Class<?> beanClass) {
   
   
        doRegisterBean(beanClass, null, null, null);
    }
    ...省略...

ClassPathBeanDefinitionScanner

Bean的扫描器,根据给定的包路径扫描注解了:@Component,@Service,@Controller,@Repository的类,使用BeanDefinitionRegistry 注册Bean到Spring容器中。

public class ClassPathBeanDefinitionScanner extends ClassPathScanningCandidateComponentProvider {
   
   

    private final BeanDefinitionRegistry registry;
    ...省略...
    //扫描一个包
    public int scan(String... basePackages){
   
   
        ...省略...
    }
    //注册一个Bean
    protected void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) {
   
   
        BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, registry);
    }

启动流程:AnnotationConfigApplicationContext

在前面的章节已经介绍过IOC容器工厂的继承体系了,这里不多赘述,下面我们直接从AnnotationConfigApplicationContext的构造器分析IOC的流程。下面是源码

    /**
        根据给定的配置类,创建新的AnnotationConfigApplicationContext容器工厂
     * Create a new AnnotationConfigApplicationContext, deriving bean definitions
     * from the given annotated classes and automatically refreshing the context.
     * @param annotatedClasses one or more annotated classes,
     * e.g. {@link Configuration @Configuration} classes
     */
     //annotatedClasses 是贴了@Configuration的Spring的配置类,
    public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
   
   
        //创建 AnnotatedBeanDefinitionReader注册器 和 ClassPathBeanDefinitionScanner扫描器
        this();
        //执行注册,传入配置类
        register(annotatedClasses);
        //刷新容器
        refresh();
    }

从该构造方法参数可以看得出,这里是可以传入多个配置类的,方法中做了三件事情

  • 调用构造器创建AnnotatedBeanDefinitionReader Bean注册器 和 ClassPathBeanDefinitionScanner Bean扫描器
  • 调用register方法执行注册
  • 调用refresh方法刷新容器

[注意] 配置类本身也是一个Bean,register方法的目的是对当前传入的配置类进行注册。

跟一下 AnnotationConfigApplicationContext#register 方法,源码如下:

@Override
public void register(Class<?>... componentClasses) {
   
   
    Assert.notEmpty(componentClasses, "At least one component class must be specified");
    //调用AnnotatedBeandefinitionReader 注册器注册Bean
    this.reader.register(componentClasses);
}

Bean的注册AnnotatedBeanDefinitionReader

代码来到 AnnotatedBeanDefinitionReader#register 方法,源码如下

public class AnnotatedBeanDefinitionReader {
   
   
    //BeanDefinition 的注册器
    private final BeanDefinitionRegistry registry;
    //名字生成器
    private BeanNameGenerator beanNameGenerator = new AnnotationBeanNameGenerator();
    //scope 解析器
    private ScopeMetadataResolver scopeMetadataResolver = new AnnotationScopeMetadataResolver();

    ...省略...
    //注册多个类
    public void register(Class<?>... componentClasses) {
   
   
        for (Class<?> componentClass : componentClasses) {
   
   
            registerBean(componentClass);
        }
    }

register方法中通过for的方式把多个配置类交给registerBean方法去注册,代码来到 .AnnotatedBeanDefinitionReader#registerBean(java.lang.Class<?>)

public void registerBean(Class<?> beanClass) {
   
   
        doRegisterBean(beanClass, null, null, null);
    }

    //从给定的 bean 类注册一个 bean,从类声明的注释中获取其元数据
    <T> void doRegisterBean(Class<T> beanClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
            @Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {
   
   
        //创建带注释的通用 Bean 定义
        AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);
        //判断配置类上是否有 Conditional 条件注解,判断是否要跳过该Bean的注册
        if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
   
   
            return;
        }

        abd.setInstanceSupplier(instanceSupplier);
        //通过 ScopeMetadataResolver 解析 当前Bean的@Scope注解,封装成 ScopeMetadata
        ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
        // scope属性,默认是 singleton 单利
        abd.setScope(scopeMetadata.getScopeName());
        //生成Bean的名字,如果从注解中没有获取到name,就生成唯一的默认 bean 名称。
        String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
        //处理注解 Bean 定义中的通用注解 ,比如读取:lazy, @Primary,@DependsOn , Description等注解属性,然后设置到BeanDefinition对象
        AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
        //检查是否有而外的限定符注解
        if (qualifiers != null) {
   
   
            for (Class<? extends Annotation> qualifier : qualifiers) {
   
   
                //如果有@Primary注解,这标记该Bean是自动注入时的首选Bean
                if (Primary.class == qualifier) {
   
   
                    abd.setPrimary(true);
                }
                //如果配置了@Lazy这设置为懒加载
                else if (Lazy.class == qualifier) {
   
   
                    abd.setLazyInit(true);
                }
                else {
   
   
                    //如果没有@Primary和Lazy配置,则指定自动注入时使用名称自动注入
                    abd.addQualifier(new AutowireCandidateQualifier(qualifier));
                }
            }
        }
        for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
   
   
            customizer.customize(abd);
        }
        //封装一个BeanDefinitionHolder,以beanName作为名字
        BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
        //Scope作用域,创建相应的代理对象
        definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
        //注册BeanDefinition
        BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
    }

该方法中做了如下事情

  • 给当前Bean创建一个 AnnotatedGenericBeanDefinition
  • 通过 ScopeMetadataResolver 元注解解析器解析 当前Bean的@Scope注解,封装成 ScopeMetadata,然后把scope设置给BeanDefinition
  • 为Bean设置name,如果没有指定name就生成一个全局唯一的name
  • 处理Bean的通用注解如:lazy, @Primary,@DependsOn , Description等注解属性
  • 创建Scope的代理对象
  • 调用 BeanDefinitionReaderUtils#registerBeanDefinition 注册Beandefinition

至于BeanDefinitionReaderUtils#registerBeanDefinition 在前面一章我们就看过了,其实现方式是通过BeanDefinitionRegistry把BeanDefinition注册到 DefaultListableBeanFactory 容器工厂管理Bean的Map中(beanDefinitionMap = new ConcurrentHashMap(256))

到这里,配置类的Bean的注册就完了,那有些同学会问,在配置类AppConfig中注册的 MyBean 是在什么起作用的呢?它是在refresh()方法中调用 finishBeanFactoryInitialization(beanFactory) 执行的。该方法中会把单利的Bean预先实例化,这里我不展开说。

总结

这篇文章比较简单,讲了一下基于注解的 AnnotationConfigApplicationContext(annotatedClasses) 容器工厂启动过程,这里做个总结

  1. 通过构造器创建 AnnotatedBeanDefinitionReader Bean注册器 和 ClassPathBeanDefinitionScanner Bean扫描器
  2. 然后将传入的配置类封装成 AnnotatedGenericBeanDefinition ,并解析该类的注解,如:@Lazy,@Scope,@Primary等属性都设置给BeanDefinition
  3. 调用BeanDefinitionReaderUtils#registerBeanDefinition把BeanDefinition注册到DefaultListableBeanFactory中一个管理Bean的Map中

文章结束,下一章我们将继续讨论AnnotationConfigApplicationContext的另外一种启动方式:基于包路径的扫描方式。 如果喜欢的请给个好评吧,你的肯定是我最大的动力 !!!

相关文章
|
8天前
|
XML Java 测试技术
Spring IOC—基于注解配置和管理Bean 万字详解(通俗易懂)
Spring 第三节 IOC——基于注解配置和管理Bean 万字详解!
72 26
|
11天前
|
缓存 Java 数据库
SpringBoot缓存注解使用
Spring Boot 提供了一套方便的缓存注解,用于简化缓存管理。通过 `@Cacheable`、`@CachePut`、`@CacheEvict` 和 `@Caching` 等注解,开发者可以轻松地实现方法级别的缓存操作,从而提升应用的性能和响应速度。合理使用这些注解可以大大减少数据库的访问频率,优化系统性能。
154 89
|
2月前
|
Java Spring
【Spring】方法注解@Bean,配置类扫描路径
@Bean方法注解,如何在同一个类下面定义多个Bean对象,配置扫描路径
178 73
|
2月前
|
XML Java 数据格式
【SpringFramework】Spring IoC-基于XML的实现
本文主要讲解SpringFramework中IoC和DI相关概念,及基于XML的实现方式。
114 69
|
2月前
|
Java Spring 容器
【SpringFramework】Spring IoC-基于注解的实现
本文主要记录基于Spring注解实现IoC容器和DI相关知识。
58 21
|
1月前
|
监控 JavaScript 数据可视化
建筑施工一体化信息管理平台源码,支持微服务架构,采用Java、Spring Cloud、Vue等技术开发。
智慧工地云平台是专为建筑施工领域打造的一体化信息管理平台,利用大数据、云计算、物联网等技术,实现施工区域各系统数据汇总与可视化管理。平台涵盖人员、设备、物料、环境等关键因素的实时监控与数据分析,提供远程指挥、决策支持等功能,提升工作效率,促进产业信息化发展。系统由PC端、APP移动端及项目、监管、数据屏三大平台组成,支持微服务架构,采用Java、Spring Cloud、Vue等技术开发。
|
2月前
|
存储 Java Spring
【Spring】获取Bean对象需要哪些注解
@Conntroller,@Service,@Repository,@Component,@Configuration,关于Bean对象的五个常用注解
|
21天前
|
XML Java 应用服务中间件
Spring Boot 两种部署到服务器的方式
本文介绍了Spring Boot项目的两种部署方式:jar包和war包。Jar包方式使用内置Tomcat,只需配置JDK 1.8及以上环境,通过`nohup java -jar`命令后台运行,并开放服务器端口即可访问。War包则需将项目打包后放入外部Tomcat的webapps目录,修改启动类继承`SpringBootServletInitializer`并调整pom.xml中的打包类型为war,最后启动Tomcat访问应用。两者各有优劣,jar包更简单便捷,而war包适合传统部署场景。需要注意的是,war包部署时,内置Tomcat的端口配置不会生效。
158 17
Spring Boot 两种部署到服务器的方式
|
21天前
|
Dart 前端开发 JavaScript
springboot自动配置原理
Spring Boot 自动配置原理:通过 `@EnableAutoConfiguration` 开启自动配置,扫描 `META-INF/spring.factories` 下的配置类,省去手动编写配置文件。使用 `@ConditionalXXX` 注解判断配置类是否生效,导入对应的 starter 后自动配置生效。通过 `@EnableConfigurationProperties` 加载配置属性,默认值与配置文件中的值结合使用。总结来说,Spring Boot 通过这些机制简化了开发配置流程,提升了开发效率。
55 17
springboot自动配置原理
|
26天前
|
XML JavaScript Java
SpringBoot集成Shiro权限+Jwt认证
本文主要描述如何快速基于SpringBoot 2.5.X版本集成Shiro+JWT框架,让大家快速实现无状态登陆和接口权限认证主体框架,具体业务细节未实现,大家按照实际项目补充。
70 11