Spring源码解读笔记

第一部分 Spring概述

1. Spring简介

Spring 是分层的轻量级开源框架，以IoC和AOP为内核，提供展现层SpringMVC和业务层事务管理等众多企业级应用技术，可以整合众多著名第三方框架和类库，成为使用最多的Java EE企业应用开源框架。

2. Spring优势

• 解耦合，简化开发：提供IoC容器，将对象间的依赖关系交由Spring控制，避免硬编码造成程序耦合，用户可以更专注于上层的应用。
• AOP编程支持：提供AOP功能，方便进行面向切面编程。
• 声明式事务支持：可以通过声明式事务灵活进行事务管理，提高开发效率和质量。
• 方便集成各种开源框架：提供了对各种优秀框架（Struts、Hibernate、Quartz等）的支持。
• 降低JavaEE API的使用难度：对JavaEE API（JDBC、JavaMail、远程调用等）进行封装，使用难度降低。

3. Spring的核心结构

Spring是一个分层清晰并且依赖关系、职责定位明确的轻量级框架，主要包括几大模块：数据处理模块、Web模块、AOP/Aspects模块、Core Container模块和Test模块。

• Spring核心容器（Core container）：Spring框架最核心的部分，管理着Spring应用中bean的创建、配置和管理，提供DI功能。
• 面向切面编程（AOP/Aspects）：Spring对面向切面编程提供支持，可以帮助应用对象解耦合。
• 数据访问与集成（Data Access）：Spring的JDBC和DAO模块封装了大量模版代码，可以使得数据库代码变得简洁，让开发者更专注于业务，还可避免数据库资源释放失败而引起的问题。AOP为数据访问提供了事务管理服务，同时还对ORM进行集成。
• Web模块：提供了SpringMVC框架给Web应用，还提供了多种构建和其他应用交互的远程调用方案。
• Test模块：集成了Junit，使得开发者能够更方便的进行测试。

第二部分 核心思想

注意：IoC和AOP并不是Spring提出，在Spring之前就已经存在，只不过更偏向于理论化，Spring只是在技术层次把这两个思想做了非常好的实现。

1. IoC

1.1 什么是IoC？

IoC全称IoC Inversion of Control（控制反转），它是一个技术思想，不是一个技术实现。

描述的事情：Java开发领域对象的创建、管理的问题

传统开发方式：比如类A依赖于类B，通常会在类A中new一个B的对象

IoC思想下开发方式：不用自己new对象，而是由IoC容器去实例化对象并管理它，开发者需要哪个对象，直接从IoC容器中取即可

为什么叫做控制反转？

控制：指对象的创建（实例化、管理）的权利

反转：控制权交给IoC容器

1.2 IoC解决了什么问题

IoC解决了对象之间的耦合问题

1.3 IoC和DI的区别

DI全称Dependancy Injection（依赖注入）

IoC和DI描述的是同一件事，只不过角度不一样

2. AOP

2.1 什么是AOP

AOP全称Aspect oriented Programming（面向切面编程）

AOP是OOP的一个延续，虽然有了OOP的存在，但是有一些情况是OOP处理不了的，因此AOP出场，AOP独辟蹊径提出横向抽取机制，将横切逻辑代码和业务逻辑代码分离。

代码拆分容易，但是如何在不改变原有业务逻辑的情况下，悄无声息的把横切逻辑代码应用到原有的业务逻辑中，达到和原来一样的效果却比较难。

2.2 AOP解决了什么问题

在不改变原有业务逻辑情况下，增强横切逻辑代码，从根本上解耦合，避免横切逻辑代码重复。

2.3 为什么叫做面向切面编程

【切】：指横切逻辑，原有业务逻辑代码不能动的情况下，只能操作横切逻辑代码，所以面向横切逻辑。

【面】：横切逻辑代码往往影响的是很多方法，每一个方法如同一个点，点点成面。

