SpringIOC-02-BeanDefinition介绍

// 接口都比较简单  就是定义了对对象属性的一些访问方法
//说明它可以持有Bean元数据元素，作用是可以持有XML文件的一个bean标签对应的Object（或者@Configuration元配置对象）
public interface AttributeAccessor {
	
	void setAttribute(String name, @Nullable Object value);
	@Nullable
	Object getAttribute(String name);
	@Nullable
	Object removeAttribute(String name);
	boolean hasAttribute(String name);
	String[] attributeNames();
}

//接口提供了一个getResource()方法,用来传输一个可配置的源对象。
public interface BeanMetadataElement {

	/**
	 * Return the configuration source {@code Object} for this metadata element
	 * (may be {@code null}).
	 * 返回元数据元素配置元对象
	 */
	@Nullable
	Object getSource();
}

public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {

	// 单例Bean还是原型Bean
	String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON;
	String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE;
	
	// Bean角色
	int ROLE_APPLICATION = 0; //应用程序重要组成部分
	int ROLE_SUPPORT = 1; //做为大量配置的一部分（支持、扩展类）  实际上就是说，我这个Bean是用户的，是从配置文件中过来的。
	int ROLE_INFRASTRUCTURE = 2; //指内部工作的基础构造  实际上是说我这Bean是Spring自己的，和你用户没有一毛钱关系


	// Modifiable attributes
	//parent definition（若存在父类的话，就设置进去）
	void setParentName(@Nullable String parentName);
	@Nullable
	String getParentName();
	
	// 指定Class类型。需要注意的是该类型还有可能被改变在Bean post-processing阶段
	// 若是getFactoryBeanName  getFactoryMethodName这种情况下会改变
	void setBeanClassName(@Nullable String beanClassName);
	@Nullable
	String getBeanClassName();

	//SCOPE_SINGLETON或者SCOPE_PROTOTYPE两种
	void setScope(@Nullable String scope);
	@Nullable
	String getScope();

	// @Lazy 是否需要懒加载（默认都是立马加载的）
	void setLazyInit(boolean lazyInit);
	boolean isLazyInit();
	
	// 此Bean定义需要依赖的Bean（显然可以有多个）
	void setDependsOn(@Nullable String... dependsOn);
	@Nullable
	String[] getDependsOn();
	
	// 这个Bean是否允许被自动注入到别的地方去（默认都是被允许的）
	// 注意：此标志只影响按类型装配，不影响byName的注入方式的~~~~
	void setAutowireCandidate(boolean autowireCandidate);
	boolean isAutowireCandidate();

	// 是否是首选的  @Primary
	void setPrimary(boolean primary);
	boolean isPrimary();
	
	// 指定使用的工厂Bean（若存在）的名称~
	void setFactoryBeanName(@Nullable String factoryBeanName);
	@Nullable
	String getFactoryBeanName();
	//指定工厂方法~
	void setFactoryMethodName(@Nullable String factoryMethodName);
	@Nullable
	String getFactoryMethodName();
	
	// 获取此Bean的构造函数参数值们  ConstructorArgumentValues：持有构造函数们的 
	// 绝大多数情况下是空对象 new ConstructorArgumentValues出来的一个对象
	// 当我们Scan实例化Bean的时候，可能用到它的非空构造，这里就会有对应的值了，然后后面就会再依赖注入了
	ConstructorArgumentValues getConstructorArgumentValues();
	default boolean hasConstructorArgumentValues() {
		return !getConstructorArgumentValues().isEmpty();
	}

	// 获取普通属性集合~~~~
	MutablePropertyValues getPropertyValues();
	default boolean hasPropertyValues() {
		return !getPropertyValues().isEmpty();
	}

	// Read-only attributes
	boolean isSingleton();
	boolean isPrototype();
	boolean isAbstract();
	
	// 对应上面的role的值
	int getRole();
	//@Description
	@Nullable
	String getDescription();
	// 返回该Bean定义来自于的资源的描述（用于在出现错误时显示上下文）
	@Nullable
	String getResourceDescription();
	//返回原始BeanDefinition，如果没有则返回@null
	// 若这个Bean定义被代理、修饰过  这个方法可以返回原始的
	@Nullable
	BeanDefinition getOriginatingBeanDefinition();
}

public interface AnnotatedBeanDefinition extends BeanDefinition {
	//获取该bean definition的注解元数据
	AnnotationMetadata getMetadata();
	
