Spring源码系列:核心概念解析

spring,源码,系列,核心,概念,解析 · 浏览次数 : 332

小编点评

**Bean管理** * **AbstractBeanFactory**:根据接口定义创建bean,并进行初始化。 * **AnnotationConfigApplicationContext**:由AnnotationConfigReader实例化,并进行配置加载。 * **BeanFactoryPostProcessor**:在BeanFactory创建完毕后,进行干涉。 * **FactoryBean**:实现FactoryBean接口,负责创建和注入对象。 **生命周期** * **Bean创建**:由AbstractBeanFactory创建,并进行初始化。 * **Bean初始化**:在Bean创建完成后,进行初始化。 * **Bean销毁**:在Bean创建完毕后,进行销毁。 **注入** * **@Component**:标注类,在Spring容器中注入对象。 * **@Autowired**:在方法中注入对象。 * **@FactoryBean**:定义工厂类,负责创建对象。 **后置处理器** * **@Bean**:定义后置处理器,在对象创建完毕后进行干涉。 * **@PostProcess**:在对象创建完毕后进行干涉。 **配置** * **@Bean**:定义配置类中的方法,在Spring容器中注入对象。 * **@Configuration**:定义配置类,并在Spring容器中加载配置。 **ASM** * **SimpleMetadataReaderFactory**:用于解析类文件的元数据信息。 * **MetadataReader**:用于获取类中的注解信息。 * **AnnotationMetadataSpring**:启动时进行元数据扫描。 **其他** * **BeanFactoryPostProcessor**:在BeanFactory创建完毕后,进行干涉。 * **FactoryBean**:实现FactoryBean接口,负责创建和注入对象。 * **@Component**:标注类,在Spring容器中注入对象。 * **@Autowired**:在方法中注入对象。 * **@FactoryBean**:定义工厂类,负责创建对象。

正文

前言

本文旨在为读者解析Spring源码中的关键类,以便读者在深入阅读源码时,能够了解关键类的作用和用途。在阅读Spring源码时,经常会遇到一些不熟悉的概念,了解关键类的作用可以帮助读者更好地理解这些概念。

BeanDefinition

BeanDefinition是Spring框架中的一个重要概念,它定义了一个Bean的基本属性和行为,比如:

  1. BeanClassName,当前的bean名字
  2. Scope,是否单例,具体枚举:#SCOPE_SINGLETON、#SCOPE_PROTOTYPE
  3. LazyInit,是否懒加载,默认不是
  4. DependsOn,是否依赖其他bean,如果依赖,则会先创建依赖bean
  5. InitMethodName,初始化方法名称
  6. DestroyMethodName,销毁类方法名称
  7. ......还有更多,但是这几个大体已经差不多了

BeanDefinition的作用非常重要,它可以帮助Spring容器更好地管理Bean的生命周期和依赖关系。在Spring框架中,我们经常会通过注解方式来定义Bean:

  1. < bean/>
  2. @Bean
  3. @Component(@Controller、@Service)

这些都是被称为申明式定义Bean。就是使用Spring提供好的封装。

除了注解方式,我们还可以通过编程方式来定义Bean,这时就需要直接使用BeanDefinition来创建BeanDefinition对象,并设置对应的属性,然后将其注册到Spring容器中,比如

    // 创建一个Spring容器
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);

        AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
        beanDefinition.setBeanClass(UserService.class);
        //当然还可以设置其他上面我说的其他属性:懒加载什么的
        applicationContext.registerBeanDefinition("userService", beanDefinition);

        UserService userService = (UserService) applicationContext.getBean("userService");
        userService.test();

无论是通过注解方式还是编程方式来定义Bean,最终都是需要使用BeanDefinition来描述Bean的基本属性和行为,然后将其放入Spring容器中进行管理。

BeanDefinitionReader

BeanDefinitionReader是Spring框架中的一个重要组件,主要用于读取和操作BeanDefinition对象。虽然我们在使用Spring框架时很少直接使用BeanDefinitionReader,但在Spring源码中却扮演着非常重要的角色,相当于Spring源码的基础设施。

BeanDefinitionReader的核心方法包括以下几个:

  1. BeanDefinitionRegistry,用来注册bean定义,相当于一个工厂
  2. BeanNameGenerator,用来生成bean名字的生成器
  3. loadBeanDefinitions,从资源中加载bean

XmlBeanDefinitionReader