第三部分 手写实现IoC和AOP

1. 银行转账案例问题分析

1. 问题一：service层实现类在使用dao层对象时，直接在TransferService中通过AccountDao accountDao = new AccountDaoImpl获得dao层对象，然而new关键字却将service层和dao层实现类耦合在一起，如果技术架构发生变动，dao层的实现要使用其他技术，切换成本太大，每一个new的地方都需要修改源代码，重新编译，面向接口开发的意义将大打折扣。
2. 问题二：service层代码没有进行事务控制，如果转账过程中出现异常，将导致数据错乱，后果很严重。

2. 问题解决思路

• 针对问题一解决方案：把类的全限定名配置在xml中，通过工厂模式，加载配置文件并进行解析，通过反射技术，生产对象。
  • 更进一步，声明一个变量并提供set方法，在反射的时候将所需要的对象注入进去，完成依赖关系维护。
• 针对问题二解决方案：（1）dao层让两次update操作使用同一个connection对象连接，可以给当前线程绑定一个connection，和当前线程有关系的数据库操作都是用这个connection；（2）把事务控制添加在service层。通过动态代理的方式，获取到service接口的代理类，在进行原有逻辑调用前后添加开启事务，事务提交，异常时事务回滚等；（3）servlet层通过代理工厂获取service的委托对象。

第四部分 Spring IoC的应用

1.Spring IoC基础

1.1 BeanFactory与ApplicationContext区别

BeanFactory是Spring框架中IoC容器的顶层接口，只是用来定义一些基础功能和基础规范，而ApplicationContext是它的一个子接口，ApplicationContext具备BeanFactory提供的全部功能。

通常称BeanFactory为Spring IoC的基础容器，ApplicationContext是容器的高级接口，比BeanFactory要拥有更多的功能，比如国际化支持和访问（xml，java配置类）等。

启动IoC容器的方式

• Java环境下启动IoC容器

  • ClassPathXmlApplicationContext：类的根路径下加载配置文件（推荐使用）
  • FileSystemXmlApplicationContext：磁盘路径下加载配置文件
  • AnnotationConfigApplicationContext：纯注解模式下启动Spring容器

• Web环境下启动IoC容器

  • 从xml启动容器，在web.xml中配置

    
    
    	Archetype Created Web Application
    	
    	
    		contextConfigLocation
    		classpath:applicationContext.xml
    	
    	
    	
    		org.springframework.web.context.ContextLoaderListener
    	
    
    

  • 从配置类启动容器

    
    
    	Archetype Created Web Application
    	
    	
    		contextClass
    		org.springframework.web.context.support.AnnotationConfigWebAppli
    cationContext
    		
    
    	
    	
    		contextConfigLocation
    		com.lagou.edu.SpringConfig
    	
    	
    	
    		org.springframework.web.context.ContextLoaderListener
    	
    
    

1.2 纯xml模式

• xml文件头

• 实例化Bean的三种方式

  • 方式一：使用无参构造函数

    默认情况下，会通过反射调用无参构造函数来创建对象。如果类中没有无参构造函数，将创建失败。

  • 方式二：使用静态方法创建

    在实际开发中，我们使用的对象有时候并不是直接通过构造函数就可以创建处理，它可能在创建的过程中会做很多额外的操作。此时会提供一个创建对象的方法，恰好这个方法是static修饰的方法，即是这种情况。

    方式三：使用实例化方法创建

    此种方法和方式二类似，区别是用于获取对象的方法不再是static修饰的，而是类中的普通方法。此种方式比静态方法创建的使用几率高一些。

