本文要介绍的是spring中的class——BeanDefinition
首先要解释下，为什么称BeanDefinition为spring中的class。java开发者都清楚，对象通过class来进行实例化，因为class对象承载着对象所具有的属性、方法以及父子继承的关系等信息。在spring容器中管理着的Bean组件，也是经过一个实例化的过程，而这个实例化过程，仅仅是依靠class对象所拥有的信息是远远不够的，要知道，Bean组件要解决的还有作用域、实例化条件、组件依赖等一系列问题，spring将这样的一个对象封装在BeanDefinition对象中。
因此，我们可以这样来理解：Bean是高级的实例，BeanDefinition是高级的class。
BeanDefinition
先看下类结构图，BeanDefinition继承了AttributeAccessor和BeanMetadataElement两个接口。
AttributeAccessor
/**
* Interface defining a generic contract for attaching and accessing metadata
* to/from arbitrary objects.
*/
public interface AttributeAccessor {
这段注释说明了，实现该接口的任意对象都可以连接和访问到对象的属性；再看下其定义的方法，可以猜想应该是对属性的增删改查的一些操作。到这里，可以大胆的假设，这里应该是用一个散列表来管理的，而get、set、remove等方法是对map对象的put、get和remove操作。
-
AttributeAccessorSupport
有了这个猜想，我们去看下它的实现类AttributeAccessorSupport：
public abstract class AttributeAccessorSupport implements AttributeAccessor, Serializable {
/** Map with String keys and Object values */
private final Map<String, Object> attributes = new LinkedHashMap<String, Object>(0);
@Override
public void setAttribute(String name, Object value) {
Assert.notNull(name, "Name must not be null");
if (value != null) {
this.attributes.put(name, value);
}
else {
removeAttribute(name);
}
}
...
}
果不其然，它确实是用Map来实现定义的功能，值得注意的是这里使用了LinkedHashMap而不是HashMap。LinkedHashMap相较于最常用的HashMap，它能够记录插入顺序，即你遍历先得到的结果，一定是先插入的。这里用了LinkedHashMap，设计者希望在遍历的时候能够得到有序的的键值对，比如这里的方法attributeNames()。
BeanMetadataElement
/**
* Interface to be implemented by bean metadata elements
* that carry a configuration source object.
*/
public interface BeanMetadataElement {
Object getSource();
}
实现这个接口便拥有了元数据，这一定是为实体类准备的吧。我们看看它的实现类。
BeanMetadataAttribute
/**
* Holder for a key-value style attribute that is part of a bean definition.
* Keeps track of the definition source in addition to the key-value pair.
*/
public class BeanMetadataAttribute implements BeanMetadataElement {
private final String name;
private final Object value;
private Object source;
...
}
标准的entity，这个类为BeanDefinition提供了键值对形式的属性(attribute)，除了键值对外，还保留了对元数据的跟踪。
BeanMetadataAttributeAccessor
既然是为BeanDefinition提供了键值对形式的属性，那么对属性访问功能提供者也应支持这种形式的属性设置和访问。于是以下的实现便是自然而然了。
public class BeanMetadataAttributeAccessor extends AttributeAccessorSupport implements BeanMetadataElement {
...
public void addMetadataAttribute(BeanMetadataAttribute attribute) {
super.setAttribute(attribute.getName(), attribute);
}
public BeanMetadataAttribute getMetadataAttribute(String name) {
return (BeanMetadataAttribute) super.getAttribute(name);
}
@Override
public void setAttribute(String name, Object value) {
super.setAttribute(name, new BeanMetadataAttribute(name, value));
}
@Override
public Object getAttribute(String name) {
BeanMetadataAttribute attribute = (BeanMetadataAttribute) super.getAttribute(name);
return (attribute != null ? attribute.getValue() : null);
}
@Override
public Object removeAttribute(String name) {
BeanMetadataAttribute attribute = (BeanMetadataAttribute) super.removeAttribute(name);
return (attribute != null ? attribute.getValue() : null);
}
-
BeanDefinition&AbstractBeanDefinition
/**
* A BeanDefinition describes a bean instance, which has property values,
* constructor argument values, and further information supplied by
* concrete implementations.
*/
public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {
...
}
BeanDefinition描述了一个Bean实例所拥有的实例、结构参数和参数值，为具体实现提供了进一步的信息。如果用类比的眼光来看，AbstractBeanDefinition是一个实体对象，主要作用是承载信息，它实现了Bean实例化过程中所需要的大部分方法及属性，由于属性较多，接下来将会在源码中添加注释来说明各种属性的主要作用。
public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor
implements BeanDefinition, Cloneable {
private volatile Object beanClass;
private String scope = SCOPE_DEFAULT; //bean的作用域
private boolean abstractFlag = false; //该对象是否为抽象的
private boolean lazyInit = false; //是否懒加载(也叫延迟加载，个人喜好叫法)
private int autowireMode = AUTOWIRE_NO; //注入模式(默认id注入，还有通过名称、类型注入)
private int dependencyCheck = DEPENDENCY_CHECK_NONE; //依赖检查(不检查、检查对象、检查属性、全部检查)
private String[] dependsOn; //所依赖的对象名称数组
private boolean autowireCandidate = true; //是否允许自动注入
private boolean primary = false; //是否优先注入
private final Map<String, AutowireCandidateQualifier> qualifiers =
new LinkedHashMap<String, AutowireCandidateQualifier>(0); //已经注入的对象
private boolean nonPublicAccessAllowed = true; //是否允许非public访问
private boolean lenientConstructorResolution = true; //允许构造和析构(销毁)
private ConstructorArgumentValues constructorArgumentValues; //参数属性列表(实现了BeanMetadataElement来进行参数信息存储)
private MutablePropertyValues propertyValues; //注入的properties文件信息列表(properties文件是存储键值对信息的文件)
private MethodOverrides methodOverrides = new MethodOverrides(); //重写的方法列表
private String factoryBeanName; //对应工厂类名
private String factoryMethodName;
private String initMethodName; //初始化方法
private String destroyMethodName; //销毁方法
private boolean enforceInitMethod = true; //是否强制执行初始化方法(实例化成功后执行该方法)
private boolean enforceDestroyMethod = true; //是否强制执行销毁方法。
private boolean synthetic = false; //是否为合成对象(这个很难，希望得到解释的欢迎留言)
private int role = BeanDefinition.ROLE_APPLICATION; //角色信息(三个等级，不具体说明了)
private String description; //描述而已
private Resource resource;
...
}
再加上继承BeanMetadataAttributeAccessor类，拥有一个Map来管理属性信息。
总结
至此，已经将BeanDefinition所承载的信息做了大概的介绍，对文章首部提出的类图做一个总结；
还有几个方法是未实现的，比如在BeanDefinition接口中定义的getParentName()方法，该类是一个抽象类，若要完善和使用这个类的功能就需要对其进行扩展。
文章到这里就结束了，欢迎对源码感兴趣的朋友们一起来讨论学习~
