【Spring】二、SpringIOC Bean的初始化流程

系统管理员 2023-10-09 14:16 2阅读 0赞

上一篇：[【Spring】一、Spring注解真的你会用吗][Spring_Spring]

下一篇：[【Spring】三、SpringIOC Bean的初始化流程-循环依赖][Spring_SpringIOC Bean_-]

#### 文章目录 ####

*  一、 Spring源码中对象的介绍
 *   *  1、IoC 和 DI
     *  2、bean
     *  3、BeanDefinition
     *  4、BeanFactory 和 ApplicationContext
     *  5、FactoryBean
 *  二、 SpringIOC源码分析
 *   *  1、宏观分析
     *  2、refresh()方法12个步骤分析
     *  3、IOC容器12步中的第5步剖析
     *  4、IOC容器12步中的第11步剖析
 *  三、 基于注解的Spring IOC容器宏观总结
 *  四、 画图总结

## 一、 Spring源码中对象的介绍 ##

首先咱们先回顾一下spring的基础知识，

### 1、IoC 和 DI ###

IoC （Inversion of Control），即控制反转。这不是一种新的技术，而是 Spring 的一种设计思想。

在传统的程序设计，我们直接在对象内部通过 new 来创建对象，是程序主动去创建依赖对象；而在 Spring 中有专门的一个容器来创建和管理这些对象，并将对象依赖的其他对象注入到该对象中，这个容器我们一般称为 IoC 容器。

所有的类的创建、销毁都由 Spring 来控制，也就是说控制对象生存周期的不再是引用它的对象，而是 Spring。对于某个具体的对象而言，以前是它控制其他对象，现在是所有对象都被 Spring 控制，所以这叫控制反转。

DI（Dependency Injection），即依赖注入，由 Martin Fowler 提出。可以认为 IoC 和 DI 其实是同一个概念的不同角度描述。

依赖注入是指组件之间的依赖关系由容器在运行期决定，形象的说，即由容器动态的将某个依赖关系注入到组件之中。依赖注入的目的并非为软件系统带来更多功能，而是为了提升组件重用的频率，并为系统搭建一个灵活、可扩展的平台。

通过依赖注入机制，我们只需要通过简单的配置，而无需任何代码就可指定目标需要的资源，完成自身的业务逻辑，而不需要关心具体的资源来自何处，由谁实现。

### 2、bean ###

***官方概念：在 Spring 中，构成应用程序主干并由 Spring IoC 容器管理的对象称为 bean。bean 是一个由 Spring IoC 容器实例化，组装和管理的对象。***

大白话：bean 可以认为是那些我们想注入到 Spring IoC 容器的 Java 对象实例的抽象。

我们经常会在 Service 上使用 @Service 注解，然后在要使用该 Service 的类中通过 @Autowire 注解来注入，这个 Service 就是一个 bean。在这个地方，@Service 注解相当于告诉 IoC 容器：这个类你需要帮我创建和管理；而 @Autowire 注解相当于告诉 IoC 容器：我需要依赖这个类，你需要帮我注入进来。

### 3、BeanDefinition ###

理解了 bean，BeanDefinition 就好理解了。BeanDefinition 是 bean 的定义，用来存储 bean 的所有属性方法定义。

### 4、BeanFactory 和 ApplicationContext ###

**BeanFactory：基础类型 IoC 容器，提供完整的 IoC 服务支持。**

ApplicationContext：BeanFactory 的子接口，在 BeanFactory 的基础上构建，是相对比较高级的 IoC 容器实现。包含 BeanFactory 的所有功能，还提供了其他高级的特性，比如：事件发布、国际化信息支持、统一资源加载策略等。正常情况下，我们都是使用的 ApplicationContext。  
以电话来举例：  
我们家里使用的 “座机” 就类似于 BeanFactory，可以进行电话通讯，满足了最基本的需求。