• Bean的生命周期

  • 作用范围的改变：在Spring框架管理Bean对象的创建时，Bean对象默认是单例，但是它支持配置的方式改变作用范围。

  • 不同作用范围的生命周期

    单例模式：singleton

    对象出生：创建容器是，对象就被创建

    对象活着：容器在，对象就一直存在

    对象死亡：销毁容器，对象就被销毁

    一句话总结：单例模式的bean对象生命周期与容器相同

    多例模式：prototype

    对象出生：使用对象时，创建新的对象实例

    对象活着：对象在使用，就一直存在

    对象死亡：对象长时间不用时，被java的垃圾回收器回收

    一句话总结：多例模式的bean对象，spring只负责创建，不负责销毁

• Bean的标签属性

  id属性： bean的唯一标识，一个标签内部，标识必须唯一。

  class属性： bean对象的全限定类名。

  name属性： bean的名称，多个名称用空格分隔。

  factory-bean属性： 用于指定创建当前bean对象的工厂bean的唯一标识。指定此属性后class失效

  factory-method属性： 用于指定创建当前bean对象的工厂方法，配合factory-bean属性使用，class属性失效。

  scope属性： bean的作用范围，默认singleton。需使用多例模式时，可配置为prototype。

  init-method属性： bean对象的初始化方法，会在bean对象装配后调用。必须是无参方法。

  destory-method属性： bean对象的销毁方法，会在bean对象销毁前执行。scope为singleton时起作用。

• DI依赖注入的xml配置

  • 依赖注入分类

    • 按照注入的方式分类

      构造函数注入： 利用带参构造函数实现对类成员的数据赋值。

      set方法注入： 通过类成员的set方法实现数据的注入。（使用最多）

    • 按照注入的数据类型分类

      基本数据类型和String

      注入的数据类型是基本数据类型或者是字符串类型的数据。

      其它Bean类型

      注入的数据类型是对象类型，这个对象时要求出现在IoC容器中的。

      复杂类型（集合类型）

      注入的数据类型是Array，List，Set，Map，Properties中的一种类型。

  • 依赖注入的配置实现之函数注入

    利用构造函数实现对类成员的赋值。

    使用要求：类中提供的构造函数参数个数必须和配置的参数个数一直，且数据类型匹配。

    注意：当无参构造时，则必须提供构造函数参数的注入，否则会报错。

    使用构造函数注入时，涉及的标签时constructor-arg，标签有如下属性：

    name： 用于给构造函数中指定名称的参数赋值。

    index： 用于给构造函数中指定索引位置的参数赋值。

    value： 用于指定基本数据类型或者String类型的数据。

    ref： 用于指定其它Bean类型的数据。

  • 依赖注入的配置实现之set方法注入

    利用字段的set方法实现赋值的注入方式。实际开发中使用最多的注入方式。

    使用set方法注入时，需要使用property标签，标签有如下属性：

    name： 指定注入时调用的set方法名称。（注：不包含set）

    value： 指定注入的数据，支持基本数据类型和String类型。

    ref： 指定注入的数据。支持其它Bean类型。写的是其它Bean的唯一标识。

    • 复杂数据类型注入

      指的是集合数据类型，分为两类，List和Map

      set方法注入：

      List结构的集合数据注入时，array,list,set这三个标签通用，注值的value标签内部可直接写值，也可以使用bean标签配置一个对象，或者用ref标签引用一个已经配过的bean的唯一标识。

      Map结构的集合数据注入时，map标签使用entry子标签实现注入，entry标签可以使用 key 和 value 属性指定存入map中的数据。使用 value-ref 属性指定已经配置好的bean的引用。

1.3 xml与注解相结合模式

注意：

1）实际企业开发中，纯xml模式已经很少使用

2）引入注解功能，不需要引入额外的jar

3）xml+注解结合模式，xml文件依然存在，所以IoC容器的启动依然从加载xml开始

4）第三方jar中的bean定义在xml，自己开发的bean定义使用注解

• xml中标签与注解的对应（IoC）

  @Component，注解加在类上，针对分层代码开发提供@Controller、@Service、

  @Repository分别用于控制层、服务层、dao层的bean的定义。用法一样，只是为了清晰区分。

