有关Spring的Configuration配置类@Bean注册对象的初始化过程的源码探究

傷城~ 2022-11-22 05:19 114阅读 0赞

> 探究@Configuration中的@Bean对象的初始化过程

## 文章目录  @\[toc\]  先说结论  探究过程  构建JavaConfig配置样例  确定大致范围  探究AnnotationConfigApplicationContext初始化过程  深入refresh方法  invokeBeanFactoryPostProcessors  processConfigBeanDefinitions  加载@Bean方法定义的bean对象的BeanDefinition  @Bean对象实例化和初始化  一些收获  最后 ##

自从Spring3.0以来，就新提出了基于注解配置Bean对象的方式，具体的使用方式相信大家一定非常熟悉了，这里就放一篇简单的文章吧：

[https://www.cnblogs.com/duanxz/p/7493276.html][https_www.cnblogs.com_duanxz_p_7493276.html]

需要说明的是，这篇文章不是对@Configuration使用方法的探究，而是博主对于@Configuration里面@Bean注解定义的bean对象是如何初始化的小探究。

--------------------

## 先说结论 ##

使用@Configuration注册的JavaConfig类进行注册的Bean对象（这里只讨论简单的Bean对象）：

1.  在refresh()方法中，首先通过内置的BeanDefinitionRegisterPostProcessor前置处理器internalConfigurationAnnotationProcessor扫描并且加载使用@Bean注册对象的BeanDefinition
2.  然后在refresh()方法的bean实例化和初始化阶段，获得这个Bean对象的工厂方法（就是配置类中自定义的那个方法）
3.  使用反射执行这个工厂方法，完成了Bean对象的实例化过程（其实初始化赋值也在这个过程完成了！因为在这个方法里你自己用了构造函数赋值了啊！）获得了Bean对象
4.  最后使用大家熟知的BeanWrapper将这个对象包装，放入beanFactory容器中

--------------------

## 探究过程 ##

### 构建JavaConfig配置样例 ###

首先新建一个spring项目，并且创建相应的JavaConfig类

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center]  
MyJavaConfig类：

@Configuration
    public class MyJavaConfig {
        
        @Bean
        public User user(){
        
            return new User("dzzhyk", "123");
        }
    }

User类如下：省略了get和set方法，以及toString方法

package com.example;
    
    public class User {
        
        private String username;
        private String password;
    
        public User() {
        
        }
    
        public User(String username, String password) {
        
            this.username = username;
            this.password = password;
        }
    }

测试类Test如下：

public class Test {
        
        public static void main(String[] args) {
        
            AnnotationConfigApplicationContext context = 
            		new AnnotationConfigApplicationContext(MyJavaConfig.class);
    
            User user = (User) context.getBean("user");
            System.out.println(user.toString());
        }
    }

在spring-config.xml配置文件中开启包扫描：

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:context="http://www.springframework.org/schema/context"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        ">
    
        <context:component-scan base-package="com.example" />
    
    </beans>

以上就是一个最简洁的使用JavaConfig的样例，我们运行Test测试类可以得到输出如下：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 1]

--------------------

### 确定大致范围 ###

接下来让我们打个断点在第一行

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 3][]  
这里可以确定的是，此时容器肯定已经创建并且初始化完成了。接下来要问的是，使用javaConfig创建的Bean对象的属性注入了吗？让我们打开容器中的beanFactory->singletonObjects查看user对象：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 4]

可以看到，在getBean之前，这个Bean对象已经被创建并且拥有了配置的属性了。所以我们只需要debug容器初始化过程（第一行）就可以了。

--------------------

### 探究AnnotationConfigApplicationContext初始化过程 ###

对于ApplicationContext容器的初始化过程，这篇文章就不再赘述了，实际上AnnotationConfigApplicationContext的初始化过程也和抽象ApplicationContext的初始化过程完全相同，大致分为三步：

1.  初始化容器里的private参数，主要是reader和scanner两个东西
2.  由scanner执行scan，扫描配置文件获取BeanDefinition，并且注册register所有Bean定义
3.  执行refresh()方法创建bean实例，加入IoC容器

