一、BeanDefinition体系结构
这个接口描述bean的结构,对应XML中的< bean >或者配置类中的@Bean 它集成了BeanMetadataElement和AttributeAccessor,
二、接口设计
1.AttributeAccessor(定义了最基本的对任意对象的元数据的修改或者获取)
public interface AttributeAccessor {
void setAttribute(String name, Object value);
Object getAttribute(String name);
Object removeAttribute(String name);
String[] attributeNames();
}
2.BeanMetadataElement(获取元数据的配置资源)
public interface BeanMetadataElement {
Object getSource();
}
3.BeanDefinition
public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {
//scope值,单例
String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON;
//scope值,非单例
String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE;
//Bean角色:
//用户
int ROLE_APPLICATION = 0;
//某些复杂的配置
int ROLE_SUPPORT = 1;
//完全内部使用
int ROLE_INFRASTRUCTURE = 2;
//返回此bean定义的父bean定义的名称,如果有的话 <bean parent="">
String getParentName();
void setParentName(String parentName);
//获取bean对象className <bean class="">
String getBeanClassName();
void setBeanClassName(String beanClassName);
//定义创建该Bean对象的工厂l类 <bean factory-bean="">
String getFactoryBeanName();
void setFactoryBeanName(String factoryBeanName);
//定义创建该Bean对象的工厂方法 <bean factory-method="">
String getFactoryMethodName();
void setFactoryMethodName(String factoryMethodName);
//<bean scope="singleton/prototype">
String getScope();
void setScope(String scope);
//懒加载 <bean lazy-init="true/false">
boolean isLazyInit();
void setLazyInit(boolean lazyInit);
//依赖对象 <bean depends-on="">
String[] getDependsOn();
void setDependsOn(String[] dependsOn);
//是否为被自动装配 <bean autowire-candidate="true/false">
boolean isAutowireCandidate();
void setAutowireCandidate(boolean autowireCandidate);
//是否为主候选bean 使用注解:@Primary
boolean isPrimary();
void setPrimary(boolean primary);
//返回此bean的构造函数参数值。
ConstructorArgumentValues getConstructorArgumentValues();
//获取普通属性集合
MutablePropertyValues getPropertyValues();
//是否为单例
boolean isSingleton();
//是否为原型
boolean isPrototype();
//是否为抽象类
boolean isAbstract();
//获取这个bean的应用
int getRole();
//返回对bean定义的可读描述。
String getDescription();
//返回该bean定义来自的资源的描述(用于在出现错误时显示上下文)
String getResourceDescription();
BeanDefinition getOriginatingBeanDefinition();
}
4.AbstractBeanDefinition
bean定义文件中的大部分属性都保存在该类中,代码太多,单独分析
5.GenericBeanDefinition
public class GenericBeanDefinition extends AbstractBeanDefinition {
//父bean名称
private String parentName;
//构造方法
public GenericBeanDefinition() {
super();
}
//构造方法
public GenericBeanDefinition(BeanDefinition original) {
super(original);
}
//设置parentName
public void setParentName(String parentName) {
this.parentName = parentName;
}
public String getParentName() {
return this.parentName;
}
//深度拷贝自身
@Override
public AbstractBeanDefinition cloneBeanDefinition() {
return new GenericBeanDefinition(this);
}
@Override
public boolean equals(Object other) {
return (this == other || (other instanceof GenericBeanDefinition && super.equals(other)));
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder("Generic bean");
if (this.parentName != null) {
sb.append(" with parent '").append(this.parentName).append("'");
}
sb.append(": ").append(super.toString());
return sb.toString();
}
}
GenericBeanDefinition是自2.5以后新加入的bean文件配置属性定义类,是一站式服务类,用于替代ChildBeanDefinition类
6.ChildBeanDefinition
public class ChildBeanDefinition extends AbstractBeanDefinition {
//父bean名称
private String parentName;
//构造方法
public ChildBeanDefinition(String parentName) {
super();
this.parentName = parentName;
}
//构造方法
public ChildBeanDefinition(String parentName, MutablePropertyValues pvs) {
super(null, pvs);
this.parentName = parentName;
}
//构造方法
public ChildBeanDefinition(
String parentName, ConstructorArgumentValues cargs, MutablePropertyValues pvs) {
super(cargs, pvs);
this.parentName = parentName;
}
//构造方法
public ChildBeanDefinition(
String parentName, Class<?> beanClass, ConstructorArgumentValues cargs, MutablePropertyValues pvs) {
super(cargs, pvs);
this.parentName = parentName;
setBeanClass(beanClass);
}
//构造方法
public ChildBeanDefinition(
String parentName, String beanClassName, ConstructorArgumentValues cargs, MutablePropertyValues pvs) {
super(cargs, pvs);
this.parentName = parentName;
setBeanClassName(beanClassName);
}
//构造方法
public ChildBeanDefinition(ChildBeanDefinition original) {
super((BeanDefinition) original);
}
//设置parentName
public void setParentName(String parentName) {
this.parentName = parentName;
}
public String getParentName() {
return this.parentName;
}
//验证当前bean定义
@Override
public void validate() throws BeanDefinitionValidationException {
super.validate();
if (this.parentName == null) {
throw new BeanDefinitionValidationException("'parentName' must be set in ChildBeanDefinition");
}
}
//深度拷贝bean定义
@Override
public AbstractBeanDefinition cloneBeanDefinition() {
return new ChildBeanDefinition(this);
}
@Override
public boolean equals(Object other) {
if (this == other) {
return true;
}
if (!(other instanceof ChildBeanDefinition)) {
return false;
}
ChildBeanDefinition that = (ChildBeanDefinition) other;
return (ObjectUtils.nullSafeEquals(this.parentName, that.parentName) && super.equals(other));
}
@Override
public int hashCode() {
return ObjectUtils.nullSafeHashCode(this.parentName) * 29 + super.hashCode();
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder("Child bean with parent '");
sb.append(this.parentName).append("': ").append(super.toString());
return sb.toString();
}
}
在配置文件中可以定义父和子,父用RootBeanDefinition表示,而子用ChildBeanDefiniton表示,而没有父的就使用RootBeanDefinition表示
7.RootBeanDefinition
public class RootBeanDefinition extends AbstractBeanDefinition {
//默认允许缓存
boolean allowCaching = true;
//bean定义的持有者(修饰bean定义)
private BeanDefinitionHolder decoratedDefinition;
//bean指定的目标类型定义
private volatile Class<?> targetType;
//是否已经指定引用非重载方法的工厂方法名。
boolean isFactoryMethodUnique = false;
//用于构造函数注入属性的锁对象
final Object constructorArgumentLock = new Object();
/** Package-visible field for caching the resolved constructor or factory method */
//缓存已解析的构造函数或工厂方法
Object resolvedConstructorOrFactoryMethod;
/** Package-visible field that marks the constructor arguments as resolved */
//将构造函数参数标记为已解析。
boolean constructorArgumentsResolved = false;
/** Package-visible field for caching fully resolved constructor arguments */
//缓存完全解析的构造函数参数
Object[] resolvedConstructorArguments;
/** Package-visible field for caching partly prepared constructor arguments */
//缓存部分准备好的构造函数参数
Object[] preparedConstructorArguments;
//后处理锁对象
final Object postProcessingLock = new Object();
/** Package-visible field that indicates MergedBeanDefinitionPostProcessor having been applied */
//表明已应用mergedbeandefinitionpostprocessor
boolean postProcessed = false;
/** Package-visible field that indicates a before-instantiation post-processor having kicked in */
//指示已启动的一个实例化之前的后置处理器。
volatile Boolean beforeInstantiationResolved;
//1.
private Set<Member> externallyManagedConfigMembers;
//2.
private Set<String> externallyManagedInitMethods;
//3.
private Set<String> externallyManagedDestroyMethods;
//构造方法
public RootBeanDefinition() {
super();
}
//构造方法
public RootBeanDefinition(Class<?> beanClass) {
super();
setBeanClass(beanClass);
}
//构造方法
@Deprecated
public RootBeanDefinition(Class beanClass, boolean singleton) {
super();
setBeanClass(beanClass);
setSingleton(singleton);
}
//构造方法
@Deprecated
public RootBeanDefinition(Class beanClass, int autowireMode) {
super();
setBeanClass(beanClass);
setAutowireMode(autowireMode);
}
//构造方法
public RootBeanDefinition(Class<?> beanClass, int autowireMode, boolean dependencyCheck) {
super();
setBeanClass(beanClass);
setAutowireMode(autowireMode);
if (dependencyCheck && getResolvedAutowireMode() != AUTOWIRE_CONSTRUCTOR) {
setDependencyCheck(RootBeanDefinition.DEPENDENCY_CHECK_OBJECTS);
}
}
//构造方法
@Deprecated
public RootBeanDefinition(Class beanClass, MutablePropertyValues pvs) {
super(null, pvs);
setBeanClass(beanClass);
}
//构造方法
@Deprecated
public RootBeanDefinition(Class beanClass, MutablePropertyValues pvs, boolean singleton) {
super(null, pvs);
setBeanClass(beanClass);
setSingleton(singleton);
}
//构造方法
public RootBeanDefinition(Class<?> beanClass, ConstructorArgumentValues cargs, MutablePropertyValues pvs) {
super(cargs, pvs);
setBeanClass(beanClass);
}
//构造方法
public RootBeanDefinition(String beanClassName) {
setBeanClassName(beanClassName);
}
//构造方法
public RootBeanDefinition(String beanClassName, ConstructorArgumentValues cargs, MutablePropertyValues pvs) {
super(cargs, pvs);
setBeanClassName(beanClassName);
}
//构造方法
public RootBeanDefinition(RootBeanDefinition original) {
super((BeanDefinition) original);
this.allowCaching = original.allowCaching;
this.decoratedDefinition = original.decoratedDefinition;
this.targetType = original.targetType;
this.isFactoryMethodUnique = original.isFactoryMethodUnique;
}
//构造方法
RootBeanDefinition(BeanDefinition original) {
super(original);
}
//不含有父bean定义
public String getParentName() {
return null;
}
//不含有父bean定义,否则抛错
public void setParentName(String parentName) {
if (parentName != null) {
throw new IllegalArgumentException("Root bean cannot be changed into a child bean with parent reference");
}
}
//设置bean定义的修饰者(对bean定义进行一层修饰,持有bean定义)
public void setDecoratedDefinition(BeanDefinitionHolder decoratedDefinition) {
this.decoratedDefinition = decoratedDefinition;
}
public BeanDefinitionHolder getDecoratedDefinition() {
return this.decoratedDefinition;
}
//设置这个bean指定的目标类型定义,如果已知的提前。
public void setTargetType(Class<?> targetType) {
this.targetType = targetType;
}
public Class<?> getTargetType() {
return this.targetType;
}
//指定引用非重载方法的工厂方法名。
public void setUniqueFactoryMethodName(String name) {
Assert.hasText(name, "Factory method name must not be empty");
setFactoryMethodName(name);
this.isFactoryMethodUnique = true;
}
/**
* Check whether the given candidate qualifies as a factory method.
* 检查给定的候选方法是否为工厂方法
*/
public boolean isFactoryMethod(Method candidate) {
return (candidate != null && candidate.getName().equals(getFactoryMethodName()));
}
//返回解析后的工厂方法作为Java对象方法,如果可用。
public Method getResolvedFactoryMethod() {
synchronized (this.constructorArgumentLock) {
Object candidate = this.resolvedConstructorOrFactoryMethod;
return (candidate instanceof Method ? (Method) candidate : null);
}
}
public void registerExternallyManagedConfigMember(Member configMember) {
synchronized (this.postProcessingLock) {
if (this.externallyManagedConfigMembers == null) {
this.externallyManagedConfigMembers = new HashSet<Member>(1);
}
this.externallyManagedConfigMembers.add(configMember);
}
}
public boolean isExternallyManagedConfigMember(Member configMember) {
synchronized (this.postProcessingLock) {
return (this.externallyManagedConfigMembers != null &&
this.externallyManagedConfigMembers.contains(configMember));
}
}
public void registerExternallyManagedInitMethod(String initMethod) {
synchronized (this.postProcessingLock) {
if (this.externallyManagedInitMethods == null) {
this.externallyManagedInitMethods = new HashSet<String>(1);
}
this.externallyManagedInitMethods.add(initMethod);
}
}
public boolean isExternallyManagedInitMethod(String initMethod) {
synchronized (this.postProcessingLock) {
return (this.externallyManagedInitMethods != null &&
this.externallyManagedInitMethods.contains(initMethod));
}
}
public void registerExternallyManagedDestroyMethod(String destroyMethod) {
synchronized (this.postProcessingLock) {
if (this.externallyManagedDestroyMethods == null) {
this.externallyManagedDestroyMethods = new HashSet<String>(1);
}
this.externallyManagedDestroyMethods.add(destroyMethod);
}
}
public boolean isExternallyManagedDestroyMethod(String destroyMethod) {
synchronized (this.postProcessingLock) {
return (this.externallyManagedDestroyMethods != null &&
this.externallyManagedDestroyMethods.contains(destroyMethod));
}
}
@Override
public RootBeanDefinition cloneBeanDefinition() {
return new RootBeanDefinition(this);
}
@Override
public boolean equals(Object other) {
return (this == other || (other instanceof RootBeanDefinition && super.equals(other)));
}
@Override
public String toString() {
return "Root bean: " + super.toString();
}
}
8.AnnotatedBeanDefinition
public interface AnnotatedBeanDefinition extends BeanDefinition {
AnnotationMetadata getMetadata();
MethodMetadata getFactoryMethodMetadata();
}
//实现类一:支持注释元数据的普通bean定义
public class AnnotatedGenericBeanDefinition extends GenericBeanDefinition implements AnnotatedBeanDefinition {
//当前bean的注解元数据
private final AnnotationMetadata metadata;
//通过给定beanClass 构造对象
public AnnotatedGenericBeanDefinition(Class<?> beanClass) {
setBeanClass(beanClass);
this.metadata = new StandardAnnotationMetadata(beanClass, true);
}
//给定注解元数据,构造对象
public AnnotatedGenericBeanDefinition(AnnotationMetadata metadata) {
Assert.notNull(metadata, "AnnotationMetadata must not be null");
if (metadata instanceof StandardAnnotationMetadata) {
setBeanClass(((StandardAnnotationMetadata) metadata).getIntrospectedClass());
}
else {
setBeanClassName(metadata.getClassName());
}
this.metadata = metadata;
}
//获取bean的注解元数据
public final AnnotationMetadata getMetadata() {
return this.metadata;
}
}
//实现类二:支持注释元数据bean定义
//通过 Annotation 配置方式定义的 Bean 属性经 Spring 框架解析后会封装成 ScannedGenericBeanDefinition
public class ScannedGenericBeanDefinition extends GenericBeanDefinition implements AnnotatedBeanDefinition {
//当前bean的注解元数据
private final AnnotationMetadata metadata;
//metadatareader:扫描指定类的注释元数据
public ScannedGenericBeanDefinition(MetadataReader metadataReader) {
Assert.notNull(metadataReader, "MetadataReader must not be null");
this.metadata = metadataReader.getAnnotationMetadata();
setBeanClassName(this.metadata.getClassName());
}
//获取bean的注解元数据
public final AnnotationMetadata getMetadata() {
return this.metadata;
}
}