首页  流程图  详情

spring IOC 源码

2023-03-13 17:50:30   2  举报





自己画的spring源码流程图，仅供参考

java

spring

作者其他创作

大纲/内容

主要逻辑

//对我们的配置类进行Order排序

//定义一个集合用户保存当前准备创建的BeanDefinitionRegistryPostProcessorList<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

添加

很重要DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);

//没有任何拍下接口的

清理

注册一些内置的后置处理器AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);

//获取所有的bean定义String[] newCandidateNames = registry.getBeanDefinitionNames();

//实现了我们ordered接口的List<String> orderedPostProcessorNames = new ArrayList<>();

//循环判断当前循环的还没有被解析过

清除上下文级别的资源缓存（例如来自扫描的ASM元数据）

循环处理bean定义后置处理器包括我们自己定义的

创建一个早期的事件监听对象

//在这里获取我们的早期事件

设置资源加载器

没有找到配置类直接返回

// 创建我们通过@CompentScan导入进来的bean name的生成器

ioc容器刷新接口

//判断我们ioc容器中的是不是>候选原始的bean定义的个数

//强行把我们的bean工厂转为BeanDefinitionRegistry，因为待会需要注册Bean定义BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;

//用于保存我们的已经解析的配置类，长度默认为解析出来默认的配置类的集合长度Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());

//同时也加入到processedBeans集合中去processedBeans.add(ppName);

// 处理关于aspectj

注册事件监听器工厂

//循环上一步获取的BeanDefinitionRegistryPostProcessor的类型名称

// 在这里赋null。也就是值此之后都将没有早期事件了

font color=\"#f44336\

//真正的解析我们的配置类parser.parse(candidates);

//保存BeanFactoryPostProcessor类型实现了Ordered接口的List<String> orderedPostProcessorNames = new ArrayList<>();

//获取容器中所有的监听器对象// 这个时候正常流程是不会有监听器的// （因为监听器不会在这之前注册，在initApplicationEventMulticaster后在registerListeners之前，只有一个可能在：在onRefresh里面注册了监听器）

* 为我们的Spring应用上下文对象创建我们的beanFactoryDefaultListableBeanFactory beanFactory = createBeanFactory();

//调用完之后，马上clear掉currentRegistryProcessors.clear();

//加入到集合中internalPostProcessors.add(pp);

//第一步:去容器中获取BeanDefinitionRegistryPostProcessor的bean的处理器名称

//保存BeanDefinitionRegistryPostProcessor类型的后置处理器 BeanDefinitionRegistryPostProcessor 提供注册List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

* 创建一个读取注解的Bean定义读取器 * 什么是bean定义？BeanDefinition * 完成了spring内部BeanDefinition的注册（主要是后置处理器）this.reader = new AnnotatedBeanDefinitionReader(this);

//调用没有实现任何优先级接口的BeanDefinitionRegistryPostProcessor//定义一个重复处理的开关变量默认值为trueboolean reiterate = true;

new AnnotatedGenericBeanDefinition(annotatedClass);

//注册了bean工厂的内部的bean

//排序并且注册我们实现了Order接口的后置处理器

//获取IOC 容器中目前所有bean定义的名称String[] candidateNames = registry.getBeanDefinitionNames();

10: 把我们的事件监听器注册到多播器上registerListeners();

//设置@Import导入进来的bean的名称生成器(默认类首字母小写）也可以自己定义，一般不会

//判断是否实现了PriorityOrdered 优先级最高

//用于保存我们的配置类BeanDefinitionHolder放入上面筛选出来的配置类Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);

* 创建一个容器用于保存早期待发布的事件集合 * 什么是早期事件? * 就是我们的事件监听器还没有注册到多播器上的时候都称为早期事件 * 早期事件不需要手动publishEvent发布，在registerListeners中会自动发布，发布完早期事件就不存在了。this.earlyApplicationEvents = new LinkedHashSet<>();

开始处理bean的后置处理器

析通用注解，解填充到AnnotatedGenericBeanDefinition，解析的注解为Lazy，Primary，DependsOn，Role，Description

//若已经存在了就信息销毁等操作