而现在非常普及的智能手机，iPhone、小米等，就类似于 ApplicationContext，除了能进行电话通讯，还有其他很多功能：拍照、地图导航、听歌等。

### 5、FactoryBean ###

一般情况下，我们将 bean 的创建和管理都交给 Spring IoC 容器，Spring 会利用 bean 的 class 属性指定的类来实例化 bean。

但是如果我们想自己实现 bean 的创建操作，可以实现吗？答案是可以的，FactoryBean 就可以实现这个需求。

**FactoryBean 是一种特殊的 bean，它是个工厂 bean，可以自己创建 bean 实例，如果一个类实现了 FactoryBean 接口，则该类可以自己定义创建实例对象的方法，只需要实现它的 getObject() 方法即可。**

FactoryBean 可能对于普通开发来说基本用不到也没去注意过，但是它其实应用的非常广，特别是在中间件中，如果你看过一些中间件的源码，一定会看到 FactoryBean 的身影。

## 二、 SpringIOC源码分析 ##

### 1、宏观分析 ###

1、ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
    
    2、new AnnotationConfigApplicationContext(SpringConfig.class);--> {
        
         2.1、this();-->{
        
    	    //spring内部加载了5个BeanDefinition：就是对bean的描述;
    	    2.1.1、this.reader = new AnnotatedBeanDefinitionReader(this);
    	    //放置了@Compment注解
    	    2.1.2、this.scanner = new ClassPathBeanDefinitionScanner(this);
        }
         2.2、register(componentClasses); {
        
    	//把componentClasses(SpringConfig)变成bean的描述：BeanDefinition;
    	//然后把BeanDefinition包装成BeanDefinitionHolder;
    	//然后取出BeanDefinitionHolder里面的BeanDefinition;
    	//注册到Map<String, BeanDefinition> beanDefinitionMap中;
    }
        2.3、refresh();//参考下面的具体步骤
    }
    
    3、refresh(); {
        
        //该方法总共有12个步骤，重点看第5步和第11步，宏观上的步骤是：
        //根据项目中的bean（@Service、@Compment...注解的bean）得到BeanDefinition
       //把BeanDefinition放入（注册）beanDefinitionMap中
        //把beanDefinitionMap里面的BeanDefinition拿出来，依次创建所对应的对象；
    }
    }

### 2、refresh()方法12个步骤分析 ###

/**
    	 * 刷新应用上下文，实际上即初始化和启动Spring应用上下文(容器)
    	 *
    	 * @throws BeansException
    	 * @throws IllegalStateException
    	 */
    	@Override
    	public void refresh() throws BeansException, IllegalStateException {
        
    		//线程同步
    		synchronized (this.startupShutdownMonitor) {
        
    			// 1、预准备刷新上下文
    			// Prepare this context for refreshing.
    			prepareRefresh();
    
    			// 2、TODO 告诉子类去刷新内部的bean factory，获得刷新的bean factory，最终得到是DefaultListableBeanFactory，并且加载bean的定义
    			// Tell the subclass to refresh the internal bean factory.
    			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    
    			// 3、预处理bean工厂，为在上下文中使用，注册systemEnvironment，environment，systemProperties几个bean
    			// Prepare the bean factory for use in this context.
    			prepareBeanFactory(beanFactory);
    
    			try {
        
    				//4、由子类覆盖该方法做额外的处理，默认spring框架什么也没有做
    				// Allows post-processing of the bean factory in context subclasses.
    				postProcessBeanFactory(beanFactory);
    
    				//TODO 注解开发的时候，对包扫描的得到bean定义在此步骤完成的,底层就是扫描注解得到bean的定义，然后放入到bean定义的Map中
    				//5、激活各种BeanFactory处理器，目前BeanFactory没有注册任何BeanFactoryPostProcessor，此处相当于不做操作
    				// Invoke factory processors registered as beans in the context.
    				invokeBeanFactoryPostProcessors(beanFactory);
    
    				//6、注册拦截Bean创建的Bean处理器，如果没有bean processors，此步骤什么也不做
    				// Register bean processors that intercept bean creation.
    				registerBeanPostProcessors(beanFactory);
    
    				//7、在上下文初始化注册messageSource的bean，不同语言环境信息，国际化处理
    				// Initialize message source for this context.
    				initMessageSource();
    
    				//8、在上下文初始化注册applicationEventMulticaster的bean，应用消息广播
    				// Initialize event multicaster for this context.
    				initApplicationEventMulticaster();
    
    				//9、初始化其他的bean，默认情况下Spring框架什么也不做
    				// Initialize other special beans in specific context subclasses.
    				onRefresh();
    
    				//10、在所有bean中查找listener bean并注册到消息广播中，没有的话就什么也不做；
    				// Check for listener beans and register them.
    				registerListeners();
    
    				//11、TODO 初始化所有剩下的非延迟初始化的单例bean对象
    				// Instantiate all remaining (non-lazy-init) singletons.
    				finishBeanFactoryInitialization(beanFactory);
    
    				//12、完成刷新过程，通知生命周期处理器lifecycleProcessor刷新过程，同时发出ContextRefreshEvent通知相关事件
    				// Last step: publish corresponding event.
    				//TODO 如果是spring mvc，里面会调用spring mvc dispatcherServlet的九大初始化
    				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();
    			}
    		}
    	}