• DI依赖注入的注解实现方式

  @Autowired（推荐使用）：采取的策略为按照类型注入。

  @Resource：默认安装ByName自动注入。

  • 如果同时指定了name和type，则从Spring 上下文中找到唯一匹配的bean进行装配，找不到抛出异常。
  • 如果指定了name，则从上下文中查找名称（id）匹配的bean进行装配，找不到抛出异常。
  • 如果指定了type，则从上下文中找到类似匹配的唯一bean进行装配，找不到或是找到多个，都会抛出异常。
  • 如果既没有指定name，又没有指定type，则自动安装byName方式进行装配；

  注意：@Resource在JDK 11中已经移除，如需使用，需单独引入jar包

  
  	javax.annotation
  	javax.annotation-api
  	1.3.2
  
  

1.4 纯注解模式

改造xml+注解模式，将xml中遗留的内容全部以注解的形式迁移出去，最终删除xml，从java配置类启动。

对应注解

@Configuration注解，表名当前类是配置类

@ComponentScan注解，替代context:component-scan

@PropertySource，引入外部属性配置文件

@Import引入其他配置类

@Value对变量赋值，可以直接赋值，也可以使用${}读取资源配置文件中的信息。

@Bean将方法返回对象加入Spring IoC容器

2. Spring IoC高级特性

2.1 lazy-init延迟加载

Bean的延迟加载（延迟创建）

该bean默认的设置为:

lazy-init=“false”，立即加载，表示在spring启动时，立刻进行实例化。

如果不想让Bean在ApplicationContext实现初始化时被提前实例化，可将lazy-init设置为true。

设置lazy-init为true的bean将不会在ApplicationContext启动时提前被实例化，而是第一次向容器通过getBean索取bean时实例化的。

应用场景

（1）开启延迟加载一定程度提高容器启动和运转性能。

（2）对于不常使用的Bean设置延迟加载，这样偶尔使用的时候再加载，不必要从一开始该Bean就占用资源

2.2 FactoryBean 和 BeanFactory

BeanFactory接口是容器的顶级接口，定义了容器的一些基础行为，负责生产和管理Bean的一个工厂，具体使用它下面的子接口类型（如ApplicationContext）

Spring中Bean有两种，一种是普通Bean，一种是工厂Bean（FactoryBean），FactoryBean可以生成某一个类型的Bean实例，也就是说我们可以借助它自定义Bean的创建过程。

Bean创建的三种方式中的静态方法和实例化方法和FactoryBean作用类似，FactoryBean使用较多。

2.3 后置处理器

Spring提供了两种后置处理Bean的扩展接口，分别为BeanPostProcessor和BeanFactoryPostProcessor

工厂初始化（BeanFactory）—>Bean对象

在BeanFactory初始化之后可以使用BeanFactoryPostProcessor进行后置处理做一些事情

在Bean对象实例化（Bean的生命周期还没有完成）之后可以使用BeanPostProcessor进行后置处理做一些事情

注意：对象不一定是Spring Bean，Spring Bean一定是对象。

• BeanPostProcessor

  BeanPostProcessor是针对Bean级别的处理，可以针对具体的Bean，该接口提供两个方法，分别在Bean的初始化方法前后执行，初始化方法类似于init-method指定的方法。

  public interface BeanPostProcessor {
  
  	@Nullable
  	default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
  		return bean;
  	}
  
  	@Nullable
  	default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
  		return bean;
  	}
  
  }
  

  定义一个类实现BeanPostProcessor，默认对整个Spring容器中所有Bean进行处理，如对具体某个Bean处理，可通过方法参数判断，两个参数分别为Object和String，参数一：bean实例，参数二：bean的name或id

  注意：处理是发生在Spring容器的实例化和依赖注入之后。

