Spring（四）核心容器 - BeanDefinition 解析

时间  2020-02-05
标签 spring 核心 容器 beandefinition 解析 栏目 Spring 繁體版
原文   原文链接

前言

在上篇文章中，咱们讨论了 refresh 的前四个方法，主要是对 ApplicationContext 上下文启动作一些准备工做。原计划是对接下来的 invokeBeanFactoryPostProcessors 方法进行讨论，但该方法涉及 Spring 中一个很是重要的概念： BeanDefinition，因此，这里先对 BeanDefinition 进行讨论，这样也有利于完善 Spring 的知识体系。java

注：本篇文章使用的 SpringBoot 版本为 2.0.3.RELEASE，其 Spring 版本为 5.0.7.RELEASE

正文

现现在，咱们通常获取对象的方式有两种，一种是手动直接 new；另外一种是交给 Spring 管理，Spring 将管理的对象称之为 Bean，容器会先实例化 Bean，而后自动注入，实例化的过程就须要依赖 BeanDefinition。编程

BeanDefinition 用于保存 Bean 的相关信息，包括属性、构造方法参数、依赖的 Bean 名称及是否单例、延迟加载等，它是实例化 Bean 的原材料，Spring 就是根据 BeanDefinition 中的信息实例化 Bean。缓存

BeanDefinition的继承体系

BeanDefinition 是一个接口，它有多个实现类，这些实现类分别描述不一样类型的 Bean。ide

image

BeanDefinition

一个 BeanDefinition 描述了一个 Bean 实例，实例包含属性值、构造方法参数值以及更多实现信息。该 BeanDefinition 只是是一个最小的接口，主要目的是容许修改属性值和其余 Bean 元数据，这里列出几个核心方法。函数

public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {

    // 单例、原型标识符
    String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON;
    String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE;

    // 标识 Bean 的类别，分别对应 用户定义的 Bean、来源于配置文件的 Bean、Spring 内部的 Bean
    int ROLE_APPLICATION = 0;
    int ROLE_SUPPORT = 1;
    int ROLE_INFRASTRUCTURE = 2;

    // 设置、返回 Bean 的父类名称
    void setParentName(@Nullable String parentName);
    String getParentName();

    // 设置、返回 Bean 的 className
    void setBeanClassName(@Nullable String beanClassName);
    String getBeanClassName();

    // 设置、返回 Bean 的做用域
    void setScope(@Nullable String scope);
    String getScope();

    // 设置、返回 Bean 是否懒加载
    void setLazyInit(boolean lazyInit);
    boolean isLazyInit();
    
    // 设置、返回当前 Bean 所依赖的其它 Bean 名称。
    void setDependsOn(@Nullable String... dependsOn);
    String[] getDependsOn();
    
    // 设置、返回 Bean 是否能够自动注入。只对 @Autowired 注解有效
    void setAutowireCandidate(boolean autowireCandidate);
    boolean isAutowireCandidate();
    
    // 设置、返回当前 Bean 是否为主要候选 Bean 。
    // 当同一个接口有多个实现类时，经过该属性来配置某个 Bean 为主候选 Bean。
    void setPrimary(boolean primary);
    boolean isPrimary();

    // 设置、返回建立该 Bean 的工厂类。
    void setFactoryBeanName(@Nullable String factoryBeanName);
    String getFactoryBeanName();
    
    // 设置、返回建立该 Bean 的工厂方法
    void setFactoryMethodName(@Nullable String factoryMethodName);
    String getFactoryMethodName();
    
    // 返回该 Bean 构造方法参数值、全部属性
    ConstructorArgumentValues getConstructorArgumentValues();
    MutablePropertyValues getPropertyValues();

    // 返回该 Bean 是不是单例、是不是非单例、是不是抽象的
    boolean isSingleton();
    boolean isPrototype();
    boolean isAbstract();

    // 返回 Bean 的类别。类别对应上面的三个属性值。
    int getRole();

    ...
}

能够看到 BeanDefinition 接口提供了一系列操做 Bean 元数据的set、get方法，这些操做为 Bean 的描述定义了一套模板，具体的实现则交由子类。post

AnnotatedBeanDefinition

AnnotatedBeanDefinition 是 BeanDefinition 子接口之一，该接口扩展了 BeanDefinition 的功能，其用来操做注解元数据。通常状况下，经过注解方式获得的 Bean（@Component、@Bean），其 BeanDefinition 类型都是该接口的实现类。spa

public interface AnnotatedBeanDefinition extends BeanDefinition {

    // 得到当前 Bean 的注解元数据
    AnnotationMetadata getMetadata();

    // 得到当前 Bean 的工厂方法上的元数据
    MethodMetadata getFactoryMethodMetadata();
}

