Spring IOC（一）体系结构

时间：2021-07-29 09:22:50

Spring IOC（一）体系结构

Spring 系列目录(https://www.cnblogs.com/binarylei/p/10198698.html)

BeanFactory 是Spring IOC 容器的鼻祖，是 IOC 容器的基础接口，所有的容器都是从它这里继承实现而来，可见其地位。BeanFactory 提供了最基本的 IOC 容器的功能，即所有的容器至少需要实现的标准。

Spring IOC（一）体系结构

一、BeanFactory

public interface BeanFactory {

    String FACTORY_BEAN_PREFIX = "&";

    // 1. getBean

    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;

    // 2. @since 5.1

    <T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);

    <T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);

    // 3. containsBean

    boolean containsBean(String name);

    // 4. 单例、多例。 bean 的生命周期

    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;

    boolean isPrototype(String name) throws NoSuchBeanDefinitionException;

    // 5. 匹配 bean 的 Class 类型或泛型(ResolvableType)

    boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;

    boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;

    // 6. 其它属性

    Class<?> getType(String name) throws NoSuchBeanDefinitionException;

    String[] getAliases(String name);

}

这些接口定义勾画出了 IOC 容器的基本方法特性。BeanFactory 功能如下：

  1. BeanFactory 是 Spring 容器的 Root Interface
  2. BeanFactory 持有 BeanDefinition，每一个 bean 都有独有的名字。BeanFactory 可以返回单例或多例的对象，取决于 Bean 定义文件。
  3. 可以通过 setters，constructors 进行依赖注入更好，其实这也是常用的方法。
  4. BeanFactory 通过载入配置源文件(XML 文件)的方式，来配置 Bean。
  5. BeanFactory 支持的 bean 生命周期的顺序。有以下接口：
    1. BeanNameAware#setBeanName
    2. BeanClassLoaderAware#setBeanClassLoader
    3. BeanFactoryAware#setBeanFactory
    4. ResourceLoaderAware#setResourceLoader
    5. ApplicationEventPublisherAware#setApplicationEventPublisher
    6. MessageSourceAware#setMessageSource
    7. ApplicationContextAware#setApplicationContext
    8. ServletContextAware#setServletContext
    9. BeanPostProcessors#postProcessBeforeInitialization
    10. InitializingBean#afterPropertiesSet
    11. a custom init-method definition
    12. BeanPostProcessors#postProcessAfterInitialization
    13. DisposableBean#destroy
    14. a custom destroy-method definition

BeanFactory 作为最顶层的一个接口类，它定义了 IOC 容器的基本功能规范，BeanFactory 有三个直接子类接口：ListableBeanFactory、HierarchicalBeanFactory 和 AutowireCapableBeanFactory，还有一个实现类 SimpleJndiBeanFactory。所以接下来依次分析三个子接口。

二、HierarchicalBeanFactory 可分层次 BeanFactory

从 HierarchicalBeanFactory 接口开始就有了父子工厂的概念。

public interface HierarchicalBeanFactory extends BeanFactory {

    // 1. 获取父工厂

    BeanFactory getParentBeanFactory();

    // 2. 在当前工厂(不向上查找父工厂)中获取指定的 bean

    boolean containsLocalBean(String name);

}

三、ListableBeanFactory 可枚举的 BeanFactory

从 ListableBeanFactory 接口开始可以枚举出本工厂生产的所有 bean 了。

public interface ListableBeanFactory extends BeanFactory {

    // 1. 查找 BeanDefinition

    boolean containsBeanDefinition(String beanName);

    int getBeanDefinitionCount();

    String[] getBeanDefinitionNames();

    // 2. 根据类型查找所有 bean 的名称，包括 FactoryBean

    //    includeNonSingletons=false 表示只取单例；

    //    allowEagerInit=true 表示立即加载，false 表示延迟加载。注意：FactoryBean 都是立刻加载的

    String[] getBeanNamesForType(Class<?> type);

    String[] getBeanNamesForType(Class<?> type, boolean includeNonSingletons,

        boolean allowEagerInit);

    // 3. 根据类型查找所有 bean，返回 <beanName, bean>

    <T> Map<String, T> getBeansOfType(Class<T> type) throws BeansException;

    <T> Map<String, T> getBeansOfType(Class<T> type, boolean includeNonSingletons,

        boolean allowEagerInit) throws BeansException;

    // 4.1 根据类上的注解类型查找指定的 bean

    String[] getBeanNamesForAnnotation(Class<? extends Annotation> annotationType);

    Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType)

        throws BeansException;

    // 4.2 查找指定 bean 上的注解

    <A extends Annotation> A findAnnotationOnBean(String beanName,

        Class<A> annotationType) throws NoSuchBeanDefinitionException;

}