	//@since 4.1.1
	//Obtain metadata for this bean definition's factory method（如果不存在就返回null）
	@Nullable
	MethodMetadata getFactoryMethodMetadata();
}

public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor
		implements BeanDefinition, Cloneable {
		
	//=====================定义众多常量。这一些常量会直接影响到spring实例化Bean时的策略
	// 个人觉得这些常量的定义不是必须的，在代码里判断即可。Spring定义这些常量的原因很简单，便于维护，让读代码的人知道每个值的意义(所以以后我们在书写代码时，也可以这么来搞)

	//默认的SCOPE，默认是单例
	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; //对所有属性的依赖进行检查

	//若Bean未指定销毁方法，容器应该尝试推断Bean的销毁方法的名字，目前来说，推断的销毁方法的名字一般为close或是shutdown
	//（即未指定Bean的销毁方法，但是内部定义了名为close或是shutdown的方法，则容器推断其为销毁方法）
	public static final String INFER_METHOD = "(inferred)";


	//=====================属性：基本囊括了Bean实例化需要的所有信息
	
	//Bean的class对象或是类的全限定名
	@Nullable
	private volatile Object beanClass;

	//默认的scope是单例
	@Nullable
	private String scope = SCOPE_DEFAULT;
	//默认不为抽象类
	private boolean abstractFlag = false;
	//默认不进行自动装配
	private boolean lazyInit = false;
	//默认不是懒加载
	private int autowireMode = AUTOWIRE_NO;
	//默认不进行依赖检查
	private int dependencyCheck = DEPENDENCY_CHECK_NONE;
	// @@DependsOn 默认没有
	@Nullable
	private String[] dependsOn;
	// autowire-candidate属性设置为false，这样容器在查找自动装配对象时，将不考虑该bean，
	// 备注：并不影响本身注入其它的Bean
	private boolean autowireCandidate = true;
	// 默认不是首选的
	private boolean primary = false;
	
	//用于记录Qualifier，对应子元素qualifier=======这个字段有必要解释一下
	// 唯一向这个字段放值的方法为本类的：public void addQualifier(AutowireCandidateQualifier qualifier)    copyQualifiersFrom这个不算，那属于拷贝
	// 调用处：AnnotatedBeanDefinitionReader#doRegisterBean  但是Spring所有调用处，qualifiers字段传的都是null~~~~~~~~~尴尬
	// 通过我多放跟踪发现，此处这个字段目前【永远】不会被赋值（除非我们手动调用对应方法为其赋值）   但是有可能我才疏学浅，若有知道的  请告知，非常非常感谢  我考虑到它可能是预留字段~~~~
	// 我起初以为这样可以赋值：
	//@Qualifier("aaa")
	//@Service
	//public class HelloServiceImpl   没想到，也是不好使的，Bean定义里面也不会有值
	// 因此对应的方法getQualifier和getQualifiers 目前应该基本上都返回null或者[]
	private final Map<String, AutowireCandidateQualifier> qualifiers = new LinkedHashMap<>(0);
	//我理解为通过这个函数的逻辑初始化Bean，而不是构造函数或是工厂方法（相当于自己去实例化，而不是交给Bean工厂）
	@Nullable
	private Supplier<?> instanceSupplier;
	//是否允许访问非public方法和属性，应用于构造函数、工厂方法、init、destroy方法的解析 默认是true，表示啥都可以访问
	private boolean nonPublicAccessAllowed = true;
	// 是否以一种宽松的模式解析构造函数，默认为true（宽松和严格体现在类型匹配上）
	private boolean lenientConstructorResolution = true;
	//工厂类名（注意是String类型，不是Class类型） 对应bean属性factory-method
	@Nullable
	private String factoryBeanName;
	//工厂方法名（注意是String类型，不是Method类型）
	@Nullable
	private String factoryMethodName;
	//记录构造函数注入属性，对应bean属性constructor-arg
	@Nullable
	private ConstructorArgumentValues constructorArgumentValues;
	
	//Bean属性的名称以及对应的值，这里不会存放构造函数相关的参数值，只会存放通过setter注入的依赖
	@Nullable
	private MutablePropertyValues propertyValues;
	//方法重写的持有者，记录lookup-method、replaced-method元素  @Lookup等
	@Nullable
	private MethodOverrides methodOverrides;

	//init函数的名字
	@Nullable
	private String initMethodName;
	//destory函数的名字
	@Nullable
	private String destroyMethodName;
	//是否执行init-method，程序设置
	private boolean enforceInitMethod = true;
	private boolean enforceDestroyMethod = true;

	//是否是合成类（是不是应用自定义的，例如生成AOP代理时，会用到某些辅助类，这些辅助类不是应用自定义的，这个就是合成类）
	//创建AOP时候为true
	private boolean synthetic = false;
	
	//Bean的角色，为用户自定义Bean
	private int role = BeanDefinition.ROLE_APPLICATION;

	// Bean的描述信息
	@Nullable
	private String description;
	//the resource that this bean definition came from
	// 这个Bean哪儿来的
	@Nullable
	private Resource resource;

	//=====================方法：就不逐一解释了，大部分都是get、set 只贴出一些特殊的

	// 其实就是给reource赋值了，使用了BeanDefinitionResource
	public void setOriginatingBeanDefinition(BeanDefinition originatingBd) {
		this.resource = new BeanDefinitionResource(originatingBd);
	}
	// 上面有赋值，所以get的时候就是返回上面set进来的值
	public BeanDefinition getOriginatingBeanDefinition() {
		return (this.resource instanceof BeanDefinitionResource ?
				((BeanDefinitionResource) this.resource).getBeanDefinition() : null);
	}
	
	//克隆Bean的定义信息
	@Override
	public Object clone() {
		return cloneBeanDefinition();
	}
	public abstract AbstractBeanDefinition cloneBeanDefinition();
}