该接口能够返回两个元数据的类：代理

  • AnnotationMetadata：主要对 Bean 的注解信息进行操做，如：获取当前 Bean 标注的全部注解、判断是否包含指定注解。
  • MethodMetadata：方法的元数据类。提供获取方法名称、此方法所属类的全类名、是不是抽象方法、判断是不是静态方法、判断是不是final方法等。

AbstractBeanDefinition

AbstractBeanDefinition 是 BeanDefinition 的子抽象类，也是其余 BeanDefinition 类型的基类，其实现了接口中定义的一系列操做方法，并定义了一系列的常量属性，这些常量会直接影响到 Spring 实例化 Bean 时的策略。核心属性以下。code

public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor
        implements BeanDefinition, Cloneable {

    // 默认的 SCOPE，默认是单例
    public static final String SCOPE_DEFAULT = "";

    // 不进行自动装配
    public static final int AUTOWIRE_NO = AutowireCapableBeanFactory.AUTOWIRE_NO;
    // 根据 Bean 的名字进行自动装配，byName
    public static final int AUTOWIRE_BY_NAME = AutowireCapableBeanFactory.AUTOWIRE_BY_NAME;
    // 根据 Bean 的类型进行自动装配，byType
    public static final int AUTOWIRE_BY_TYPE = AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE;
    // 根据构造器进行自动装配
    public static final int AUTOWIRE_CONSTRUCTOR = AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR;
    // 首先尝试按构造器自动装配。若是失败，再尝试使用 byType 进行自动装配。（Spring 3.0 以后已废除）
    public static final int AUTOWIRE_AUTODETECT = AutowireCapableBeanFactory.AUTOWIRE_AUTODETECT;

    // 经过依赖检查来查看 Bean 的每一个属性是否都设置完成
    // 如下常量分别对应：不检查、对依赖对象检查、对基本类型，字符串和集合进行检查、对所有属性进行检查
    public static final int DEPENDENCY_CHECK_NONE = 0;
    public static final int DEPENDENCY_CHECK_OBJECTS = 1;
    public static final int DEPENDENCY_CHECK_SIMPLE = 2;
    public static final int DEPENDENCY_CHECK_ALL = 3;

    // 关闭应用上下文时需调用的方法名称
    public static final String INFER_METHOD = "(inferred)";

    // 存放 Bean 的 Class 对象
    private volatile Object beanClass;

    // Bean 的做用范围
    private String scope = SCOPE_DEFAULT;

    // 非抽象
    private boolean abstractFlag = false;
    // 非延迟加载
    private boolean lazyInit = false;
    // 默认不自动装配
    private int autowireMode = AUTOWIRE_NO;
    // 默认不依赖检查
    private int dependencyCheck = DEPENDENCY_CHECK_NONE;

    // 依赖的 Bean 列表
    private String[] dependsOn;

    // 能够做为自动装配的候选者，意味着能够自动装配到其余 Bean 的某个属性中
    private boolean autowireCandidate = true;
    
    // 建立当前 Bean 实例工厂类名称
    private String factoryBeanName;
    // 建立当前 Bean 实例工厂类中方法名称
    private String factoryMethodName;

    // 存储构造方法的参数
    private ConstructorArgumentValues constructorArgumentValues;
    // 存储 Bean 属性名称以及对应的值
    private MutablePropertyValues propertyValues;
    // 存储被覆盖的方法信息
    private MethodOverrides methodOverrides;

    // init、destroy 方法名称
    private String initMethodName;
    private String destroyMethodName;

    // 是否执行 init 和 destroy 方法
    private boolean enforceInitMethod = true;
    private boolean enforceDestroyMethod = true;

    // Bean 是不是用户定义的而不是应用程序自己定义的
    private boolean synthetic = false;

    // Bean 的身份类别，默认是用户定义的 Bean
    private int role = BeanDefinition.ROLE_APPLICATION;

    // Bean 的描述信息
    private String description;

    // Bean 定义的资源
    private Resource resource;
    
    ...
}

以上是 AbstractBeanDefinition 中定义的一些常量和属性，该类中还有一部分是操做这些属性的 set 和 get 方法，这些方法都由子类来操做，且应用程序中真正使用的也是这些子类 BeanDefinition。对象

先来看 AbstractBeanDefinition 直接实现类：RootBeanDefinition、GenericBeanDefinition、ChildBeanDefinition。

RootBeanDefinition

该类继承自 AbstractBeanDefinition，它能够单独做为一个 BeanDefinition，也能够做为其余 BeanDefinition 的父类。

RootBeanDefinition 在 AbstractBeanDefinition 的基础上定义了更多属性。

public class RootBeanDefinition extends AbstractBeanDefinition {

    // BeanDefinitionHolder 存储 Bean 的名称、别名、BeanDefinition
    private BeanDefinitionHolder decoratedDefinition;

    // AnnotatedElement 是java反射包的接口，经过它能够查看 Bean 的注解信息
    private AnnotatedElement qualifiedElement;