**在以上的12个步骤中，只有第5步和第11步是非常重要的，是我们源码阅读重点需关注的，其他步骤可以略读，下面我们分别剖析一下这两个步骤，首先剖析第5步：**

### 3、IOC容器12步中的第5步剖析 ###

*  第五步方法代码

/**
    	 * Instantiate and invoke all registered BeanFactoryPostProcessor beans,
    	 * respecting explicit order if given.
    	 * <p>Must be called before singleton instantiation.
    	 */
    	protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
        
    
    		//TODO 对所有的BeanDefinitionRegistryPostProcessors 、手动注册的BeanFactoryPostProcessor
    		// 以及通过配置文件方式的BeanFactoryPostProcessor按照 PriorityOrdered、Ordered、no ordered三种方式分开处理、调用
    		PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
    
    		// Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
    		// (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
    		if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
        
    			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
    			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    		}
    	}

主要调用链路方法解析

1、调用BeanFactoryPostProcessors
    PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
    
    2、调用PostProcessors，里面处理bean的定义
    invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
    
    //3、BeanDefinition的注册
    postProcessor.postProcessBeanDefinitionRegistry(registry);
    
    4、处理配置类的bean的定义
    processConfigBeanDefinitions(registry);
    
    5、解析每一个带有@Configuration注解的类
    ConfigurationClassParser parser = new ConfigurationClassParser(...);
    
    //对配置类中注解进行处理
    parser.parse(candidates);
    
    6、加载bean的定义: 把BeanDefinition放入到一个Map中
    this.reader.loadBeanDefinitions(configClasses);
    
    7、注册bean的定义
    this.registry.registerBeanDefinition(beanName, beanDefToRegister);
    
    8、注册bean定义，即把beanDefinition放入Map中
    this.beanDefinitionMap.put(beanName, beanDefinition);

上面是第5步的主要流程，要基于该流程反复断点调试跟几轮代码，潜移默化中提升源码的阅读能力，此能力需要坚持一个过程和一段时间，非一蹴而就；

### 4、IOC容器12步中的第11步剖析 ###

**- 第11步方法**

