BeanFactory 体系结构

前一篇 Spring Ioc 概述 中已对 Spring Ioc 做了一些基本的介绍，在文章的最后分别举了使用 ClassPathXmlApplicationContext 和 AnnotationConfigApplicationContext 来创建 Spring Ioc 容器的例子。分析这两个类的继承关系，他们均为 ApplicationContext 的实现类，因此就先通过 ClassPathXmlApplicationContext 的继承关系来分析。

• ClassPathXmlApplicationContext 类图

  
  images

  从类图中分析 ClassPathXmlApplicationContext 的类继承关系

  ClassPathXmlApplicationContext
      -- AbstractXmlApplicationContext
          -- AbstractRefreshableConfigApplicationContext
              -- InitializingBean
              -- BeanNameAware
              -- AbstractRefreshableApplicationContext
                  -- AbstractApplicationContext
                      -- DefaultResourceLoader
                      -- ConfigurableApplicationContext
                          -- ApplicationContext
  ApplicationContext
      -- EnvironmentCapable
      -- MessageSource
      -- ApplicationEventPublisher
      -- ResourcePatternResolver
      -- ListableBeanFactory
      -- HierarchicalBeanFactory
          -- BeanFactory                      
  

从类的继承关系可以看出，ClassPathXmlApplicationContext 实现了 ApplicationContext 接口，而 ApplicationContext 接口又是在 BeanFactory 接口的基础上进行了扩展。因此先从 BeanFactory 及其子接口开始分析。

BeanFactory

