Spring IoC(控制反转)和依赖注入(DI)详解

一、控制反转(IoC)和依赖注入(DI)的理解

什么是IoC

IoC—Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。在Java开发中，IoC意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接创建。它能指导我们如何设计出松耦合、更优良的程序。

用图例说明一下，传统程序设计如图1-1，都是主动去创建相关对象然后再组合起来：

当有了IoC/DI的容器后，在客户端类中不再主动去创建这些对象了，如图1-2所示：

什么是DI

DI—Dependency Injection，即“依赖注入”：组件之间依赖关系由容器在运行期决定，形象的说，即由容器动态的将某个依赖关系注入到组件之中。依赖注入的目的并非为软件系统带来更多功能，而是为了提升组件重用的频率，并为系统搭建一个灵活、可扩展的平台。通过依赖注入机制，我们只需要通过简单的配置，而无需任何代码就可指定目标需要的资源，完成自身的业务逻辑，而不需要关心具体的资源来自何处，由谁实现。

理解DI的关键是：“谁依赖谁，为什么需要依赖，谁注入谁，注入了什么”，那我们来深入分析一下：

• 谁依赖于谁：当然是应用程序依赖于IoC容器；
• 为什么需要依赖：应用程序需要IoC容器来提供对象需要的外部资源；
• 谁注入谁：很明显是IoC容器注入应用程序某个对象，应用程序依赖的对象；
• 注入了什么：就是注入某个对象所需要的外部资源（包括对象、资源、常量数据）。

IoC和DI是什么关系呢？其实它们是同一个概念的不同角度描述，由于控制反转概念比较含糊（可能只是理解为容器控制对象这一个层面，很难让人想到谁来维护对象关系），所以2004年大师级人物Martin Fowler又给出了一个新的名字：“依赖注入”，相对IoC 而言，“依赖注入”明确描述了“被注入对象依赖IoC容器配置依赖对象”。

IoC优缺点

• 优点：实现组件之间的解耦，提供程序的灵活性和可维护性
• 缺点：对象生成因为是使用反射编程，在效率上有损耗

二、Spring的IoC容器

什么是容器？

在每个框架中都有一个容器的概念，所谓的容器就是将常用的服务封装起来，然后，用户只需要遵循一定的规则，就可以达到统一、灵活、安全、方便、快速的目的。具有依赖注入功能的容器，负责实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。

Bean是什么？

由IoC容器管理的那些组成应用程序的对象就叫Bean。Bean就是由Spring容器初始化、装配及管理的对象，除此之外，Bean就与应用程序中的其他对象没什么区别了。

元数据 BeanDefinition

确定如何实例化Bean、管理Bean之间的依赖关系及管理Bean，就需要配置元数据，在Spring中由BeanDefintion代表。

IoC容器如何工作（以XML配置方式解释）？

• 准备配置文件：配置文件中声明 Bean 定义也就是 Bean 配置元数据。
• 由 IoC 容器进行解析元数据：IoC 容器的 Bean Reader 读取并解析配置文件，根据定义生成 BeanDefintion 配置元数据对象，IoC 容器根据 BeanDefintion 进行实例化、配置及组装 Bean。
• 实例化 IoC 容器：由客户端实例化容器，获取需要的 Bean。

IoC容器的原理

IoC容器其实就是一个大工厂，它用来管理我们所有的对象以及依赖关系。

• 根据Bean配置信息在容器内部创建Bean定义注册表
• 根据注册表加载、实例化bean、建立Bean与Bean之间的依赖关系
• 将这些准备就绪的Bean放到Map缓存池中，等待应用程序调用

BeanFactory 和 ApplicationContext

BeanFactory是spring的原始接口，针对原始结构的实现类功能比较单一，BeanFactory接口实现的容器，特点是在每次获取对象时才会创建对象。

BeanFactory的继承体系：

ApplicationContext继承了BeanFactory接口，拥有BeanFactory的全部功能，并且扩展了很多高级特性，每次容器启动时就会创建所有的对象。

ApplicationContext的继承体系：

创建ApplicationContext的方法： 

• 从类路径下加载配置文件:ClassPathXmlApplicationContext ("applicationContext.xml");
• 从硬盘绝对路径下加载配置文件: FileSystemXmlApplicationContext(“d:/xxx/yyy/xxx”);

其中在ApplicationContext子类中有一个比较重要的：WebApplicationContext，是专门为Web应用准备的。

Web应用与Spring融合：

我们看看BeanFactory的生命周期：

接下来我们再看看ApplicationContext的生命周期：

