Spring IOC ( 三) : AbstractBeanDefiniton类源码分析

 

 

 

public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor
		implements BeanDefinition, Cloneable {

	/**
	 * 常数为默认作用域的名称：“”，相当于单身状态，但是从父bean定义（如适用）所覆盖。
	 */
	public static final String SCOPE_DEFAULT = "";


	/**
	 * 常数，指示没有自动装配。
	 */
	public static final int AUTOWIRE_NO = AutowireCapableBeanFactory.AUTOWIRE_NO;

	/**
	 * 常数，表示按name自动装配bean的属性。
	 */
	public static final int AUTOWIRE_BY_NAME = AutowireCapableBeanFactory.AUTOWIRE_BY_NAME;

	/**
	 * 常数，指示按类型自动装配bean的属性。
	 */
	public static final int AUTOWIRE_BY_TYPE = AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE;

	/**
	 * 常数，表示自动装配一个构造。
	 */
	public static final int AUTOWIRE_CONSTRUCTOR = AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR;

	/**
	 * 常数指示不依赖检查。
	 */
	public static final int DEPENDENCY_CHECK_NONE = 0;

	/**
	 * 常数，表示为对象引用的依赖检查。
	 */
	public static final int DEPENDENCY_CHECK_OBJECTS = 1;

	/**
	 * 常数，指出“简单”的属性的依赖检查。
	 */
	public static final int DEPENDENCY_CHECK_SIMPLE = 2;

	/**
	 * 常数，指示所有属性的依赖检查
	 */
	public static final int DEPENDENCY_CHECK_ALL = 3;

//应该是这个bean的Class类型吧
	private volatile Object beanClass;
//默认scope为“”，相当于单例
	private String scope = SCOPE_DEFAULT;
//bean默认为单例的
	private boolean singleton = true;
//bean默认不是原型的
	private boolean prototype = false;
//bean默认不是抽象的
	private boolean abstractFlag = false;
//bean默认不开启延迟初始化
	private boolean lazyInit = false;
//bean默认自动装配功能是关闭的
	private int autowireMode = AUTOWIRE_NO;
//bean的默认依赖检查方式
	private int dependencyCheck = DEPENDENCY_CHECK_NONE;
//这个bean要初始化依赖的bean名称数组
	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;
//不太清楚
	private boolean lenientConstructorResolution = true;
//	构造参数持有者
	private ConstructorArgumentValues constructorArgumentValues;
//	一个或多个属性的持有者
	private MutablePropertyValues propertyValues;
// 	方法重写的持有者
	private MethodOverrides methodOverrides = new MethodOverrides();
//     这个bean的工厂bean名称
	private String factoryBeanName;
// 这个bean的工厂方法名
	private String factoryMethodName;
//这个bean的初始化方法名
	private String initMethodName;
//这个bean的销毁方法名
	private String destroyMethodName;
//默认执行初始化方法
	private boolean enforceInitMethod = true;
//默认执行销毁方法
	private boolean enforceDestroyMethod = true;
//  不太清楚
	private boolean synthetic = false;
//暗示角色是应用程序的重要组成部分
	private int role = BeanDefinition.ROLE_APPLICATION;
//这个bean的描述
	private String description;
//这个bean定义的资源
	private Resource resource;


	/**
	 * 创建新的AbstractBeanDefinition实例并给定ConstructorArgumentValues实例和MutabePropertyValues实例
	 */
	protected AbstractBeanDefinition(ConstructorArgumentValues cargs, MutablePropertyValues pvs) {
		setConstructorArgumentValues(cargs);
		setPropertyValues(pvs);
	}


	/**
	 * 创建一个新的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());
//			
			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());
//			
			setResource(originalAbd.getResource());
		}
		else {
			setResourceDescription(original.getResourceDescription());
		}
	}


	/**
	 * Override settings in this bean definition (assumably a copied parent
	 * from a parent-child inheritance relationship) from the given bean
	 * definition (assumably the child).
	 * <ul>
	 * <li>Will override beanClass if specified in the given bean definition.
	 * <li>Will always take <code>abstract</code>, <code>scope</code>,
	 * <code>lazyInit</code>, <code>autowireMode</code>, <code>dependencyCheck</code>,
	 * and <code>dependsOn</code> from the given bean definition.
	 * <li>Will add <code>constructorArgumentValues</code>, <code>propertyValues</code>,
	 * <code>methodOverrides</code> from the given bean definition to existing ones.
	 * <li>Will override <code>factoryBeanName</code>, <code>factoryMethodName</code>,
	 * <code>initMethodName</code>, and <code>destroyMethodName</code> if specified
	 * in the given bean definition.
	 * </ul>
	 */
	public void overrideFrom(BeanDefinition other) {
		if (StringUtils.hasLength(other.getBeanClassName())) {
			setBeanClassName(other.getBeanClassName());
		}
		if (StringUtils.hasLength(other.getFactoryBeanName())) {
			setFactoryBeanName(other.getFactoryBeanName());
		}
		if (StringUtils.hasLength(other.getFactoryMethodName())) {
			setFactoryMethodName(other.getFactoryMethodName());
		}
		if (StringUtils.hasLength(other.getScope())) {
			setScope(other.getScope());
		}
		setAbstract(other.isAbstract());
		setLazyInit(other.isLazyInit());
		setRole(other.getRole());
		getConstructorArgumentValues().addArgumentValues(other.getConstructorArgumentValues());
		getPropertyValues().addPropertyValues(other.getPropertyValues());
		setSource(other.getSource());
		copyAttributesFrom(other);

		if (other instanceof AbstractBeanDefinition) {
			AbstractBeanDefinition otherAbd = (AbstractBeanDefinition) other;
			if (otherAbd.hasBeanClass()) {
				setBeanClass(otherAbd.getBeanClass());
			}
			setAutowireCandidate(otherAbd.isAutowireCandidate());
			setAutowireMode(otherAbd.getAutowireMode());
			copyQualifiersFrom(otherAbd);
			setPrimary(otherAbd.isPrimary());
			setDependencyCheck(otherAbd.getDependencyCheck());
			setDependsOn(otherAbd.getDependsOn());
			setNonPublicAccessAllowed(otherAbd.isNonPublicAccessAllowed());
			setLenientConstructorResolution(otherAbd.isLenientConstructorResolution());
			if (StringUtils.hasLength(otherAbd.getInitMethodName())) {
				setInitMethodName(otherAbd.getInitMethodName());
				setEnforceInitMethod(otherAbd.isEnforceInitMethod());
			}
			if (StringUtils.hasLength(otherAbd.getDestroyMethodName())) {
				setDestroyMethodName(otherAbd.getDestroyMethodName());
				setEnforceDestroyMethod(otherAbd.isEnforceDestroyMethod());
			}
			getMethodOverrides().addOverrides(otherAbd.getMethodOverrides());
			setSynthetic(otherAbd.isSynthetic());
			setResource(otherAbd.getResource());
		}
		else {
			setResourceDescription(other.getResourceDescription());
		}
	}

	/**
	 * 套用这个bean提供的默认值。
	 */
	public void applyDefaults(BeanDefinitionDefaults defaults) {
		setLazyInit(defaults.isLazyInit());
		setAutowireMode(defaults.getAutowireMode());
		setDependencyCheck(defaults.getDependencyCheck());
		setInitMethodName(defaults.getInitMethodName());
		setEnforceInitMethod(false);
		setDestroyMethodName(defaults.getDestroyMethodName());
		setEnforceDestroyMethod(false);
	}
         //************************各个属性信息的get/set方法这里忽略***********************//  
	/**
	 * Set the originating (e.g. decorated) BeanDefinition, if any.
	 */
	public void setOriginatingBeanDefinition(BeanDefinition originatingBd) {
		this.resource = new BeanDefinitionResource(originatingBd);
	}

	public BeanDefinition getOriginatingBeanDefinition() {
		return (this.resource instanceof BeanDefinitionResource ?
				((BeanDefinitionResource) this.resource).getBeanDefinition() : null);
	}

	/**
	 * Validate this bean definition.
	 * @throws BeanDefinitionValidationException in case of validation failure
	 */
	public void validate() throws BeanDefinitionValidationException {
		if (!getMethodOverrides().isEmpty() && getFactoryMethodName() != null) {
			throw new BeanDefinitionValidationException(
					"Cannot combine static factory method with method overrides: " +
					"the static factory method must create the instance");
		}

		if (hasBeanClass()) {
			prepareMethodOverrides();
		}
	}

	/**
	 * Validate and prepare the method overrides defined for this bean.
	 * Checks for existence of a method with the specified name.
	 * @throws BeanDefinitionValidationException in case of validation failure
	 */
	public void prepareMethodOverrides() throws BeanDefinitionValidationException {
		// Check that lookup methods exists.
		MethodOverrides methodOverrides = getMethodOverrides();
		if (!methodOverrides.isEmpty()) {
			for (MethodOverride mo : methodOverrides.getOverrides()) {
				prepareMethodOverride(mo);
			}
		}
	}

	/**
	 * Validate and prepare the given method override.
	 * Checks for existence of a method with the specified name,
	 * marking it as not overloaded if none found.
	 * @param mo the MethodOverride object to validate
	 * @throws BeanDefinitionValidationException in case of validation failure
	 */
	protected void prepareMethodOverride(MethodOverride mo) throws BeanDefinitionValidationException {
		int count = ClassUtils.getMethodCountForName(getBeanClass(), mo.getMethodName());
		if (count == 0) {
			throw new BeanDefinitionValidationException(
					"Invalid method override: no method with name '" + mo.getMethodName() +
					"' on class [" + getBeanClassName() + "]");
		}
		else if (count == 1) {
			// Mark override as not overloaded, to avoid the overhead of arg type checking.
			mo.setOverloaded(false);
		}
	}


	/**
	 * Clone this bean definition.
	 * To be implemented by concrete subclasses.
	 * @return the cloned bean definition object
	 */
	public abstract AbstractBeanDefinition cloneBeanDefinition();

}