XmlBeanDefinitionReader是BeanDefinitionReader的子类,可以用于从XML文件中读取BeanDefinition并注册到Spring容器中。使用XmlBeanDefinitionReader的步骤如下:

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
XmlBeanDefinitionReader xmlBeanDefinitionReader = new XmlBeanDefinitionReader(context);
//加载xml中配置的所有<bean>
int i = xmlBeanDefinitionReader.loadBeanDefinitions("spring.xml");
System.out.println(context.getBean("userService"))

AnnotatedBeanDefinitionReader

细心的朋友,应该可以发现AnnotatedBeanDefinitionReader是一个单独的类,不是BeanDefinitionReader的子类,但它的方法与BeanDefinitionReader基本相同,官方说是方便的适配器,用于编程注册bean类,他可以解析@Conditional,@Scope、@Lazy、@Primary、@DependsOn、@Role、@Description相关注解,具体操作如下:

// 创建一个Spring容器
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);

//        AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
//        beanDefinition.setBeanClass(UserService.class);
//        applicationContext.registerBeanDefinition("userService", beanDefinition);

        new AnnotatedBeanDefinitionReader(applicationContext).registerBean(UserService.class);

        UserService userService = (UserService) applicationContext.getBean("userService");
        userService.test();

同样的,他也可以让我们注册的bean走完创建的整个生命周期过程。

ClassPathBeanDefinitionScanner

ClassPathBeanDefinitionScanner也是一个用于注册BeanDefinition的工具类,与BeanDefinition接口没有直接关系。ClassPathBeanDefinitionScanner可以扫描指定包路径下带有特定注解的类,并将其解析成BeanDefinition,注册到Spring容器中。主要是他有个scan方法对我们定义的basepackage包路径进行解析扫描所有带有@component、@ManagedBean(JSR-250标准)、@Named(JSR-330标准)
使用ClassPathBeanDefinitionScanner的步骤如下:

// 创建一个Spring容器  
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);  
  
new ClassPathBeanDefinitionScanner(applicationContext).scan("com.xiaoyu");  
UserService userService = (UserService) applicationContext.getBean("userService");  
userService.test();

BeanFactory

BeanFactory是Spring框架中的一个重要接口,他就是Spring用于管理Bean对象的创建和管理,看他的几个主要方法就知道了:

  1. getBean,可以根据name、type等获取bean对象
  2. containsBean,是否bean工厂中有某个对象
  3. isSingleton,判断是否是单例
  4. isTypeMatch,判断改name是否匹配类型
  5. getType,根据bean名字获取类型
  6. getAliases。获取别名数组
    看着主要几个接口实现,基本都是围绕bean所做的,然后根据接口再看他的实现类就方便许多了,

DefaultListableBeanFactory

如果看过源码的朋友肯定对这个实现类不陌生,如果对这个实现类陌生的朋友,那请记住这个重要的实现类,它实现了很多接口、且继承了多层父类,所以他的功能也是相当之多。我们来看看他的主要方法:

  1. containsBeanDefinition,查看是否包含某个bean定义,因为该类维护了一个Map<String, BeanDefinition> beanDefinitionMap属性。
  2. determineAutowireCandidate,决定注入哪个bean,@Primary-->优先级最高--->name
  3. doResolveDependency,解析依赖,进行注入
  4. registerBeanDefinition,注册bean定义到beanDefinitionMap属性
  5. preInstantiateSingletons,进行创建bean实例

具体使用操作也是基本类似的

AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();  
beanDefinition.setBeanClass(UserService.class);  
defaultListableBeanFactory.registerBeanDefinition("userService",beanDefinition);  
  
UserService userService1 = (UserService) defaultListableBeanFactory.getBean("userService");  
userService1.test();

从他的结构图也能看出来:

image

AbstractBeanFactory

该类是抽象bean,介绍他主要目的就是getbean时,走的主要逻辑就是该类实现的dogetbean方法(请记住这个重要的方法),所以确实需要关注下,主要方法如下:

  1. doGetBean,获取bean的主要逻辑,没有则创建
  2. getMergedBeanDefinition,bean定义的合并逻辑,主要是将父类beanfactory中的属性被子类覆盖

AbstractAutowireCapableBeanFactory

继承自刚才提到的AbstractBeanFactory,主要方法如下:

  1. autowireByName,按照name注入
  2. autowireByType,根据类型
  3. createBean,创建bean流程,实例化前可以使用BeanPostProcessors后置处理器
  4. createBeanInstance,正在创建bean,这边使用到了之前入门讲过的推断构造器实现实例化
  5. doCreateBean,创建bean,循环依赖、属性填充、初始化
  6. initializeBean,初始化bean,包括初始化前、初始化、初始化后
  7. instantiateUsingFactoryMethod,利用factorymethod初始化bean
  8. invokeAwareMethods,初始化bean时的回调函数Aware接口
  9. populateBean,初始化之前,属性赋值