public static void main(String[] args) {
       AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(RootConfig.class);

       // 向工厂里注册Bean信息
       GenericBeanDefinition parentBeanDef = new GenericBeanDefinition();
       parentBeanDef.setBeanClass(Parent.class);
       parentBeanDef.setBeanClassName(Parent.class.getName());
       parentBeanDef.setScope(BeanDefinition.SCOPE_SINGLETON);

       // 就这样，我们可以动态的给子Bean 设置一个父Bean进去
       GenericBeanDefinition childBeanDef = new GenericBeanDefinition();
       childBeanDef.setParentName(parentBeanDef.getBeanClassName());
       childBeanDef.setBeanClass(Child.class);

       applicationContext.registerBeanDefinition("parent", parentBeanDef);
       applicationContext.registerBeanDefinition("child", childBeanDef);

       System.out.println(applicationContext.getBeanDefinition("parent"));
       System.out.println(applicationContext.getBeanDefinition("child")); //Generic bean with parent 'com.fsx.bean.Parent': class [com.fsx.bean.Child]; scope=;...
   }

//简单的说：在多继承体系中，RootBeanDefinition代表的是当前初始化类的父类的BeanDefinition 若没有父类，那就是它自己嘛
public class RootBeanDefinition extends AbstractBeanDefinition {
	
	//BeanDefinitionHolder存储有Bean的名称、别名、BeanDefinition
	@Nullable
	private BeanDefinitionHolder decoratedDefinition;
	// AnnotatedElement 是java反射包的接口，通过它可以查看Bean的注解信息
	@Nullable
	private AnnotatedElement qualifiedElement;
	//允许缓存
	boolean allowCaching = true;
	//从字面上理解：工厂方法是否唯一
	boolean isFactoryMethodUnique = false;
	//封装了java.lang.reflect.Type,提供了泛型相关的操作，具体请查看：
	// ResolvableType 可以专题去了解一下子，虽然比较简单 但常见
	@Nullable
	volatile ResolvableType targetType;
	//缓存class，表明RootBeanDefinition存储哪个类的信息
	@Nullable
	volatile Class<?> resolvedTargetType;
	//缓存工厂方法的返回类型
	@Nullable
	volatile ResolvableType factoryMethodReturnType;

	/** Common lock for the four constructor fields below */
	final Object constructorArgumentLock = new Object();

	//缓存已经解析的构造函数或是工厂方法，Executable是Method、Constructor类型的父类
	@Nullable
	Executable resolvedConstructorOrFactoryMethod;
	//表明构造函数参数是否解析完毕
	boolean constructorArgumentsResolved = false;
	//缓存完全解析的构造函数参数
	@Nullable
	Object[] resolvedConstructorArguments;
	//缓存待解析的构造函数参数，即还没有找到对应的实例，可以理解为还没有注入依赖的形参
	@Nullable
	Object[] preparedConstructorArguments;

