之前,我们已尽完成了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());
}
}
代码中的注释已经相当详细了,这里不多做解释!