Spring IOC 源码笔记

最新推荐文章于 2024-09-27 20:07:43 发布

QuantumBroken

最新推荐文章于 2024-09-27 20:07:43 发布

阅读量112

点赞数

分类专栏： spring 文章标签： spring

本文链接：https://blog.csdn.net/aajjw/article/details/117469395

版权

spring 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

接口，类和组件

BeanFactory：IOC容器的顶级接口，通过BeanFactory获取bean
HierarchicalBeanFactory：具有层级结构的BeanFactory，即父子BeanFactory
ConfigurableBeanFactory：可配置的BeanFactory接口，提供配置方法配置BeanFactory
ListableBeanFactory：BeanFactory接口的扩展，由可以枚举其所有 bean 实例的 bean 工厂实现，而不是按照客户的要求逐一尝试通过名称查找 bean。
AutowireCapableBeanFactory：
- 为已经实例化的对象装配属性，这些属性对象都是Spring管理的；
- 实例化一个类型，并自动装配，这些属性对象都是Spring管理的，实例话的类不被Spring管理。所以这个接口提供功能就是自动装配bean相关的，具体实现方式来看源代码。
DefaultListableBeanFactory：BeanFactory接口的（间接，默认）实现类
- 对ConfigurableListableBeanFactory和BeanDefinitionRegistry接口的默认实现
- 通常是先读取bean定义，再对bean进行实例化，因此获取bean是耗时低的
- bean定义的读取器是独立实现的，而不是继承DefaultListableBeanFactory，如：XmlBeanDefinitionReader
BeanDefinitionReader：Bean定义读取器接口
- 持有Bean注册器-BeanDefinitionRegistry，通常是DefaultListableBeanFactory实现
- 将读取到的bean定义注册到bean注册器中
XmlBeanDefinitionReader
- 通过SAX读取XML文件，获得Document对象
- 委托BeanDefinitionDocumentReader解析XML内容，获得BeanDefinition，注册到BeanFactory中
BeanDefinitionDocumentReader
- 将XmlBeanDefinitionReader读取的Document对象解析XML内容，获得BeanDefinition，注册到BeanFactory中
ApplicationContext：应用上下文接口
- 用于访问应用程序组件的 Bean 工厂方法。继承自ListableBeanFactory 。
- 以通用方式加载文件资源的能力。继承自org.springframework.core.io.ResourceLoader接口。
- 能够将事件发布到注册的侦听器。继承自ApplicationEventPublisher接口。
- 解析消息的能力，支持国际化。继承自MessageSource接口。
- 从父上下文继承。后代上下文中的定义将始终优先。这意味着，例如，单个父上下文可以被整个 Web 应用程序使用，而每个 servlet 都有自己的子上下文，该子上下文独立于任何其他 servlet 的子上下文
AbstactApplicationContext：ApplicationContext接口的抽象类，启动的主流程在其中定义
直接启动spring容器
- ClassPathXmlApplicationContext：从类的根路径下加载配置⽂件（推荐使⽤）
- FileSystemXmlApplicationContext：从磁盘路径上加载配置⽂件
- AnnotationConfigApplicationContext：纯注解模式下启动Spring容器
web（servlet）项目通过配置监听器-org.springframework.web.context.ContextLoaderListener集成spring
- XmlWebApplicationContext：默认ApplicationContext的实现类
spring boot
- SERVLET应用：AnnotationConfigServletWebServerApplicationContext
- REACTIVE应用：AnnotationConfigReactiveWebServerApplicationContext
- 其他：AnnotationConfigApplicationContext

ApplicationContext初始化主流程

AbstactApplicationContext#refresh

