Spring IOC(一)体系结构

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

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

一、BeanFactory

  1. public interface BeanFactory {
  2. String FACTORY_BEAN_PREFIX = "&";
  3. // 1. getBean
  4. Object getBean(String name) throws BeansException;
  5. <T> T getBean(String name, Class<T> requiredType) throws BeansException;
  6. Object getBean(String name, Object... args) throws BeansException;
  7. <T> T getBean(Class<T> requiredType) throws BeansException;
  8. // 2. @since 5.1
  9. <T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);
  10. <T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);
  11. // 3. containsBean
  12. boolean containsBean(String name);
  13. // 4. 单例、多例。 bean 的生命周期
  14. boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
  15. boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
  16. // 5. 匹配 bean 的 Class 类型或泛型(ResolvableType)
  17. boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
  18. boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;
  19. // 6. 其它属性
  20. Class<?> getType(String name) throws NoSuchBeanDefinitionException;
  21. String[] getAliases(String name);
  22. }

这些接口定义勾画出了 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 接口开始就有了父子工厂的概念。

  1. public interface HierarchicalBeanFactory extends BeanFactory {
  2. // 1. 获取父工厂
  3. BeanFactory getParentBeanFactory();
  4. // 2. 在当前工厂(不向上查找父工厂)中获取指定的 bean
  5. boolean containsLocalBean(String name);
  6. }

三、ListableBeanFactory 可枚举的 BeanFactory

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

  1. public interface ListableBeanFactory extends BeanFactory {
  2. // 1. 查找 BeanDefinition
  3. boolean containsBeanDefinition(String beanName);
  4. int getBeanDefinitionCount();
  5. String[] getBeanDefinitionNames();
  6. // 2. 根据类型查找所有 bean 的名称,包括 FactoryBean
  7. // includeNonSingletons=false 表示只取单例;
  8. // allowEagerInit=true 表示立即加载,false 表示延迟加载。注意:FactoryBean 都是立刻加载的
  9. String[] getBeanNamesForType(Class<?> type);
  10. String[] getBeanNamesForType(Class<?> type, boolean includeNonSingletons,
  11. boolean allowEagerInit);
  12. // 3. 根据类型查找所有 bean,返回 <beanName, bean>
  13. <T> Map<String, T> getBeansOfType(Class<T> type) throws BeansException;
  14. <T> Map<String, T> getBeansOfType(Class<T> type, boolean includeNonSingletons,
  15. boolean allowEagerInit) throws BeansException;
  16. // 4.1 根据类上的注解类型查找指定的 bean
  17. String[] getBeanNamesForAnnotation(Class<? extends Annotation> annotationType);
  18. Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType)
  19. throws BeansException;
  20. // 4.2 查找指定 bean 上的注解
  21. <A extends Annotation> A findAnnotationOnBean(String beanName,
  22. Class<A> annotationType) throws NoSuchBeanDefinitionException;
  23. }

总结一下:

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

