Spring中的BeanDefinition,BeanDefinitionRegistry,BeanFactory 细节

总结 BeanDefinition注册到BeanDefinitionRegistry中，并且在BeanFactory的 getBean()中，创建并返回Bean

默认BeanFactory：IOC 容器基本实现，是 Spring 内部的使用接口，不提供开发人员进行使用 加载配置文件时候不会创建对象，在获取对象（使用）才去创建对象

ApplicationContext：BeanFactory 接口的子接口，提供更多更强大的功能，一般由开发人员进行使用加载配置文件时候就会把在配置文件对象进行创建，getBean之前就创建了对象

创建对象的时机这个不重要，这个也不影响是否是单例的，也不影响是否用代理Proxy创建对象

BeanDefinitionRegistry,BeanFactory的区别

	1.这是两个接口，一个是用map注册 BeanDefinition的，一个接口时 getBean（)创建并返回bean的
	2.通常一个实现类DefaultListableBeanFactory，同时实现上面两个接口，它既用map注册BeanDefinition,
	同时，实现了 getBean()方法

简单来说，beanFactory 里面 既有 beanDefinitionRegistry map 存了 bean的定义信息
然后通过 getBean() 去 map中获取 beanDefinition 然后创建 对象，并且里面有一个缓存map 去缓存 单实例对象

      Spring 容器启动后首先是读取bean的xml配置文件，然后解析xml文件中的各种bean的定义，将xml文件中的每一个<bean />元素分别转换成一个BeanDefinition对象，其中保存了从配置文件中读取到的该bean的各种信息, 读完配置文件之后，得到了很多的BeanDefinition对象，然后通过BeanDefinitionRegistry将这些bean注册到beanFactory中, 这就是Spring IOC容器启动时的基本流程. 

     下面我们们仔细研究一下 BeanDefinition,BeanDefinitionRegistry,BeanFactory 三个对象的组成及功能. 

1. BeanDefinition: 将Bean的定义信息存储到这个BeanDefinition相应的属性中，之后对Bean的操作就是直接对BeanDefinition进行的. 在这个接口中定义的属性有诸如类名、sccope、属性、构造函数参数列表、依赖的bean、是否单例类等. 
    它继承 AttributeAccessor 和 BeanMetadataElement 接口.  

•       AttributeAccessor接口:   定义了对属性的修改，包括获取、设置、删除。
•      BeanMetadataElement,Bean 元对象持有的配置元素可以通过 getSource() 方法来获取。

    BeanDefinition对应的就是<bean>元素的配置的属性信息，列表如下:

	bean标签的属性

	1）scope：**用来配置spring bean的作用域
	2）singleton：**表示bean为单例的
	3）abstract：设置为true，将该bean仅仅作为模板使用，应用程序上下文不会试图预先初始化它
	4）lazy-init：**设为true，延迟加载，该bean不会在ApplicationContext启动时提前被实例化，而是第一次向容器通过getBean索取bean时实例化
	注：只对singleton的bean起作用
	5）autowire：**自动装配
	6）dependency-check：依赖检查
	7）depends-on：**表示一个bean的实例化依靠另一个bean先实例化
	8）autowire-candidate：**设为false，容器在查找自动装配对象时，将不考虑该bean，即它不会被考虑作为其他bean自动装配的候选者，但是该bean本身可以使用自动装配来注入其他bean
	9）primary：该bean优先被注入
	10）init-method：**初始化bean时调用的方法
	11）destory-method：**容器销毁之前所调用的方法
	12）factory-method：当调用factory-method所指向的方法时，才开始实例化bean
	13）factory-bean：调用静态工厂方法的方式创建bean
	
	二、bean的子元素
	1）meta：元数据，当需要使用里面的信息时可以通过key获取
	2）lookup-method：获取器注入，是把一个方法声明为返回某种类型的bean但实际要返回的bean是在配置文件里面配置的
	3）replaced-method：可以在运行时调用新的方法替换现有的方法，还能动态的更新原有方法的逻辑
	4）constructor-arg：** 对bean自动寻找对应的构造函数，并在初始化的时候将设置的参数传入进去
	5）property：** 基本数据类型赋值
	6）qualifier：** 通过Qualifier指定注入bean的名称

