文章目录
注解方式IOC加载源码解读
目前Spring仅支持两种IOC加载的模式。一种是XML，一种是注解。当然XML中也针对各别注解进行解析操作。注解方式IOC加载，使用的BeanFactory的后置处理器来执行的。
1. 注解方式的启动类使用
// 创建一个AnnotationConfigApplicationContext对象，参数为注册的Spring配置类。
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class);
// 获取某个bean
User user = applicationContext.getBean(User.class);
// 调用这个bean来查看源码。
user.say();
2. AnnotationConfigApplicationContext的构造方法。
因为ICO的是在构造方法之中就会完成。从AnnotationConfigApplicationContext的构造方法入手，看看都做了什么工作。
this()，调用当前的无参构造，register方法注册配置类，refresh调用的是Spring的模板方法。
2.1 this()，调用AnnotationConfigApplicationContext的无参构造方法。
查看this()
在java中调用当前类的无参构造，还会去调用父类的无参构造，所以我们看一下父类的无参构造做了什么事情？后续再看一下AnnotatedBeanDefinitionReader的构造方法和ClassPathBeanDefinitionScanner的构造方法。
可以看出，在父类的无参构造中创建了一个beanFactory的实例对象，之前我们说过register是由DefaultListableBeanFactory来完成的。由此可知，我们在创建AnnotationConfigApplicationContext对象的时候，DefaultListableBeanFactory对象、AnnotatedBeanDefinitionReader对象，ClassPathBeanDefinitionScanner对象也会随即创建成功。
2.1.1 查看AnnotatedBeanDefinitionReader构造方法。
最后会调用到这里，会在这里注册一下后置处理器。
public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
BeanDefinitionRegistry registry, @Nullable Object source) {
// 此处是获取我们之前创建好的DefaultListableBeanFactory对象。之前一说过真正的注册是在DefaultListableBeanFactory中完成的。
DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
// 此处先忽略
if (beanFactory != null) {
if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
}
if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
}
}
// 创建一个集合，长度为8
Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
// 查询BeanDefinitionMap 中是否已经注册了名字为CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME的类定义对象。
// 如果是第一次调用的时候，一般是没有的，此时BeanDefinitionMap是个空的。
if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
// 将ConfigurationClassPostProcessor.class类封装成一个BeanDefinition的子类，切记此时只是在注册。还为实例化。
RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
// 设置什么的配置源，此时这个source是空的，此时不需要关心。
def.setSource(source);
// 注册到BeanDefinitionMap中，并且添加到beanDefs集合中。
beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
}
// 注册AutowiredAnnotationBeanPostProcessor类，与上无异
if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
}
// Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
// JSR-250，是java本身定义了一些注解，spring支持了这些注解。大致有：@PostConstruct和@PreDestroy@Resource
// 一流的公司提供协议，JSR-250协议，就是说我这些注解是用于什么什么的，你们要实现支持必须跟我定义的用途一致。
if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
}
// Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
// Spring注册支持jpa注解的beanFactory后置处理器
if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition();
try {
def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
AnnotationConfigUtils.class.getClassLoader()));
}
catch (ClassNotFoundException ex) {
throw new IllegalStateException(
"Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
}
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
}
// 注册EventListenerMethodProcessor类
if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
}
// 注册DefaultEventListenerFactory类
if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
}
return beanDefs;
}
调试一下，看一下一共注册了多少后置处理器。一共加载了五个。发现JPA的处理器没有加载，我们没有与数据库交互，不加载也是正常的。
2.1.2 查看ClassPathBeanDefinitionScanner构造方法。
最终会调用到这个构造方法。其实这里的ClassPathBeanDefinitionScanner对象基本上是无用的。为了扩展AnnotationConfigApplicationContext工作所添加的一个。
为AnnotationConfigApplicationContext添加了一个自助扫描包的功能，比如以下用法。
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class);
// 自己指定扫描包的路径
applicationContext.scan("...");
2.2 register(配置类)，查看干了什么事情
主要的过程就是把配置类，解析一下成BeanDefinition对象，然后注册到map中。当然也支持手动去注册bean。调试一下看看：
由此图可以，我们的配置类的BeanDefinition已经注册到Map中了。
2.3 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.
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
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);
// Register bean processors that intercept bean creation.
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
initMessageSource();
// Initialize event multicaster for this context.
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
onRefresh();
// Check for listener beans and register them.
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
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();
}
}
}
正常调用：
- prepareRefresh(); 容器刷新前的准备，设置上下文状态，获取属性，验证必要的属性等
- ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); 如果是xml方式的话：销毁原来的beanFactory，创建一个新的beanFactory，并且执行IOC加载。注解方式的话，直接返回已经创建好的bean。
- prepareBeanFactory(beanFactory); 此方法，针对beanFactory对象进行一些前置的配置。
- postProcessBeanFactory(beanFactory); 此方法，用于扩展对beanFactory的操作，可以自己继承AnnotationConfigApplicationContext，来实现这个方法。
- invokeBeanFactoryPostProcessors(beanFactory);此方法，调用已经注册好的beanFactory后置处理器。
- registerBeanPostProcessors(beanFactory); 此方法，实例化并注册bean的后置处理器，之前bean后置处理器的BeanDefinition已经注册过。
- initMessageSource(); 此方法，初始化国际化工具类MessageSource
- initApplicationEventMulticaster(); 此方法，初始化事件广播器
- onRefresh(); 此方法，模板方法，在容器刷新的时候可以自定义逻辑，不同的Spring容器做不同的事情。
- registerListeners(); 此方法，注册监听器，广播early application events
- finishBeanFactoryInitialization(beanFactory); 此方法，实例化所有剩余的（非懒加载）单例。因为之前的某些bean已经被初始化过了。
- finishRefresh(); 此方法，refresh做完之后需要做的其他事情。
异常调用：
13. destroyBeans(); 此方法，出现异常的时候，清楚掉已经创建好的bean实例。
14. cancelRefresh(ex); 此方法，出现异常的时候，设置上下文的活动态为false。表示停止spring 容器的工作。
最终调用：
15. resetCommonCaches();此方法，清楚一些缓存。
2.3.1 invokeBeanFactoryPostProcessors(beanFactory);
在注解方式的IOC加载中，因为IOC的加载是在BeanFactory的后置处理器中完成的。所以此时来调用后置处理器完成BeanDefintion的所有解析加载工作。查看invokeBeanFactoryPostProcessors(beanFactory);
// 此方法进行beanFactory的后置处理器调用，参数beanFactory是之前创建好的DefaultListableBeanFactory对象，参数beanFactoryPostProcessors，是beanFactory后置处理器对象的集合，但是这个时候是空的。
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
// Invoke BeanDefinitionRegistryPostProcessors first, if any.
// 创建一个处理器bean的set集合。
Set<String> processedBeans = new HashSet<>();
// 此时BeanDefinitionRegistry的null，所以此方法不会走，考虑的其他的情况，所以有这段代码。
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
BeanDefinitionRegistryPostProcessor registryProcessor =
(BeanDefinitionRegistryPostProcessor) postProcessor;
registryProcessor.postProcessBeanDefinitionRegistry(registry);
registryProcessors.add(registryProcessor);
}
else {
regularPostProcessors.add(postProcessor);
}
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let the bean factory post-processors apply to them!
// Separate between BeanDefinitionRegistryPostProcessors that implement
// PriorityOrdered, Ordered, and the rest.
// 创建一个list集合，后续用于存放已经实例化的beanFactory后置处理器。
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
// 首先去调用，实现了BeanDefinitionRegistryPostProcessors接口的后置处理器。并且实现了PriorityOrdered接口的。此处获取对应的对象名称。
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
// 循环判断，找出实现PriorityOrdered接口的beanFactory的后置处理器，调用优先级最高。
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
// 如果已经实现了，调用getBean去创建对象。Spring自己也会去调用getBean对象，不只是我们会去调用。并且放入到马上被调用的beanFactory的后置处理器中。
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
// 放入到所有的后置处理器中。
processedBeans.add(ppName);
}
}
// 进行排序，因为实现PriorityOrdered.class接口的也可以有很多个，可以根据值来设置调用的优先顺序。
sortPostProcessors(currentRegistryProcessors, beanFactory);
// 把将要调用的beanFactory的后置处理去放入到registryProcessors中。
registryProcessors.addAll(currentRegistryProcessors);
// 这里开始真正的调用beanFactory的后置处理器。
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
// 已经被调用后清除currentRegistryProcessors集合。
currentRegistryProcessors.clear();
// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
// 再次获取一次beanFactory的后置处理器名单。
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
// 循环调用
for (String ppName : postProcessorNames) {
// 先判断是否已经被调用过，然后调用实现Ordered接口的beanFactory的后置处理器
if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
// 依然是去创建实现了Ordered接口的beanFactory的后置处理器对象。
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
// 加入到processedBeans集合中
processedBeans.add(ppName);
}
}
// 仍然进行排序
sortPostProcessors(currentRegistryProcessors, beanFactory);
// 放入到registryProcessors集合中
registryProcessors.addAll(currentRegistryProcessors);
// 调用实现了Odered接口的beanFactory后置处理器
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
// 清除currentRegistryProcessors集合。
currentRegistryProcessors.clear();
// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
// 调用剩下的没有实现Ordered 和PriorityOrdered 接口的beanFactory的后置处理器。
boolean reiterate = true;
while (reiterate) {
reiterate = false;
// 获取所有的实现了BeanDefinitionRegistryPostProcessor接口的bean的后置处理器。
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
// 循环判断
for (String ppName : postProcessorNames) {
// 是否已经被调用过，如果没有被调用，就会被调用。
if (!processedBeans.contains(ppName)) {
// 创建bean对象，添加到这个集合中currentRegistryProcessors
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
reiterate = true;
}
}
// 进行排序
sortPostProcessors(currentRegistryProcessors, beanFactory);
// 添加到registryProcessors集合中
registryProcessors.addAll(currentRegistryProcessors);
// 开始调用。具体的可以看下面。
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
// 清除集合。
currentRegistryProcessors.clear();
}
// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
// 因为BeanDefinitionRegistryPostProcessor接口是继承BeanFactoryPostProcessor接口的，所以我们之前只是调用了postProcessBeanDefinitionRegistry方法，还有一个postProcessBeanFactory没有调用。在此处调用。
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
// 这个没什么意义。
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
}
else {
// Invoke factory processors registered with the context instance.
// 此处用于其他工程对象进行调用的。
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let the bean factory post-processors apply to them!
// 获取所有实现BeanFactoryPostProcessor接口的beanFactory后置处理器。
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
// 创建三个集合，priorityOrderedPostProcessors 存放实现了priorityOrdered接口的，
// orderedPostProcessorNames 存放实现了ordered接口的。
// nonOrderedPostProcessorNames 没有实现任何排序接口的。
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
List<String> orderedPostProcessorNames = new ArrayList<>();
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
// 循环遍历
for (String ppName : postProcessorNames) {
// 出去上一个阶段调用过的。
if (processedBeans.contains(ppName)) {
// skip - already processed in first phase above
}
// 找出实现了PriorityOrdered接口的。
else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
// 并且此时已经创建好bean了。
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
}
// 找出实现了Ordered接口的。
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
// 找出没有实现排序接口的。
nonOrderedPostProcessorNames.add(ppName);
}
}
// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
// 最先调用实现了priorityOrdered接口的，进行排序
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 进行调用
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
// 然后调用实现了ordered接口的。
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
for (String postProcessorName : orderedPostProcessorNames) {
// 创建了实现ordered接口的实例。
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
// 排序
sortPostProcessors(orderedPostProcessors, beanFactory);
// 调用
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
// Finally, invoke all other BeanFactoryPostProcessors.
// 最后调用没有实现排序接口的
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
for (String postProcessorName : nonOrderedPostProcessorNames) {
// 创建实例
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
// 进行调用。
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
// Clear cached merged bean definitions since the post-processors might have
// modified the original metadata, e.g. replacing placeholders in values...
// 清楚缓存， 因为beanFactory的后置处理器可能已经修改了bean的信息。
beanFactory.clearMetadataCache();
}
/**
* Invoke the given BeanDefinitionRegistryPostProcessor beans.
*/
private static void invokeBeanDefinitionRegistryPostProcessors(
Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry) {
// 调用实现了BeanDefinitionRegistryPostProcessor接口的postProcessBeanDefinitionRegistry方法。
for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
postProcessor.postProcessBeanDefinitionRegistry(registry);
}
}
/**
* Invoke the given BeanFactoryPostProcessor beans.
*/
private static void invokeBeanFactoryPostProcessors(
Collection<? extends BeanFactoryPostProcessor> postProcessors, ConfigurableListableBeanFactory beanFactory) {
for (BeanFactoryPostProcessor postProcessor : postProcessors) {
postProcessor.postProcessBeanFactory(beanFactory);
}
}
2.3.2 ConfigurationClassPostProcessor类
首先，我们IOC加载，最先解析的肯定是@Configuration注解。此类就是解析这个注解然后进行IOC加载的。
此类实现了BeanDefinitionRegistryPostProcessor接口和PriorityOrdered接口。由上可知，所以此类肯定先调用了postProcessBeanDefinitionRegistry 方法，之后调用了postProcessBeanFactory方法。
2.3.2.1 postProcessBeanDefinitionRegistry 方法
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
// 获取已经注册了所有的beanDefintion的名字
String[] candidateNames = registry.getBeanDefinitionNames();
// 循环遍历名称
for (String beanName : candidateNames) {
// 通过名称获取到BeanDefinition对象。
BeanDefinition beanDef = registry.getBeanDefinition(beanName);
// 判断BeanDefinition对象是否已经当成配置类处理过了。
if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {
if (logger.isDebugEnabled()) {
logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
}
}
// 判断是否是BeanDefinition对象，即是否有@Configuration注解。
else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
// 如果是加入到configCandidates集合中，等待被处理。
configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
}
}
// Return immediately if no @Configuration classes were found
// 健壮判断。
if (configCandidates.isEmpty()) {
return;
}
// Sort by previously determined @Order value, if applicable
// 将配置文件根据@Order注解排个序。
configCandidates.sort((bd1, bd2) -> {
int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
return Integer.compare(i1, i2);
});
// Detect any custom bean name generation strategy supplied through the enclosing application context
SingletonBeanRegistry sbr = null;
// 针对factorBean进行的一些是否是单例判断。
if (registry instanceof SingletonBeanRegistry) {
sbr = (SingletonBeanRegistry) registry;
if (!this.localBeanNameGeneratorSet) {
BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(
AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR);
if (generator != null) {
this.componentScanBeanNameGenerator = generator;
this.importBeanNameGenerator = generator;
}
}
}
if (this.environment == null) {
this.environment = new StandardEnvironment();
}
// Parse each @Configuration class
// 这里才是真正的开始解析配置类。创建一个配置类的解析器
ConfigurationClassParser parser = new ConfigurationClassParser(
this.metadataReaderFactory, this.problemReporter, this.environment,
this.resourceLoader, this.componentScanBeanNameGenerator, registry);
// 马上要被调用的。
Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
// 已经被调用的。
Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
do {
// 在这里循环低啊用，查看parse方法，在下面。
parser.parse(candidates);
// 校验工作、
parser.validate();
Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
configClasses.removeAll(alreadyParsed);
// Read the model and create bean definitions based on its content
if (this.reader == null) {
this.reader = new ConfigurationClassBeanDefinitionReader(
registry, this.sourceExtractor, this.resourceLoader, this.environment,
this.importBeanNameGenerator, parser.getImportRegistry());
}
this.reader.loadBeanDefinitions(configClasses);
alreadyParsed.addAll(configClasses);
candidates.clear();
if (registry.getBeanDefinitionCount() > candidateNames.length) {
String[] newCandidateNames = registry.getBeanDefinitionNames();
Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
Set<String> alreadyParsedClasses = new HashSet<>();
for (ConfigurationClass configurationClass : alreadyParsed) {
alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
}
for (String candidateName : newCandidateNames) {
if (!oldCandidateNames.contains(candidateName)) {
BeanDefinition bd = registry.getBeanDefinition(candidateName);
if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
!alreadyParsedClasses.contains(bd.getBeanClassName())) {
candidates.add(new BeanDefinitionHolder(bd, candidateName));
}
}
}
candidateNames = newCandidateNames;
}
}
while (!candidates.isEmpty());
// Register the ImportRegistry as a bean in order to support ImportAware @Configuration classes
if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
}
if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
// Clear cache in externally provided MetadataReaderFactory; this is a no-op
// for a shared cache since it'll be cleared by the ApplicationContext.
((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
}
}
// 配置类的解析逻辑
public void parse(Set<BeanDefinitionHolder> configCandidates) {
for (BeanDefinitionHolder holder : configCandidates) {
BeanDefinition bd = holder.getBeanDefinition();
try {
if (bd instanceof AnnotatedBeanDefinition) {
// 注解方式会走这里。查看parse方法。
parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
}
else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
}
else {
parse(bd.getBeanClassName(), holder.getBeanName());
}
}
catch (BeanDefinitionStoreException ex) {
throw ex;
}
catch (Throwable ex) {
throw new BeanDefinitionStoreException(
"Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
}
}
this.deferredImportSelectorHandler.process();
}
// 注解方式走这里。
protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException {
processConfigurationClass(new ConfigurationClass(metadata, beanName), DEFAULT_EXCLUSION_FILTER);
}
// 继续往下走
protected void processConfigurationClass(ConfigurationClass configClass, Predicate<String> filter) throws IOException {
if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
return;
}
ConfigurationClass existingClass = this.configurationClasses.get(configClass);
if (existingClass != null) {
if (configClass.isImported()) {
if (existingClass.isImported()) {
existingClass.mergeImportedBy(configClass);
}
// Otherwise ignore new imported config class; existing non-imported class overrides it.
return;
}
else {
// Explicit bean definition found, probably replacing an import.
// Let's remove the old one and go with the new one.
this.configurationClasses.remove(configClass);
this.knownSuperclasses.values().removeIf(configClass::equals);
}
}
// Recursively process the configuration class and its superclass hierarchy.
// 此时有一种情况，就是@Configuration在父类上，这里就回去判断父类上有没有。
SourceClass sourceClass = asSourceClass(configClass, filter);
do {
// 会走和这个方法。
sourceClass = doProcessConfigurationClass(configClass, sourceClass, filter);
}
while (sourceClass != null);
this.configurationClasses.put(configClass, configClass);
}
// 最终会调用这个方法。
@Nullable
protected final SourceClass doProcessConfigurationClass(
ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
throws IOException {
// Component注解处理逻辑
if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
// Recursively process any member (nested) classes first
processMemberClasses(configClass, sourceClass, filter);
}
// Process any @PropertySource annotations
// PropertySources的处理逻辑
for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
sourceClass.getMetadata(), PropertySources.class,
org.springframework.context.annotation.PropertySource.class)) {
if (this.environment instanceof ConfigurableEnvironment) {
processPropertySource(propertySource);
}
else {
logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
"]. Reason: Environment must implement ConfigurableEnvironment");
}
}
// Process any @ComponentScan annotations
// @ComponentScan 的处理逻辑。此处很重要。这里就是扫描包的逻辑。
Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
if (!componentScans.isEmpty() &&
!this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
for (AnnotationAttributes componentScan : componentScans) {
// The config class is annotated with @ComponentScan -> perform the scan immediately
Set<BeanDefinitionHolder> scannedBeanDefinitions =
this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
// Check the set of scanned definitions for any further config classes and parse recursively if needed
for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
if (bdCand == null) {
bdCand = holder.getBeanDefinition();
}
if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
parse(bdCand.getBeanClassName(), holder.getBeanName());
}
}
}
}
// Process any @Import annotations
// 这里是@Import 注解的逻辑
processImports(configClass, sourceClass, getImports(sourceClass), filter, true);
// Process any @ImportResource annotations
// 这里是@ImportResource 注解的逻辑
AnnotationAttributes importResource =
AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
if (importResource != null) {
String[] resources = importResource.getStringArray("locations");
Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
for (String resource : resources) {
String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
configClass.addImportedResource(resolvedResource, readerClass);
}
}
// Process individual @Bean methods
// 这里是@Bean 注解的逻辑
Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
for (MethodMetadata methodMetadata : beanMethods) {
configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
}
// Process default methods on interfaces
processInterfaces(configClass, sourceClass);
// Process superclass, if any
if (sourceClass.getMetadata().hasSuperClass()) {
String superclass = sourceClass.getMetadata().getSuperClassName();
if (superclass != null && !superclass.startsWith("java") &&
!this.knownSuperclasses.containsKey(superclass)) {
this.knownSuperclasses.put(superclass, configClass);
// Superclass found, return its annotation metadata and recurse
return sourceClass.getSuperClass();
}
}
// No superclass -> processing is complete
return null;
在此 postProcessBeanDefinitionRegistry 方法中，我们可以看到 @Configuration @Component 和 @PropertySources ，@ComponentScans，@ComponentScan，@ImportResource 的处理逻辑。
2.3.2.2 postProcessBeanFactory 方法
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
int factoryId = System.identityHashCode(beanFactory);
if (this.factoriesPostProcessed.contains(factoryId)) {
throw new IllegalStateException(
"postProcessBeanFactory already called on this post-processor against " + beanFactory);
}
this.factoriesPostProcessed.add(factoryId);
if (!this.registriesPostProcessed.contains(factoryId)) {
// BeanDefinitionRegistryPostProcessor hook apparently not supported...
// Simply call processConfigurationClasses lazily at this point then.
processConfigBeanDefinitions((BeanDefinitionRegistry) beanFactory);
}
// 此处给工厂对象创建代理对象。比如说为@bean在方法上加了，就不会重复创建Bean了。代理会先去缓存中找一把。
enhanceConfigurationClasses(beanFactory);
// 给工厂对象添加了一个ImportAwareBeanPostProcessor。Bean的后置处理器。
beanFactory.addBeanPostProcessor(new ImportAwareBeanPostProcessor(beanFactory));
}
以上就是注解方式IOC加载的流程。
3. 图解。
扫一扫
8067
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
