Spring 源码核心解析流程架构图
2022-01-18 18:23:55 0 举报
登录查看完整内容
精通spring源码流程图 交流可加微信xri2117
作者其他创作
大纲/内容
else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class))
存在
注册 registerBeanDefinition
if (event instanceof ApplicationEvent) {
添加
判断如果是 @Import的类
递归处理，有可能 import 进来的类又有 @Import 注解
创建的实例加入到容器
List<SourceClass> annotatedClasses = new ArrayList<>(classNames.length)
true
进行注册
getApplicationEventMulticaster() 获取 refresh() 方法中注册时间类 new SimpleApplicationEventMulticaster然后加入到 applicationListenerBeans 容器中
this.beanDefinitionNames.add(beanName)
String beanName = (!names.isEmpty() ? names.remove(0) : methodName)
核心方法 拿到类的完整限定名才可以获取 MetaData 对象
Set<BeanDefinitionHolder> beanDefinitions
if (!processedBeans.contains(ppName))
org.springframework.context.annotation.internalConfigurationAnnotationProcessor
注册建立映射关系
for (AnnotationAttributes componentScan : componentScans)
扫描
refreshBeanFactory()
匹配的加入到 BeanDefinition set
设置一些默认值填充 支持了@Lazy @DependOn注解
for (String ppName : postProcessorNames)
初始化beanFacotry
for (String ppName : postProcessorNames)
false
加入到 importBeanDefinitionRegistrars 容器中，这里还没有调用 registerBeanDefinitions
registerListeners()
publishEvent(new ContextRefreshedEvent(this));
metadata = metadataReader.getAnnotationMetadata()
添加负责把 ApplicantsListener 类型的 Bean 注册到 ApplicationContext中
getResourcePatternResolver().getResources(packageSearchPath)
直接返回
创建 beanDefinition
BeanDefinition bd = holder.getBeanDefinition()
上面已经执行过核心扫描所有类 这里再次进行寻找实现了 BeanDefinitionRegistryPostProcessor 接口的类就有可能获取到自己写的交给spring管理的类注意这里是 已经容器扫描过的并不是容器还没开始之前直接加入到 addBeanFactoryPostProcessor
this.beanFactory = new DefaultListableBeanFactory()
AnnotationConfigApplicationContext(Class<?>... annotatedClasses)
执行扫描
加入到容器 private final List<BeanPostProcessor> beanPostProcessors = new CopyOnWriteArrayList<>();
registryProcessor.postProcessBeanDefinitionRegistry(registry)
排序后执行调用
调用了 实现BeanFactoryPostProcessor接口以及子类BeanDefinitionRegistryPostProcessor 接口的postProcessBeanFactory方法
if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME))
metadata = ((AnnotatedBeanDefinition) beanDef).getMetadata()
finishBeanFactoryInitialization(beanFactory)
获取内部使用的 BeanProcessor 容器
如果 B 类是被 A类 import进来的 B类的 importedBy 容器肯定不会空 @Import 进来的类，和内部类走这里变成 BeanDefinition
BeanDefinitionHolder 容器
String[] basePackagesArray = componentScan.getStringArray(\"basePackages\")
创建RootBeanDefinition
调用方法 一样是收集
空方法
new RootBeanDefinition(ConfigurationClassPostProcessor.class);
把实现了 DeferredImportSelector 接口的类 包装为 holder 对象
registerAnnotationConfigProcessors(this.registry)
loadBeanDefinitionsFromImportedResources(configClass.getImportedResources())
beanFactory.setBeanClassLoader(getClassLoader());
return beanDefinitions
if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME))
this.beanMethods.add(method)
内部使用的 BeanProcessor
判断
doScan(basePackages)
包装成 BeanDefinitionHolder
循环 包装为 BeanMethod 对象 加入到 ConfigurationClass 中
beanDef.setDestroyMethodName(destroyMethodName)
调用 ImportBeanDefinitionRegistrar 接口的方法 不是重点
if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME))
while (sourceClass != null)
for (SourceClass annotation : sourceClass.getAnnotations())
loadBeanDefinitionsForBeanMethod(beanMethod)
initMessageSource()
AnnotationMetadata original = sourceClass.getMetadata()
判断自己自己有没有定义事件管理类 大部分是没有
这里调用 ConfigurationClassPostProcessor 类的postProcessBeanDefinitionRegistry 方法
候选的 BeanDefinitionHolder容器
isConditionMatch(metadataReader)
反射实例化
parse.最后 执行的 doScan 里面扫描的只是 includeFilters 里面的 @Component 注解循环遍历 scannedBeanDefinitions 扫描里面是否有其他注解 例如 @Bean @Import 等等
核心方法 解析配置类中 @Bean的方法 暂时没有处理，只是收集
如果有 @Configuration 注解，并且proxyBeanMethods 没有设置为 false 就是 full 完全匹配标识
获取
校验是否有重复bean的名字 有则抛出异常
Spring BeanFactory 的 BeanPostProcessor容器
循环发布
判断是否是 ApplicationEvent
判断扫描出来的 BeanDefinition 是不是配置类 (full lite) 是就继续解析
调用 getImportGroup 方法，返回实现了 Group 接口的类
注解的元数据
for (String className : classNames)
definitionHolder.getBeanName()
判断是否有 @ComponentScan @Component @Import @ImportResource@Bean注解返回 true | false
返回
触发getBean实例化
判断beanDefinitionMap中 是否有 PersistenceAnnotationBeanPostProcessor 没有进行注册
obtainFreshBeanFactory()
容器启动后发布时事件 例如Nacos的客户端要注册到Nacos
if (beanDef instanceof AnnotatedBeanDefinition &&\t\t\t\tclassName.equals(((AnnotatedBeanDefinition) beanDef).getMetadata().getClassName()))
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory))
registerBeanPostProcessors(beanFactory)
注解方式启动类入口
使用注解方式已经创建过只有xml方式会执行扫描并创建Definition
if (trackedConditionEvaluator.shouldSkip(configClass))
只提供了一个方法 传入beanFactory 对 beanFactory 做一些处理 比如可以添加一些单例的 bean 也可以获取 BeanDefinition但是不能注册 BeanDefinitionvoid postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)beanFactory.registerSingleton(\"dog\
创建 reader委托者 注册核心组件
排序后注册到 BeanFactory BeanPostProcessor容器
创建容器
GenericApplicationContext的构造方法
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this))
如果存在 destroyMethod 设置 destroyMethod 属性
循环自己加入 beanFactory 的 BeanFactoryPostProcessor 接口实现类
递归开始递归寻找文件 包装成Resource对象
如果存在 Scope注解 设置 bean的作用域 属性
内部类 ListenerRetriever
finishRefresh()
封装了类的所有信息 元数据
上面 ConfigurationClassPostProcessor.class 这个类已经扫描了所有并且封装为了BeanDefinition这里把所有是BeanPostProcessor 接口的类型的名称获取到
Set<BeanDefinition> candidates = findCandidateComponents(basePackage)
beanFactory.addBeanPostProcessor(postProcessor)
new AnnotatedGenericBeanDefinition(beanClass)
for (String ppName : nonOrderedPostProcessorNames)
判断包含的
处理 @ImportResource 注解 ，没啥用，加载xml配置文件
继承
这里只会获取注册了的BeanDefinition 比如 new AnnotationConfigApplicationContext(SpringDemo.class)放入的就是注册过的，其他的还没扫描所以获取不到
添加三个Bean
new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class)
registerBean(componentClass)
加入到 defaultRetriever 内部类中的 容器 applicationListenerBeans
判断是否是候选的需要处理的配置类 BeanDefinition，如果是则放入容器 configCandidates
@Configuration@Component @ComponentScan @Import @ImportResource@Bean这些注解都算配置类@Configuration 算完全匹配
do
核心方法 @Bean @Import 内部类 @ImportedResource ImportBeanDefinitionRegistrar 具体处理逻辑
setBeanClassName(this.metadata.getClassName())
grouping.getImports().forEach(entry -> {
如果存在 initMethod 设置 initMethod 属性
beanDef.setUniqueFactoryMethodName(methodName)
设置 FactoryBeanName 重要！ 设置的就是 A 类由 @Bean注解的方法 设置的就是 A类的 beanName
核心方法
onRefresh()
加入 ApplicationListenerDetector
ConfigurationClass结构图
获取 metadata对象，打了@Bean注解的方法上 可能同时存在其他注解 metadata就是收集过的这些注解
这个方法着重理解模板设计模式，因为在springboot中，这个方法是用来做内嵌tomcat启动的普通的 容器是一个模板方法 springboot 才有实现
重复名称则抛出异常
设置bean名字
调用解析方法 几乎都是调用这个扫描注解创建的 BeanDefinition传入 BeanDefinition 元数据 Metadata
Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(ifc)
this();
getBean自己定义的事件管理类
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
return imports
return null
if (selector instanceof DeferredImportSelector)
public class SimpleApplicationEventMulticaster extends AbstractApplicationEventMulticaster
已经解析过的 BeanDefinition 因为解析是递归的 do while 比如 @Import 的类里面也有 @Import 注解
beanDef.setFactoryBeanName(configClass.getBeanName())
是
beanDef.setInitMethodName(initMethodName)
获取进行排序
否
processConfigBeanDefinitions(registry)
else
会实现BeanDefinitionRegistryPostProcessor 的两个方法 对类进行扫描注册
从 metadata 中获取 @Configuration 注解
BeanDefinitionRegistryPostProcessorBeanFactoryPostProcessor完成对这两个接口的调用扫描整个项目的Bean 也在这里做的 doScan
跳过的直接 return
获取 Metadata 对象
new RootBeanDefinition(PersistenceAnnotationBeanPostProcessor.class)
准备上下文
返回个是boolean 为true 进入方法 进行包装 ScannedGenericBeanDefinition
核心方法 注册各种核心组件
scanCandidateComponents(basePackage)
获取 beanDefinition
for (MethodMetadata methodMetadata : beanMethods)
Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates)
org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor
判断beanDefinitionMap中 是否有 AutowiredAnnotationBeanPostProcessor 没有进行注册
metadata = AnnotationMetadata.introspect(beanClass)
获取该类的内部类，并又包装成 sourceClass 对象
if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator))
创建候选 BeanDefinition 配置类的解析器 解析 @Configuration
注册BeanPostProcessor
isCandidateComponent(metadataReader)
for循环处理传入的class
this.deferredImportSelectors.add(holder)
registerBeanDefinitionForImportedConfigurationClass(configClass)
if (pp instanceof MergedBeanDefinitionPostProcessor)
进行循环
创建内部使用的 BeanPostProcessor 实现了MergedBeanDefinitionPostProcessor 接口的 BeanPostProcessor容器
把 解析过的beanDefinition 名字放到 list容器中
for (Resource resource : resources)
拿到要注册的bean 名称
AnnotationMetadata metadata = configClass.getMetadata(
new ScannedGenericBeanDefinition(metadataReader)
candidates.add(sbd)
return beanMethods
if (config != null && !Boolean.FALSE.equals(config.get(\"proxyBeanMethods\")))
应用事件容器
如果存在 autowireCandidate 设置 autowireCandidate 属性
获取BeanFactory
设置唯一的 FactoryMethodName 就是设置的 @Bean 注解的方法名称
过滤器中加入@Component，类型 AnnotationTypeFilter翻译过来为注解类型过滤
List<BeanPostProcessor> beanPostProcessors
调用程序员实现的onApplicationEvent 方法
核心方法 刷新容器
loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars())
String[] candidateNames = registry.getBeanDefinitionNames();
prepareRefresh()
核心方法处理 @Import 注解
isConfigurationCandidate(metadata)
判断是否是 AbstractBeanDefinition 类型
返回父类
beanFactory.preInstantiateSingletons()
包装beanDefitnion
注册 BeanPostProcessor 提前实例化 实现了 BeanPostProcessor 接口的类 加入到 beanFactory
else if (beanDef instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) beanDef).hasBeanClass())
for (AnnotationAttributes filter : componentScan.getAnnotationArray(\"excludeFilters\")) {\t\t\tfor (TypeFilter typeFilter : typeFiltersFor(filter)) {\t\t\t\tscanner.addExcludeFilter(typeFilter);\t\t\t}\t\t}
判断上面有没有 @ComponentScan @Component @Import @ImportResource @Bean
核心方法 解析流程 重要!重要!重要!其实就是把类上面的特殊注解解析出来最终封装成beanDefinition
parser.parse(candidates)
spring核心容器之一 存放 注册的 BeanDefinition名称
如果是扫描注解产生的 BeanDefinition
循环的目的就是可能有父类 父类也有注解需要解析
这里建立映射关系 key 实现了ImportBeanDefinitionRegistrar 接口的实例 和 Metadata 对象
boolean autowireCandidate = bean.getBoolean(\"autowireCandidate\")
@Import 里面可能是多个类 进行循环
判断类型是否是 MergedBeanDefinitionPostProcessor，如果是则代码是内部使用的
else if
for (BeanMethod beanMethod : configClass.getBeanMethods())
for (ConfigurationClass configClass : configurationModel)
获取注解的 value值 加入到 imports
赋值
for (BeanDefinitionHolder holder : configCandidates)
收集 @Import 注解的类
beanDefinitions.add(definitionHolder);
else if (config != null || isConfigurationCandidate(metadata))
这个对象理解为跟类或者接口对应，然后把 metadata 对象包装进去了
解析
递归调用
this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
国际化 不用看
扫描对应的类上是否有 @PropertySources 和 @PropertySource 注解，有的话进行处理 @PropertySources 和 @PropertySource 注解
for (BeanDefinitionHolder holder : scannedBeanDefinitions)
创建扫描器 和默认扫描的过滤器 includeFilters 以及排除的 excludeFilters
创建 ScannedGenericBeanDefinition
判断beanDefinitionMap中 是否有 ConfigurationClassPostProcessor 没有进行注册
for循环
spring的核心类 实现了BeanDefinitionRegistryPostProcessor 接口 对beanDeifinition做注册
获取 ConfigurationClass
核心方法 isConfigurationCandidate(metadata)
核心方法 填充 beanDefinition解析 @Lazy @Primary @DependsOn @Role @Description 注解
listener.onApplicationEvent(event);
创建扫描器 加入默认扫描注解 includeFilters
判断是否实现 PriorityOrdered接口口
handler.processGroupImports()
new创建后 赋值给属性
org.springframework.context.event.internalEventListenerFactory
xml方式才会执行
List<BeanPostProcessor> internalPostProcessors
这个方法是spring中最重要的方法1、bean实例化过程2、ioc3、注解支持4、BeanPostProcessor 的执行5、Aop的入口
beanName
metadata.hasAnnotatedMethods(Bean.class.getName())
是则加入内部容器
if (configClass.isImported())
已经解析完成的类 加入 alreadyParsed 容器
Ordered接口的
是一个对象
把 beanDefinition放入到 map中 key bean名字 val beanDefinition
for (SourceClass candidate : importCandidates)
强行转换
for (String beanName : candidateNames)
拥有的属性
循环 @Import 注解中获取的的每个类
执行查找类型为 BeanDefinitionRegistryPostProcessor 的beanDefinition beanName 这里可以找到一个 在初始化AnnotationConfigApplicationContext() 注册的一个组件ConfigurationClassPostProcessor.class
返回扫描的候选的组件 beanDefinition
把 metadata 对象和 beanName 封装成 ConfigurationClass 对象
获取实现了 BeanDefinitionRegistryPostProcessor 接口的所有类的BeanDefinition对象的 beanName
核心方法 填充 beanDefinition解析 @Lazy @Primary @DependsOn @Role @Description 注解
判断是否要跳过
if (candidate.isAssignable(ImportSelector.class))
for (MethodMetadata methodMetadata : beanMethods)
持有
for (BeanDefinition candidate : candidates)
new ClassPathBeanDefinitionScanner(this)
return candidates
List<SourceClass> candidates = new ArrayList<>(memberClasses.size())
调用重载构造方法
处理 GroupImports
Collection<SourceClass> memberClasses = sourceClass.getMemberClasses()
获取 MetadataReader 包装为 SourceClass 返回
只有注解信息 开始遍历封装好的 BeanDefinition set 进行填充
是否有跳过的
alreadyParsed.addAll(configClasses)
建立实现了 Group 接口类和 DeferredImportSelectorGrouping 的映射关系
逐一发布
String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata())
getImports(sourceClass)
AnnotationConfigApplicationContext()
List<String> beanDefinitionNames
添加 ApplicationContextAwareProcessor 用于回调Aware接口的方法的 后置处理器
容器启动完成后发布事件
AnnotationMetadata metadata
执行顺序 1
设置标识 full 完全匹配
循环postProcessorNames
processPropertySource(propertySource)
Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass)
if (pp instanceof MergedBeanDefinitionPostProcessor)
beanName applicationEventMulticaster
if (configClass.getMetadata().isAnnotated(Component.class.getName()))
BeanPostProcessor内部存放顺序1.先存放的 实现priorityOrdere 接口的2. 再存放Ordered接口的3. 其次存放没实现任何接口的4. 最后存放内部的 实现了 MergedBeanDefinitionPostProcessor接口
List<BeanDefinitionHolder> configCandidates = new ArrayList<>()
排序后循环处理每个内部类
核心 注册BeanDefinition
获取 metadata 对象
解析配置类中 @Bean的方法 暂时没有处理，只是收集
排序后调用内部的 BeanProcessor接口
this.reader.register(componentClasses)
for (AnnotationAttributes filter : componentScan.getAnnotationArray(\"includeFilters\")) {\t\t\tfor (TypeFilter typeFilter : typeFiltersFor(filter)) {\t\t\t\tscanner.addIncludeFilter(typeFilter);\t\t\t}\t\t}
1. 创建 beanFactory对象2. xml 标签解析3. 解析出来的xml标签 封装为BeanDefinition对象
return annotatedClasses
postProcessor.postProcessBeanDefinitionRegistry(registry)
refresh()
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
BeanFactoryPostProcessor
类关系
并发发布
Set<MethodMetadata> beanMethods = original.getAnnotatedMethods(Bean.class.getName())
获取接口循环
public final Set<String> applicationListenerBeans
candidates.clear()
DeferredImportSelectorGroupingHandler handler = new DeferredImportSelectorGroupingHandler()
解析出来的 @import 导入类的列表
new RootBeanDefinition(DefaultEventListenerFactory.class)
xml解析流程 不是重点
if (this.deferredImportSelectors == null)
初始化事件管理类
执行顺序 2
核心方法处理 @Import 注解如果导入的是普通类 那么会直接把它当作配置类解析如果导入的是普通 ImportSelector 那么会将返回的类再次调用 processImports()如果导入的是特殊 ImportSelector DeferredImportSelector 那么暂时不处理 会在解析解析完当前这轮配置类后 将配置类解析成 BeanDefinition如果导入的是 ImportBeanDefinitionRegistrar 那么暂时不处理 会在解析解析完当前这轮配置类后 将配置类解析成 BeanDefinitiongetImports(sourceClass)方法作用是 获取类上面的 @Import 注解并封装成SourceClass
把BeanDefinition 再次包装为 BeanDefinitionHolder candidate（BeanDefinition）beanName（bean名称）
核心 注册 beanDefinition
initApplicationEventMulticaster()
初始化候选的 BeanDefinitionHolder 容器
比较复杂，springboot 中自动配置用到了
如果componentScan 有 includeFilters 设置 IncludeFilter
比较差异又走一遍解析流程
加入到 deferredImportSelectors
加入到容器 Set
org.springframework.context.event.internalEventListenerProcessor
this.register(annotatedClasses)
创建 DeferredImportSelectorGroup 接口的处理类
设置 beanFactory 的OrderComparator 为 AnnotationAwareOrderComparator 比较器
只要 sourceClass 不是空 就进行循环
ConfigurationClass configurationClass = this.configurationClasses.get(entry.getMetadata())
没实现任何接口的
new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class)
对 @Condition 注解的支持，过滤掉不需要实例化的类
是否又父类
ConfigurationClass configClass = beanMethod.getConfigurationClass()
return sourceClass.getSuperClass()
核心方法 重要！解析配置类 会执行 doScan扫描
metadataReaderFactory.getMetadataReader(className)
registerDefaultFilters()
通过getBean获取赋值给属性
for (SourceClass candidate : candidates)
设置作用域 @Scope
BeanDefinitionRegistryPostProcessor
如果componentScan 有 excludeFilters 设置 设置 ExcludeFilter
调用父类的构造方法
configClasses.removeAll(alreadyParsed)
if (candidate instanceof AbstractBeanDefinition)
if (candidate instanceof AnnotatedBeanDefinition)
new RootBeanDefinition(EventListenerMethodProcessor.class)
往事件管理类中注册事件类
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext))
扫描包注册 beanDefinition
注册到 beanFactory 一级缓存
applicationEvent = (ApplicationEvent) event;
提供了一个可以对 BeanDefinition 做注册的方法 例如spring的扫描类就是通过这个方法 如果自己实现postProcessBeanDefinitionRegistry 需要通过上下文对象 addBeanFactoryPostProcessor 才可以在启动前被发现void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)
是否设置线程池
判断类上面是否有 @Component 注解
获取 方法上有 @Bean 注解的方法 包装为 BeanMetadata对象
List<DeferredImportSelectorHolder> deferredImportSelectors
handler.register(holder)
创建beanDefitnion
prepareBeanFactory(beanFactory)
priorityOrdere 接口的
asSourceClass 传入完整限定名
Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size())
MethodMetadata metadata = beanMethod.getMetadata()
扫描组件
判断如果包含includeFilters 中的注解或者排除的注解
传入路径
通过类型进行查找
if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME))
判断是否有 @Conditional注解 如果没有 直接返回false 进行解析逻辑
注册默认过滤器 加入@Component
for (SourceClass ifc : sourceClass.getInterfaces())
核心方法 递归处理有 @Component 注解的内部类，因为类里面可能有内部类 所以进行递归
创建set进行传入 候选的 BeanDefinitionHolder
事件管理类
循环收集到接口里有 @Bean 注解的方法
只赋值了class名字 类的全路径
循环遍历 resources 数组
spring核心容器之一 存放 BeanDefinition
设置标识 lite 低匹配
如果是 ImportSelector 类型 进入方法体
parse 里面的逻辑，基本上跟 <component-scan> 自定义标签解析的逻辑差不多
准备 BeanFacoty 一些辅助功能1. 设置 BeanFacoty 的类加载器2. 添加三个 BeanPostProcessor 添加的是具体 BeanPostProcessor 实例对象3. 记录 ResolvableDependency4. 添加三个 bean 对象
又来一遍 不包含在processedBeans 集合里 并两个接口都没实现的
candidate.setScope(scopeMetadata.getScopeName());
beanPostProcessor 应用
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors)
注册beandifinition
beanDef.setAutowireCandidate(false)
继承于
if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME))
循环
循环每一个候选的 BeanDefinitionHolder 进行解析但是很有可能解析到其他的配置类 因为是扫描全部的类
又来一遍 不包含在processedBeans 集合里 并且实现Ordered 接口
封装为 BeanDefinitionHolder
从上下文中 获取实现了 ApplicationListener 接口的所有beanName
for (SourceClass memberClass : memberClasses)
List<BeanDefinitionHolder> configCandidates
扫描到有注解的类 封装BeanDefinition对象 包装为BeanDefinitionHolder 放入beanDefinitions 容器
核心方法 递归 去处理没一个内部类candidate 子 configClass 父，candidate 是 configClass的内部类需要看一下 candidate.asConfigClass(configClass) 这个方法
for (String ppName : orderedPostProcessorNames)
beanDef.setScope(attributes.getString(\"value\"))
核心方法 在这里调用实现了ImportSelector接口的类 selectImports 方法，返回所有的需要 import 到 spring 容器的类的完整限定名
循环所有 ConfigurationClass
调用在上下文中注册为bean的后置处理器
进行包装
核心注册
清空掉候选的
Set<ConfigurationClass> importedBy
Set<BeanDefinition> candidates = new LinkedHashSet<>()
判断beanDefinitionMap中 是否有 CommonAnnotationBeanPostProcessor 没有进行注册
排序候选的 BeanDefinitionHolder
invokeBeanFactoryPostProcessors(beanFactory)
找到的类
if (ConfigurationClassUtils.isConfigurationCandidate(memberClass.getMetadata()) &&\t\t\t\t\t\t!memberClass.getMetadata().getClassName().equals(configClass.getMetadata().getClassName()))
判断 返回 true | false
getImports(sourceClass)方法作用是 获取类上面的 @Import 注解并封装成SourceClass
这里调用了 group.selectImports()
String initMethodName = bean.getString(\"initMethod\")
获取所有的 beanNames
判断beanDefinitionMap中 是否有 EventListenerMethodProcessorr 没有进行注册 用来处理 @EventListener 注解
广播发布
是否 AnnotatedBeanDefinition 类型
return scanner.doScan(StringUtils.toStringArray(basePackages))
private ApplicationEventMulticaster applicationEventMulticaster;
if (metadata == null || !metadata.isAnnotated(Conditional.class.getName()))
if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME))
通过类型查找
beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
处理 ConfigurationClass 把 metadata 对象和 beanName 封装成 ConfigurationClass 对象
ConfigurationClass
调用 BeanDefinitionRegistryPostProcessor 接口的方法 用户自定义的具体实现
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
非扫描注解产生的 BeanDefinition
核心方法 循环 @Bean 注解的方法变成 BeanDefinition configClass.getBeanMethods()获取所有 @Bean的方法
AnnotationConfigApplicationContext初始化的时候父类已经创建了
new AnnotatedBeanDefinitionReader(this)
如果是一个DeferredImportSelector类型
Class<? extends Group> group = deferredImport.getImportSelector().getImportGroup()
ConfigurationClassPostProcessor.postProcessBeanFactory(beanFactory)
this.includeFilters.add(new AnnotationTypeFilter(Component.class))
true 添加
this.defaultRetriever.applicationListenerBeans.add(listenerBeanName);
if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME))
while (!candidates.isEmpty())
主要是这个类 判断条件也为 true
this.reader.loadBeanDefinitions(configClasses);
设置类加载器
postProcessBeanFactory(beanFactory)
判断beanDefinitionMap中 是否有 DefaultEventListenerFactory 没有进行注册 用来处理 @EventListener 注解
循环自己加入 beanFactory 的 BeanFactoryPostProcessor 接口实现类 必须要手动 context.addBeanFactoryPostProcessor(new MyBeanFactoryPostProcessor());
Set<BeanMethod> beanMethods
return this.beanFactory;
this()初始化的扫描器
判断是否配置类
设置name属性 有name使用name 没有则使用方法名
获取 sourceClass 的 metadata对象 判断是否有 @ComponentScans @ComponentScan有的话进行处理
进行注册 BeanDefinition
getMetadataReaderFactory().getMetadataReader(resource);
getBeanFactory()
String destroyMethodName = bean.getString(\"destroyMethod\")
AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate)
创建内部使用的 BeanPostProcessor 容器
注册核心组件
Executor executor = getTaskExecutor();
创一个默认的 SimpleApplicationEventMulticaster 事件管理类
postProcessor.postProcessBeanDefinitionRegistry(registry);
org.springframework.context.annotation.internalCommonAnnotationProcessor
AnnotatedGenericBeanDefinition configBeanDef = new AnnotatedGenericBeanDefinition(metadata)
for (DeferredImportSelectorGrouping grouping : this.groupings.values())
return new SourceClass(this.metadataReaderFactory.getMetadataReader(className))
Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
不是主要流程
获取扫描包路径，可能是个多个路径
0 条评论
回复 删除
下一页
