Spring源码学习-RootBeanDefinition

前言：看完了Spring BeanDefinition与AbstractBeanDefinition后，现在开始学习RootBeanDefinition

简介

类图

RootBeanDefinition继承AbstractBeanDefinition抽象类。

一个RootBeanDefinition定义表明它是一个可合并的bean definition：即在spring beanFactory运行期间，可以返回一个特定的bean。RootBeanDefinition可以作为一个重要的通用的bean definition 视图。

RootBeanDefinition用来在配置阶段进行注册bean definition。然后，从spring 2.5后，编写注册bean definition有了更好的的方法：GenericBeanDefinition。GenericBeanDefinition支持动态定义父类依 赖，而非硬编码作为root bean definition。其中RootBeanDefinition是最常用的实现类，它对应一般性的元素标签

在 配置文件中可以定义父和子，父用RootBeanDefinition表示， 而子用ChildBeanDefiniton表示，而没有父的就使用 RootBeanDefinition表示。

方法

字段

字段

下面是我对该类字段的理解

/** 允许缓存 */
boolean allowCaching = true;

/** 在生成代理的时候会使用，表明是否已经生成代理 */
volatile Boolean beforeInstantiationResolved;

/** resolvedConstructorOrFactoryMethod、constructorArgumentsResolved、resolvedConstructorArguments、preparedConstructorArguments 4个参数的锁 */
final Object constructorArgumentLock = new Object();

/** 表明构造函数参数是否解析完毕*/
boolean constructorArgumentsResolved = false;

/** BeanDefinitionHolder实例，储存beanDefinition和bean的名称、别名 */
private BeanDefinitionHolder decoratedDefinition;

/** 以下三个属性是外部管理的方法集合，配置、初始化、銷毀 */

/** 记录Member接口，Member接口用来表示“类”中的一个成员(字段或方法)或构造函数。 */
private Set<Member> externallyManagedConfigMembers;

/** 记录执行过的Destroy方法，以便进行生命周期回调 */
private Set<String> externallyManagedDestroyMethods;

/** 记录执行过的Init方法名，以便进行生命周期回调 */
private Set<String> externallyManagedInitMethods;

/** 工厂方法返回类型 */
volatile ResolvableType factoryMethodReturnType;

/** 工厂方法是否唯一 */
boolean isFactoryMethodUnique = false;

/** 表示是否被MergedBeanDefinitionPostProcessor处理过*/
boolean postProcessed = false;

/** postProcessed、beforeInstantiationResolved这两个变量的锁 */
final Object postProcessingLock = new Object();

/** 缓存构造函数参数 */
Object[] preparedConstructorArguments;

/**  AnnotatedElement实例字段，储存bean注解信息 */
private AnnotatedElement qualifiedElement;

/** 缓存完全解析的构造函数参数 */
Object[] resolvedConstructorArguments;

/** 缓存已经解析的构造函数或是工厂方法 */
Object resolvedConstructorOrFactoryMethod;

/** 缓存class数据，用于表示RootBeanDefinition存储的是哪个类的信息*/
volatile Class<?> resolvedTargetType;

/** 目标类型，涉及泛型 */
volatile ResolvableType targetType;

构造方法

// 创建一个新的RootBeanDefinition，通过它的bean进行配置属性和配置方法
public RootBeanDefinition() {
    // 调用父类AbstractBeanDefinition构造方法
	super();
}

// 通过给定的beanDefinition创建RootBeanDefinitio
RootBeanDefinition(BeanDefinition original) {
	super(original);
}

// 以单例创建RootBeanDefinitio，给定bean的class对象
public RootBeanDefinition(Class<?> beanClass) {
	super();
	setBeanClass(beanClass);
}

// 以单例创建RootBeanDefinitio,提供构造函数参数和属性值
public RootBeanDefinition(Class<?> beanClass, ConstructorArgumentValues cargs, MutablePropertyValues pvs) {
    super(cargs, pvs);
    setBeanClass(beanClass);
}

// 以单例创建RootBeanDefinitio,采用自动连线方式
public RootBeanDefinition(Class<?> beanClass, int autowireMode, boolean dependencyCheck) {
    super();
    setBeanClass(beanClass);
    setAutowireMode(autowireMode);
    if (dependencyCheck && getResolvedAutowireMode() != AUTOWIRE_CONSTRUCTOR) {
    	setDependencyCheck(DEPENDENCY_CHECK_OBJECTS);
    }
}

// 通过给定的RootBeanDefinition创建RootBeanDefinitio
public RootBeanDefinition(RootBeanDefinition original) {
    super(original);
    this.decoratedDefinition = original.decoratedDefinition;
    this.qualifiedElement = original.qualifiedElement;
    this.allowCaching = original.allowCaching;
    this.isFactoryMethodUnique = original.isFactoryMethodUnique;
    this.targetType = original.targetType;
}

// 以单例创建RootBeanDefinitio,提供bean的className
public RootBeanDefinition(String beanClassName) {
    setBeanClassName(beanClassName);
}

// 以单例创建RootBeanDefinitio,提供bean的className、构造函数参数和属性值
public RootBeanDefinition(String beanClassName, ConstructorArgumentValues cargs, MutablePropertyValues pvs) {
    super(cargs, pvs);
    setBeanClassName(beanClassName);
}

cloneBeanDefinition

深拷贝一个RootBeanDefinition

@Override
public RootBeanDefinition cloneBeanDefinition() {
	return new RootBeanDefinition(this);
}

equals方法

重写equals方法