以上大致可以从AnnotationConfigApplicationContext的构造函数看出：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 5]

首先进入this()方法，这个方法肯定是调用了默认构造方法，发现就是初始化了reader和scanner

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 6]

接下来步进到register(componentClasses)方法：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 8]

此时发现，目前只有spring自带的5个beanDefinition，我们配置需要扫描路径下的对象还没有载入进来。

当然，此时还没有执行refresh()方法，所以肯定不会有singleObject对象实例，bean实例化还没有进行！

继续前进，直接跳过register函数的执行：

此时MyJavaConfig里面定义的bean对象还没有注册其BeanDefinition

--------------------

### 深入refresh方法 ###

让我们继续深入refresh方法。可以确定的是，refresh方法应该是容器IoC最重要的方法，主要的作用是刷新bean容器，实例化beanDefinitionMap里面的对象并且交给管理；

在refresh方法里面，还会处理各种预定义或自定义的前置、后置处理器，用来在bean的生命周期中进行对bean的增强；

除了上面这些内容，refresh方法还进行了许多其他操作，比如注册各种监听器Listener

AbstructApplicationContext里面的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();
    		}
    	}
    }

在学习完成refresh()方法的大致内容之后，我们继续关注本次探讨的主题：@Bean对象注册和初始化

目前可以肯定的是：@Bean对象注册和初始化肯定都在refresh()方法中完成了

我们知道bean对象的实例化大致分为2步：

1.  获取并且注册BeanDefinition
2.  根据BeanDefinition初始化得到bean实例对象

--------------------

### invokeBeanFactoryPostProcessors ###

我们一边观察beanFactory中的beanDefinitionMap对象，一边在refresh()方法内步进，观察到底是哪个具体方法注册了user的BeanDefinition，我们就找到了invokeBeanFactoryPostProcessors这个方法。

invokeBeanFactoryPostProcessors是用来执行bean工厂的前置处理器的方法

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 11]  
上面的注释写着：初始化并且执行所有已经注册的BeanFactoryPostProcessor处理器，如果指定了顺序还会按照顺序执行，在一个单例对象初始化之前必须调用这个方法。

此时会感到奇怪：我们并没有给这个user类工厂指定前置处理器，那么还记得之前spring自带的5个beanDefinition吗，也就是说spring内置了一个默认的前置处理器来处理。

继续进入上图中的invokeBeanFactoryPostProcessors：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 12]