• BeanFactoryPostProcessor

  BeanFactory级别的处理，针对整个Bean的工厂进行处理，典型应用：PropertyPlaceholderConfigurer，此接口只提供了一个方法，方法参数为：ConfigurableListableBeanFactory，该参数定义了一些方法，如getBeanDefinition，可根据此方法，找到定义bean的BeanDefinition对象（可进行修改）

  BeanDefinition对象： xml中定义的bean标签，Spring解析bean标签成为一个JavaBean（就是BeanDefinition）

第五部分 Spring IoC源码深度剖析

• 好处：提高培养代码架构思维、深入理解框架
• 原则
  • 定焦原则：主线
  • 宏观原则：关注源码结构和业务流程，淡化具体代码细节
• 读源码的方法和技巧
  • 断点（调用栈）
  • 反调（Find Usages）
  • 经验（Spring框架中doXXX，做具体处理的地方）

1. Spring IoC容器初始化主题流程

1.1 Spring IoC的容器体系

IoC容器是Spring的核心模块，是抽象了对象管理、依赖关系管理的框架解决方案。提供了很多容器，其中BeanFactory是顶级容器，不能被实例化。

BeanFactory顶级接口方法栈如下：

1.2 Bean生命周期关键时机点

Spring的生命周期

构造器执行、初始化方法执行、Bean后置处理器的before/after方法：AbstractApplicationContext#refresh#finishBeanFactoryInitialization

Bean工厂后置处理器初始化、方法执行：

AbstractApplicationContext#refresh#invokeBeanFactoryPostProcessors

Bean后置处理器初始化：AbstractApplicationContext#refresh#registerBeanPostProcessors

关键点	触发代码
构造器	refresh#finishBeanFactoryInitialization
BeanFactoryPostProcessor初始化	refresh#invokeBeanFactoryPostProcessors
BeanFactoryPostProcessor方法调用	refresh#invokeBeanFactoryPostProcessors
BeanPostProcessor初始化	refresh#registerBeanPostProcessors
BeanPostProcessor方法调用	refresh#finishBeanFactoryInitialization

1.3 Spring IoC容器初始化主体流程

Spring IoC容器初始化的关键环节就在AbstractApplicationContext#refresh() 方法中。

@Override
public void refresh() throws BeansException, IllegalStateException {
	// 对象锁加锁
	synchronized (this.startupShutdownMonitor) {
		// 1.刷新前的预处理
		prepareRefresh();

		// 2.获取BeanFactory；默认实现是DefaultListableBeanFactory,加载BeanDefition 并注册到 BeanDefitionRegistry
		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

		// 3.BeanFactory的预准备工作（BeanFactory进行一些设置，比如context的类加载器等）
		prepareBeanFactory(beanFactory);

		try {
			// 4.BeanFactory准备工作完成后进行的后置处理工作
			postProcessBeanFactory(beanFactory);

			// 5.实例化实现了BeanFactoryPostProcessor接口的Bean，并调用接口方法
			invokeBeanFactoryPostProcessors(beanFactory);

			// 6.注册BeanPostProcessor（Bean的后置处理器），在创建bean的前后等执行
			registerBeanPostProcessors(beanFactory);

			// 7.初始化MessageSource组件（做国际化功能；消息绑定，消息解析）
			initMessageSource();

			// 8.初始化事件派发器
			initApplicationEventMulticaster();

			// 9.子类重写这个方法，在容器刷新的时候可以自定义逻辑；
			onRefresh();

			// 10.注册应用的监听器。就是注册实现了ApplicationListener接口的监听器bean
			registerListeners();

			/*
				11.初始化所有剩下的非懒加载的单例bean
				初始化创建非懒加载方式的单例Bean实例（未设置属性）
				填充属性
				初始化方法调用（比如调用afterPropertiesSet方法、init-method方法）
				调用BeanPostProcessor（后置处理器）对实例bean进行后置处理
			 */
			finishBeanFactoryInitialization(beanFactory);

			/*
				12.完成context的刷新。主要是调用LifecycleProcessor的onRefresh()方法，并且发布事件（ContextRefreshedEvent）
			 */
			finishRefresh();
		}

		...
	}
}	

