/*

  * Copyright 2002-2016 the original author or authors.

  *

  * Licensed under the Apache License, Version 2.0 (the "License");

  * you may not use this file except in compliance with the License.

  * You may obtain a copy of the License at

  *

  *      http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */

 package org.springframework.beans.factory.support;

 import java.lang.reflect.Constructor;

 import java.util.Arrays;

 import java.util.LinkedHashMap;

 import java.util.LinkedHashSet;

 import java.util.Map;

 import java.util.Set;

 import org.springframework.beans.BeanMetadataAttributeAccessor;

 import org.springframework.beans.MutablePropertyValues;

 import org.springframework.beans.factory.config.AutowireCapableBeanFactory;

 import org.springframework.beans.factory.config.BeanDefinition;

 import org.springframework.beans.factory.config.ConstructorArgumentValues;

 import org.springframework.core.io.DescriptiveResource;

 import org.springframework.core.io.Resource;

 import org.springframework.util.Assert;

 import org.springframework.util.ClassUtils;

 import org.springframework.util.ObjectUtils;

 import org.springframework.util.StringUtils;

 /**

  * Base class for concrete, full-fledged {@link BeanDefinition} classes,

  * factoring out common properties of {@link GenericBeanDefinition},

  * {@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 GenericBeanDefinition

  * @see RootBeanDefinition

  * @see ChildBeanDefinition

  */

 @SuppressWarnings("serial")

 public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor

         implements BeanDefinition, Cloneable {

     public static final String SCOPE_DEFAULT = "";

     /***************************自动注入时的策略***************************/

     public static final int AUTOWIRE_NO = AutowireCapableBeanFactory.AUTOWIRE_NO;

     public static final int AUTOWIRE_BY_NAME = AutowireCapableBeanFactory.AUTOWIRE_BY_NAME;

     public static final int AUTOWIRE_BY_TYPE = AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE;

     public static final int AUTOWIRE_CONSTRUCTOR = AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR;

     @Deprecated

     public static final int AUTOWIRE_AUTODETECT = AutowireCapableBeanFactory.AUTOWIRE_AUTODETECT;

     /***************************依赖检查的策略***************************/

     //不做检查

     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;

     public static final String INFER_METHOD = "(inferred)";

     //表示这个Bean的类,可能是字符串，比如"com.insaneXs.TestA",也可能是class对象

     private volatile Object beanClass;

     //表示这个bean的范围

     private String scope = SCOPE_DEFAULT;

     //是否是抽象的，在定义bean的时候，由abstract属性设置,抽象的BeanDefition在getBean时会抛出异常

     private boolean abstractFlag = false;

     //是否延迟加载

     private boolean lazyInit = false;

     private int autowireMode = AUTOWIRE_NO;

     private int dependencyCheck = DEPENDENCY_CHECK_NONE;

     //依赖关系，在定义bean的时候，由depend-on属性设置，被依赖的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;

     //工厂类Bean的名字

     private String factoryBeanName;

     //工厂方法的名字

     private String factoryMethodName;

     //构造函数参数的封装

     private ConstructorArgumentValues constructorArgumentValues;

     //在定义bean时，property标签设置的属性

     private MutablePropertyValues propertyValues;

     //跟Bean定义时的look-up有关

     private MethodOverrides methodOverrides = new MethodOverrides();

     //指定init方法名称,会在初始化的时候被调用

     private String initMethodName;

     //指定destroy方法名称，会在被销毁时调用

     private String destroyMethodName;

     private boolean enforceInitMethod = true;

     private boolean enforceDestroyMethod = true;

     //表示该Bean是否是由程序生成的

     private boolean synthetic = false;

     private int role = BeanDefinition.ROLE_APPLICATION;

     private String description;

     private Resource resource;

     protected AbstractBeanDefinition() {

         this(null, null);

     }

     protected AbstractBeanDefinition(ConstructorArgumentValues cargs, MutablePropertyValues pvs) {

         setConstructorArgumentValues(cargs);

         setPropertyValues(pvs);

     }

     //深拷贝

     protected AbstractBeanDefinition(BeanDefinition original) {

         setParentName(original.getParentName());

         setBeanClassName(original.getBeanClassName());

         setScope(original.getScope());

         setAbstract(original.isAbstract());

         setLazyInit(original.isLazyInit());

         setFactoryBeanName(original.getFactoryBeanName());

         setFactoryMethodName(original.getFactoryMethodName());

         setConstructorArgumentValues(new ConstructorArgumentValues(original.getConstructorArgumentValues()));

         setPropertyValues(new MutablePropertyValues(original.getPropertyValues()));

         setRole(original.getRole());

         setSource(original.getSource());

         copyAttributesFrom(original);

         if (original instanceof AbstractBeanDefinition) {

             AbstractBeanDefinition originalAbd = (AbstractBeanDefinition) original;

             if (originalAbd.hasBeanClass()) {

                 setBeanClass(originalAbd.getBeanClass());

             }

             setAutowireMode(originalAbd.getAutowireMode());

             setDependencyCheck(originalAbd.getDependencyCheck());

             setDependsOn(originalAbd.getDependsOn());

             setAutowireCandidate(originalAbd.isAutowireCandidate());

             setPrimary(originalAbd.isPrimary());

             copyQualifiersFrom(originalAbd);

             setNonPublicAccessAllowed(originalAbd.isNonPublicAccessAllowed());

             setLenientConstructorResolution(originalAbd.isLenientConstructorResolution());

             setMethodOverrides(new MethodOverrides(originalAbd.getMethodOverrides()));

             setInitMethodName(originalAbd.getInitMethodName());

             setEnforceInitMethod(originalAbd.isEnforceInitMethod());

             setDestroyMethodName(originalAbd.getDestroyMethodName());

             setEnforceDestroyMethod(originalAbd.isEnforceDestroyMethod());

             setSynthetic(originalAbd.isSynthetic());

             setResource(originalAbd.getResource());

         }

         else {

             setResourceDescription(original.getResourceDescription());

         }

     }

     //由其他BeanDefinition的值来覆盖自身的值

     public void overrideFrom(BeanDefinition other) {

         if (StringUtils.hasLength(other.getBeanClassName())) {

             setBeanClassName(other.getBeanClassName());

         }

         if (StringUtils.hasLength(other.getScope())) {

             setScope(other.getScope());

         }

         setAbstract(other.isAbstract());

         setLazyInit(other.isLazyInit());

         if (StringUtils.hasLength(other.getFactoryBeanName())) {

             setFactoryBeanName(other.getFactoryBeanName());

         }

         if (StringUtils.hasLength(other.getFactoryMethodName())) {

             setFactoryMethodName(other.getFactoryMethodName());

         }

         getConstructorArgumentValues().addArgumentValues(other.getConstructorArgumentValues());

         getPropertyValues().addPropertyValues(other.getPropertyValues());

         setRole(other.getRole());

         setSource(other.getSource());

         copyAttributesFrom(other);

         if (other instanceof AbstractBeanDefinition) {

             AbstractBeanDefinition otherAbd = (AbstractBeanDefinition) other;

             if (otherAbd.hasBeanClass()) {

                 setBeanClass(otherAbd.getBeanClass());

             }

             setAutowireMode(otherAbd.getAutowireMode());

             setDependencyCheck(otherAbd.getDependencyCheck());

             setDependsOn(otherAbd.getDependsOn());

             setAutowireCandidate(otherAbd.isAutowireCandidate());

             setPrimary(otherAbd.isPrimary());

             copyQualifiersFrom(otherAbd);

             setNonPublicAccessAllowed(otherAbd.isNonPublicAccessAllowed());

             setLenientConstructorResolution(otherAbd.isLenientConstructorResolution());

             getMethodOverrides().addOverrides(otherAbd.getMethodOverrides());

             if (StringUtils.hasLength(otherAbd.getInitMethodName())) {

                 setInitMethodName(otherAbd.getInitMethodName());

                 setEnforceInitMethod(otherAbd.isEnforceInitMethod());

             }

             if (otherAbd.getDestroyMethodName() != null) {

                 setDestroyMethodName(otherAbd.getDestroyMethodName());

                 setEnforceDestroyMethod(otherAbd.isEnforceDestroyMethod());

             }

             setSynthetic(otherAbd.isSynthetic());

             setResource(otherAbd.getResource());

         }

         else {

             setResourceDescription(other.getResourceDescription());

         }

     }

     //根据默认设置来修改自身

     public void applyDefaults(BeanDefinitionDefaults defaults) {

         setLazyInit(defaults.isLazyInit());

         setAutowireMode(defaults.getAutowireMode());

         setDependencyCheck(defaults.getDependencyCheck());

         setInitMethodName(defaults.getInitMethodName());

         setEnforceInitMethod(false);

         setDestroyMethodName(defaults.getDestroyMethodName());

         setEnforceDestroyMethod(false);

     }

     //设置bean的className

     @Override

     public void setBeanClassName(String beanClassName) {

         this.beanClass = beanClassName;

     }

     //获取这个Bean的className

     @Override

     public String getBeanClassName() {

         Object beanClassObject = this.beanClass;

         //如果已经被解析成class,则通过class.getName方法返回class的名称

         if (beanClassObject instanceof Class) {

             return ((Class<?>) beanClassObject).getName();

         }

         else {

             return (String) beanClassObject;

         }

     }

     //设置这个bean的class

     public void setBeanClass(Class<?> beanClass) {

         this.beanClass = beanClass;

     }

     //返回这个bean的class,如果beanClass为空,未被解析，则会抛出异常

     public Class<?> getBeanClass() throws IllegalStateException {

         Object beanClassObject = this.beanClass;

         if (beanClassObject == null) {

             throw new IllegalStateException("No bean class specified on bean definition");

         }

         if (!(beanClassObject instanceof Class)) {

             throw new IllegalStateException(

                     "Bean class name [" + beanClassObject + "] has not been resolved into an actual Class");

         }

         return (Class<?>) beanClassObject;

     }

     //beanClass是否被解析成class

     public boolean hasBeanClass() {

         return (this.beanClass instanceof Class);

     }

     //解析beanClass

     public Class<?> resolveBeanClass(ClassLoader classLoader) throws ClassNotFoundException {

         String className = getBeanClassName();

         if (className == null) {

             return null;

         }

         Class<?> resolvedClass = ClassUtils.forName(className, classLoader);

         this.beanClass = resolvedClass;

         return resolvedClass;

     }

     //设置bean的范围

     @Override

     public void setScope(String scope) {

         this.scope = scope;

     }

     //获取bean的返回

     @Override

     public String getScope() {

         return this.scope;

     }

     //是否是单例

     @Override

     public boolean isSingleton() {

         return SCOPE_SINGLETON.equals(scope) || SCOPE_DEFAULT.equals(scope);

     }

     //是否是prototype

     @Override

     public boolean isPrototype() {

         return SCOPE_PROTOTYPE.equals(scope);

     }

     public void setAbstract(boolean abstractFlag) {

         this.abstractFlag = abstractFlag;

     }

     @Override

     public boolean isAbstract() {

         return this.abstractFlag;

     }

     @Override

     public void setLazyInit(boolean lazyInit) {

         this.lazyInit = lazyInit;

     }

     @Override

     public boolean isLazyInit() {

         return this.lazyInit;

     }

     public void setAutowireMode(int autowireMode) {

         this.autowireMode = autowireMode;

     }

     public int getAutowireMode() {

         return this.autowireMode;

     }

     //获取自动注入模式

     public int getResolvedAutowireMode() {

         //如果是自动检测，则根据构造函数来判断

         if (this.autowireMode == AUTOWIRE_AUTODETECT) {

             // Work out whether to apply setter autowiring or constructor autowiring.

             // If it has a no-arg constructor it's deemed to be setter autowiring,

             // otherwise we'll try constructor autowiring.

             Constructor<?>[] constructors = getBeanClass().getConstructors();

             for (Constructor<?> constructor : constructors) {

                 if (constructor.getParameterTypes().length == 0) {

                     return AUTOWIRE_BY_TYPE;

                 }

             }

             return AUTOWIRE_CONSTRUCTOR;

         }

         else {

             return this.autowireMode;

         }

     }

     public void setDependencyCheck(int dependencyCheck) {

         this.dependencyCheck = dependencyCheck;

     }

     public int getDependencyCheck() {

         return this.dependencyCheck;

     }

     @Override

     public void setDependsOn(String... dependsOn) {

         this.dependsOn = dependsOn;

     }

     @Override

     public String[] getDependsOn() {

         return this.dependsOn;

     }

     @Override

     public void setAutowireCandidate(boolean autowireCandidate) {

         this.autowireCandidate = autowireCandidate;

     }

     @Override

     public boolean isAutowireCandidate() {

         return this.autowireCandidate;

     }

     @Override

     public void setPrimary(boolean primary) {

         this.primary = primary;

     }

     @Override

     public boolean isPrimary() {

         return this.primary;

     }

     //自动注入时，用来增加其他限制

     public void addQualifier(AutowireCandidateQualifier qualifier) {

         this.qualifiers.put(qualifier.getTypeName(), qualifier);

     }

     public boolean hasQualifier(String typeName) {

         return this.qualifiers.keySet().contains(typeName);

     }

     public AutowireCandidateQualifier getQualifier(String typeName) {

         return this.qualifiers.get(typeName);

     }

     public Set<AutowireCandidateQualifier> getQualifiers() {

         return new LinkedHashSet<AutowireCandidateQualifier>(this.qualifiers.values());

     }

     public void copyQualifiersFrom(AbstractBeanDefinition source) {

         Assert.notNull(source, "Source must not be null");

         this.qualifiers.putAll(source.qualifiers);

     }

     public void setNonPublicAccessAllowed(boolean nonPublicAccessAllowed) {

         this.nonPublicAccessAllowed = nonPublicAccessAllowed;

     }

     public boolean isNonPublicAccessAllowed() {

         return this.nonPublicAccessAllowed;

     }

     //构造器是否宽松匹配

     public void setLenientConstructorResolution(boolean lenientConstructorResolution) {

         this.lenientConstructorResolution = lenientConstructorResolution;

     }

     public boolean isLenientConstructorResolution() {

         return this.lenientConstructorResolution;

     }

     //设置获取工厂Bean的Name

     @Override

     public void setFactoryBeanName(String factoryBeanName) {

         this.factoryBeanName = factoryBeanName;

     }

     @Override

     public String getFactoryBeanName() {

         return this.factoryBeanName;

     }

     //设置工厂方法,通常用来实现单例模式

     @Override

     public void setFactoryMethodName(String factoryMethodName) {

         this.factoryMethodName = factoryMethodName;

     }

     @Override

     public String getFactoryMethodName() {

         return this.factoryMethodName;

     }

     //设置构造函数参数

     public void setConstructorArgumentValues(ConstructorArgumentValues constructorArgumentValues) {

         this.constructorArgumentValues =

                 (constructorArgumentValues != null ? constructorArgumentValues : new ConstructorArgumentValues());

     }

     @Override

     public ConstructorArgumentValues getConstructorArgumentValues() {

         return this.constructorArgumentValues;

     }

     public boolean hasConstructorArgumentValues() {

         return !this.constructorArgumentValues.isEmpty();

     }

     //设置属性

     public void setPropertyValues(MutablePropertyValues propertyValues) {

         this.propertyValues = (propertyValues != null ? propertyValues : new MutablePropertyValues());

     }

     @Override

     public MutablePropertyValues getPropertyValues() {

         return this.propertyValues;

     }

     //方法注入

     public void setMethodOverrides(MethodOverrides methodOverrides) {

         this.methodOverrides = (methodOverrides != null ? methodOverrides : new MethodOverrides());

     }

     public MethodOverrides getMethodOverrides() {

         return this.methodOverrides;

     }

     //设置init方法

     public void setInitMethodName(String initMethodName) {

         this.initMethodName = initMethodName;

     }

     public String getInitMethodName() {

         return this.initMethodName;

     }

     public void setEnforceInitMethod(boolean enforceInitMethod) {

         this.enforceInitMethod = enforceInitMethod;

     }

     public boolean isEnforceInitMethod() {

         return this.enforceInitMethod;

     }

     //设置destory方法

     public void setDestroyMethodName(String destroyMethodName) {

         this.destroyMethodName = destroyMethodName;

     }

     public String getDestroyMethodName() {

         return this.destroyMethodName;

     }

     public void setEnforceDestroyMethod(boolean enforceDestroyMethod) {

         this.enforceDestroyMethod = enforceDestroyMethod;

     }

     public boolean isEnforceDestroyMethod() {

         return this.enforceDestroyMethod;

     }

     //是否由代码生成

     public void setSynthetic(boolean synthetic) {

         this.synthetic = synthetic;

     }

     public boolean isSynthetic() {

         return this.synthetic;

     }

     public void setRole(int role) {

         this.role = role;

     }

     @Override

     public int getRole() {

         return this.role;

     }

     public void setDescription(String description) {

         this.description = description;

     }

     @Override

     public String getDescription() {

         return this.description;

     }

     public void setResource(Resource resource) {

         this.resource = resource;

     }

     public Resource getResource() {

         return this.resource;

     }

     public void setResourceDescription(String resourceDescription) {

         this.resource = new DescriptiveResource(resourceDescription);

     }

     @Override

     public String getResourceDescription() {

         return (this.resource != null ? this.resource.getDescription() : null);

     }

     public void setOriginatingBeanDefinition(BeanDefinition originatingBd) {

         this.resource = new BeanDefinitionResource(originatingBd);

     }

     @Override

     public BeanDefinition getOriginatingBeanDefinition() {

         return (this.resource instanceof BeanDefinitionResource ?

                 ((BeanDefinitionResource) this.resource).getBeanDefinition() : null);

     }

     //校验

     public void validate() throws BeanDefinitionValidationException {

         //指定了工厂方法的bean,不能Y由methodOverriders。

         //因为工厂方法已经指定了bean实例化的方法，CGLib在这种情况下无效

         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();

         }

     }

     public void prepareMethodOverrides() throws BeanDefinitionValidationException {

         // Check that lookup methods exists.

         MethodOverrides methodOverrides = getMethodOverrides();

         if (!methodOverrides.isEmpty()) {

             Set<MethodOverride> overrides = methodOverrides.getOverrides();

             synchronized (overrides) {

                 for (MethodOverride mo : overrides) {

                     prepareMethodOverride(mo);

                 }

             }

         }

     }

     //确认这个重写的方法是否有被重载

     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) {

             //重载的值默认为true,

             //API上说设置为false可以提高运行性能

             mo.setOverloaded(false);

         }

     }

     @Override

     public Object clone() {

         return cloneBeanDefinition();

     }

     public abstract AbstractBeanDefinition cloneBeanDefinition();

     @Override

     public boolean equals(Object other) {

         if (this == other) {

             return true;

         }

         if (!(other instanceof AbstractBeanDefinition)) {

             return false;

         }

         AbstractBeanDefinition that = (AbstractBeanDefinition) other;

         if (!ObjectUtils.nullSafeEquals(getBeanClassName(), that.getBeanClassName())) return false;

         if (!ObjectUtils.nullSafeEquals(this.scope, that.scope)) return false;

         if (this.abstractFlag != that.abstractFlag) return false;

         if (this.lazyInit != that.lazyInit) return false;

         if (this.autowireMode != that.autowireMode) return false;

         if (this.dependencyCheck != that.dependencyCheck) return false;

         if (!Arrays.equals(this.dependsOn, that.dependsOn)) return false;

         if (this.autowireCandidate != that.autowireCandidate) return false;

         if (!ObjectUtils.nullSafeEquals(this.qualifiers, that.qualifiers)) return false;

         if (this.primary != that.primary) return false;

         if (this.nonPublicAccessAllowed != that.nonPublicAccessAllowed) return false;

         if (this.lenientConstructorResolution != that.lenientConstructorResolution) return false;

         if (!ObjectUtils.nullSafeEquals(this.constructorArgumentValues, that.constructorArgumentValues)) return false;

         if (!ObjectUtils.nullSafeEquals(this.propertyValues, that.propertyValues)) return false;

         if (!ObjectUtils.nullSafeEquals(this.methodOverrides, that.methodOverrides)) return false;

         if (!ObjectUtils.nullSafeEquals(this.factoryBeanName, that.factoryBeanName)) return false;

         if (!ObjectUtils.nullSafeEquals(this.factoryMethodName, that.factoryMethodName)) return false;

         if (!ObjectUtils.nullSafeEquals(this.initMethodName, that.initMethodName)) return false;

         if (this.enforceInitMethod != that.enforceInitMethod) return false;

         if (!ObjectUtils.nullSafeEquals(this.destroyMethodName, that.destroyMethodName)) return false;

         if (this.enforceDestroyMethod != that.enforceDestroyMethod) return false;

         if (this.synthetic != that.synthetic) return false;

         if (this.role != that.role) return false;

         return super.equals(other);

     }

     @Override

     public int hashCode() {

         int hashCode = ObjectUtils.nullSafeHashCode(getBeanClassName());

         hashCode = 29 * hashCode + ObjectUtils.nullSafeHashCode(this.scope);

         hashCode = 29 * hashCode + ObjectUtils.nullSafeHashCode(this.constructorArgumentValues);

         hashCode = 29 * hashCode + ObjectUtils.nullSafeHashCode(this.propertyValues);

         hashCode = 29 * hashCode + ObjectUtils.nullSafeHashCode(this.factoryBeanName);

         hashCode = 29 * hashCode + ObjectUtils.nullSafeHashCode(this.factoryMethodName);

         hashCode = 29 * hashCode + super.hashCode();

         return hashCode;

     }

     @Override

     public String toString() {

         StringBuilder sb = new StringBuilder("class [");

         sb.append(getBeanClassName()).append("]");

         sb.append("; scope=").append(this.scope);

         sb.append("; abstract=").append(this.abstractFlag);

         sb.append("; lazyInit=").append(this.lazyInit);

         sb.append("; autowireMode=").append(this.autowireMode);

         sb.append("; dependencyCheck=").append(this.dependencyCheck);

         sb.append("; autowireCandidate=").append(this.autowireCandidate);

         sb.append("; primary=").append(this.primary);

         sb.append("; factoryBeanName=").append(this.factoryBeanName);

         sb.append("; factoryMethodName=").append(this.factoryMethodName);

         sb.append("; initMethodName=").append(this.initMethodName);

         sb.append("; destroyMethodName=").append(this.destroyMethodName);

         if (this.resource != null) {

             sb.append("; defined in ").append(this.resource.getDescription());

         }

         return sb.toString();

     }

 }