public static void invokeBeanFactoryPostProcessors(
    			ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
        
    
    	// 执行可能的 BeanDefinitionRegistryPostProcessors
    	Set<String> processedBeans = new HashSet<>();
    
    	if (beanFactory instanceof BeanDefinitionRegistry) {
        
    		// 获得IoC容器对象
    		BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
    		// bean工厂的处理器
    		List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
    		// bean定义的处理器
    		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);
    			}
    		}
    
    		/*
    		不要在这里初始化FactoryBeans：我们需要保留所有未初始化的常规bean，以便让bean工厂后处理器对其应用！
    		*/
    		List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
    
    		// 首先, 执行最高优先级的 BeanDefinitionRegistryPostProcessors
    		String[] postProcessorNames =
    				beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
    		for (String ppName : postProcessorNames) {
        
    			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
        
    			
    				// 实例化BeanDefinitionRegistryPostProcessor对象
    				currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
    				processedBeans.add(ppName);
    			}
    		}
    		
    		// 对已经获得的BeanDefinitionRegistryPostProcessors排序
    		sortPostProcessors(currentRegistryProcessors, beanFactory);
    		
    		// 加入已经注册的处理器中
    		registryProcessors.addAll(currentRegistryProcessors);
    		
    		// 执行所有的BeanDefinitionRegistryPostProcessor
    		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
    		
    		// 执行完毕后，把已经执行的BeanDefinitionRegistryPostProcessors都清空
    		// 接下来准备执行自定义的BeanDefinitionRegistryPostProcessors
    		currentRegistryProcessors.clear();
    
    		// 执行自定义的有顺序的 BeanDefinitionRegistryPostProcessors
    		postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
    		for (String ppName : postProcessorNames) {
        
    			if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
        
    				currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
    				processedBeans.add(ppName);
    			}
    		}
    		sortPostProcessors(currentRegistryProcessors, beanFactory);
    		registryProcessors.addAll(currentRegistryProcessors);
    		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
    		currentRegistryProcessors.clear();
    
    		// 执行所有剩余的 BeanDefinitionRegistryPostProcessors
    		boolean reiterate = true;
    		while (reiterate) {
        
    			reiterate = false;
    			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
    			for (String ppName : postProcessorNames) {
        
    				if (!processedBeans.contains(ppName)) {
        
    					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
    					processedBeans.add(ppName);
    					reiterate = true;
    				}
    			}
    			sortPostProcessors(currentRegistryProcessors, beanFactory);
    			registryProcessors.addAll(currentRegistryProcessors);
    			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
    			currentRegistryProcessors.clear();
    		}
    
    		// 执行到目前为止所有的处理器 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!
    	String[] postProcessorNames =
    			beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
    
    	// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
    	// Ordered, and the rest.
    	List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    	List<String> orderedPostProcessorNames = new ArrayList<>();
    	List<String> nonOrderedPostProcessorNames = new ArrayList<>();
    	for (String ppName : postProcessorNames) {
        
    		if (processedBeans.contains(ppName)) {
        
    			// 跳过，因为上面已经执行过了
    		}
    		else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
        
    			priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
    		}
    		else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
        
    			orderedPostProcessorNames.add(ppName);
    		}
    		else {
        
    			nonOrderedPostProcessorNames.add(ppName);
    		}
    	}
    
    	// 执行优先的 BeanFactoryPostProcessors
    	sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    	invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
    
    	// 执行有序的 BeanFactoryPostProcessors
    	List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
    	for (String postProcessorName : orderedPostProcessorNames) {
        
    		orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    	}
    	sortPostProcessors(orderedPostProcessors, beanFactory);
    	invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
    
    	// 执行其他的 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.clearMetadataCache();
    }

这一段代码很长，大体做了2件事：

1.  执行所有可能的 BeanDefinitionRegistryPostProcessor
2.  执行所有 BeanFactoryPostProcessor，因为BeanFactoryPostProcessor是BeanDefinitionRegistryPostProcessor的高层次类，所以在第二步执行的时候，会跳过前面已经执行过的BeanDefinitionRegistryPostProcessor

另外我们也知道了一些事情：

1.  BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor的接口SPI扩展实现，允许用来在所有的BeanFactoryPostProcessor执行之前加入更多新的BeanDefinition
2.  BeanFactoryPostProcessor是用来对BeanDefinition处理的，其作用时间为BeanDefinition实例化之前

--------------------

### processConfigBeanDefinitions ###

让我们继续回想本次的主题：@Bean对象注册和初始化，目前我们所处的位置，是为@Bean对象创建BeanDefinition的时候，但是在进入invokeBeanFactoryPostProcessors方法之前，这个BeanDefinition还不存在；

通过对invokeBeanFactoryPostProcessors方法的探究，我们又知道，存在一个BeanDefinitionRegistryPostProcessor，它的作用是在BeanFactoryPostProcessor执行之前加入一些新的BeanDefinition，那么@Bean对象的定义很可能就是在这时候被加入的。

所以我们就在invokeBeanFactoryPostProcessors方法里面步进

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 14]

获得了一个处理器对象 internalConfigurationAnnotationProcessor

根据名字可以判断，这是Spring内部的配置类注解处理器，所以很有可能就是这个处理器从@Bean标注的方法中获取了BeanDefinition并且加入beanDefinitionMap中。

于是我们在下面的执行方法上打断点进入invokeBeanDefinitionRegistryPostProcessors方法

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 15]  
继续深入，在这里遍历了当前所有的处理器并且调用了他们的处理方法postProcessBeanDefinitionRegistry

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 16]

继续前进，找到这个方法的实现：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 17]

最终的实现位置是：processConfigBeanDefinitions方法，位于ConfigurationClassPostProcessor类中

