Spring源码阅读：BeanDefinition的实现类

发表于 分类于 Waline： 阅读次数：

BeanDefinition 用来描述 spring bean，是一个接口，它的具体实现类主要有 RootBeanDefinition、ChildBeanDefinition、GenericBeanDefinition 等，分别适用于不同的场景。

对于一个接口多个实现类来说，通常会有一些可以共用的部分，这些代码就可以提取到一个抽象的基础类里面，实现代码的复用。

BeanDefinition 接口的抽象基础类是 AbstractBeanDefinition，下面来看下它都实现了哪些功能

AbstractBeanDefinition

AbstractBeanDefinition 的类继承结构如下图所示：

image-20200119003147713

AbstractBeanDefinition 并没有从零开始，它继承了 BeanMetadataAttributeAccessor 类，从而可以利用已有的功能对 bean 的 meta 数据进行管理。

1
2
public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor
		implements BeanDefinition, Cloneable

AbstractBeanDefinition 的常量定义

AbstractBeanDefinition 定义了一些常量，主要是 autowire 和 依赖检查，具体见下面的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/**
 * 默认的 scope，等价于 singleton
 */
public static final String SCOPE_DEFAULT = "";

/**
 * Autowire
 */
public static final int AUTOWIRE_NO = AutowireCapableBeanFactory.AUTOWIRE_NO;
public static final int AUTOWIRE_BY_NAME = AutowireCapableBeanFactory.AUTOWIRE_BY_NAME;
public static final int AUTOWIRE_BY_TYPE = AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE;
public static final int AUTOWIRE_CONSTRUCTOR = AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR;
public static final int AUTOWIRE_AUTODETECT = AutowireCapableBeanFactory.AUTOWIRE_AUTODETECT;

/**
 * 依赖检查
 */
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;

/**
 * 是否要推断 destroy 方法，比如在 destroy 时调用 close 方法或 shutdown 方法
 */
public static final String INFER_METHOD = "(inferred)";

AbstractBeanDefinition 对象的属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
// 对应的 beanClass
private volatile Object beanClass;
// scope
private String scope = SCOPE_DEFAULT;
// 是否为抽象类
private boolean abstractFlag = false;
// 是否延迟初始化
private boolean lazyInit = false;
// autowire 模式
private int autowireMode = AUTOWIRE_NO;
// 依赖检查配置
private int dependencyCheck = DEPENDENCY_CHECK_NONE;
// 依赖的类的名字
private String[] dependsOn;
// 是否为 autowire 候选
private boolean autowireCandidate = true;
// 是否为 autowire 的首选 bean
private boolean primary = false;
// 用于解析 autowire，key 为类型名
private final Map<String, AutowireCandidateQualifier> qualifiers = new LinkedHashMap<>();
// 用于构建 bean 实例的 Supplier
private Supplier<?> instanceSupplier;
// public 访问权限
private boolean nonPublicAccessAllowed = true;
// 构造器解析宽松模式
private boolean lenientConstructorResolution = true;
// factoryBean 的名字
private String factoryBeanName;
// 工厂方法的名字
private String factoryMethodName;
// 构造器参数值
private ConstructorArgumentValues constructorArgumentValues;
// bean 的属性值
private MutablePropertyValues propertyValues;
// override 方法数据
private MethodOverrides methodOverrides;
// 初始化方法名
private String initMethodName;
// 销毁方法名
private String destroyMethodName;
// 是否强制调用初始化方法
private boolean enforceInitMethod = true;
// 是否强制调用销毁方法
private boolean enforceDestroyMethod = true;
// 是否为用户创建的 bean
private boolean synthetic = false;
// role
private int role = BeanDefinition.ROLE_APPLICATION;
// bean 的描述
private String description;
// bean 的 resource 来源
private Resource resource;

AbstractBeanDefinition 对象的方法

AbstractBeanDefinition 对象的方法与属性值对应，基本都很容易理解

getBeanClassName

获取 bean class 的名字，需要先检测下 beanClass 属性的类型，然后决定如何处理。

