二、Spring MVC 源码学习（BeanDefinition）

一、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;
    }
}