spring源码阅读4——BeanDefinition

2017-04-27 本文已影响390人鹰涯

本文要介绍的是spring中的class——BeanDefinition

首先要解释下，为什么称BeanDefinition为spring中的class。java开发者都清楚，对象通过class来进行实例化，因为class对象承载着对象所具有的属性、方法以及父子继承的关系等信息。在spring容器中管理着的Bean组件，也是经过一个实例化的过程，而这个实例化过程，仅仅是依靠class对象所拥有的信息是远远不够的，要知道，Bean组件要解决的还有作用域、实例化条件、组件依赖等一系列问题，spring将这样的一个对象封装在BeanDefinition对象中。
因此，我们可以这样来理解：Bean是高级的实例，BeanDefinition是高级的class。

BeanDefinition

先看下类结构图，BeanDefinition继承了AttributeAccessor和BeanMetadataElement两个接口。

BeanDefinition家族

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操作。

AttributeAccessor接口定义的方法

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()方法，该类是一个抽象类，若要完善和使用这个类的功能就需要对其进行扩展。

文章到这里就结束了，欢迎对源码感兴趣的朋友们一起来讨论学习~

spring源码阅读4——BeanDefinition

BeanDefinition

总结

猜你喜欢

热点阅读