初始化的过程都是比较长，我们可以分类来对其进行解析：

• Bean自身的方法：如调用 Bean 构造函数实例化 Bean，调用 Setter 设置 Bean 的属性值以及通过<bean>的 init-method 和 destroy-method 所指定的方法；
• Bean级生命周期接口方法：如 BeanNameAware、 BeanFactoryAware、 InitializingBean 和 DisposableBean，这些接口方法由 Bean 类直接实现；
• 容器级生命周期接口方法：在上图中带“★” 的步骤是由 InstantiationAwareBean PostProcessor 和 BeanPostProcessor 这两个接口实现，一般称它们的实现类为“ 后处理器” 。 后处理器接口一般不由 Bean 本身实现，它们独立于 Bean，实现类以容器附加装置的形式注册到Spring容器中并通过接口反射为Spring容器预先识别。当Spring 容器创建任何 Bean 的时候，这些后处理器都会发生作用，所以这些后处理器的影响是全局性的。当然，用户可以通过合理地编写后处理器，让其仅对感兴趣Bean 进行加工处理

ApplicationContext和BeanFactory不同之处在于：

• ApplicationContext会利用Java反射机制自动识别出配置文件中定义的BeanPostProcessor、 InstantiationAwareBeanPostProcessor 和BeanFactoryPostProcessor后置器，并自动将它们注册到应用上下文中。而BeanFactory需要在代码中通过手工调用addBeanPostProcessor()方法进行注册
• ApplicationContext在初始化应用上下文的时候就实例化所有单实例的Bean。而BeanFactory在初始化容器的时候并未实例化Bean，直到第一次访问某个Bean时才实例化目标Bean。

有了上面的知识点了，我们再来详细地看看Bean的初始化过程：

简要总结：

• BeanDefinitionReader读取Resource所指向的配置文件资源，然后解析配置文件。配置文件中每一个<bean>解析成一个BeanDefinition对象，并保存到BeanDefinitionRegistry中；
• 容器扫描BeanDefinitionRegistry中的BeanDefinition；调用InstantiationStrategy进行Bean实例化的工作；使用BeanWrapper完成Bean属性的设置工作；
• 单例Bean缓存池：Spring 在DefaultSingletonBeanRegistry类中提供了一个用于缓存单实例 Bean 的缓存器，它是一个用HashMap实现的缓存器，单实例的Bean以beanName为键保存在这个HashMap中。

两者装载bean的区别

• BeanFactory在启动的时候不会去实例化Bean，只有从容器中拿Bean的时候才会去实例化；
• ApplicationContext在启动的时候就把所有的Bean全部实例化了。它还可以为Bean配置lazy-init=true来让Bean延迟实例化； 

用BeanFactory还是ApplicationContent？

• BeanFactory：延迟实例化。应用启动的时候占用资源很少；对资源要求较高的应用，比较有优势； 
• ApplicationContext：① 所有的Bean在启动的时候都加载，系统运行的速度快； ② 在启动的时候所有的Bean都加载了，我们就能在系统启动的时候，尽早的发现系统中的配置问题 。

建议web应用，在启动的时候就把所有的Bean都加载了。（把费时的操作放到系统启动中完成） 。

Bean 工厂（com.springframework.beans.factory.BeanFactory）是Spring 框架最核心的接口，它提供了高级IoC 的配置机制。

应用上下文（com.springframework.context.ApplicationContext）建立在BeanFactory 基础之上。

几乎所有的应用场合我们都直接使用ApplicationContext 而非底层的BeanFactory。

IoC容器装配Bean

装配的方式

Spring4.x开始IoC容器装配Bean有4种方式：

• XML配置
• 注解
• JavaConfig
• 基于Groovy DSL配置(这种很少见)

总的来说：我们以Xml配置+注解来装配Bean居多，其中注解这种方式占大部分！

依赖注入方式

依赖注入的方式有3种方式：

• 属性注入-->通过setter()方法注入
• 构造函数注入
• 工厂方法注入

总的来说使用属性注入是比较灵活和方便的，这是大多数人的选择！

对象之间的关系

<bean>对象之间有三种关系：

• 依赖-->挺少用的(使用depends-on就是依赖关系了-->前置依赖【依赖的Bean需要初始化之后，当前Bean才会初始化】)
• 继承-->可能会用到(指定abstract和parent来实现继承关系)
• 引用-->最常见(使用ref就是引用关系了)

Bean的作用域

• 单例Singleton
• 多例prototype
• 与Web应用环境相关的Bean作用域：① reqeust ② session