@Override
public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        // Prepare this context for refreshing.
        // 刷新前的准备工作，即准备和验证环境信息/上下文环境
        prepareRefresh();

        // Tell the subclass to refresh the internal bean factory.
        // 初始化BeanFactory-默认实现是DefaultListableBeanFactory
        // 1. 使用SAX对xml文件进行读取，转化为Document
        // 2. 对xml中的各种标签进行解析
        //   2.1 如果是bean标签，将其解析为BeanDefition，并注册到容器中，一般是DefaultListableBeanFactory.beanDefinitionMap
        //   2.2 如果是包扫描标签，则使用ComponentScanBeanDefinitionParser解析
        //      2.2.1 解析的注解类型为：@Component及其子注解（@Repository、@Service、@Controller、@Configuration）
        //      2.2.2 将包扫描路径转化为绝对路径，通过字节流读取包扫描路径下的.class文件
        //      2.2.3 通过ClassReader及其他组件直接解析.class文件的内容为BeanDefition，使用asm技术按JVM规范解析.class文件
        //      2.2.4 将上一步解析得到的BeanDefition注册到容器中，一般是DefaultListableBeanFactory.beanDefinitionMap
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // Prepare the bean factory for use in this context.
        // 对beanFactory进行设置，如类加载器和post-processors
        prepareBeanFactory(beanFactory);

        try {
            // Allows post-processing of the bean factory in context subclasses.
            //子类扩展点：模板设计模式
            postProcessBeanFactory(beanFactory);

            // Invoke factory processors registered as beans in the context.
            // invokeBeanFactoryPostProcessors()方法是执行所有BeanFactory的后置处理器
			//   * 即执行实现BeanDefinitionRegistryPostProcessor接口的实现类，
			//   * 这样就会执行到ConfigurationClassPostProcessor#processConfigBeanDefinitions()
			//   	* 直译：配置类（@Configuration注解的类）后置处理器#处理配置Bean定义信息
			//   	* 该方法委托ConfigurationClassParser#doProcessConfigurationClass()对配置Bean进行解析
			//			* 该方法可以解析@Component，@PropertySource，@ComponentScan， @Import，@ImportResource，@Bean等注解
            invokeBeanFactoryPostProcessors(beanFactory);

            // Register bean processors that intercept bean creation.
            //注册BeanPostProcessors
            // 1. 从beanFactory.beanDefinitionMap中找到BeanPostProcessor接口的实现类的beanDefinition
            // 2. 使用beanFactory.getBean()方法进行实例化/初始化
            // 3. 排序
            // 4. 将排序后的beanPostProcessors注册到beanFactory.beanPostProcessors
            registerBeanPostProcessors(beanFactory);

            // Initialize message source for this context.
            // 初始化MessageSource，国际化支持
            initMessageSource();

            // Initialize event multicaster for this context.
            // 初始化应用消息广播器，并放入applicationEventMulticaster的bean中
            initApplicationEventMulticaster();

            // Initialize other special beans in specific context subclasses.
            // 子类扩展点，子类初始化其他的bean
            onRefresh();

            // Check for listener beans and register them.
            // 在注册的bean中找到listener，注册到广播器中
            registerListeners();

            // Instantiate all remaining (non-lazy-init) singletons.
            //singletons & non-lazy-init bean的初始化
            //  * 通过BeanDefinitions初始化单例非懒加载的bean
            //  	1. 通过反射创建一个bean对象
            //  	2. 设置属性，
            //  	3. initializeBean()
            //			beanPostProcessor.postProcessBeforeInitialization
            //			初始化方法调用：afterPropertiseSet方法，init-method方法
            //			beanPostProcessor.postProcessAfterInitialization
            //  	PS:重要的几个BeanPostProcessor
            //         CommonAnnotationBeanPostProcessor解析@Resource注解完成注入，
            //           还可以解析@PostConstruct、@PreDestroy等bean生命周期注解，
            //           其中依赖注入是调用InstantiationAwareBeanPostProcessor.postProcessProperties()方法
            //              InstantiationAwareBeanPostProcessor接口是BeanPostProcessor子接口
            //           是在设置属性的时候执行的
            //         AutowiredAnnotationBeanPostProcessor解析@Autowired 和 @Value 注解
            //           其中依赖注入是调用InstantiationAwareBeanPostProcessor.postProcessProperties()方法
            //           是在设置属性的时候执行的
            //         AnnotationAwareAspectJAutoProxyCreator AOP
            //           调用BeanPostProcessor.postProcessAfterInitialization
            //		     判断当前类是否可以被切面类代理
            //           如果当前类可以被代理，则使用ProxyFactory类生产出代理类
            //              默认情况下，当前类实现了接口，则使用JDK动态代理，否则使用CGLib代理
            //  * 如果有依赖注入和循环依赖，见下面分析
            //原型Bean的初始化时机：每次通过BeanFactory.getBean()时新生成一个
            //懒加载Bean的初始化时机：延迟使用时加载
            finishBeanFactoryInitialization(beanFactory);

            // Last step: publish corresponding event.
            // 完成刷新过程，通知lifecycleProcessor，同时发出contextRefresh通知别人
            finishRefresh();
        }

        catch (BeansException ex) {
            if (logger.isWarnEnabled()) {
                logger.warn("Exception encountered during context initialization - " +
                        "cancelling refresh attempt: " + ex);
            }

            // Destroy already created singletons to avoid dangling resources.
            destroyBeans();

            // Reset 'active' flag.
            cancelRefresh(ex);

            // Propagate exception to caller.
            throw ex;
        }

        finally {
            // Reset common introspection caches in Spring's core, since we
            // might not ever need metadata for singleton beans anymore...
            resetCommonCaches();
        }
    }
}

处理循环引用

构造器注入无法处理，直接报错

Setter注入，3级缓存池

singletonFactories：bean name --> ObjectFactory 初始化中
earlySingletonObjects：bean name --> bean instance
singletonObjects：bean name --> bean instance

bean的初始化过程

如果无需初始化其他的bean(只有A类)

调用无参构造器，new出一个A类对象a
放到singletonFactories中
填充属性
放到singletonObjects中，从singletonFactories和earlySingletonObjects中移除

如果需要初始化其他的bean（A->B）

调用无参构造器，new出一个A类对象a
放到singletonFactories中
填充属性
- 调用无参构造器，new出一个B类对象b
- 将b放到singletonFactories中
- 填充属性
- 将b放到singletonObjects中，从singletonFactories和earlySingletonObjects中移除
将a放到singletonObjects中，从singletonFactories和earlySingletonObjects中移除

如果有循环引用（A->B，B->A）

调用无参构造器，new出一个A类对象a
放到singletonFactories中
填充属性
- 调用无参构造器，new出一个B类对象b
- 将b放到singletonFactories中
- 填充属性
  - 在singletonFactories中获取到a的引用，完成依赖注入
  - 将a从singletonFactories移除，放到earlySingletonObjects中
- 将b放到singletonObjects中，从singletonFactories和earlySingletonObjects中移除
将a放到singletonObjects中，从singletonFactories和earlySingletonObjects中移除