前言
正如我们所熟悉的，spring 是一个“大型的工厂”，在这个工厂中会产生一个个的实例，这些实例可以是单例的、非单例的。
工厂中的实例，也就是这次我们要进行分析的对象，BeanDefinition。
可以认为Spring中管理的所有对象，这些对象都是BeanDefinition.
源码环境
spring 4.x
源码分析
类图
我们先看一下类图：
BeanDefinition类图
我们重点关注一下BeanDefinition,它是一个接口，并且继承了BeanMetadataElement,AttributeAccessor.
先分析一下这个类的关系
BeanMetadataElement
public interface BeanMetadataElement {
Object getSource();//返回对象的元数据
}
这里边所讲的元数据，可以理解为一个对象实例。
AttributeAccessor
public interface AttributeAccessor {
void setAttribute(String name, Object value);
Object getAttribute(String name);
Object removeAttribute(String name);
boolean hasAttribute(String name);
String[] attributeNames();
}
根据方法的命名，我们可以看出，这些方法都是对对象实例的操作。
BeanDefinition
public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {
//代码 不粘了
}
看一下类的结构图:
BeanDefinition类的结构图
这个类，主要提供了一些对象的读取信息，和一些基本的设置信息。（比如类是不是单例啊、）
总结一下，BeanMetadataElement提供对象元数据，AttributeAccessor只对对象的属性进行读取和设置，BeanDefinition拥有了这两个接口的功能以外，还有读取类的基本信息的功能。
AbstractBeanDefinition
再来看AbstractBeanDefinition这个类，从名字中可以看出，它是一个模板抽象类。
AbstractBeanDefinition类图
根据类图，我们得知它继承了BeanMetadataAttributeAccessor,而BeanMetadataAttributeAccessor又继承了AttributeAccessorSupport。
从名字得知(AttributeAccessor),继承的父类都是对于对象属性的一些管理功能。
我们看一下和它有关系的两个父类:AttributeAccessorSupport,BeanMetadataAttributeAccessor
public abstract class AttributeAccessorSupport implements AttributeAccessor, Serializable {
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);
}
}
//..... 其他方法省略
}
AttributeAccessorSupport 使用了Map进行属性的存储的。当然这个类是个抽象类，需要有具体实现的
public class BeanMetadataAttributeAccessor extends AttributeAccessorSupport implements BeanMetadataElement {
private Object source;
public void setSource(Object source) {
this.source = source;
}
@Override
public Object getSource() {
return this.source;
}
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));
}
//... 其他方法省略
}
BeanMetadataAttributeAccessor代表了一个bean元数据的属性操作。
ok,我们再来看AbstractBeanDefinition:
public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor
implements BeanDefinition, Cloneable {
//....源码不贴了
}
它完成了BeanDefinition的大部分工作，当然它也预留了一些我们必须要重写的方法:
需要子类实现的方法
- cloneBeanDefinition(): 克隆方法
- getParentName():当前Bean的父类
- setParentName():设置当前Bean的父类
AbstractBeanDefinition实现类 GenericBeanDefinition/RootBeanDefinition/ChildBeanDefinition
GenericBeanDefinition是spring2.5之后才有的，这个的想法是用来替代RootBeanDefinition/ChildBeanDefinition,而RootBeanDefinition/ChildBeanDefinition可以在spring预加载的时候使用。
那我们主要关注一下GenericBeanDefinition这个类。
public class GenericBeanDefinition extends AbstractBeanDefinition {
private String parentName;
/**
* 创建GenericBeanDefinition之后，可以通过一下方法对bean的属性进行配置
* @see #setBeanClass
* @see #setBeanClassName
* @see #setScope
* @see #setAutowireMode
* @see #setDependencyCheck
* @see #setConstructorArgumentValues
* @see #setPropertyValues
*/
public GenericBeanDefinition() {
super();
}
public GenericBeanDefinition(BeanDefinition original) {
super(original);
}
@Override
public void setParentName(String parentName) {
this.parentName = parentName;
}
@Override
public String getParentName() {
return this.parentName;
}
@Override
public AbstractBeanDefinition cloneBeanDefinition() {
return new GenericBeanDefinition(this);
}
//其他代码省略
}
通过代码分析，我们现在就可以创建一个spring可以使用的bean了:
public class Test {
public static void main(String[] args) throws Exception {
GenericBeanDefinition genericBeanDefinition = new GenericBeanDefinition();
genericBeanDefinition.setBeanClass(Test.class);
genericBeanDefinition.setBeanClassName("springBean");
genericBeanDefinition.setScope(BeanDefinition.SCOPE_SINGLETON);
genericBeanDefinition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
// genericBeanDefinition.setPropertyValues();给属性添加值
System.out.println(genericBeanDefinition);
}
}
输出:
Generic bean: class [springBean]; scope=singleton; abstract=false; lazyInit=false; autowireMode=2; dependencyCheck=0; autowireCandidate=true; primary=false; factoryBeanName=null; factoryMethodName=null; initMethodName=null; destroyMethodName=null
这样操作，就创建好了一个spring可以使用的bean了。
AnnotatedBeanDefinition
public interface AnnotatedBeanDefinition extends BeanDefinition {
AnnotationMetadata getMetadata();
MethodMetadata getFactoryMethodMetadata();
}
BeanDefinition的另一个扩展，就是枚举相关的AnnotatedBeanDefinition。当然这个扩展是从spring 2.5之后才有的。
AnnotatedGenericBeanDefinition
AnnotatedGenericBeanDefinition 是AnnotatedBeanDefinition的一个具体实现。传入指定类后，可以获取类中的注解:
public class Test {
public static void main(String[] args) throws Exception {
AnnotatedGenericBeanDefinition genericBeanDefinition = new AnnotatedGenericBeanDefinition(Person.class);
genericBeanDefinition.setBeanClassName("springBean");
genericBeanDefinition.setScope(BeanDefinition.SCOPE_SINGLETON);
genericBeanDefinition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
// genericBeanDefinition.setPropertyValues();给属性添加值
System.out.println(genericBeanDefinition.getMetadata().getAnnotationTypes());
}
@TT
class Person{
}
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface TT{
}
}
输出:
[Test$TT]
ScannedGenericBeanDefinition
ScannedGenericBeanDefinition是AnnotatedBeanDefinition的另一个实现，与AnnotatedGenericBeanDefinition不同的是，ScannedGenericBeanDefinition是通过扫描 class，然后操作 asm进行解析的。
除此之外，其他是一样的。以后我们再来讨论关于asm相关的知识。
结束语
通过对于BeanDefinition的类图分析和源码分析，已经很清晰的了解了Spring工厂中的Bean是如何设计的，并且掌握了几个特别有用的BeanDefinition的创建方式，比如：GenericBeanDefinition、AnnotatedGenericBeanDefinition、ScannedGenericBeanDefinition。
因为我们也了解了从设计到实现的过程，所以，如果真的有需要，我们也可以通过实现AbstractBeanDefinition，实现自己的BeanDefinition，进行功能点的扩展。
网友评论