对以上信息进行包装的BeanDefinition的源代码如下:  ( 两张图可以对应着查看，是否一一对应)

	public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {
	    String SCOPE_SINGLETON = "singleton"; //单例模式
	    String SCOPE_PROTOTYPE = "prototype"; //原型模式（就是正常情况下的）
	    
	    //此bean的角色
	    int ROLE_APPLICATION = 0; //表示这个bean是用户定义的
	    int ROLE_SUPPORT = 1; //表示这个bean是第三方插件或工具的
	    int ROLE_INFRASTRUCTURE = 2; //表示这个bean是spring内部自己的
	    
	    //设置or获取此bean的父bean的名字
	    void setParentName(@Nullable String var1);
	    @Nullable
	    String getParentName();
	    //设置or获取此bean的类名
	    void setBeanClassName(@Nullable String var1);
	    @Nullable
	    String getBeanClassName();
	    //设置or获取此bean的模式（单例模式还是原型模式）
	    void setScope(@Nullable String var1);
	    @Nullable
	    String getScope();
	    //设置or获取此bean的延迟初始化属性（true，false）
	    void setLazyInit(boolean var1);
	    boolean isLazyInit();
	    //设置or获取依赖
	    void setDependsOn(@Nullable String... var1);
	    @Nullable
	    String[] getDependsOn();
	    //设置or获取此bean的是否接受被自动装配（true， false）
	    void setAutowireCandidate(boolean var1);
	    boolean isAutowireCandidate();
	    //设置or获取是否是首要（true，false）
	    void setPrimary(boolean var1);
	    boolean isPrimary();
	    //设置or获取工厂bean的名字
	    void setFactoryBeanName(@Nullable String var1);
	    @Nullable
	    String getFactoryBeanName();
	    //设置or 获取工厂bean里的生成方法名
	    void setFactoryMethodName(@Nullable String var1);
	    @Nullable
	    String getFactoryMethodName();
	    //获取构造函数的所有参数值
	    ConstructorArgumentValues getConstructorArgumentValues();
	    //判断构造函数参数是否为空
	    default boolean hasConstructorArgumentValues() {
	        return !this.getConstructorArgumentValues().isEmpty();
	    }
	    //获取所有的property
	    MutablePropertyValues getPropertyValues();
	    default boolean hasPropertyValues() {
	        return !this.getPropertyValues().isEmpty();
	    }
	    //设置or获取初始化方法名
	    void setInitMethodName(@Nullable String var1);
	    @Nullable
	    String getInitMethodName();
	    //设置or获取销毁方法名
	    void setDestroyMethodName(@Nullable String var1);
	    @Nullable
	    String getDestroyMethodName();
	    //设置角色，就是前面的三个整数（0,1,2），用户定义、第三方的、spring内部的
	    void setRole(int var1);
	    int getRole();
	    //设置or获取此bean的描述信息
	    void setDescription(@Nullable String var1);
	    @Nullable
	    String getDescription();
	    //判断此bean是否是单例、原型、抽象的
	    boolean isSingleton();
	    boolean isPrototype();
	    boolean isAbstract();
	    //获取资源描述，这个资源文件
	    @Nullable
	    String getResourceDescription();
	 
	    @Nullable
	    BeanDefinition getOriginatingBeanDefinition();
	}

2. BeanDefinitionRegistry:    定义Bean的常规操作，来注册BeanDefinition, 内部就是用一个 Map 实现. 
   主要功能：

• 以Map<String, BeanDefinition>的形式注册bean
• 根据beanName 删除和获取 beanDefiniation
• 得到持有的beanDefiniation的数目
• 根据beanName 判断是否包含beanDefiniation

它的默认实现类，主要有三个：SimpleBeanDefinitionRegistry、DefaultListableBeanFactory、GenericApplicationContext. 

BeanDefinitionRegistry源码:

	public interface BeanDefinitionRegistry extends AliasRegistry {
	 
		// 关键 -> 往注册表中注册一个新的 BeanDefinition 实例 
		void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException;
		// 移除注册表中已注册的 BeanDefinition 实例
		void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
		// 从注册中心取得指定的 BeanDefinition 实例
		BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
		// 判断 BeanDefinition 实例是否在注册表中（是否注册）
		boolean containsBeanDefinition(String beanName);
		
		// 取得注册表中所有 BeanDefinition 实例的 beanName（标识）
		String[] getBeanDefinitionNames();
		// 返回注册表中 BeanDefinition 实例的数量
		int getBeanDefinitionCount();
		// beanName（标识）是否被占用
		boolean isBeanNameInUse(String beanName);
	}

它的三个实现类的区别

SimpleBeanDefinitionRegistry 是 BeanDefinitionRegistry 一个简单的实现，它还继承 SimpleAliasRegistry（ AliasRegistry 的简单实现），它仅仅只提供注册表功能，无工厂功能。SimpleBeanDefinitionRegistry 使用 ConcurrentHashMap 来存储注册的 BeanDefinition。

DefaultListableBeanFactory，它是ConfigurableListableBeanFactory（其实就是 BeanFactory ） 和 BeanDefinitionRegistry 接口的默认实现：一个基于 BeanDefinition 元数据的完整 bean 工厂。它同样是用 ConcurrentHashMap 数据结构来存储注册的 BeanDefinition。