//判断我们的beanFactory实现了BeanDefinitionRegistry(实现了该结构就有注册和获取Bean定义的能力）

为容器设置一个序列化ID

获得bean名称

//判断是否实现了Ordered 优先级其次

// 定义已处理的后置处理器Set<String> processedBeans = new HashSet<>();

//保存BeanFactoryPostProcessor类型的后置 BeanFactoryPostProcessor 提供修改List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();

// 发布容器启动完毕事件

8: 创建事件多播器initApplicationEventMulticaster();

是

//把他加入到用于保存到registryProcessors中registryProcessors.addAll(currentRegistryProcessors);

//把监听器挨个的注册到我们的多播器上去

调用自定义Order接口BeanDefinitionRegistryPostProcessor完毕-优先级No2-End

// 把当前的加入到总的里面去registryProcessors.addAll(currentRegistryProcessors);

postProcessBeanDefinitionRegistry

全部添加

@Required 注解处理器

调用内置实现PriorityOrdered接口ConfigurationClassPostProcessor完毕--优先级No1-End

//为bean工厂设置我们标准的SPEL表达式解析器对象

//把监听器的名称注册到我们的多播器上

//再调用BeanFactoryPostProcessor实现了 Ordered.

// 注册当前spring容器到LiveBeansView// 提供servlet(LiveBeansViewServlet)在线查看所有的bean json 、为了支持Spring Tool Suite的智能提示

Autowired注解处理器

判断

//进行强制转化

//判断是否实现了PriorityOrdered接口的

先处理bean定义工厂后置处理器

//再次设置为truereiterate = true;

2: 获取告诉子类初始化bean工厂prepareBeanFactory(beanFactory);

// 创建我们通过@Import导入进来的bean的名称

用来校验我们容器启动必须依赖的环境变量的值

//判断是否实现了OrderedorderedPostProcessorNames.add(ppName);

//循环我们传递进来的beanFactoryPostProcessors也就是我们自定义的

//判断是否有没有解析过

//保存BeanFactoryPostProcessor类型实现了priorityOrderedList<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();

//加入到已经解析的集合中alreadyParsed.addAll(configClasses);

//为我们的bean工厂设置了一个propertityEditor 属性资源编辑器对象(用于后面的给bean对象赋值使用)

//冻结所有的 bean 定义，说明注册的 bean 定义将不被修改或任何进一步的处理

//把ApplicationContext对象赋值给AnnotatedBeanDefinitionReaderthis.registry = registry;

this.scopeMetadataResolver.resolveScopeMetadata(abd);

//进入循环马上把开关变量给改为falsereiterate = false;

注册实现了order接口的排序器

* 当注册了依赖解析后，例如当注册了对 BeanFactory.class 的解析依赖后， * 当 bean 的属性注入的时候，一旦检测到属性为 BeanFactory 类型便会将 beanFactory 的实例注入进去。 * 知道为什么可以 @Autowired * ApplicationContext applicationContext 就是因为这里设置了

方法解析

判断是否需要跳过注解，spring中有一个@Condition注解，当不满足条件，这个bean就不会被解析

//判断我们的后置处理器是不是BeanDefinitionRegistryPostProcessor

/ 实例化我们所有的非排序接口的

//原始的老的候选的bean定义Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));

3: 对bean工厂进行属性填充prepareBeanFactory(beanFactory);

* 创建BeanDefinition扫描器 * 可以用来扫描包或者类，继而转换为bd * spring默认的扫描包不是这个scanner对象 * 而是自己new的一个ClassPathBeanDefinitionScanner * spring在执行工程后置处理器ConfigurationClassPostProcessor时，去扫描包时会new一个ClassPathBeanDefinitionScanner * 这里的scanner仅仅是为了程序员可以手动调用AnnotationConfigApplicationContext对象的scan方法this.scanner = new ClassPathBeanDefinitionScanner(this);

// 把实现了priorityOrdered注册到容器中

排序

//注册我们的配置类register(annotatedClasses);

5: bean工厂的后置处理器1). 会在此将class扫描成beanDefinition 2).bean工厂的后置处理器调用invokeBeanFactoryPostProcessors(beanFactory);

1 准备刷新上下文环境prepareRefresh();

