3.8 spring - AbstractBeanDefinition 介绍

　　之前,我们已尽完成了xml 文档到 GenericBeanDefinition的转换,

也就是说,到这里,所有的配置都可以在GenericBeanDefinition 的实例中找到对应的配置.

　　GenericBeanDefinition只是子类实现,而大部分功能都是通用属性,都是保存在AbstractBeanDefinition中,

那么我们再次通过AbstractBeanDefinition 的属性来复习一下 我们都解析了哪些对应的配置.

AbstractBeanDefinition 的结果图如下:

我们在来看看源代码!

 /**
  * Base class for concrete, full-fledged
  * {@link org.springframework.beans.factory.config.BeanDefinition} classes, factoring out
  * common properties of {@link RootBeanDefinition} and {@link ChildBeanDefinition}.
  *
  * <p>
  * The autowire constants match the ones defined in the
  * {@link org.springframework.beans.factory.config.AutowireCapableBeanFactory} interface.
  *
  * @author Rod Johnson
  * @author Juergen Hoeller
  * @author Rob Harrop
  * @author Mark Fisher
  * @see RootBeanDefinition
  * @see ChildBeanDefinition
  */
 @SuppressWarnings("serial")
 public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor
         implements BeanDefinition, Cloneable {

     /**
      * Constant for the default scope name: "", equivalent to singleton status but to be
      * overridden from a parent bean definition (if applicable).
      *
      * 常数为默认作用域的名称：“”，相当于单身状态，但是从父bean定义（如适用）所覆盖。
      *
      */
     public static final String SCOPE_DEFAULT = "";

     /**
      * Constant that indicates no autowiring at all.
      *
      * 常数，指示没有自动装配。
      *
      * @see #setAutowireMode
      */
     public static final int AUTOWIRE_NO = AutowireCapableBeanFactory.AUTOWIRE_NO;

     /**
      * Constant that indicates autowiring bean properties by name.
      *
      * 常数，表示按name自动装配bean的属性。
      *
      * @see #setAutowireMode
      */
     public static final int AUTOWIRE_BY_NAME = AutowireCapableBeanFactory.AUTOWIRE_BY_NAME;

     /**
      * Constant that indicates autowiring bean properties by type.
      *
      * 常数，指示按类型自动装配bean的属性。
      *
      * @see #setAutowireMode
      */
     public static final int AUTOWIRE_BY_TYPE = AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE;

     /**
      * Constant that indicates autowiring a constructor.
      *
      * 常数，表示自动装配一个构造。
      *
      * @see #setAutowireMode
      */
     public static final int AUTOWIRE_CONSTRUCTOR = AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR;

     /**
      * Constant that indicates determining an appropriate autowire strategy through
      * introspection of the bean class.
      *
      * 常数指示不依赖检查。
      *
      * @see #setAutowireMode
      * @deprecated as of Spring 3.0: If you are using mixed autowiring strategies, use
      *             annotation-based autowiring for clearer demarcation of autowiring
      *             needs.
      */
     @Deprecated
     public static final int AUTOWIRE_AUTODETECT = AutowireCapableBeanFactory.AUTOWIRE_AUTODETECT;

     /**
      * Constant that indicates no dependency check at all.
      *
      * 常数，表示为对象引用的依赖检查。
      *
      * @see #setDependencyCheck
      */
     public static final int DEPENDENCY_CHECK_NONE = 0;

     /**
      * Constant that indicates dependency checking for object references.
      *
      * 常数，表示为对象引用的依赖检查。
      *
      * @see #setDependencyCheck
      */
     public static final int DEPENDENCY_CHECK_OBJECTS = 1;

     /**
      * Constant that indicates dependency checking for "simple" properties.
      *
      * 常数，指出“简单”的属性的依赖检查。
      *
      * @see #setDependencyCheck
      * @see org.springframework.beans.BeanUtils#isSimpleProperty
      */
     public static final int DEPENDENCY_CHECK_SIMPLE = 2;

     /**
      * Constant that indicates dependency checking for all properties (object references
      * as well as "simple" properties).
      *
      * 常数，指示所有属性的依赖检查
      *
      * @see #setDependencyCheck
      */
     public static final int DEPENDENCY_CHECK_ALL = 3;

     /**
      * Constant that indicates the container should attempt to infer the
      * {@link #setDestroyMethodName destroy method name} for a bean as opposed to explicit
      * specification of a method name. The value {@value} is specifically designed to
      * include characters otherwise illegal in a method name, ensuring no possibility of
      * collisions with legitimately named methods having the same name.
      *
      * 常数，方法检查
      */
     public static final String INFER_METHOD = "(inferred)";

     /**
      * 应该是这个bean的Class类型吧
      */
     private volatile Object beanClass;

     /**
      * bean的作用范围,对应Bean属性scope
      */
     private String scope = SCOPE_DEFAULT;

     /**
      * 是否是抽象Bean ,对应bean属性abstractFlag
      */
     private boolean abstractFlag = false;

     /**
      * 是否延迟加载,对应Bean属性lazy-init
      */
     private boolean lazyInit = false;

     /**
      * 自动注入模式,,对应Bean属性autowire
      */
     private int autowireMode = AUTOWIRE_NO;

     /**
      * 依赖检查,Spring 3.0后弃用这个属性
      */
     private int dependencyCheck = DEPENDENCY_CHECK_NONE;

     /**
      * 用来表示一个Bean的实例化依靠另一个Bean先实例化,对应Bean属性depend-on
      */
     private String[] dependsOn;

     /**
      * autowire-candidate属性设置为false,这样容器在查找自动装配对象时,将不考虑该bean,即它不会被考虑为其他bean自动装配的候选者,
      * 但是该bean本身还是可以使用自动装配来注入其他属性,
      *
      * 对应Bean属性autowire-candidate
      */
     private boolean autowireCandidate = true;

     /**
      * 自动装配当出现多个bean候选者,将作为首选者,是默认不是主要候选者,对应Bean属性primary
      */
     private boolean primary = false;

     /**
      * 用于记录qualifiers ,对应Bean属性qualifier
      */
     private final Map<String, AutowireCandidateQualifier> qualifiers = new LinkedHashMap<String, AutowireCandidateQualifier>(
             0);

     /**
      * 允许访问非公开的构造器和方法
      */
     private boolean nonPublicAccessAllowed = true;

     /**
      * 是否以一种宽松的模式解析构造函数,默认为true,
      *
      * 如果为false,则在如下情况,
      *
      * interface Person{}
      *
      * class Theacher implemente Person{}
      *
      * class Main{
      *
      * Main(Person p){}
      *
      * Main(Theacher t){}
      *
      * 抛出异常,因为Spring无法准确定位哪个构造函数,
      *
      * 程序设置
      *
      * }
      *
      */
     private boolean lenientConstructorResolution = true;

     /**
      * 记录构造函数注入属性, 对应Bean属性constructor-arg
      */
     private ConstructorArgumentValues constructorArgumentValues;

     /**
      * 普通属性的集合
      */
     private MutablePropertyValues propertyValues;

     /**
      * 方法重写的持有者 ,记录 lookup-method,replaced-method元素
      */
     private MethodOverrides methodOverrides = new MethodOverrides();

     /**
      * 对应Bean的factory-bean 的属性,用法:
      *
      * <bean id = "factoryBean" class = "test.TestFactoryBean">
      *
      * <bean id = "ct" factory-bean= "factoryBean" factory-method = "getBean">
      *
      *
      */
     private String factoryBeanName;

     /**
      * 这个bean的工厂方法名
      */
     private String factoryMethodName;

     /**
      * 这个bean的初始化方法名
      */
     private String initMethodName;

     /**
      * 这个bean的销毁方法名
      */
     private String destroyMethodName;

     /**
      * 是否执行 init-method 方法,默认执行初始化方法,程序设置
      */
     private boolean enforceInitMethod = true;

     /**
      * 是否执行 destory-method 方法,默认执行销毁方法,程序设置
      */
     private boolean enforceDestroyMethod = true;

     /**
      * 是否是用户定义的而不是应用程序本身定义的, 创建AOP的时候为true,程序设置
      */
     private boolean synthetic = false;

     /**
      * 定义这个bean的应用,
      *
      * ROLE_APPLICATION:用户,
      *
      * ROLE_INFRASTRUCTURE:完全内部使用,与用户无关;
      *
      * ROLE_SUPPORT:某些复杂配置的一部分
      */
     private int role = BeanDefinition.ROLE_APPLICATION;

     /**
      * bean 的描述信息
      */
     private String description;

     /**
      * 这个Bean定义的资源
      */
     private Resource resource;

     /**
      * Create a new AbstractBeanDefinition with default settings.
      */
     protected AbstractBeanDefinition() {
         this(null, null);
     }

     /**
      * Create a new AbstractBeanDefinition with the given constructor argument values and
      * property values.
      */
     /*
      * 创建新的AbstractBeanDefinition实例并给定ConstructorArgumentValues实例和MutabePropertyValues实例
      */
     protected AbstractBeanDefinition(ConstructorArgumentValues cargs,
             MutablePropertyValues pvs) {
         setConstructorArgumentValues(cargs);
         setPropertyValues(pvs);
     }

     /**
      * Create a new AbstractBeanDefinition as a deep copy of the given bean definition.
      *
      * @param original the original bean definition to copy from
      */
     /*
      * 创建一个新的AbstractBeanDefinition并深入拷贝给定的BeanDefinition实例
      */
     protected AbstractBeanDefinition(BeanDefinition original) {
         // 抽象方法，由子类实现，设置父类名
         setParentName(original.getParentName());
         // 设置这个bean的类名称
         setBeanClassName(original.getBeanClassName());
         // 设置这个bean的工厂bean名称
         setFactoryBeanName(original.getFactoryBeanName());
         // 设置这个bean的工厂方法名称
         setFactoryMethodName(original.getFactoryMethodName());
         // 设置这个bean的作用范围，如单例的还是原型的，也有可能是其它的
         setScope(original.getScope());
         // 设置这个bean是否是抽象的
         setAbstract(original.isAbstract());
         // 设置这个bean是否开启延载初始化
         setLazyInit(original.isLazyInit());
         // 设置这个bean的角色
         setRole(original.getRole());
         // 设置这个bean的构造参数持有者
         setConstructorArgumentValues(new ConstructorArgumentValues(
                 original.getConstructorArgumentValues()));
         // 设置这个bean的Property持有者
         setPropertyValues(new MutablePropertyValues(original.getPropertyValues()));
         // 设置这个bean的配置源
         setSource(original.getSource());
         // 这个bean复制属性组名称
         copyAttributesFrom(original);
         // 判断origina是否是AbstractBeanDefinition子类
         if (original instanceof AbstractBeanDefinition) {
             AbstractBeanDefinition originalAbd = (AbstractBeanDefinition) original;
             if (originalAbd.hasBeanClass()) {
                 // 设置这个bean的Class类型
                 setBeanClass(originalAbd.getBeanClass());
             }
             // 设置这个bean的自动装配模式
             setAutowireMode(originalAbd.getAutowireMode());
             // 设置这个bean的依赖检查
             setDependencyCheck(originalAbd.getDependencyCheck());
             // 设置这个bean初始化要依赖的bean名称数组
             setDependsOn(originalAbd.getDependsOn());
             // 设置这个bean是否自动装配候选
             setAutowireCandidate(originalAbd.isAutowireCandidate());
             // 设置这个bean的qualifier
             copyQualifiersFrom(originalAbd);
             // 设置这个bean是否是主要候选者
             setPrimary(originalAbd.isPrimary());
             // 设置是否允许访问非public的构造器和方法
             setNonPublicAccessAllowed(originalAbd.isNonPublicAccessAllowed());
             // 设置是否以一种宽松的模式解析构造函数
             setLenientConstructorResolution(originalAbd.isLenientConstructorResolution());
             // 设置这个bean的初始化方法名
             setInitMethodName(originalAbd.getInitMethodName());
             // 设置是否执行初始化方法
             setEnforceInitMethod(originalAbd.isEnforceInitMethod());
             // 设置这个bean的销毁方法名
             setDestroyMethodName(originalAbd.getDestroyMethodName());
             // 设置是否执行销毁方法
             setEnforceDestroyMethod(originalAbd.isEnforceDestroyMethod());
             // 设置这个bean的方法重写持有者
             setMethodOverrides(new MethodOverrides(originalAbd.getMethodOverrides()));
             // 设置这个bean是人造的或者是应用程序本身
             setSynthetic(originalAbd.isSynthetic());
             // 设置这个Bean定义的资源
             setResource(originalAbd.getResource());
         }
         else {
             setResourceDescription(original.getResourceDescription());
         }
     }

　　代码中的注释已经相当详细了,这里不多做解释!