总结一下：

  1. 从这个工厂接口开始，可以枚举列出工厂可以生产的所有实例。即可以只查找 beanName，也可以查找对应的对象实例。
  2. 从这个工厂接口开始，BeanDefinition 登场了。
  3. 注意如果是一个层次继承的工厂，则只会列出当前工厂的实例，而不会列出祖先层的实例。

四、AutowireCapableBeanFactory 可自动装配的 BeanFactory

从 AutowireCapableBeanFactory 接口开始可以自动装配 bean 了。

AutowireCapableBeanFactory 直接继承自 BeanFacotory，它扩展了自动装配的功能，根据类定义 BeanDefinition 装配 Bean、执行后置处理器等。值得注意的是，这个接口并没有被 ApplicationContext 继承，因为应用程序几乎不用用到这些接口，当然也可以通过 ApplicationContext#getAutowireCapableBeanFactory() 获得这个 BeanFactory 实例。

public interface AutowireCapableBeanFactory extends BeanFactory {

    // 1. 自动装配的模式，AUTOWIRE_AUTODETECT 已废弃

    int AUTOWIRE_NO = 0;

    int AUTOWIRE_BY_NAME = 1;

    int AUTOWIRE_BY_TYPE = 2;

    int AUTOWIRE_CONSTRUCTOR = 3;

    int AUTOWIRE_AUTODETECT = 4;

    //-------------------------------------------------------------------------

    // Typical methods for creating and populating external bean instances

    //-------------------------------------------------------------------------

    // 2. 默认的方式创建、自动装配、配置 bean

    <T> T createBean(Class<T> beanClass) throws BeansException;

    void autowireBean(Object existingBean) throws BeansException;

    Object configureBean(Object existingBean, String beanName) throws BeansException;

    //-------------------------------------------------------------------------

    // Specialized methods for fine-grained control over the bean lifecycle

    //-------------------------------------------------------------------------

    // 3. 根据给定的策略，创建、自动装配、配置 bean

    Object createBean(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;

    Object autowire(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;

    void autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck)

            throws BeansException;

    // 4. bean 属性注入

    void applyBeanPropertyValues(Object existingBean, String beanName) throws BeansException;

    // 5. bean 生命周期相关的初始化，如 BeanFactoryAware#setBeanFactory、InitializingBean#afterPropertiesSet

    Object initializeBean(Object existingBean, String beanName) throws BeansException;

    void destroyBean(Object existingBean);

    // 6. 后置处理器 BeanPostProcessors 执行

    Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)

            throws BeansException;

    Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)

            throws BeansException;

    // 7.

    <T> NamedBeanHolder<T> resolveNamedBean(Class<T> requiredType) throws BeansException;

    // 8. 属性注入时根据类型查找依赖，支持 List<BeanA> list 集合类型注入

    Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName)

            throws BeansException;

    Object resolveDependency(DependencyDescriptor descriptor, String beanName,

            Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException;

}

总结一下：

  1. 首先几个属性，是装配策略：

    • AUTOWIRE_BY_NAME：把与 Bean 的属性具有相同的名字的其他 Bean 自动装配到这个属性上。举个例子就是：当有一个属性名字为 person 时，则自动装配策略选择 id 为 person 的 Bean 进行装配。
    • AUTOWIRE_BY_TYPE：把与 Bean 的属性具有相同的类型的其他 Bean 自动装配到这个属性。
    • AUTOWIRE_BY_CONSTRUCT：把与 bean 的构造器入参具有相同类型的其他 Bean 自动装配到 Bean 构造器的对应参数中。

  2. 还有两类方法，实际上工作中很少直接用这几个接口

    • Typical methods for creating and populating external bean instances，该类是用来根据典型方法默认创建 Bean 和装配 Bean 的方法。
    • Specialized methods for fine-grained control over the bean lifecycle，该类是用来根据装配策略细化装配，具体控制 Bean 生命周期的方法。

实现类为 AbstractAutowireCapableBeanFactory。还有两个配置的接口 ConfigurableBeanFactory 和 ConfigurableListableBeanFactory 也需要关注一下。

五、ConfigurableBeanFactory 配置 BeanFactory