• BeanFactory 体系结构

  
  images

  BeanFactory 的体系结构图中，包含了一系列的接口及实现类

  1. 接口

     -- BeanFactory(一级接口)
         一级接口，定义了获取 Bean、BeanType、单例多例的方法
         
         -- ListableBeanFactory(二级接口)
         可列表化的BeanFactory，添加了根据BeanDefinition相关的一些操作，以及列表化返回结果的接口
         
         -- HierarchicalBeanFactory(二级接口)
             实现了工厂的分层，引入父子容器的概念
             1. 父子容器是相互隔离的，他们内部可以存在名称相同的 Bean
             2. 子容器可以访问父容器的Bean，父容器不能访问子容器的Bean
             3. 调用子容器的getBean方法，会沿着当前的容器向上层查找，直到找到对应的Bean为止
             4. 子容器可以通过任何方式注入父容器中的Bean，而父容器无法注入子容器的Bean
             
             -- ConfigurableBeanFactory(三级接口)
             对 HierarchicalBeanFactory 增强，同时继承了 SingletonBeanRegistry
         
         -- AutowireCapableBeanFactory(二级接口)
             1. 对于想要拥有自动装配能力，并且想要把这种能力暴露给外部应用BeanFactory类需要实现此接口。
             2. 正常情况下不要使用此接口，应该更倾向于使用BeanFactory或者ListableBeanFactory接口。
             3. 此接口主要是针对框架之外，没有向Spring托管的Bean的应用。通过暴露此功能，Spring框架之外的程序，具有自动装配Spring的功能
             4. 需要注意的是ApplicationContext并没有实现此接口。因为应用代码很少使用此功能。如果确实需要的话可以调用ApplicationContext.getAutowireCapableBeanFactory()的方法，来获取此接口的实例
             5. 如果一个类实现了此接口，那么很大程度上它还需要实现BeanFactoryWare接口。它可以在应用上下文中返回BeanFactory;
                 
                 -- ConfigurableListableBeanFactory(四级接口)
     

     public interface BeanFactory {
     
         /**作用：如果在使用beanName获取Bean时，在BeanName前添加这个前缀， 
         *  那么使用这个BeanName获得的Bean实例是其所在FactoryBean的实例，
         *  也就是实现 FactoryBean 接口的那个类的Bean实例 
         **/
         String FACTORY_BEAN_PREFIX = "&";
     
         // 定义四个获取 Bean 的方法
         Object getBean(String name) throws BeansException;
         <T> T getBean(String name, Class<T> requiredType) throws BeansException;
         Object getBean(String name, Object... args) throws BeansException;
         <T> T getBean(Class<T> requiredType) throws BeansException;
         <T> T getBean(Class<T> requiredType, Object... args) throws BeansException;
     
         // 
         <T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);
         <T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);
     
         // 是否包含对应名称的Bean
         boolean containsBean(String name);
     
         // 单例还是多例
         boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
         boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
     
         // Bean 名称与类型是否匹配
         boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
         boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;
     
         // 获取 BeanName 对应的 class
         @Nullable
         Class<?> getType(String name) throws NoSuchBeanDefinitionException;
         @Nullable
         Class<?> getType(String name, boolean allowFactoryBeanInit) throws NoSuchBeanDefinitionException;
         
         // 根据实例的名字获取实例的别名
         String[] getAliases(String name);
     
     }
     

  2. 抽象类

     • AbstractBeanFactory
       实现了 ConfigurableBeanFactory 接口的大部分功能

       public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
       }
       

     • AbstractAutowireCapableBeanFactory
       继承自 AbstractBeanFactory ，并额外实现了二级接口 AutowireCapableBeanFactory

       public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
       implements AutowireCapableBeanFactory {
       }
       

  3. 实现类

     • DefaultListableBeanFactory
       继承自 AbstractAutowireCapableBeanFactory ，实现了最强大的四级接口 ConfigurableListableBeanFactory ，并实现了一个外来接口 BeanDefinitionRegistry ，它并非抽象类。

       public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
       implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
       }
       

     • XmlBeanFactory
       继承自 DefaultListableBeanFactory ，重写了一些功能，使自己更强大。

       public class XmlBeanFactory extends DefaultListableBeanFactory {
       }
       

  4. 额外的接口BeanDefinitionRegistry
     这个接口基本用来操作定义在工厂内部的BeanDefinition的

     public interface BeanDefinitionRegistry extends AliasRegistry { 
         // 给定bean名称，注册一个新的bean定义 
         void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException; 
         
         /*
         * 根据指定Bean名移除对应的Bean定义 
         */ 
         void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException; 
         
         /*
         * 根据指定bean名得到对应的Bean定义
         */ 
         BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException; 
         
         /** 查找，指定的Bean名是否包含Bean定义 */ 
         boolean containsBeanDefinition(String beanName); 
         
         String[] getBeanDefinitionNames();//返回本容器内所有注册的Bean定义名称 
         int getBeanDefinitionCount();//返回本容器内注册的Bean定义数目 
         boolean isBeanNameInUse(String beanName);//指定Bean名是否被注册过。
     }
     

• BeanDefinition 体系结构

  
  images
  1. AttributeAccessor

  // 定义用于附加和访问元数据的通用的接口，来自任意对象
  public interface AttributeAccessor {
      // 将name的属性值设置为value
      void setAttribute(String name, Object value);
  　　// 获取name的属性值，如果该属性不存在，则返回Null
      Object getAttribute(String name);
  　　// 删除name的属性值，如果找不到Name属性的值则返回Null
      Object removeAttribute(String name);
      // 如果name属性值存在则返回true，否者返回false
      boolean hasAttribute(String name);
      // 返回所有的属性名称
      String[] attributeNames();
  
  }
  

  2. BeanMetadataElement

  public interface BeanMetadataElement {
      /**
      * Return the configuration source {@code Object} for this metadata element
      * (may be {@code null}).
      */
      @Nullable
      Object getSource();
  
  }
  

至此 BeanFactory 的体系结构便简单介绍完了。BeanFactory 体系中核心主要是：

1. BeanFactory：Bean 工厂定义了一系列操作 Bean 的方法
2. BeanDefinition: Spring 对 Bean 信息的一个抽象，其中包含了 Bean 的作用域、懒加载信息、class、 beanName 等一列 Bean 的元数据信息
3. BeanDefinitionRegistry： BeanDefinition 的注册器，将 Bean 配置信息转化为 BeanDefinition 对象