    // 容许缓存
    boolean allowCaching = true;
    
    // 工厂方法是否惟一
    boolean isFactoryMethodUnique = false;

    // 封装了 java.lang.reflect.Type，提供了泛型相关的操做
    volatile ResolvableType targetType;

    // 缓存 Class，表示 RootBeanDefinition 存储哪一个类的信息
    volatile Class<?> resolvedTargetType;

    // 缓存工厂方法的返回类型
    volatile ResolvableType factoryMethodReturnType;

    // 这是如下四个构造方法字段的通用锁
    final Object constructorArgumentLock = new Object();
    // 用于缓存已解析的构造方法或工厂方法
    Executable resolvedConstructorOrFactoryMethod;
    // 将构造方法参数标记为已解析
    boolean constructorArgumentsResolved = false;
    // 用于缓存彻底解析的构造方法参数
    Object[] resolvedConstructorArguments;
    // 缓存待解析的构造方法参数
    Object[] preparedConstructorArguments;

    // 这是如下两个后处理字段的通用锁
    final Object postProcessingLock = new Object();
    // 代表是否被 MergedBeanDefinitionPostProcessor 处理过
    boolean postProcessed = false;
    // 在生成代理的时候会使用，代表是否已经生成代理
    volatile Boolean beforeInstantiationResolved;

    // 实际缓存的类型是 Constructor、Field、Method 类型
    private Set<Member> externallyManagedConfigMembers;

    // InitializingBean中 的 init 回调函数名 afterPropertiesSet 会在这里记录，以便进行生命周期回调
    private Set<String> externallyManagedInitMethods;

    // DisposableBean 的 destroy 回调函数名 destroy 会在这里记录，以便进生命周期回调
    private Set<String> externallyManagedDestroyMethods;

    ...
}

ChildBeanDefinition

该类继承自 AbstractBeanDefinition。其至关于一个子类，不能够单独存在，必须依赖一个父 BeanDetintion，构造 ChildBeanDefinition 时，经过构造方法传入父 BeanDetintion 的名称或经过 setParentName 设置父名称。它能够从父类继承方法参数、属性值，并能够重写父类的方法，同时也能够增长新的属性或者方法。若从新定义 init 方法，destroy 方法或者静态工厂方法，ChildBeanDefinition 会重写父类的设置。

从 Spring 2.5 开始，以编程方式注册 Bean 定义的首选方法是 GenericBeanDefinition，GenericBeanDefinition 能够有效替代 ChildBeanDefinition 的绝大分部使用场合。

GenericBeanDefinition

GenericBeanDefinition 是 Spring 2.5 之后新引入的 BeanDefinition，是 ChildBeanDefinition 更好的替代者，它一样能够经过 setParentName 方法设置父 BeanDefinition。

最后三个 BeanDefinition 既实现了 AnnotatedBeanDefinition 接口，又间接继承 AbstractBeanDefinition 抽象类，这些 BeanDefinition 描述的都是注解形式的 Bean。

ConfigurationClassBeanDefinition

该类继承自 RootBeanDefinition ，并实现了 AnnotatedBeanDefinition 接口。这个 BeanDefinition 用来描述在标注 @Configuration 注解的类中，经过 @Bean 注解实例化的 Bean。

其功能特色以下：

一、若是 @Bean 注解没有指定 Bean 的名字，默认会用方法的名字命名 Bean。

二、标注 @Configuration 注解的类会成为一个工厂类，而标注 @Bean 注解的方法会成为工厂方法，经过工厂方法实例化 Bean，而不是直接经过构造方法初始化。

三、标注 @Bean 注解的类会使用构造方法自动装配

AnnotatedGenericBeanDefinition

该类继承自 GenericBeanDefinition ，并实现了 AnnotatedBeanDefinition 接口。这个 BeanDefinition 用来描述标注 @Configuration 注解的 Bean。

ScannedGenericBeanDefinition

该类继承自 GenericBeanDefinition ，并实现了 AnnotatedBeanDefinition 接口。
这个 BeanDefinition 用来描述标注 @Component 注解的 Bean，其派生注解如 @Service、@Controller 也同理。

总结

最后，咱们来作个总结。BeanDefinition 主要是用来描述 Bean，其存储了 Bean 的相关信息，Spring 实例化 Bean 时需读取该 Bean 对应的 BeanDefinition。BeanDefinition 总体能够分为两类，一类是描述通用的 Bean，还有一类是描述注解形式的 Bean。通常前者在 XML 时期定义 <bean> 标签以及在 Spring 内部使用较多，而现今咱们大都使用后者，经过注解形式加载 Bean。

以上就是本章内容，若是文章中有错误或者须要补充的请及时提出，本人感激涕零。

参考：
http://cmsblogs.com/?p=11731
https://cloud.tencent.com/dev...

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程