1
2
3
4
5
6
7
8
9
10
11
12
public String getBeanClassName() {
  // 根据 beanClass 属性获取
  Object beanClassObject = this.beanClass;
  // 类型为 Class，直接取它的名字
  if (beanClassObject instanceof Class) {
    return ((Class<?>) beanClassObject).getName();
  }
  // 否则强转为 String 类型
  else {
    return (String) beanClassObject;
  }
}

resolveBeanClass

解析 bean class。先拿到类名，然后通过反射获取 class，当然这里是 ClassUtils 来解析，中间会使用缓存提高性能。

1
2
3
4
5
6
7
8
9
10
11
public Class<?> resolveBeanClass(@Nullable ClassLoader classLoader) throws ClassNotFoundException {
  // 先拿到类名
  String className = getBeanClassName();
  if (className == null) {
    return null;
  }
  // 通过工具类解析为 class
  Class<?> resolvedClass = ClassUtils.forName(className, classLoader);
  this.beanClass = resolvedClass;
  return resolvedClass;
}

deep copy

深度拷贝时需要新创建一个 BeanDefinition，然后将原始的 BeanDefinition 的各个属性值全部复制过来，这在生成 MergedBeanDefinition 时会用到

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
protected AbstractBeanDefinition(BeanDefinition original) {
	setParentName(original.getParentName());
	setBeanClassName(original.getBeanClassName());
	setScope(original.getScope());
	setAbstract(original.isAbstract());
	setLazyInit(original.isLazyInit());
	setFactoryBeanName(original.getFactoryBeanName());
	setFactoryMethodName(original.getFactoryMethodName());
	setRole(original.getRole());
	setSource(original.getSource());
	copyAttributesFrom(original);

	if (original instanceof AbstractBeanDefinition) {
		AbstractBeanDefinition originalAbd = (AbstractBeanDefinition) original;
		if (originalAbd.hasBeanClass()) {
			setBeanClass(originalAbd.getBeanClass());
		}
		if (originalAbd.hasConstructorArgumentValues()) {
			setConstructorArgumentValues(new ConstructorArgumentValues(original.getConstructorArgumentValues()));
		}
		if (originalAbd.hasPropertyValues()) {
			setPropertyValues(new MutablePropertyValues(original.getPropertyValues()));
		}
		if (originalAbd.hasMethodOverrides()) {
			setMethodOverrides(new MethodOverrides(originalAbd.getMethodOverrides()));
		}
		setAutowireMode(originalAbd.getAutowireMode());
		setDependencyCheck(originalAbd.getDependencyCheck());
		setDependsOn(originalAbd.getDependsOn());
		setAutowireCandidate(originalAbd.isAutowireCandidate());
		setPrimary(originalAbd.isPrimary());
		copyQualifiersFrom(originalAbd);
		setInstanceSupplier(originalAbd.getInstanceSupplier());
		setNonPublicAccessAllowed(originalAbd.isNonPublicAccessAllowed());
		setLenientConstructorResolution(originalAbd.isLenientConstructorResolution());
		setInitMethodName(originalAbd.getInitMethodName());
		setEnforceInitMethod(originalAbd.isEnforceInitMethod());
		setDestroyMethodName(originalAbd.getDestroyMethodName());
		setEnforceDestroyMethod(originalAbd.isEnforceDestroyMethod());
		setSynthetic(originalAbd.isSynthetic());
		setResource(originalAbd.getResource());
	} else {
		setConstructorArgumentValues(new ConstructorArgumentValues(original.getConstructorArgumentValues()));
		setPropertyValues(new MutablePropertyValues(original.getPropertyValues()));
		setResourceDescription(original.getResourceDescription());
	}
}

RootBeanDefinition

RootBeanDefinition 用于在 Spring BeanFactory 运行时表示合并的 bean definition，它可能是由多个存在继承关系的 bean definition 合并得到的，本质上 RootBeanDefinition 是 bean definition 在运行时的统一视图。

RootBeanDefinition 继承自 AbstractBeanDefinition，它也提供了很多属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
private BeanDefinitionHolder decoratedDefinition;