使用到了Web应用环境相关的Bean作用域的话，是需要我们手动配置代理的~

原因也很简单：因为我们默认的Bean是单例的，为了适配Web应用环境相关的Bean作用域--->每个request都需要一个对象，此时我们返回一个代理对象出去就可以完成我们的需求了！

处理自动装配的歧义性

一个接口两个实现类，怎么在注入的时候优先调用某个实现类？

可以归纳成两种解决方案： 

1、使用@Primary注解设置为首选的注入Bean

2、使用@Qualifier注解设置特定名称的Bean来限定注入，也可以使用自定义的注解来标识。

装配bean总结

分别应用的场景：

Bean中各种属性的注入方式

实例化bean的两种方式

1、调用无参构造方法

<bean id="personDao" class="cn.offcn.dao.impl.PersonDaoImpl"></bean>

<bean id="personDao" class="cn.offcn.dao.impl.PersonDaoImpl">
   <property name="id" value="200"></property>
   <property name="name" value="张三"></property>
</bean>

当personDaoImpl被实例化后，给property标签所指定的属性进行赋值，赋值也称注入。

2、调用有参构造方法

 <bean id="personDao" class="cn.offcn.dao.impl.PersonDaoImpl">
     <constructor-arg name="id" value="300"></constructor-arg>
     <constructor-arg name="name" value="李四"></constructor-arg>
 </bean>

调用有参构造方法，第一个参是int类型，第二个参数String的构造方法进行初始化。

非基本类型和String类型属性注入

 ref 注入的是对象。ref的值是spring容器中的key

<bean id="myDate" class="java.util.Date"></bean>
 
<bean id="personDao" class="cn.offcn.dao.impl.PersonDaoImpl">
	<property name="id" value="200"></property>
	<property name="name" value="张三"></property>
	<property name="birthday" ref="myDate"></property>
	<property name="books">
		<list>
			<bean class="cn.offcn.dao.impl.Book">
				<property name="bookName" value="三个男人和一个女人的故事"></property>
				<property name="bookNo" value="ISBN:8859-100"></property>
			</bean>
			<bean class="cn.offcn.dao.impl.Book">
				<property name="bookName" value="学会理解"></property>
				<property name="bookNo" value="ISBN:8859-101"></property>
			</bean>
			<bean class="cn.offcn.dao.impl.Book">
				<property name="bookName" value="红楼梦"></property>
				<property name="bookNo" value="ISBN:8859-102"></property>
			</bean>
		</list>
	</property>
	<property name="names">
		<set>
			<value>叶文龙</value>
			<value>陈白</value>
			<value>赵青</value>
		</set>
	</property>
	<property name="persons">
		<map>
			<entry key="personName" value="赵正日"></entry>
			<entry key="personAge" value="22"></entry>
			<entry key="personAddress" value="北京市朝阳区王八大街8号"></entry>
		</map>
	</property>
	<property name="pp">
		<props>
			<prop key="driver">com.mysql.jdbc.Driver</prop>
			<prop key="url">jdbc:mysql:///aaa</prop>
			<prop key="username">root</prop>
			<prop key="password">123456</prop>
		</props>
	</property>
	<property name="addresses">
		<array>
			<value>北京</value>
			<value>天津</value>
			<value>上海</value>

		</array>
	</property>
</bean>

三、Spring IoC相关面试题

什么是spring?

Spring是个java企业级应用的开源开发框架。Spring主要用来开发Java应用，但是有些扩展是针对构建J2EE平台的web应用。Spring框架目标是简化Java企业级应用开发，并通过POJO为基础的编程模型促进良好的编程习惯。

使用Spring框架的好处是什么？

1. 轻量：Spring 是轻量的，基本的版本大约2MB。
2. 控制反转：Spring通过控制反转实现了松散耦合，对象们给出它们的依赖，而不是创建或查找依赖的对象们。
3. 面向切面的编程(AOP)：Spring支持面向切面的编程，并且把应用业务逻辑和系统服务分开。
4. 容器：Spring 包含并管理应用中对象的生命周期和配置。
5. MVC框架：Spring的WEB框架是个精心设计的框架，是Web框架的一个很好的替代品。
6. 事务管理：Spring 提供一个持续的事务管理接口，可以扩展到上至本地事务下至全局事务（JTA）。
7. 异常处理：Spring 提供方便的API把具体技术相关的异常（比如由JDBC，Hibernate or JDO抛出的）转化为一致的unchecked 异常。

Spring由哪些模块组成?

简单可以分成6大模块： 