可以从他的关键方法看出,主要作用就是初始化bean的全过程,也是很重要的类

HierarchicalBeanFactory

这里说下HierarchicalBeanFactory类,他只是一个接口类,但是如果想要使用beanfactory的层次结构,例如获取父beanfactory,那就必须实现HierarchicalBeanFactory类,比如前面说的bean定义的合并逻辑,就需要获取父beanfactory,从而实现父子bean定义的覆盖合并

ApplicationContext

ApplicationContext是个接口,实际上也是一个BeanFactory,不过比BeanFactory
更加强大,它本身并没有太多方法,但是它继承了很多接口,因为接口之间是可以多继承的。

image

关于他的父接口,这里不做多说明,详情的话请看下子文章(后续更新)。

AnnotationConfigApplicationContext

一看这个类,大家都知道了,我们用的实例全是用这个类去启动我们的spring的,我们看看他的主要方法:

  1. AnnotationConfigApplicationContext,构造器,会初始化DefaultListableBeanFactory、AnnotatedBeanDefinitionReader、ClassPathBeanDefinitionScanner;然后开始调用refresh()方法。
  2. register,会使用编程式定义将bean注入spring容器。就如我们的APPConfig
  3. scan,走ClassPathBeanDefinitionScanner的scan,扫描包路径,将声明式的bean注入进spring容器
  4. setBeanNameGenerator,bean名称生成器

ClassPathXmlApplicationContext

主要就是去解析xml配置的bean定义将其注入到spring容器中,功能其实跟AnnotationConfigApplicationContext类似,但是却没有AnnotationConfigApplicationContext强大,比如不能注册BeanDefinition。

BeanPostProcessor

BeanPostProcess表示Bena的后置处理器,可以有多个BeanPostProcessor,我们自己也可以去定义一个BeanPostProcessor;

@Component
public class MyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        if ("userService".equals(beanName)) {
            System.out.println("userService");
            return new User();
        }
        System.out.println("MyBeanPostProcessor.postProcessBeforeInitialization");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        System.out.println("MyBeanPostProcessor.postProcessAfterInitialization");
        return bean;
    }

我们可以通过实现bean的后置处理器,来对某一个bean或者所有bean的进行干预,博主只是随便写了一个,没有什么太大意义。

BeanFactoryPostProcessor

BeanFactoryPostProcessor表示Bean工厂的后置处理器,其实和BeanPostProcessor类似,BeanPostProcessor是干涉Bean的创建过程,BeanFactoryPostProcessor是干涉BeanFactory的创建过程,我们也可以自定义:

@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("加工beanFactory");
    }
}

FactoryBean

FactoryBean和BeanFactory不是一个东西,大家不要混淆两个概念,BeanFactory是管理我们注入的bean等,而FactoryBean本身也会被Spring管理,一旦Spring知道我们的bean实现了FactoryBean,那么会自动调用getObject方法获取我们自己创建的bean,这个bean完完全全交给我们自己创建了,我们可以这样定义一个FactoryBean:


@Component
public class MyFactoryBean implements FactoryBean {

    @Override
    public Object getObject() throws Exception {
        UserService service = new UserService();
        return service;
    }

    @Override
    public Class<?> getObjectType() {
        return UserService.class;
    }

}

但是需要注意的是,这些注入UserService时,是不会有属性依赖注入的,毕竟他没有走bean的生命创建周期。细心的朋友会发现,这根我在配置类中写@bean形式的类有啥区别,现象来讲,他俩都可以被创建出来,但是值得一提的是,FactoryBean创建出来的bean是没走spring定义的bean生命周期的。

MetadataReader、ClassMetadata、AnnotationMetadata

Spring启动时需要扫描指定包路径下的所有类文件来获取需要注入或管理的Bean信息。然而,并非所有类都是需要的,这时可以使用ASM技术来解析类文件的元数据信息,包括类上的注解信息和类的基本信息。ASM技术可以在运行时动态生成和修改Java字节码,从而高效地解析类文件的元数据信息,避免了大量的IO操作和类加载,提高了应用的性能。以下是一个简单的实例:

        SimpleMetadataReaderFactory simpleMetadataReaderFactory = new SimpleMetadataReaderFactory();
        MetadataReader metadataReader = simpleMetadataReaderFactory.getMetadataReader("com.xiaoyu.service.UserService");
        System.out.println(metadataReader.getClassMetadata().getClassName());
        metadataReader.getAnnotationMetadata().getAnnotationTypes().forEach(System.out::println);

