public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {

	// 單例、原型標識符
	String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON;
	String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE;

    // 標識 Bean 的類別，分別對應(yīng) 用戶定義的 Bean、來源于配置文件的 Bean、Spring 內(nèi)部的 Bean
	int ROLE_APPLICATION = 0;
	int ROLE_SUPPORT = 1;
	int ROLE_INFRASTRUCTURE = 2;

    // 設(shè)置、返回 Bean 的父類名稱
	void setParentName(@Nullable String parentName);
	String getParentName();

    // 設(shè)置、返回 Bean 的 className
	void setBeanClassName(@Nullable String beanClassName);
	String getBeanClassName();

    // 設(shè)置、返回 Bean 的作用域
	void setScope(@Nullable String scope);
	String getScope();

    // 設(shè)置、返回 Bean 是否懶加載
	void setLazyInit(boolean lazyInit);
	boolean isLazyInit();
	
	// 設(shè)置、返回當(dāng)前 Bean 所依賴的其它 Bean 名稱。
	void setDependsOn(@Nullable String... dependsOn);
	String[] getDependsOn();
	
	// 設(shè)置、返回 Bean 是否可以自動注入。只對 @Autowired 注解有效
	void setAutowireCandidate(boolean autowireCandidate);
	boolean isAutowireCandidate();
	
	// 設(shè)置、返回當(dāng)前 Bean 是否為主要候選 Bean 。
	// 當(dāng)同一個接口有多個實現(xiàn)類時，通過該屬性來配置某個 Bean 為主候選 Bean。
	void setPrimary(boolean primary);
	boolean isPrimary();

    // 設(shè)置、返回創(chuàng)建該 Bean 的工廠類。
	void setFactoryBeanName(@Nullable String factoryBeanName);
	String getFactoryBeanName();
	
	// 設(shè)置、返回創(chuàng)建該 Bean 的工廠方法
	void setFactoryMethodName(@Nullable String factoryMethodName);
	String getFactoryMethodName();
	
	// 返回該 Bean 構(gòu)造方法參數(shù)值、所有屬性
	ConstructorArgumentValues getConstructorArgumentValues();
	MutablePropertyValues getPropertyValues();

    // 返回該 Bean 是否是單例、是否是非單例、是否是抽象的
	boolean isSingleton();
	boolean isPrototype();
	boolean isAbstract();

    // 返回 Bean 的類別。類別對應(yīng)上面的三個屬性值。
	int getRole();

    ...
}

public interface AnnotatedBeanDefinition extends BeanDefinition {

	// 獲得當(dāng)前 Bean 的注解元數(shù)據(jù)
	AnnotationMetadata getMetadata();

	// 獲得當(dāng)前 Bean 的工廠方法上的元數(shù)據(jù)
	MethodMetadata getFactoryMethodMetadata();
}