• Core
• AOP
• ORM
• DAO
• Web
• Spring EE

BeanFactory 实现举例

Bean工厂是工厂模式的一个实现，提供了控制反转功能，用来把应用的配置和依赖从真正的应用代码中分离。

XmlBeanDefinitionReader和DefaultListableBeanFactory。

什么是Spring的依赖注入？

依赖注入，是IoC的一个方面，说的是你不用创建对象，而只需要描述它如何被创建。你不在代码里直接组装你的组件和服务，但是要在配置文件里描述哪些组件需要哪些服务，之后一个容器（IoC容器）负责把他们组装起来。

有哪些不同类型的IoC（依赖注入）方式？

1. 构造器依赖注入：构造器依赖注入通过容器触发一个类的构造器来实现的，该类有一系列参数，每个参数代表一个对其他类的依赖。
2. Setter方法注入：Setter方法注入是容器通过调用无参构造器或无参static工厂 方法实例化bean之后，调用该bean的setter方法，即实现了基于setter的依赖注入。

什么是Spring beans?

Spring beans 是那些形成Spring应用的主干的java对象。它们被Spring IOC容器初始化，装配，和管理。这些beans通过容器中配置的元数据创建。比如，以XML文件中<bean/> 的形式定义。

有四种重要的方法给Spring容器提供配置元数据：

• XML配置文件。
• 基于注解的配置。
• 基于java的配置。

解释Spring框架中bean的生命周期

• Spring容器 从XML 文件中读取bean的定义，并实例化bean。
• Spring根据bean的定义填充所有的属性。
• 如果bean实现了BeanNameAware 接口，Spring 传递bean 的ID 到 setBeanName方法。
• 如果Bean 实现了 BeanFactoryAware 接口， Spring传递beanfactory 给setBeanFactory 方法。
• 如果有任何与bean相关联的BeanPostProcessors，Spring会在postProcesserBeforeInitialization()方法内调用它们。
• 如果bean实现IntializingBean了，调用它的afterPropertySet方法，如果bean声明了初始化方法，调用此初始化方法。
• 如果有BeanPostProcessors 和bean 关联，这些bean的postProcessAfterInitialization() 方法将被调用。
• 如果bean实现了 DisposableBean，它将调用destroy()方法。

解释不同方式的自动装配

• no：默认的方式是不进行自动装配，通过显式设置ref 属性来进行装配。
• byName：通过参数名 自动装配，Spring容器在配置文件中发现bean的autowire属性被设置成byname，之后容器试图匹配、装配和该bean的属性具有相同名字的bean。
• byType:：通过参数类型自动装配，Spring容器在配置文件中发现bean的autowire属性被设置成byType，之后容器试图匹配、装配和该bean的属性具有相同类型的bean。如果有多个bean符合条件，则抛出错误。
• constructor：这个方式类似于byType， 但是要提供给构造器参数，如果没有确定的带参数的构造器参数类型，将会抛出异常。
• autodetect：首先尝试使用constructor来自动装配，如果无法工作，则使用byType方式。

只用注解的方式时，注解默认是使用byType的！

IoC的优点？

IoC 或 依赖注入把应用的代码量降到最低。它使应用容易测试，单元测试不再需要单例和JNDI查找机制。最小的代价和最小的侵入性使松散耦合得以实现。IOC容器支持加载服务时的饿汉式初始化和懒加载。

Spring框架中的单例Beans是线程安全的么？

Spring框架并没有对单例bean进行任何多线程的封装处理。关于单例bean的线程安全和并发问题需要开发者自行去搞定。但实际上，大部分的Spring bean并没有可变的状态(比如Service类和DAO类)，所以在某种程度上说Spring的单例bean是线程安全的。如果你的bean有多种状态的话（比如 View Model 对象），就需要自行保证线程安全。

最浅显的解决办法就是将多态bean的作用域由“singleton”变更为“prototype”

FileSystemResource和ClassPathResource有何区别？

在FileSystemResource 中需要给出spring-config.xml文件在你项目中的相对路径或者绝对路径。在ClassPathResource中spring会在ClassPath中自动搜寻配置文件，所以要把ClassPathResource文件放在ClassPath下。

如果将spring-config.xml保存在了src文件夹下的话，只需给出配置文件的名称即可，因为src文件夹是默认。

简而言之，ClassPathResource在环境变量中读取配置文件，FileSystemResource在配置文件中读取配置文件。

四、参考

https://segmentfault.com/a/1190000014979704?utm_source=sf-related

https://segmentfault.com/a/1190000017348726?utm_source=tag-newest