private AnnotatedElement qualifiedElement;

boolean allowCaching = true;

boolean isFactoryMethodUnique = false;

volatile ResolvableType targetType;

/** 从 bean definition 解析出的 bean 的 class 类型 **/
volatile Class<?> resolvedTargetType;

/** 用于缓存一般类型工厂方法的返回类型 */
volatile ResolvableType factoryMethodReturnType;

/** 用于缓存一个位于的工厂方法，作为 introspection 的候选 */
volatile Method factoryMethodToIntrospect;

/** 一个公共的锁对象，操作下面四个构造函数相关的属性时会用到 */
final Object constructorArgumentLock = new Object();

/** 缓存的构造器或工厂方法 **/
Executable resolvedConstructorOrFactoryMethod;

/** 构造函数是否解析过的标志 */
boolean constructorArgumentsResolved = false;

/** 解析出来的构造函数参数 */
Object[] resolvedConstructorArguments;

/** 用于缓存部分已经准备好的构造函数参数 */
Object[] preparedConstructorArguments;

/** 一个公共的锁对象，操作下面两个属性时会用到 */
final Object postProcessingLock = new Object();

/** 当前 bean 是否被 MergedBeanDefinitionPostProcessor 处理过 **/
boolean postProcessed = false;

/** before-instantiation 后处理器是否处理过的标志 */
volatile Boolean beforeInstantiationResolved;

/** 外部管理的配置成员（可以是 field、method 或者 constructor） **/
private Set<Member> externallyManagedConfigMembers;

/** 外部管理的 init 方法 **/
private Set<String> externallyManagedInitMethods;

/** 外部管理的 destroy 方法 **/
private Set<String> externallyManagedDestroyMethods;

ChildBeanDefinition

ChildBeanDefinition 用于表示继承关系的 bean definition，它从父 bean definition 继承配置信息，例如构造函数参数值、属性值和方法重写（method overrides），并可选择添加新值。如果指定了 init 方法、destroy 方法或静态工厂方法，它们将覆盖相应的父 bean definition 设置。其余的设置将始终从子 definition 中获取：depends on、autowire 模式、dependency check、singleton、lazy init

GenericBeanDefinition

GenericBeanDefinition 是用于标准 bean definition 的一站式服务，与其他类型的 bean definition 一样，它允许指定一个类加上可选的构造函数参数值和属性值。此外，bean definition 继承关系可以通过 parentName 属性灵活地配置。

通常情况下，可以使用 GenericBeanDefinition 来注册用户自定义的 bean definition（后处理器可以对其进行操作，甚至可以重新配置 parentName）

相关文章
  • 2020-01-14
    Spring源码阅读：BeanDefinitionRegistry接口

    BeanDefinitionRegistry 是一个接口，从名字上就可以看出来，它是一个管理 BeanDefinition 的注册中心。通常情况下，BeanFactory 的具体实现类也会实现该接口，用于管理 AbstractBeanDefinition 继承结构下的 BeanDefinition 实例，例如 RootBeanDefinition 和 ChildBeanDefinition 实例。

  • 2020-01-17
    Spring源码阅读：BeanDefinition接口

    前面说到 BeanDefinitionRegistry 是用来管理 BeanDefinition 的注册中心，但是还没看到 BeanDefinition 长什么样，下面就来了解下。

  • 2020-04-05
    Spring的MergedBeanDefinition后处理器

    MergedBeanDefinitionPostProcessor 是 Spring 提供的一种后处理器，它可以用于对 merged bean 进行一些操作。

  • 2020-01-22
    Spring源码阅读：XmlBeanFactory的继承结构

    XmlBeanFactory 可以说是 Spring 中一个最简单的 BeanFactory，通过它可以了解 Spring 的设计思路。

  • 2020-03-31
    Spring Bean的创建过程

    当调用 BeanFactory.getBean 方法获取 Bean 时，如果 Bean 还未创建，则会触发 Bean 的创建，本文主要关注 Bean 的创建过程。