步进可以观察到，candidateNames中是所有的已知BeanDefinition，通过一个for循环，找到是配置类的BeanDefinition

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 19]

最后得到的configCandidates就是过滤出来的配置类

--------------------

### 加载@Bean方法定义的bean对象的BeanDefinition ###

现在，已经有了配置类的BeanDefinition，目标是加载该配置类中标注了@Bean方法所定义的bean对象的BeanDefinition

如果是我，我会这么做：

1.  解析这个配置类的BeanDefinition
2.  获取这个BeanDefinition记录的类的所有方法
3.  遍历这些方法，找出带有@Bean标记的方法
4.  逐个解析这些包含@Bean标记的方法，结合各种注解信息创建BeanDefinition
5.  把这些创建的BeanDefinition加入到IoC的beanDefinitionMap中

既然我都想到了，Spring的开发者肯定也早就想到了，所以下面的过程和我说的大致相同

不过，Spring作为一个框架，肯定具有高度的整合性，所以不可能是手工解析，而是借助包装的思想，用reader等等包装类来解析。

对于配置类的BeanDefinition对象，Spring也对其进行了包装，得到了ConfigurationClass类

对于配置类中的所有方法，Spring也对其进行了包装，称为BeanMethod类

所以，最后根据方法创建BeanDefinition的函数，称为loadBeanDefinitionsForBeanMethod()

综上，源码部分就一直步进就可以了：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 20]

继续进入loadBeanDefinitions方法：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 21]

可以看到，在这个方法里面为每个配置类都执行了loadBeanDefinitionsForConfigurationClass方法，和上面我们自己的思路差不多。

进入loadBeanDefinitionsForConfigurationClass方法：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 22]

这里就拿到了所有的方法BeanMethod，然后进入loadBeanDefinitionsForBeanMethod方法：

这个方法很长，我就不截图了，具体在做什么大家肯定很清楚了！就是解析这个方法的各种信息，然后创建一个需要的beanDefinition出来！

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 23]

我们直接把断点打在287行，这个方法的结尾：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 24]

此时看一下debug信息，beanDefToRegister就是我们的user类的bean定义：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 25]  
这个bean定义里面，指明了该bean对象的创建工厂类、构造该对象实例的具体工厂方法（user），同时注明该对象的自动装配模式是3，也就是构造器装配

![自动装配类型定义][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 26]

### @Bean对象实例化和初始化 ###

通过上面的BeanDefinition解析，可以看到这种使用@Bean注册的对象都需要使用构造器注入，其构造工厂就是配置类，其构造函数就是配置类下定义的那个函数，所以在refresh()方法执行到实例化的时候，就会使用工厂方法创建这个对象（前提不是懒加载）

既然你已经自定义了工厂函数，那么在实例化的同时就完成了属性赋值操作

让我们回到refresh()函数：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 27]  
可以看到，在初始化自定义的 @Bean对象之前，还要初始化很多其他的内容，比如Bean处理器对象，监听器对象，其他特殊对象，这样才能在进行你自己的bean对象初始化的时候完成很多功能。

让我们进入finishBeanFactoryInitialization函数，这里其实就不是本次的重点了，而是所有通用的IoC容器初始化过程都大致如此，所以我会说的比较简略。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 29]

当bd为我们的user定义时，因为他不是FactoryBean即工厂类型的Bean对象，所以直接调用下面879行的getBean方法实例化他：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 30]

进入getBean方法，这方法明显是一个重载后的方法：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 31]

doGetBean方法的实现体太长，在此就不贴了，可以确定的是我们的user对象是单例，所以直接定位到321行：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 32]

不管中间如何进行，最终都会来到一个方法：instantiateUsingFactoryMethod

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 33]

这个方法的介绍上面也写的很明白：使用一个工厂方法实例化bean对象

在这里面创建了一个新的包装类BeanWrapperImpl，然后找到这个beanDefinition的工厂类，找到这个工厂方法factoryMethod，然后确定这个方法需要的参数args