GenericApplicationContext ，他实现注册、注销功能都是委托 DefaultListableBeanFactory 实现的. 

	public class GenericApplicationContext extends AbstractApplicationContext implements BeanDefinitionRegistry {
	    //底层是将操作委托给了  DefaultListableBeanFactory 
		private final DefaultListableBeanFactory beanFactory;
	    ......
	}

所以我们只看  DefaultListableBeanFactory的核心源码:

	// 注册表，由 BeanDefinition 的标识 （beanName） 与其实例组成
	private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, bean>(64);
	 
	// 标识（beanName）集合
	private final List<String> beanDefinitionNames = new ArrayList<String>(64);
	 
	 
	public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
	   throws BeanDefinitionStoreException {
	 
	        // 省略其他代码
	 
	  else {
	   if (hasBeanCreationStarted()) {
	    // Cannot modify startup-time collection elements anymore (for stable iteration)
	    synchronized (this.beanDefinitionMap) {
	     this.beanDefinitionMap.put(beanName, beanDefinition);
	     List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
	     updatedDefinitions.addAll(this.beanDefinitionNames);
	     updatedDefinitions.add(beanName);
	     this.beanDefinitionNames = updatedDefinitions;
	     if (this.manualSingletonNames.contains(beanName)) {
	      Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
	      updatedSingletons.remove(beanName);
	      this.manualSingletonNames = updatedSingletons;
	     }
	    }
	   }
	   else {
	    // 注册 BeanDefinition   ****最重要的一句
	    this.beanDefinitionMap.put(beanName, beanDefinition);
	    this.beanDefinitionNames.add(beanName);
	    this.manualSingletonNames.remove(beanName);
	   }
	   this.frozenBeanDefinitionNames = null;
	  }
	 
	  if (existingDefinition != null || containsSingleton(beanName)) {
	   resetBeanDefinition(beanName);
	  }
	 }

3. BeanFactory :   创建Bean的工厂,  它最主要的方法就是 getBean(String beanName)，该方法从容器中返回特定名称的 Bean，BeanFactory 的功能通过其他的接口得到不断扩展

	public interface BeanFactory {
	 
	    //这里是对FactoryBean的转义定义，因为如果使用bean的名字检索FactoryBean得到的对象是工厂生成的对象，
	    //如果需要得到工厂本身，需要转义       
	    String FACTORY_BEAN_PREFIX = "&";
	 
	    这里根据bean的名字，在IOC容器中得到bean实例，这个IOC容器就是一个大的抽象工厂。
	 
	    Object getBean(String name) throws BeansException;
	 
	    //这里根据bean的名字和Class类型来得到bean实例，和上面的方法不同在于它会抛出异常：如果根据名字取得的bean实例的Class类型和需要的不同的话。
	    Object getBean(String name, Class requiredType) throws BeansException;
	 
	    //这里提供对bean的检索，看看是否在IOC容器有这个名字的bean
	    boolean containsBean(String name);
	 
	    //这里根据bean名字得到bean实例，并同时判断这个bean是不是单件
	    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
	 
	    //这里对得到bean实例的Class类型
	    Class getType(String name) throws NoSuchBeanDefinitionException;
	 
	    //这里得到bean的别名，如果根据别名检索，那么其原名也会被检索出来
	    String[] getAliases(String name);
	 
	}

BeanFactory下最通用的一个实现是 DefaultListableBeanFactory,它同时也实现了BeanDefinitionRegistry接口，因此它就承担了Bean的注册管理工作。

DefaultListableBeanFactory的类层次结构如下: 

DefaultListableBeanFactory其实要实现的功能就是以list集合的方式操作bean，为什么要拆成这么多的类和接口呢。这里面可能基于几点考虑。

1. 功能的不同维度，分不同的接口，方便以后的维护和其他人的阅读。如：AutowireCapableBeanFactory、ListableBeanFactory、HierarchicalBeanFactory等
2. 不同接口的实现，分布在不同的之类里，方便以后不同接口多种实现的扩展
3. 从整个类图的分布，可以看出spring在这块是面向接口编程，后面类的实现，他们认为只是接口功能实现的一种，随时可以拓展成多种实现

通过名字就大概可以了解每个接口的功能: 

HierarchicalBeanFactory接口是在继承BeanFactory的基础上，实现BeanFactory的父子关系。
AutowireCapableBeanFactory接口是在继承BeanFactory的基础上，实现Bean的自动装配功能
ListableBeanFactory接口是在继承BeanFactory的基础上，实现Bean的list集合操作功能
ConfigurableBeanFactory接口是在继承HierarchicalBeanFactory的基础上，实现BeanFactory的全部配置管理功能， 
SingletonBeanRegistry是单例bean的注册接口
ConfigurableListableBeanFactory接口是继承AutowireCapableBeanFactory，ListableBeanFactory，ConfigurableBeanFactory三个接口的一个综合接口
AliasRegistry接口是别名注册接口，SimpleAliasRegistry类是简单的实现别名注册接口的类