四、AutowireCapableBeanFactory 可自动装配的 BeanFactory

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

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

  1. public interface AutowireCapableBeanFactory extends BeanFactory {
  2. // 1. 自动装配的模式,AUTOWIRE_AUTODETECT 已废弃
  3. int AUTOWIRE_NO = 0;
  4. int AUTOWIRE_BY_NAME = 1;
  5. int AUTOWIRE_BY_TYPE = 2;
  6. int AUTOWIRE_CONSTRUCTOR = 3;
  7. int AUTOWIRE_AUTODETECT = 4;
  8. //-------------------------------------------------------------------------
  9. // Typical methods for creating and populating external bean instances
  10. //-------------------------------------------------------------------------
  11. // 2. 默认的方式创建、自动装配、配置 bean
  12. <T> T createBean(Class<T> beanClass) throws BeansException;
  13. void autowireBean(Object existingBean) throws BeansException;
  14. Object configureBean(Object existingBean, String beanName) throws BeansException;
  15. //-------------------------------------------------------------------------
  16. // Specialized methods for fine-grained control over the bean lifecycle
  17. //-------------------------------------------------------------------------
  18. // 3. 根据给定的策略,创建、自动装配、配置 bean
  19. Object createBean(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;
  20. Object autowire(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;
  21. void autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck)
  22. throws BeansException;
  23. // 4. bean 属性注入
  24. void applyBeanPropertyValues(Object existingBean, String beanName) throws BeansException;
  25. // 5. bean 生命周期相关的初始化,如 BeanFactoryAware#setBeanFactory、InitializingBean#afterPropertiesSet
  26. Object initializeBean(Object existingBean, String beanName) throws BeansException;
  27. void destroyBean(Object existingBean);
  28. // 6. 后置处理器 BeanPostProcessors 执行
  29. Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
  30. throws BeansException;
  31. Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
  32. throws BeansException;
  33. // 7.
  34. <T> NamedBeanHolder<T> resolveNamedBean(Class<T> requiredType) throws BeansException;
  35. // 8. 属性注入时根据类型查找依赖,支持 List<BeanA> list 集合类型注入
  36. Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName)
  37. throws BeansException;
  38. Object resolveDependency(DependencyDescriptor descriptor, String beanName,
  39. Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException;
  40. }

总结一下:

  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

  1. public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, SingletonBeanRegistry {
  2. String SCOPE_SINGLETON = "singleton";
  3. String SCOPE_PROTOTYPE = "prototype";
  4. // 1. 父工厂
  5. void setParentBeanFactory(BeanFactory parentBeanFactory) throws IllegalStateException;
  6. // 2. ClassLoader
  7. void setBeanClassLoader(@Nullable ClassLoader beanClassLoader);
  8. ClassLoader getBeanClassLoader();
  9. void setTempClassLoader(@Nullable ClassLoader tempClassLoader);
  10. ClassLoader getTempClassLoader();
  11. // 3. 缓存
  12. void setCacheBeanMetadata(boolean cacheBeanMetadata);
  13. boolean isCacheBeanMetadata();
  14. // 4. Spring el 表达式解析器
  15. void setBeanExpressionResolver(@Nullable BeanExpressionResolver resolver);
  16. BeanExpressionResolver getBeanExpressionResolver();
  17. // 5.1 ConversionService 类型转换
  18. void setConversionService(@Nullable ConversionService conversionService);
  19. ConversionService getConversionService();
  20. // 5.2 PropertyEditor 类型转换
  21. void addPropertyEditorRegistrar(PropertyEditorRegistrar registrar);
  22. void registerCustomEditor(Class<?> requiredType, Class<? extends PropertyEditor> propertyEditorClass);
  23. void copyRegisteredEditorsTo(PropertyEditorRegistry registry);
  24. // 5.3 类型转换
  25. void setTypeConverter(TypeConverter typeConverter);
  26. TypeConverter getTypeConverter();
  27. // 6. ${key} 占位符解析
  28. void addEmbeddedValueResolver(StringValueResolver valueResolver);
  29. boolean hasEmbeddedValueResolver();
  30. String resolveEmbeddedValue(String value);
  31. // 7. 后置处理器
  32. void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);
  33. int getBeanPostProcessorCount();
  34. // 8.
  35. void registerScope(String scopeName, Scope scope);
  36. String[] getRegisteredScopeNames();
  37. Scope getRegisteredScope(String scopeName);
  38. AccessControlContext getAccessControlContext();
  39. // 9. copy 配置
  40. void copyConfigurationFrom(ConfigurableBeanFactory otherFactory);
  41. // 10. bean 别名注册
  42. void registerAlias(String beanName, String alias) throws BeanDefinitionStoreException;
  43. void resolveAliases(StringValueResolver valueResolver);
  44. // 11. BeanDefinition
  45. BeanDefinition getMergedBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
  46. // 12. FactoryBean
  47. boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException;
  48. // 13. bean 创建状态
  49. void setCurrentlyInCreation(String beanName, boolean inCreation);
  50. boolean isCurrentlyInCreation(String beanName);
  51. // 14. 注册依赖
  52. void registerDependentBean(String beanName, String dependentBeanName);
  53. String[] getDependentBeans(String beanName);
  54. String[] getDependenciesForBean(String beanName);
  55. // 15. 销毁 bean
  56. void destroyBean(String beanName, Object beanInstance);
  57. void destroyScopedBean(String beanName);
  58. void destroySingletons();
  59. }

实现类为 AbstractBeanFactory。

六、ConfigurableListableBeanFactory 集大成者

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

  1. public interface ConfigurableListableBeanFactory
  2. extends ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory {
  3. // 1. 忽略依赖检查,如 String/BeanFacory
  4. void ignoreDependencyType(Class<?> type);
  5. void ignoreDependencyInterface(Class<?> ifc);
  6. // 2. 注册依赖关系
  7. void registerResolvableDependency(Class<?> dependencyType, @Nullable Object autowiredValue);
  8. // 3. 依赖注入时查找是否是可以依赖的 bean
  9. boolean isAutowireCandidate(String beanName, DependencyDescriptor descriptor)
  10. throws NoSuchBeanDefinitionException;
  11. // 4. BeanDefinition 和 bean 遍历
  12. BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
  13. Iterator<String> getBeanNamesIterator();
  14. // 5. 清除不能缓存的 BeanDefinition,当 configurationFrozen=true 时可以缓存
  15. void clearMetadataCache();
  16. // 5.2 configurationFrozen=true 时缓存 BeanDefinition 信息
  17. void freezeConfiguration();
  18. boolean isConfigurationFrozen();
  19. // 6. 实例化非懒加载的 bean
  20. void preInstantiateSingletons() throws BeansException;
  21. }