	/** Common lock for the two post-processing fields below */
	final Object postProcessingLock = new Object();

	//表明是否被MergedBeanDefinitionPostProcessor处理过
	boolean postProcessed = false;
	//在生成代理的时候会使用，表明是否已经生成代理
	@Nullable
	volatile Boolean beforeInstantiationResolved;

	//实际缓存的类型是Constructor、Field、Method类型
	@Nullable
	private Set<Member> externallyManagedConfigMembers;
	//InitializingBean中的init回调函数名——afterPropertiesSet会在这里记录，以便进行生命周期回调
	@Nullable
	private Set<String> externallyManagedInitMethods;
	//DisposableBean的destroy回调函数名——destroy会在这里记录，以便进行生命周期回调
	@Nullable
	private Set<String> externallyManagedDestroyMethods;

	//===========方法（只例举部分）
	// 由此看出，RootBeanDefiniiton是木有父的
	@Override
	public String getParentName() {
		return null;
	}
	@Override
	public void setParentName(@Nullable String parentName) {
		if (parentName != null) {
			throw new IllegalArgumentException("Root bean cannot be changed into a child bean with parent reference");
		}
	}

	// 拿到class类型
	@Nullable
	public Class<?> getTargetType() {
		if (this.resolvedTargetType != null) {
			return this.resolvedTargetType;
		}
		ResolvableType targetType = this.targetType;
		return (targetType != null ? targetType.resolve() : null);
	}

	@Override
	public RootBeanDefinition cloneBeanDefinition() {
		return new RootBeanDefinition(this);
	}
}

// 实现了AnnotatedBeanDefinition 也继承了GenericBeanDefinition
public class ScannedGenericBeanDefinition extends GenericBeanDefinition implements AnnotatedBeanDefinition {
	private final AnnotationMetadata metadata;
	...
	// 它只有一个构造函数：必须传入MetadataReader
	public ScannedGenericBeanDefinition(MetadataReader metadataReader) {
		Assert.notNull(metadataReader, "MetadataReader must not be null");
		this.metadata = metadataReader.getAnnotationMetadata();
		setBeanClassName(this.metadata.getClassName());
	}
}

public static void main(String[] args) {
        AnnotatedBeanDefinition beanDefinition = new AnnotatedGenericBeanDefinition(RootConfig.class);
        // 就这么一下子，就把注解们都拿到了，简直不要太方便，简直可以当工具类来用
        Set<String> annotationTypes = beanDefinition.getMetadata().getAnnotationTypes();
        System.out.println(annotationTypes); //[org.springframework.context.annotation.ComponentScan, org.springframework.context.annotation.Configuration]
        System.out.println(beanDefinition.isSingleton()); //true
        System.out.println(beanDefinition.getBeanClassName()); //com.config.RootConfig
    }

public class AnnotatedGenericBeanDefinition extends GenericBeanDefinition implements AnnotatedBeanDefinition {

	private final AnnotationMetadata metadata;
	@Nullable
	private MethodMetadata factoryMethodMetadata;

	/**
	 * Create a new AnnotatedGenericBeanDefinition for the given bean class.
	 * @param beanClass the loaded bean class  注意官方这个注释：已经加载进来了的Bean的Class
	 */
	public AnnotatedGenericBeanDefinition(Class<?> beanClass) {
		setBeanClass(beanClass);
		this.metadata = new StandardAnnotationMetadata(beanClass, true);
	}

	//@since 3.1.1 此处传入AnnotationMetadata ，也得保证对应的class已经被loaded
	public AnnotatedGenericBeanDefinition(AnnotationMetadata metadata) {
		Assert.notNull(metadata, "AnnotationMetadata must not be null");
		if (metadata instanceof StandardAnnotationMetadata) {
			setBeanClass(((StandardAnnotationMetadata) metadata).getIntrospectedClass());
		}
		else {
			setBeanClassName(metadata.getClassName());
		}
		this.metadata = metadata;
	}

	 //@since 4.1.1   可以由指定的工厂方法产生这个Bean
	public AnnotatedGenericBeanDefinition(AnnotationMetadata metadata, MethodMetadata factoryMethodMetadata) {
		this(metadata);
		Assert.notNull(factoryMethodMetadata, "MethodMetadata must not be null");
		setFactoryMethodName(factoryMethodMetadata.getMethodName());
		this.factoryMethodMetadata = factoryMethodMetadata;
	}