public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, SingletonBeanRegistry {

    String SCOPE_SINGLETON = "singleton";

    String SCOPE_PROTOTYPE = "prototype";

    // 1. 父工厂

    void setParentBeanFactory(BeanFactory parentBeanFactory) throws IllegalStateException;

    // 2. ClassLoader

    void setBeanClassLoader(@Nullable ClassLoader beanClassLoader);

    ClassLoader getBeanClassLoader();

    void setTempClassLoader(@Nullable ClassLoader tempClassLoader);

    ClassLoader getTempClassLoader();

    // 3. 缓存

    void setCacheBeanMetadata(boolean cacheBeanMetadata);

    boolean isCacheBeanMetadata();

    // 4. Spring el 表达式解析器

    void setBeanExpressionResolver(@Nullable BeanExpressionResolver resolver);

    BeanExpressionResolver getBeanExpressionResolver();

    // 5.1 ConversionService  类型转换

    void setConversionService(@Nullable ConversionService conversionService);

    ConversionService getConversionService();

    // 5.2 PropertyEditor 类型转换

    void addPropertyEditorRegistrar(PropertyEditorRegistrar registrar);

    void registerCustomEditor(Class<?> requiredType, Class<? extends PropertyEditor> propertyEditorClass);

    void copyRegisteredEditorsTo(PropertyEditorRegistry registry);

    // 5.3 类型转换

    void setTypeConverter(TypeConverter typeConverter);

    TypeConverter getTypeConverter();

    // 6. ${key} 占位符解析

    void addEmbeddedValueResolver(StringValueResolver valueResolver);

    boolean hasEmbeddedValueResolver();

    String resolveEmbeddedValue(String value);

    // 7. 后置处理器

    void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);

    int getBeanPostProcessorCount();

    // 8.

    void registerScope(String scopeName, Scope scope);

    String[] getRegisteredScopeNames();

    Scope getRegisteredScope(String scopeName);

    AccessControlContext getAccessControlContext();

    // 9. copy 配置

    void copyConfigurationFrom(ConfigurableBeanFactory otherFactory);

    // 10. bean 别名注册

    void registerAlias(String beanName, String alias) throws BeanDefinitionStoreException;

    void resolveAliases(StringValueResolver valueResolver);

    // 11. BeanDefinition

    BeanDefinition getMergedBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

    // 12. FactoryBean

    boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException;

    // 13. bean 创建状态

    void setCurrentlyInCreation(String beanName, boolean inCreation);

    boolean isCurrentlyInCreation(String beanName);

    // 14. 注册依赖

    void registerDependentBean(String beanName, String dependentBeanName);

    String[] getDependentBeans(String beanName);

    String[] getDependenciesForBean(String beanName);

    // 15. 销毁 bean

    void destroyBean(String beanName, Object beanInstance);

    void destroyScopedBean(String beanName);

    void destroySingletons();

}

实现类为 AbstractBeanFactory。

六、ConfigurableListableBeanFactory 集大成者

提供解析，修改 bean定义，并与初始化单例。

public interface ConfigurableListableBeanFactory

        extends ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory {

    // 1. 忽略依赖检查，如 String/BeanFacory

    void ignoreDependencyType(Class<?> type);

    void ignoreDependencyInterface(Class<?> ifc);

    // 2. 注册依赖关系

    void registerResolvableDependency(Class<?> dependencyType, @Nullable Object autowiredValue);

    // 3. 依赖注入时查找是否是可以依赖的 bean

    boolean isAutowireCandidate(String beanName, DependencyDescriptor descriptor)

            throws NoSuchBeanDefinitionException;

    // 4. BeanDefinition 和 bean 遍历

    BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

    Iterator<String> getBeanNamesIterator();

    // 5. 清除不能缓存的 BeanDefinition，当 configurationFrozen=true 时可以缓存

    void clearMetadataCache();

    // 5.2 configurationFrozen=true 时缓存 BeanDefinition 信息

    void freezeConfiguration();

    boolean isConfigurationFrozen();

    // 6. 实例化非懒加载的 bean

    void preInstantiateSingletons() throws BeansException;

}

实现类为 DefaultListableBeanFactory。

此外 Spring BeanFactory 的实现还有三个重要的实现类，功能如下：

  • AbstractBeanFactory 实现了 BeanFactory、 HierarchicalBeanFactory、ConfigurableBeanFactory 三个接口，最重要的方法是实现了 getBean(beanName) 接口，这个方法的最重要的步骤-创建 bean 则委托给模板方法 createBean 完成。

  • AbstractAutowireCapableBeanFactory 实现了 AutowireCapableBeanFactory 接口，也就是依赖注入。同时实现了 crcreateBean(beanName, mbd, args) 创建 bean 的三个重要过程：实例化(createBeanInstance)、依赖注入(populateBean)、初始化(initializeBean)。其中依赖注入又分为 autowireByName 和 autowireByType 二种，其中名称查找很简单，而类型查找就复杂了很多。Spring 将类型查找委托给了子类的 resolveDependency 完成。

  • DefaultListableBeanFactory 实现了 ConfigurableListableBeanFactory、BeanDefinitionRegistry 两个接口，提供了 Bean 和 BeanDefinition 查找注册的功能。 这个类一个很重要的功能是实现了模板方法 resolveDependency，这样就可以根据类型查找依赖。

每天用心记录一点点。内容也许不重要，但习惯很重要！

相关文章