最终，使用策略模式调用instantiate方法执行Invoke

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 35]  
可以看到，执行了配置类里面的方法，到此bean的实例化初始化结束，我们最终在容器中生成了配置的对象，就可以正常使用了。

--------------------

以上就是本次对于@Configuration配置类中@Bean对象注册和初始化过程的探究全部内容了！

## 一些收获 ##

本次对于@Configuration配置类的探究，从头到尾解释了@Bean配置方法的解析过程，更加清晰了。

Spring3.0以来推出的注解配置方式已经逐渐成为了主流，并且在SpringBoot中广泛应用，所以了解实现原理还是很有必要的一件事情。

对于源码的debug一直是比较令人头痛的事情，通过这次学习熟练了很多。

## 最后 ##

一不小心又写了这么长。。可能观感不是太好啊~

但是能给大家带来一点知识，让我很开心

欢迎持续关注我的CSDN博客，会坚持输出一些优质源码类文章

[CC\_且听风吟丶的博客][CC]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 36]

[https_www.cnblogs.com_duanxz_p_7493276.html]: https://www.cnblogs.com/duanxz/p/7493276.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/762a916bba29427ebbe08ccbd4630a22.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221120/8e5f6f1eae4e42e18c0e103d027d7b5c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221120/5a0fabab34f74c609dc3585c10058b7d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221120/6011ac3803a04c899acc273dfee0c0ed.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221120/95d9c482345848b1b9c9138e2ac615a9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221120/7df5ec7c1a3041e68b5088170e5692f8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221120/c8bf79f603cb40029d364bf85908a483.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221120/45aa6aec9f92438aa177b18cedfa0968.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20221120/0c47cb5291a54d2a8453cb8de1dffd3a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 9]: /images/20221120/0aa878777bf744a5b9cbe589275c3032.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 10]: /images/20221120/6a66a6338ddf453190f621821d2769fb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 11]: /images/20221120/e63a51e0c9804e988f8c4b5b72bd3bf8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 12]: /images/20221120/cd09bbdc9e1b40369431d129fb705fb3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 13]: /images/20221120/831e9f65e24b4b2d9bb5633f03f626a8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 14]: /images/20221120/dbe7f9b61c1a4a7b8b407808b924865d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 15]: /images/20221120/a4c780e3c5794f6a94f1613fd7c9a120.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 16]: /images/20221120/42b97f3b8ecb450690019f83ab239242.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 17]: /images/20221120/b826427ee7a249d9b58ae38861ae59ea.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 18]: /images/20221120/0877c6ba2dc9401eb520d8f509407eca.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 19]: /images/20221120/e0dcc234519848f286fa886d3f3dcc1b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 20]: /images/20221120/9d8f6624517447b4b6843e09fd0d665a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 21]: /images/20221120/d3a585a8862a4f3e82df6fc387861003.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 22]: /images/20221120/5ac3ea5ad3ae4a4db02686b90e7740f3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 23]: /images/20221120/6ae3d8c91b804baa8c24b096c4d77c6e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 24]: /images/20221120/455759b0fdf443f9a838d9714a2dbcf2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 25]: /images/20221120/ab89cba01d484e41860ba8ac6674aa06.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 26]: /images/20221120/b181adb67f2745aa92a65501bda416c4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 27]: /images/20221120/1afe45128b2a49ce850aa5200d6823a9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 28]: /images/20221120/ab85309a05bb404f941ca8cd3cf09d80.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 29]: /images/20221120/659b94988bdf4cafb84217e05732ef1f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 30]: /images/20221120/16dc5d4fbcf24937b67b616c98699688.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 31]: /images/20221120/495d961b8a9743e5be9d284642a11408.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 32]: /images/20221120/1335fe5eba75463db73c16508401af3f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 33]: /images/20221120/5a606715a3604a2bbb6956c9c10e4a49.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 34]: /images/20221120/fc1a67f183e64c96b689a01b6f838e7d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 35]: /images/20221120/87900e41103443b5964f06a4ec9415f2.png
[CC]: https://dzzhyk.blog.csdn.net/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 36]: /images/20221120/64e5289826ac490fa42da560b2c72e58.png