标签：通过 map getc nullable 之一 容器 不同 统一 创建对象
在之前的文章中，主要从Spirng IOC、Bean的实例化以及Bean之间的关系来学习了Spring的相关知识。这篇文章主要从BeanDefinition的相关知识
If you work with an ApplicationContext interface programmatically, child bean definitions are represented by the ChildBeanDefinition class. Most users do not work with them on this level. Instead, they configure bean definitions declaratively in a class such as the ClassPathXmlApplicationContext. When you use XML-based configuration metadata, you can indicate a child bean definition by using the parent attribute, specifying the parent bean as the value of this attribute. The following example shows how to do so:
<bean id="inheritedTestBean" abstract="true"
class="org.springframework.beans.TestBean">
<property name="name" value="parent"/>
<property name="age" value="1"/>
</bean>
<bean id="inheritsWithDifferentClass"
class="org.springframework.beans.DerivedTestBean"
parent="inheritedTestBean" init-method="initialize">
<property name="name" value="override"/>
<!-- the age property value of 1 will be inherited from parent -->
</bean>
上面是来自Spring官网对于BeanDefinition的相描述。
总结来说：
BeanDefinition包含了对bean做的配置，比如XML``标签的形式进行的配置BeanDefinition,并且Spring会以此作为标准来对Bean进行创建。BeanDefinition包含以下元数据：
scope，lifecycle callbacks(生命周期回调)等等；比较正常创建一个Bean对象与通过Spring通过BeanDefinition创建一个Bean对象的不同：
正常创建一个Java Bean
通过BeanBeanDefinition来创建Bean
相对于正常的创建对象，Spring对其管理的bean没有直接采用new的方式，而是先通过解析配置数据以及根据对象本身的一些定义而获取其对应的Beandefinition,并将这个Beandefinition作为之后创建这个bean的依据。同时Spring在这个过程中提供了一些扩展点，例如在图中所提到了BeafactoryProcessor。
// 获取父BeanDefinition,主要
@Nullable
String getParentName();
// 设置bean的className
void setBeanClassName(@Nullable String beanClassName);
// 设置bean的作用域
void setScope(@Nullable String scope);
// 设置是否懒加载
void setLazyInit(boolean lazyInit);
// 是否需要等待指定的bean创建完之后再创建
void setDependsOn(@Nullable String... dependsOn);
// 是否作为自动注入的候选对象
void setAutowireCandidate(boolean autowireCandidate);
// 是否作为主选的bean
void setPrimary(boolean primary);
// 创建这个bean的类的名称
void setFactoryBeanName(@Nullable String factoryBeanName);
// 创建这个bean的方法的名称
void setFactoryMethodName(@Nullable String factoryMethodName);
// 构造函数的参数
ConstructorArgumentValues getConstructorArgumentValues();
// setter方法的参数
MutablePropertyValues getPropertyValues();
// 生命周期回调方法，在bean完成属性注入后调用
void setInitMethodName(@Nullable String initMethodName);
// 生命周期回调方法，在bean被销毁时调用
void setDestroyMethodName(@Nullable String destroyMethodName);
// Spring可以对bd设置不同的角色,了解即可，不重要
// 用户定义 int ROLE_APPLICATION = 0;
// 某些复杂的配置 int ROLE_SUPPORT = 1;
// 完全内部使用 int ROLE_INFRASTRUCTURE = 2;
void setRole(int role);
/**
* Set a human-readable description of this bean definition.
* @since 5.1
*/
void setDescription(@Nullable String description);
// 根据scope判断是否是单例
boolean isSingleton();
// 根据scope判断是否是原型
boolean isPrototype();
// 跟合并beanDefinition相关，如果是abstract，说明会被作为一个父beanDefinition，不用提供class属性
boolean isAbstract();
}
BeanDefinition的继承关系
org.springframework.core.AttributeAccessor
这个接口主要定义了元数据的访问接口。AbstractBeanDefinition是实现AttributeAccessor的抽象实现类之一。Spring通过这种方式，做到了数据接口与操作方法分离；接口中仅仅提哦那个了获取属性与设置属性的相关方法。而具体的数据实现则是在起实现类中去实现完成的；
org.springframework.beans.BeanMetadataElement
这个接口只有一个获取资源对象的的方法。
当定义了一个SpringBean时，比如User ，这个时候可以理解为User对应的BeanDefinition通过GetSource来获取 到User.class 所对应的File对象；
如果通过@Bean方式定义了一个User的话，那么此时的source是被@Bean注解所标注的一个Mehthod对象。
org.springframework.core.AttributeAccessorSupportAttributeAccessorSuppor实现了AttributeAccerror这个接口，AttributeAccerror实现了访问者的设计模式，将数据结构跟操作方法进行了分离;而数据结构就在AttributeAccessorSupport这个实现类中，其内部采用了LinkedHashMap实现。
public abstract class AttributeAccessorSupport implements AttributeAccessor, Serializable {
/** Map with String keys and Object values. */
private final Map<String, Object> attributes = new LinkedHashMap<>();
@Override
public void setAttribute(String name, @Nullable Object value) {
Assert.notNull(name, "Name must not be null");
if (value != null) {
this.attributes.put(name, value);
}
else {
removeAttribute(name);
}
}
......省略下面的代码
可以看到，在这个类中，维护了一个map，这就是BeanDefinition体系中，通过访问者模式所有操作的数据对象。
org.springframework.beans.BeanMetadataAttributeAccessor这个类主要就是对上面的map中的数据操作做了更深一层的封装，就看其中的两个方法：
public void addMetadataAttribute(BeanMetadataAttribute attribute) {
super.setAttribute(attribute.getName(), attribute);
}
public BeanMetadataAttribute getMetadataAttribute(String name) {
return (BeanMetadataAttribute) super.getAttribute(name);
}public void addMetadataAttribute(BeanMetadataAttribute attribute) {
super.setAttribute(attribute.getName(), attribute);
}
public BeanMetadataAttribute getMetadataAttribute(String name) {
return (BeanMetadataAttribute) super.getAttribute(name);
}
可以发现，它只是将属性统一封装成了一个BeanMetadataAttribute,然后就调用了父类的方法，将其放入到map中。
AbstractBeanDefinition通过继承了BeanMetadataAttributeAccessor这个类，可以对BeanDefinition中的属性进行操作。这里说的属性仅仅指的是BeanDefinition中的一个map，而不是它的其它字段。
对比BeanDefinition的源码可以发现，AbstractBeanDefinition对BeanDefinition的大部分方法做了实现（没有实现parentName相关方法）。同时定义了一系列的常量及默认字段。这是因为BeanDefinition接口过于顶层，如果我们依赖BeanDefinition这个接口直接去创建其实现类的话过于麻烦，所以通 AbstractBeanDefinition做了一个下沉，并给很多属性赋了默认值。
// 默认情况不是懒加载的
private boolean lazyInit = false;
// 默认情况不采用自动注入
private int autowireMode = AUTOWIRE_NO;
// 默认情况作为自动注入的候选bean
private boolean autowireCandidate = true;
// 默认情况不作为优先使用的bean
private boolean primary = false;
........
这样做的好处是我们在创建其它子类的时候，会方便很多。
RootBeanDefinition
BeanDefinition,这几个BeanDefinition的类型都为RootBeanDefinition；BeanDefinition返回的都是RootBeanDefinition；@Bean注解配置的bean，解析出来的BeanDefinition都是RootBeanDefinition（实际上是其子类ConfigurationClassBeanDefinition）ChildBeanDefinition
GenericBeanDefinition所替代了。在5.1.x版本没有找到使用这个类的代码。GenericBeanDefinition
替代了原来的ChildBeanDefinition，比起ChildBeanDefinition更为灵活，ChildBeanDefinition在实例化的时候必须要指定一个parentName,而GenericBeanDefinition不需要。我们通过注解配置的bean以及我们的配置类（除@Bena外）的BeanDefiniton类型都是GenericBeanDefinition。
AnnotatedBeanDefinition实现了BeanDefinition接口，其源码仅仅只有两个方法，如下：
/**
* Obtain the annotation metadata (as well as basic class metadata)
* for this bean definition‘s bean class.
* @return the annotation metadata object (never {@code null})
*/
AnnotationMetadata getMetadata();
/**
* Obtain metadata for this bean definition‘s factory method, if any.
* @return the factory method metadata, or {@code null} if none
* @since 4.1.1
*/
@Nullable
MethodMetadata getFactoryMethodMetadata();
getMetadata(),主要用于获取注解元数据。主要用于保存通过注解方式定义bean所对应的BeanDefinition
，提供一个获取获取注解信息的方法；
getFactoryMethodMetadata(),这个方法跟的@Bean注解相关。当在一个配置类中使用了@Bean注解时，被@Bean注解标记的方法，就被解析成了FactoryMethodMetadata。
AnnotatedGenericBeanDefinition
通过形如下面的API注册的bean都是AnnotatedGenericBeanDefinition
public static void main(String[] args) {
AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext();
ac.register(Config.class);
}
这里Config对象，最后在Spring容器中就是一个AnnotatedGenericBeanDefinition；
通过@Import注解导入的类，最后都是解析为AnnotatedGenericBeanDefinition。
ScannedGenericBeanDefinition
都过注解扫描的类，如@Service,@Compent等方式配置的Bean都是ScannedGenericBeanDefinition
ConfigurationClassBeanDefinition
通过@Bean的方式配置的Bean为ConfigurationClassBeanDefinition
最后，还剩一个ClassDerivedBeanDefinition,这个类是跟kotlin相关的类，一般用不到，这里就不管了！
至此，算是完成了BeanDefinition部分的学习，在下一节中，将继续跟大家一起学习BeanDefinition合并的相关知识。这篇文章中，主要学习了
什么是BeanDefinition，总结起来就是一句话，Spring创建bean时的建模对象。
BeanDefinition的具体使用的子类，以及Spring在哪些地方使用到了它们。这部分内容在后面的学习中很重要，画图总结如下：
Spring 源码阅读（四）-BeanDefinition 基本概念
标签：通过 map getc nullable 之一 容器 不同 统一 创建对象
原文地址：https://www.cnblogs.com/teago/p/12775859.html