public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor
		implements BeanDefinition, Cloneable {
    // 默認的 SCOPE，默認是單例
	public static final String SCOPE_DEFAULT = "";
	// 不進行自動裝配
	public static final int AUTOWIRE_NO = AutowireCapableBeanFactory.AUTOWIRE_NO;
    // 根據(jù) Bean 的名字進行自動裝配，byName
	public static final int AUTOWIRE_BY_NAME = AutowireCapableBeanFactory.AUTOWIRE_BY_NAME;
	// 根據(jù) Bean 的類型進行自動裝配，byType
	public static final int AUTOWIRE_BY_TYPE = AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE;
	// 根據(jù)構(gòu)造器進行自動裝配
	public static final int AUTOWIRE_CONSTRUCTOR = AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR;
	// 首先嘗試按構(gòu)造器自動裝配。如果失敗，再嘗試使用 byType 進行自動裝配。（Spring 3.0 之后已廢除）
	public static final int AUTOWIRE_AUTODETECT = AutowireCapableBeanFactory.AUTOWIRE_AUTODETECT;
    // 通過依賴檢查來查看 Bean 的每個屬性是否都設(shè)置完成
    // 以下常量分別對應(yīng)：不檢查、對依賴對象檢查、對基本類型，字符串和集合進行檢查、對全部屬性進行檢查
	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;
	// 關(guān)閉應(yīng)用上下文時需調(diào)用的方法名稱
	public static final String INFER_METHOD = "(inferred)";
    // 存放 Bean 的 Class 對象
	private volatile Object beanClass;
	// Bean 的作用范圍
	private String scope = SCOPE_DEFAULT;
    // 非抽象
	private boolean abstractFlag = false;
	// 非延遲加載
	private boolean lazyInit = false;
    // 默認不自動裝配
	private int autowireMode = AUTOWIRE_NO;
    // 默認不依賴檢查
	private int dependencyCheck = DEPENDENCY_CHECK_NONE;
	// 依賴的 Bean 列表
	private String[] dependsOn;
    // 可以作為自動裝配的候選者，意味著可以自動裝配到其他 Bean 的某個屬性中
	private boolean autowireCandidate = true;
	// 創(chuàng)建當(dāng)前 Bean 實例工廠類名稱
	private String factoryBeanName;
    // 創(chuàng)建當(dāng)前 Bean 實例工廠類中方法名稱
	private String factoryMethodName;
	// 存儲構(gòu)造方法的參數(shù)
	private ConstructorArgumentValues constructorArgumentValues;
    // 存儲 Bean 屬性名稱以及對應(yīng)的值
	private MutablePropertyValues propertyValues;
    // 存儲被覆蓋的方法信息
	private MethodOverrides methodOverrides;
	// init、destroy 方法名稱
	private String initMethodName;
	private String destroyMethodName;
    // 是否執(zhí)行 init 和 destroy 方法
	private boolean enforceInitMethod = true;
	private boolean enforceDestroyMethod = true;
    // Bean 是否是用戶定義的而不是應(yīng)用程序本身定義的
	private boolean synthetic = false;
    // Bean 的身份類別，默認是用戶定義的 Bean
	private int role = BeanDefinition.ROLE_APPLICATION;
	// Bean 的描述信息
	private String description;
	// Bean 定義的資源
	private Resource resource;
	...
}

public class RootBeanDefinition extends AbstractBeanDefinition {

    // BeanDefinitionHolder 存儲 Bean 的名稱、別名、BeanDefinition
	private BeanDefinitionHolder decoratedDefinition;

	// AnnotatedElement 是java反射包的接口，通過它可以查看 Bean 的注解信息
	private AnnotatedElement qualifiedElement;

    // 允許緩存
	boolean allowCaching = true;
    
    // 工廠方法是否唯一
	boolean isFactoryMethodUnique = false;

	// 封裝了 java.lang.reflect.Type，提供了泛型相關(guān)的操作
	volatile ResolvableType targetType;

	// 緩存 Class，表示 RootBeanDefinition 存儲哪個類的信息
	volatile Class<?> resolvedTargetType;

	// 緩存工廠方法的返回類型
	volatile ResolvableType factoryMethodReturnType;

	// 這是以下四個構(gòu)造方法字段的通用鎖
	final Object constructorArgumentLock = new Object();
	// 用于緩存已解析的構(gòu)造方法或工廠方法
	Executable resolvedConstructorOrFactoryMethod;
	// 將構(gòu)造方法參數(shù)標記為已解析
	boolean constructorArgumentsResolved = false;
	// 用于緩存完全解析的構(gòu)造方法參數(shù)
	Object[] resolvedConstructorArguments;
	// 緩存待解析的構(gòu)造方法參數(shù)
	Object[] preparedConstructorArguments;

	// 這是以下兩個后處理字段的通用鎖
	final Object postProcessingLock = new Object();
	// 表明是否被 MergedBeanDefinitionPostProcessor 處理過
	boolean postProcessed = false;
	// 在生成代理的時候會使用，表明是否已經(jīng)生成代理
	volatile Boolean beforeInstantiationResolved;

	// 實際緩存的類型是 Constructor、Field、Method 類型
	private Set<Member> externallyManagedConfigMembers;

	// InitializingBean中 的 init 回調(diào)函數(shù)名 afterPropertiesSet 會在這里記錄，以便進行生命周期回調(diào)
	private Set<String> externallyManagedInitMethods;

	// DisposableBean 的 destroy 回調(diào)函數(shù)名 destroy 會在這里記錄，以便進生命周期回調(diào)
	private Set<String> externallyManagedDestroyMethods;

    ...
}