实现类为 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,这样就可以根据类型查找依赖。


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

Spring IOC(一)体系结构的更多相关文章

  1. Spring之一:IoC容器体系结构

    温故而知心. Spring IoC概述 常说spring的控制反转(依赖反转),看看维基百科的解释: 如果合作对象的引用或依赖关系的管理要由具体对象来完成,会导致代码的高度耦合和可测试性降低,这对复杂 ...

  2. 【初探Spring】------Spring IOC(三):初始化过程---Resource定位

    我们知道Spring的IoC起到了一个容器的作用,其中装得都是各种各样的Bean.同时在我们刚刚开始学习Spring的时候都是通过xml文件来定义Bean,Spring会某种方式加载这些xml文件,然 ...

  3. Spring IoC源码解析——Bean的创建和初始化

    Spring介绍 Spring(http://spring.io/)是一个轻量级的Java 开发框架,同时也是轻量级的IoC和AOP的容器框架,主要是针对JavaBean的生命周期进行管理的轻量级容器 ...

  4. 谈谈对Spring IOC的理解(转)

    学习过Spring框架的人一定都会听过Spring的IoC(控制反转) .DI(依赖注入)这两个概念,对于初学Spring的人来说,总觉得IoC .DI这两个概念是模糊不清的,是很难理解的,今天和大家 ...

  5. spring ioc 源码解析

    什么是ioc? 通俗的解释是:(spring)框架中,完成对象的创建和注入的容器. springIOC体系结构: spring IOC的创建是典型的工厂模式,这一系列的bean工厂如上所示. 其核心是 ...

  6. Spring:源码解读Spring IOC原理

    Spring IOC设计原理解析:本文乃学习整理参考而来 一. 什么是Ioc/DI? 二. Spring IOC体系结构 (1) BeanFactory (2) BeanDefinition 三. I ...

  7. 谈谈对Spring IOC的理解

    学习过Spring框架的人一定都会听过Spring的IoC(控制反转) .DI(依赖注入)这两个概念,对于初学Spring的人来说,总觉得IoC .DI这两个概念是模糊不清的,是很难理解的,今天和大家 ...

  8. Spring系列之谈谈对Spring IOC的理解

    学习过Spring框架的人一定都会听过Spring的IoC(控制反转) .DI(依赖注入)这两个概念,对于初学Spring的人来说,总觉得IOC .DI这两个概念是模糊不清的,是很难理解的,今天和大家 ...

  9. 谈谈对Spring IOC的理解【转】

    学习过Spring框架的人 一定都会听过Spring的IoC(控制反转) .DI(依赖注入)这两个概念,对于初学Spring的人来说,总觉得IoC .DI这两个概念是模糊不清的,是很难理解的,今天和大 ...

随机推荐

  1. opencv批量修改图片尺寸

    #include"opencv2/opencv.hpp" using namespace std; using namespace cv; #include<opencv2/ ...

  2. aspectj ----- 简介

    一.为什么写这个系列的博客   Aspectj一个易用的.功能强大的aop编程语言.其官网地址是:http://www.eclipse.org/aspectj/,目前最新版本为:1.7.0 RC1.但 ...

  3. git 使用说明

    git使用的一些说明 关于新用户1. 到优居客群里下载git客户端2. 安装之后打开git bash3. 生成密钥,执行如下命令:    ssh-keygen -t rsa -C "你的邮箱 ...

  4. 665. Non-decreasing Array

    Given an array with n integers, your task is to check if it could become non-decreasing by modifying ...

  5. E-R图学习笔记

    E-R图也称实体-联系图(Entity Relationship Diagram),提供了表示实体类型.属性和联系的方法,用来描述现实世界的概念模型.   方法 编辑 E-R方法是“实体-联系方法”( ...

  6. python基础入门学习2

    python 整体注释:选中所有然后CTRL+? 运算符 + - * /   **  %  // 布尔值 true 真  False 假 !=不等于 <>不等于 算数运算,赋值运算,比较运 ...

  7. python 自动补全

    一.查看python 环境变量 >>> import sys>>> sys.path 编写 tab.py import sys import atexit impo ...

  8. 7. Reverse Integer (整数的溢出)

    Reverse digits of an integer. Example1: x = 123, return 321Example2: x = -123, return -321 For the p ...

  9. python之图像识别

    1. 安装配置 1.pip install pytesseract 2.pip install pillow 3.安装tesseract-ocr:http://jaist.dl.sourceforge ...

  10. Codeforces Round #541 (Div. 2)

    Codeforces Round #541 (Div. 2) http://codeforces.com/contest/1131 A #include<bits/stdc++.h> us ...