2. BeanFactory创建流程

2.1 获取BeanFactory子流程

2.28 BeanDefinition加载解析及注册子流程

（1）该子流程涉及以下几个关键步骤

• Resource定位： 对BeanDefinition的资源定位过程。（找到定义Java Bean信息的xml文件，封装成Resource对象）

• BeanDefinition载入： 将用户定义好的Java Bean表示为IoC容器内部的数据结构（BeanDefinition）

• 注册BeanDefinition到IoC容器

（2）过程分析

• 子流程入口在AbstractRefreshableApplicationContext#refreshBeanFactory方法中

的loadBeanDefinitions方法

/*
 * 对 bean factory 执行刷新操作，关闭以前的 bean factory（如果有）
 * 并且为 context 初始化一个新的 bean factory
 */
@Override
protected final void refreshBeanFactory() throws BeansException {
	...
	try {
		// 实例化 DefaultListableBeanFactory
		DefaultListableBeanFactory beanFactory = createBeanFactory();
		...
		// 加载应用中的BeanDefinitions
		loadBeanDefinitions(beanFactory);
		synchronized (this.beanFactoryMonitor) {
			// 赋值当前bean facotry
			this.beanFactory = beanFactory;
		}
	}
	catch (IOException ex) {
		...
	}
}

• 依次调用多个类的loadBeanDefinitions方法—>AbstractXmlApplicationContext—>AbstractBeanDefinitionReader—>XmlBeanDefinitionReader一直执行到XmlBeanDefinitionReader的doLoadBeanDefinitions方法

  public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
  	...
  	try {
  		InputStream inputStream = encodedResource.getResource().getInputStream();
  		try {
  			// 把xml文件流封装为InputSource对象
  			InputSource inputSource = new InputSource(inputStream);
  			if (encodedResource.getEncoding() != null) {
  				inputSource.setEncoding(encodedResource.getEncoding());
  			}
  			// do!执行加载逻辑
  			return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
  		}
  		finally {
  			...
  		}
  	}
  	catch (IOException ex) {
  		...
  	}
  	finally {
  		...
  	}
  }
  

• 重点观察XmlBeanDefinitionReader类的registerBeanDefinitions方法，此处关注createRederContext方法和DefaultBeanDefinitionDocumentReader类的registerBeanDefinitions方法，可以看到，Spring首先完成了NamespaceHandlerResolver的初始化。

  public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
  	...
  	// 注册BeanDefinition
  	documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
  	...
  }
  

  public XmlReaderContext createReaderContext(Resource resource) {
  	return new XmlReaderContext(resource, this.problemReporter, this.eventListener,
  			this.sourceExtractor, this, getNamespaceHandlerResolver());
  }
  

  进入registerBeanDefinitions方法中追踪，调用了DefaultBeanDefinitionDocumentReader#registerBeanDefinitions方法，进入doRegisterBeanDefinitions方法，调用了parseBeanDefinitions方法

  protected void doRegisterBeanDefinitions(Element root) {
  	...
  	parseBeanDefinitions(root, this.delegate);
  	...
  }
  

  进入parseBeanDefinitions方法，可以看到又调用了parseDefaultElement，这个方法是负责解析默认标签元素的。

  protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
  	...
  				
  	// 解析默认标签元素
  	parseDefaultElement(ele, delegate);
  				
  	// 解析自定义标签元素
  	delegate.parseCustomElement(ele);
  		
  	...
  }
  

  进入parseDefaultElement可以看到又调用了processBeanDefinition，此方法负责解析bean元素为BeanDefinition，通过BeanDefinitionReaderUtils.registerBeanDefinition完成注册。

  protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
  	// 解析bean元素为BeanDefinition，但是此时使用 BeanDefinitionHolder 又包装成了 BeanDefinitionHolder 对象
  	BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
  	if (bdHolder != null) {
  		...
  		try {
  			// 完成BeanDefinition的注册
  			BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
  		}
  		catch (BeanDefinitionStoreException ex) {
  			...
  		}
  		...
  	}
  }
  

  至此，注册流程结束，所谓的注册就是把封装的xml中定义的Bean信息封装为BeanDefinition对象之后放入一个map中。

  （3）时序图