结语

通过本文的解析,我们大致了解了Spring框架中的一些关键组件及其用途,这有助于我们在深入理解Spring源码过程中建立起一个整体框架。Spring源码量很大,要真正理解透彻还需要投入大量时间进行细致学习和总结。但如果先对一些关键组件有一个大致的认识,有助于我们进行针对性学习,避免迷失在繁杂的细节中。希望本文能够对读者有一定的帮助,更希望读者在学习Spring源码的过程中,不断总结和提高,并在一定阶段有所突破。祝读者顺利!
公众号

与Spring源码系列:核心概念解析相似的内容:

Spring源码系列:核心概念解析

Spring框架中有许多关键组件,理解这些组件的作用和关系可以帮助我们更好地阅读和理解Spring源码。BeanDefinition是Spring中重要的概念,定义了一个Bean的基本属性和行为,是Spring容器管理Bean的基础。我们可以通过注解或编程方式定义BeanDefinition,然后将其注册到Spring容器中。BeanDefinitionReader是读取和操作BeanDefini

Spring源码系列(补充):详解ApplicationContext

本文介绍了Spring框架中ApplicationContext的几个核心概念,包括MessageSource、ResourcePatternResolver、获取运行时环境、ApplicationEventPublisher和OrderComparator。对于每个概念,文章都提供了具体的用法示例和注意事项。如果您正在学习或使用Spring框架,本文将为您提供有价值的参考。

Spring源码系列一:入门——Hello World

本文介绍了学习Spring源码前需要掌握的核心知识点,包括IOC、AOP、Bean生命周期、初始化和Transaction事务。通过Hello World示例,讲解了如何使用Spring,并指出了深入了解Spring内部机制的方向。

Spring源码阅读系列--全局目录

> 阅读之前要注意的东西:本文就是主打流水账式的源码阅读,主导的是一个参考,主要内容需要看官自己去源码中验证。全系列文章基于 spring 源码 5.x 版本。 写在开始前的话: 阅读spring 源码实在是一件庞大的工作,不说全部内容,单就最基本核心部分包含的东西就需要很长时间去消化了: - be

Spring入门系列:浅析知识点

本文介绍了学习Spring源码前需要掌握的核心知识点,包括IOC、AOP、Bean生命周期、初始化和Transaction事务。通过Hello World示例,讲解了如何使用Spring,并指出了深入了解Spring内部机制的方向。

《系列二》-- 1、BeanFactory.getBean 总览

[TOC] > 阅读之前要注意的东西:本文就是主打流水账式的源码阅读,主导的是一个参考,主要内容需要看官自己去源码中验证。全系列文章基于 spring 源码 5.x 版本。 写在开始前的话: 阅读spring 源码实在是一件庞大的工作,不说全部内容,单就最基本核心部分包含的东西就需要很长时间去消化了

《系列二》-- 3、FactoryBean 的使用

[TOC] > 阅读之前要注意的东西:本文就是主打流水账式的源码阅读,主导的是一个参考,主要内容需要看官自己去源码中验证。全系列文章基于 spring 源码 5.x 版本。 写在开始前的话: 阅读spring 源码实在是一件庞大的工作,不说全部内容,单就最基本核心部分包含的东西就需要很长时间去消化了

《系列二》-- 2、bean 的作用域: Scope 有哪些

[TOC] > 阅读之前要注意的东西:本文就是主打流水账式的源码阅读,主导的是一个参考,主要内容需要看官自己去源码中验证。全系列文章基于 spring 源码 5.x 版本。 写在开始前的话: 阅读spring 源码实在是一件庞大的工作,不说全部内容,单就最基本核心部分包含的东西就需要很长时间去消化了

《系列二》-- 5、单例bean缓存的获取

[TOC] > 阅读之前要注意的东西:本文就是主打流水账式的源码阅读,主导的是一个参考,主要内容需要看官自己去源码中验证。全系列文章基于 spring 源码 5.x 版本。 写在开始前的话: 阅读spring 源码实在是一件庞大的工作,不说全部内容,单就最基本核心部分包含的东西就需要很长时间去消化了

《系列二》-- 4、循环依赖及其处理方式

[TOC] > 阅读之前要注意的东西:本文就是主打流水账式的源码阅读,主导的是一个参考,主要内容需要看官自己去源码中验证。全系列文章基于 spring 源码 5.x 版本。 写在开始前的话: 阅读spring 源码实在是一件庞大的工作,不说全部内容,单就最基本核心部分包含的东西就需要很长时间去消化了