@Override
public boolean equals(Object other) {
	return (this == other || (other instanceof RootBeanDefinition && super.equals(other)));
}

get方法

/**
 * 获取BeanDefinitionHolder decoratedDefinition，该字段储存beanDefinition和bean的名称、别名
 */
public BeanDefinitionHolder getDecoratedDefinition() {
	return this.decoratedDefinition;
}

/**
 * RootBeanDefinition一般作为父Bean，所以其parent为null
 */
public String getParentName() {
	return null;
}

/**
 * 返回注解信息
 */
public AnnotatedElement getQualifiedElement() {
	return this.qualifiedElement;
}

/**
 * 返回解析的工厂方法
 */
public Method getResolvedFactoryMethod() {
	synchronized (this.constructorArgumentLock) {
		Object candidate = this.resolvedConstructorOrFactoryMethod;
		return (candidate instanceof Method ? (Method) candidate : null);
	}
}

/**
 * 返回解析类型
 */
public Class<?> getTargetType() {
	if (this.resolvedTargetType != null) {
		return this.resolvedTargetType;
	}
	return (this.targetType != null ? this.targetType.resolve() : null);
}

is方法

/**
 * 判断传入的member是否是在Bean定义的externallyManagedConfigMembers中
 */
public boolean isExternallyManagedConfigMember(Member configMember) {
	synchronized (this.postProcessingLock) {
		return (this.externallyManagedConfigMembers != null &&
				this.externallyManagedConfigMembers.contains(configMember));
	}
}

/**
 * 判断传入的销毁方法是否是在Bean定义的externallyManagedDestroyMethods中
 */
public boolean isExternallyManagedDestroyMethod(String destroyMethod) {
    synchronized (this.postProcessingLock) {
    	return (this.externallyManagedDestroyMethods != null &&
    			this.externallyManagedDestroyMethods.contains(destroyMethod));
    }
}

/**
 * 判断传入的初始化方法是否是在Bean定义的externallyManagedInitMethods中
 */
public boolean isExternallyManagedInitMethod(String initMethod) {
    synchronized (this.postProcessingLock) {
    	return (this.externallyManagedInitMethods != null &&
    			this.externallyManagedInitMethods.contains(initMethod));
    }
}

/**
 * 判断传入的Method是否是工厂方法
 */
public boolean isFactoryMethod(Method candidate) {
	return (candidate != null && candidate.getName().equals(getFactoryMethodName()));
}

registerExternallyManaged方法

/**
 * 注册方法，将传入的Member添加到externallyManagedConfigMembers集合
 */
public void registerExternallyManagedConfigMember(Member configMember) {
	synchronized (this.postProcessingLock) {
		if (this.externallyManagedConfigMembers == null) {
			this.externallyManagedConfigMembers = new HashSet<Member>(1);
		}
		this.externallyManagedConfigMembers.add(configMember);
	}
}

/**
 * 注册销毁方法，将传入的Member添加到externallyManagedDestroyMethods集合
 */
public void registerExternallyManagedDestroyMethod(String destroyMethod) {
    synchronized (this.postProcessingLock) {
    	if (this.externallyManagedDestroyMethods == null) {
    		this.externallyManagedDestroyMethods = new HashSet<String>(1);
    	}
    	this.externallyManagedDestroyMethods.add(destroyMethod);
    }   
}

/**
 * 注册初始化方法，将传入的Member添加到externallyManagedDestroyMethods集合
 */	
public void registerExternallyManagedInitMethod(String initMethod) {
    synchronized (this.postProcessingLock) {
    	if (this.externallyManagedInitMethods == null) {
    		this.externallyManagedInitMethods = new HashSet<String>(1);
    	}
    	this.externallyManagedDestroyMethods.add(initMethod);
    }
}

set方法

/**
 * 设置bean，储存beanDefinition和bean的名称、别名
 */
public void setDecoratedDefinition(BeanDefinitionHolder decoratedDefinition) {
	this.decoratedDefinition = decoratedDefinition;
}

/**
 * RootBeanDefinition不能作为child bean，传入参数不为null就会抛出异常……
 */
public void setParentName(String parentName) {
	if (parentName != null) {
		throw new IllegalArgumentException("Root bean cannot be changed into a child bean with parent reference");
	}
}

/**
 * 设置注解
 */
public void setQualifiedElement(AnnotatedElement qualifiedElement) {
	this.qualifiedElement = qualifiedElement;
}

/**
 * 设置bean class类型
 */
public void setTargetType(Class<?> targetType) {
	this.targetType = (targetType != null ? ResolvableType.forClass(targetType) : null);
}

/**
 * 设置bean 泛型
 */
public void setTargetType(ResolvableType targetType) {
	this.targetType = targetType;
}

/**
 * 指定非重载的工厂方法
 */
public void setUniqueFactoryMethodName(String name) {
	Assert.hasText(name, "Factory method name must not be empty");
	setFactoryMethodName(name);
	this.isFactoryMethodUnique = true;
}

总结一下，RootBeanDefiniiton保存了以下信息：

• 定义了id、别名与Bean的对应关系（BeanDefinitionHolder）
• Bean的注解（AnnotatedElement）
• 具体的工厂方法（Class类型），包括工厂方法的返回类型，工厂方法的Method对象
• 构造函数、构造函数形参类型
• Bean的class对象

RootBeanDefinition对AbstractBeanDefinition抽象类进一步补全，在其基础上定义了更多属性，初始化Bean需要的信息基本完善

参考

【小家Spring】Spring IoC容器中核心定义之——BeanDefinition深入分析（RootBeanDefinition、ChildBeanDefinition…）