3. Bean创建过程

• 通过最开始的关键时机点分析，Bean的创建子流程入口在AbstractApplicationContext#refresh()⽅法的finishBeanFactoryInitialization(beanFactory)处

  /*
  	Instantiate all remaining (non-lazy-init) singletons.
  	初始化所有剩下的非懒加载的单例bean
  	初始化创建非懒加载方式的单例Bean实例（未设置属性）
  	填充属性
  	初始化方法调用（比如调用afterPropertiesSet方法、init-method方法）
  	调用BeanPostProcessor（后置处理器）对实例bean进行后置处理
   */
  finishBeanFactoryInitialization(beanFactory);
  

• 进⼊finishBeanFactoryInitialization

  /**
   * 结束 bean factory 的初始化工作
   * 实例化所有单例bean
   */
  protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
  	...
  	beanFactory.setTempClassLoader(null);
  
  	// Allow for caching all bean definition metadata, not expecting further changes.
  	beanFactory.freezeConfiguration();
  
  	// Instantiate all remaining (non-lazy-init) singletons.
  	// 实例化所有立即加载的单例bean
  	beanFactory.preInstantiateSingletons();
  }
  

• 继续进⼊DefaultListableBeanFactory类的preInstantiateSingletons⽅法，可以看到工厂Bean或者普通Bean，最终都是通过getBean的方法获取实例。

  // 触发所有非延迟加载单例bean的初始化，主要步骤为getBean
  for (String beanName : beanNames) {
  	// 合并父BeanDefinition对象
  	// map.get(beanName)
  	RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
  	if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
  		if (isFactoryBean(beanName)) {
  			Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
  			// 如果是FactoryBean则加&
  			if (bean instanceof FactoryBean) {
  				final FactoryBean<?> factory = (FactoryBean<?>) bean;
  				boolean isEagerInit;
  				if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
  					isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
  									((SmartFactoryBean<?>) factory)::isEagerInit,
  							getAccessControlContext());
  				}
  				else {
  					isEagerInit = (factory instanceof SmartFactoryBean &&
  							((SmartFactoryBean<?>) factory).isEagerInit());
  				}
  				if (isEagerInit) {
  					getBean(beanName);
  				}
  			}
  		}
  		else {
  			// 实例化当前bean
  			getBean(beanName);
  		}
  	}
  }
  

• 继续跟踪下去，进⼊到了AbstractBeanFactory类的doGetBean⽅法，找到核心部分

  // 创建单例bean
  if (mbd.isSingleton()) {
  	sharedInstance = getSingleton(beanName, () -> {
  		try {
  			// 创建 bean
  			return createBean(beanName, mbd, args);
  		}
  		catch (BeansException ex) {
  			destroySingleton(beanName);
  			throw ex;
  		}
  	});
  	bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
  }
  

• 接着进入到AbstractAutowireCapableBeanFactory类的doCreateBean方法

  try {
  	// 进入，真真正正创建bean
  	Object beanInstance = doCreateBean(beanName, mbdToUse, args);
  	return beanInstance;
  }
  

• 进入doCreateBean方法，重点关注两块重点区域

  protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
  			throws BeanCreationException {
  
  	...
  	if (instanceWrapper == null) {
  		// 创建 Bean 实例，仅仅调用构造方法，但是尚未设置属性
  		instanceWrapper = createBeanInstance(beanName, mbd, args);
  	}
  	...
  
  	// 初始化bean实例
  	Object exposedObject = bean;
  	try {
  		// Bean属性填充
  		populateBean(beanName, mbd, instanceWrapper);
  		// 调用初始化方法，应用BeanPostProcessor后置处理器
  		exposedObject = initializeBean(beanName, exposedObject, mbd);
  	}
  	...
  }
  