	@Override
	public final AnnotationMetadata getMetadata() {
		 return this.metadata;
	}
	@Override
	@Nullable
	public final MethodMetadata getFactoryMethodMetadata() {
		return this.factoryMethodMetadata;
	}

}

// 它直接继承自RootBeanDefinition 
private static class ConfigurationClassBeanDefinition extends RootBeanDefinition implements AnnotatedBeanDefinition {
	... 源码和之前的差得不是太多，此处就不解释了
}

public class BeanDefinitionBuilder {
	//=================创建一个Builder  没特殊指明，都是GenericBeanDefinition
	public static BeanDefinitionBuilder genericBeanDefinition() {
		return new BeanDefinitionBuilder(new GenericBeanDefinition());
	}
	....
	public static BeanDefinitionBuilder rootBeanDefinition(String beanClassName) {
		return rootBeanDefinition(beanClassName, null);
	}
	public static BeanDefinitionBuilder childBeanDefinition(String parentName) {
		return new BeanDefinitionBuilder(new ChildBeanDefinition(parentName));
	}
}

public static void main(String[] args) {
        AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition(Child.class)
                .setRole(BeanDefinition.ROLE_APPLICATION)
                .setScope(BeanDefinition.SCOPE_SINGLETON)
                .addPropertyValue("name", "fsx")
                .setLazyInit(false)
                //Spring5.0后提供的，可以自己书写函数，在里面做任意事情
                //bdf是个AbstractBeanDefinition
                .applyCustomizers((bdf) -> {
                    AbstractBeanDefinition abdf = (AbstractBeanDefinition) bdf;
                    abdf.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_NO);
                }).getRawBeanDefinition();
        System.out.println(beanDefinition); //Generic bean: class [com.fsx.maintest.Child]; scope=singleton; abstract=false; lazyInit=false; autowireMode=0; d...
    }

public interface BeanDefinitionReader {

	// 得到Bean定义的register 
	BeanDefinitionRegistry getRegistry();
	// 返回用于加载资源的 ResourceLoader（可以为null）
	@Nullable
	ResourceLoader getResourceLoader();
	// 加载Bean的类加载器
	@Nullable
	ClassLoader getBeanClassLoader();
	// 生成Bean名称的名字生成器（若没有指定名称的话，会调用它生成）
	BeanNameGenerator getBeanNameGenerator();


	// 核心方法，loadbean定义进来，然后注册到上面的register 里面去
	int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException;
	int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException;
	int loadBeanDefinitions(String location) throws BeanDefinitionStoreException;
	int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException;

}

public abstract class AbstractBeanDefinitionReader implements EnvironmentCapable, BeanDefinitionReader {
	private final BeanDefinitionRegistry registry;
	@Nullable
	private ResourceLoader resourceLoader;
	@Nullable
	private ClassLoader beanClassLoader;
	// 会有环境变量
	private Environment environment;
	// 默认的名字生成器（类名首字母小写）
	private BeanNameGenerator beanNameGenerator = new DefaultBeanNameGenerator();

	// 此构造函数，会完成一些参数的初始化
	protected AbstractBeanDefinitionReader(BeanDefinitionRegistry registry) {
		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
		this.registry = registry;

		// Determine ResourceLoader to use.
		if (this.registry instanceof ResourceLoader) {
			this.resourceLoader = (ResourceLoader) this.registry;
		} else {
			// 注意这个处理~~~~
			this.resourceLoader = new PathMatchingResourcePatternResolver();
		}

		// Inherit Environment if possible
		// 如果注册器里有环境变量，就用它的 否则new一个标准的~~~~  它下面也提供了set方法可以设置
		if (this.registry instanceof EnvironmentCapable) {
			this.environment = ((EnvironmentCapable) this.registry).getEnvironment();
		} else {
			this.environment = new StandardEnvironment();
		}
	}

	public void setEnvironment(Environment environment) {
		Assert.notNull(environment, "Environment must not be null");
		this.environment = environment;
	}
	public void setBeanNameGenerator(@Nullable BeanNameGenerator beanNameGenerator) {
		this.beanNameGenerator = (beanNameGenerator != null ? beanNameGenerator : new DefaultBeanNameGenerator());
	}

	...	
}