//保存实现了priorityOrdered接口的List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();

为容器中注册了解析我们配置类的后置处理器ConfigurationClassPortProcessor

//保存BeanFactoryPostProcessor没有实现任何优先级接口的List<String> nonOrderedPostProcessorNames = new ArrayList<>();

调用没有实现任何优先级接口自定义BeanDefinitionRegistryPostProcessor完毕--End

//设置bean工厂的类加载器为当前application应用的加载器beanFactory.setBeanClassLoader(getClassLoader());

//注册我们普通的没有实现任何排序接口的

//注册了一个完整的ApplicationContextAwareProcessor 后置处理器用来处理ApplicationContextAware接口的回调方法

//获取bean定义中的监听器对象

//循环我们的上一步获取的所有的bean定义信息

candidates.clear();

开始遍历后置处理器 postProcessorNames

// 注册lifecycleProcessor 声明周期处理器// 作用：当ApplicationContext启动或停止时，它会通过LifecycleProcessor来与所有声明的bean的周期做状态更新

//processedBeans包含的话，表示在上面处理BeanDefinitionRegistryPostProcessor的时候处理过了-- 跳过

//加入到集合中priorityOrderedPostProcessors.add(pp);

实现了

7: 初始化国家化资源处理器initMessageSource();

//系统内部的List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();

注册我们的配置类

bean定义扫描器

//没有实现任何的优先级接口的最后调用

* xml加载spring会在这里加载beanDefinition * javaconfig只是刷新了beanFactoryrefreshBeanFactory();

//通过bean的名称来获取我们的bean定义对象BeanDefinition beanDef = registry.getBeanDefinition(beanName);

6: 注册我们的后置处理器registerBeanPostProcessors(beanFactory);

//设置@CompentScan导入进来的bean的名称生成器(默认类首字母小写）也可以自己定义，一般不会

// 为我们的bean工厂创建类型转化器 Convert

设置环境对象

// 处理aspectj的

new AnnotationConfigApplicationContext(MainConfig.class);

//注册.MergedBeanDefinitionPostProcessor类型的后置处理器 bean 合并后的处理， Autowired 注解正是通过此方法实现诸如类型的预解析。

//解析出来的配置类Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());

//实例化剩余的单实例bean

jpa注解的处理器

//注册了一个事件监听器探测器后置处理器接口

//调用没有实现任何方法接口的

11: 实例化我们剩余的单例beanfinishBeanFactoryInitialization(beanFactory);

清除

否

存储@Configuration注解注释的类

/ 处理实现Ordered的bean定义

//没有被处理过的

//循环我们的bean定义(BeanPostProcessor)

//进行正在的解析判断是不是完全的配置类还是一个非正式的配置类

//没有优先级的List<String> nonOrderedPostProcessorNames = new ArrayList<>();

bean定义读取器

getEnvironment().validateRequiredProperties();

加载我们的bean定义

Set<String> alreadyParsedClasses = new HashSet<>();

为实现了SmartLifecycle并且isAutoStartup 自动启动的Lifecycle调用start()方法

//注册ApplicationListenerDetector 应用监听器探测器的后置处理器

调用构造函数

//调用他作为BeanDefinitionRegistryPostProcessor的处理器的后置方法

//添加到我们用于保存的BeanDefinitionRegistryPostProcessor的集合中registryProcessors.add(registryProcessor);

List<BeanDefinitionHolder> configCandidates = new ArrayList<>();

//调用构造函数this();

//若没有实现BeanDefinitionRegistryPostProcessor 接口，那么他就是BeanFactoryPostProcessor//把当前的后置处理器加入到regularPostProcessors中regularPostProcessors.add(postProcessor);

处理

//真正的解析我们的bean定义processConfigBeanDefinitions(registry);

4: 留给子类去实现该接口postProcessBeanFactory(beanFactory);

@EventListener解析器

//do while 会进行第一次解析

直接getBean

//判断是否实现了MergedBeanDefinitionPostProcessor

//第一次就可以进来while (reiterate) {

没有实现

AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);

// 此处才把@Bean的方法和@Import 注册到BeanDefinitionMap中this.reader.loadBeanDefinitions(configClasses);

JSR规范的注解处理器