/**
    	 * 初始化所有剩下的非延迟初始化的单例bean对象
    	 *
    	 * Finish the initialization of this context's bean factory,
    	 * initializing all remaining singleton beans.
    	 */
    	protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
        
    
    		// Initialize conversion service for this context.
    		if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
    				beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
        
    
    			//设置conversionService的bean，与类型转换相关的bean
    			beanFactory.setConversionService(
    					beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
    		}
    
    		//如果没有内嵌的值解析器
    		// Register a default embedded value resolver if no bean post-processor
    		// (such as a PropertyPlaceholderConfigurer bean) registered any before:
    		// at this point, primarily for resolution in annotation attribute values.
    		if (!beanFactory.hasEmbeddedValueResolver()) {
        
    			//给beanfactory添加一个值解析器
    			beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
    		}
    
    		// 初始化运行时的代码织入，为AspectJ的支持
    		// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
    		String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    		for (String weaverAwareName : weaverAwareNames) {
        
    			getBean(weaverAwareName);
    		}
    
    		// 停止使用临时的ClassLoader
    		// Stop using the temporary ClassLoader for type matching.
    		beanFactory.setTempClassLoader(null);
    
    		// 缓存所有的bean definition元信息，不希望未来发生变化
    		// Allow for caching all bean definition metadata, not expecting further changes.
    		beanFactory.freezeConfiguration();
    
    		// TODO 实例化所有剩下的非延迟加载的单例bean
    		// Instantiate all remaining (non-lazy-init) singletons.
    		beanFactory.preInstantiateSingletons();
    	}

*  11步主要调链条

//1、初始化所有剩下的非延迟初始化的单例bean对象
    finishBeanFactoryInitialization(beanFactory);
    
    //2、实例化所有剩下的非延迟加载的单例bean
    beanFactory.preInstantiateSingletons();
    
    //3、获取bean，底层初始化bean对象，并对bean对象赋值和依赖注入
    getBean(beanName);
    
    //4、获取一个bean实例
    return doGetBean(name, null, null, false);
    
    //5、创建单例的bean实例
    return createBean(beanName, mbd, args);
    
    //6、创建bean实例
    Object beanInstance = doCreateBean(beanName, mbdToUse, args);
    
    //7、创建bean实例
    instanceWrapper = createBeanInstance(beanName, mbd, args); {
        
    // TODO 实例化bean实例
    return instantiateBean(beanName, mbd);
    
    //TODO 此处真正地创建了 bean 的实例对象，底层依然是反射
    beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
    
    //TODO 根据构造器实例化对象
    return BeanUtils.instantiateClass(constructorToUse);
    }
    
    //8、填充bean的属性值，给bean赋值和注入依赖，如果当前bean依赖了其他的bean，则会递归调用beanFactory.getBean()方法尝试获取目标bean
    populateBean(beanName, mbd, instanceWrapper);

## 三、 基于注解的Spring IOC容器宏观总结 ##

1.  创建AnnotationConfigApplicationContext;
2.  创建AnnotationConfigApplicationContext的时候会先创建DefaultListableBeanFactory;
3.  创建好DefaultListableBeanFactory之后，解析和扫描类上的注解并将所有Bean封装成BeanDefinition对象，该BeanDefinition对象封装了Spring所有bean的相关定义描述信息；
4.  对Spring配置的所有bean做实例化，根据BeanDefinition对象的信息，底层采用反射创建具体的bean对象；
5.  将实例化的bean对象放入到一个Map中，后续应用程序就能从该Map中获取到bean对象，该Map也就是我们的ioc容器；

## 四、 画图总结 ##

![在这里插入图片描述][d99dd9fa60b04409b8de00df2fb1d7c0.png_pic_center]

[Spring_Spring]: https://blog.csdn.net/weixin_43333483/article/details/124832616?spm=1001.2014.3001.5502
[Spring_SpringIOC Bean_-]: https://blog.csdn.net/weixin_43333483/article/details/125090668?spm=1001.2014.3001.5502
[d99dd9fa60b04409b8de00df2fb1d7c0.png_pic_center]: https://img-blog.csdnimg.cn/d99dd9fa60b04409b8de00df2fb1d7c0.png#pic_center