4. lazy-init 延迟加载机制原理

• lazy-init 延迟加载机制分析

普通 Bean 的初始化是在容器启动初始化阶段执⾏的，⽽被lazy-init=true修饰的 bean 则是在从容器⾥
第⼀次进⾏context.getBean() 时进⾏触发。Spring 启动的时候会把所有bean信息(包括XML和注解)解
析转化成Spring能够识别的BeanDefinition并存到Hashmap⾥供下⾯的初始化时⽤，然后对每个
BeanDefinition 进⾏处理，如果是懒加载的则在容器初始化阶段不处理，其他的则在容器初始化阶段进⾏初始化并依赖注⼊。

public void preInstantiateSingletons() throws BeansException {
	// 所有bean的名字
	List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

	// Trigger initialization of all non-lazy singleton beans...
	// 触发所有非延迟加载单例bean的初始化，主要步骤为getBean
	for (String beanName : beanNames) {
		// 合并父BeanDefinition对象
		// map.get(beanName)
		RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
		if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
			if (isFactoryBean(beanName)) {
				Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
				// 如果是FactoryBean则加&
				if (bean instanceof FactoryBean) {
					final FactoryBean<?> factory = (FactoryBean<?>) bean;
					boolean isEagerInit;
					if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
						isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
										((SmartFactoryBean<?>) factory)::isEagerInit,
								getAccessControlContext());
					}
					else {
						isEagerInit = (factory instanceof SmartFactoryBean &&
								((SmartFactoryBean<?>) factory).isEagerInit());
					}
					if (isEagerInit) {
						getBean(beanName);
					}
				}
			}
			else {
				/*
				如果是普通bean则进⾏初始化并依赖注⼊，此 getBean(beanName)接下来触发的逻辑
				和
				懒加载时 context.getBean("beanName") 所触发的逻辑是一样的
				*/
				getBean(beanName);
			}
		}
	}

	...
}

• 总结：

  • 对于被修饰为lazy-init的bean，Spring容器初始化阶段不会进行init并且依赖注入，当第一次调用getBean的时候才进行初始化并依赖注入

  • 对于非懒加载的bean，getBean的时候会从缓存里取，因为容器初始化阶段bean已经初始化完成并且放入缓存中

5. Spring IoC循环依赖问题

5.1 什么是循环依赖

循环依赖就是循环引用，也就是两个或两个以上的Bean互相持有对方，最终形成闭环。

注意：这里不是函数的循环调用，而是对象的相互依赖关系。

Spring中循环依赖场景有：

• 构造器的循环依赖（构造器注入）
• Field属性的循环依赖（set注入）

5.2 循环依赖处理机制

• 单例bean构造器参数循环依赖（无法解决）

• propotype原型bean循环依赖（无法解决）

  总结：Spring不支持原型bean的循环依赖

• 单例bean通过setXXX或者使用**@Autowired**进行循环依赖

  Spring的循环依赖的理论依据基于java的引用传递，当获得对象的引用时，对象的属性是可以延后设置的，但是构造器必须是在获取引用之前

  Spring通过setXXX或者使用@Autowired方法解决循环依赖其实是通过提前暴露一个ObectFactory对象来完成的，简单来说ClassA在调用构造器完成对象初始化之后，在调用ClassA的setClassB方法之前，就把ClassA实例化的对象通过ObjectFactory提前暴露到Spring容器中

  • Spring容器初始化ClassA通过构造器初始化对象后提前暴露到Spring容器

    //将初始化后的对象提前已ObjectFactory对象注⼊到容器中
    addSingletonFactory(beanName, new ObjectFactory