Spring框架中IoC容器与DI依赖注入教程

IOC也是Spring的核心之一了，之前学的时候是采用xml配置文件的方式去实现的，后来其中也多少穿插了几个注解，但是没有说完全采用注解实现。那么这篇文章就和大家分享一下，全部采用注解来实现IOC + DI

一、Spring 是什么

我们通常所说的 Spring 指的是 Spring Framework (Spring 框架)，它是⼀个开源框架，有着活跃而庞大的社区，这就是它之所以能长久不衰的原因。Spring ⽀持⼴泛的应⽤场景，它可以让 Java 企业级的应用程序开发起来更简单。

⽤⼀句话概括 Spring：Spring 是包含了众多工具方法的 IoC 容器。

那么问题来了，什么是容器？什么又是 IoC 容器呢？

1.1 什么是容器

顾名思义，容器是用来容纳某种物品的。

我们接触过的容器都有哪些？

List/Map -> 数据存储容器
Tomcat -> Web 容器

1.2 什么是 IoC

IoC = Inversion of Control 翻译成中⽂是 “控制(权)反转” 的意思，也就是说 Spring 是⼀个 “控制反转” 的容器。怎么理解这句话呢？我们先从以下示例开始 ~

二、理解 IoC

2.1 传统程序开发的问题

假如，我们现在构建⼀辆 “车” 的程序，我们的实现思路是这样的：

构建⼀辆车 (Car Class)，然而车需要依赖车身 (FrameWork Class)，而车身需要依赖底盘 (Bottom Class)，而底盘需要依赖轮胎 (Tire Class)，最终程序的实现代码如下：(轮胎只有一个 size 属性)

package old; /** * 构建“车” */ public class Car { private Framework framework; public Car(int size) { framework = new Framework(size); } public static void main(String[] args) { int size = 15; // 构建并运行车 Car car = new Car(size); car.init(); } // 运行 public void init() { System.out.println("Car init."); // 依赖 framework init() 方法 framework.init(); } }

package old; /** * 车身 */ public class Framework { private Bottom bottom; public Framework(int size) { bottom = new Bottom(size); } public void init() { System.out.println("Framework init."); // 依赖 Bottom:init() bottom.init(); } }

package old; /** * 底盘 */ public class Bottom { private Tire tire; public Bottom(int size) { tire = new Tire(size); // 自己（创）造 } public void init() { System.out.println("Bottom init."); // 依赖：Tire:init() tire.init(); } }

package old; /** * 轮胎 */ public class Tire { // 尺寸 private int size = 17; // 材质... // 花纹... // 颜色... // ... public Tire(int size) { this.size = size; } public void init() { System.out.println("Tire size:" + size); } }

以上程序中，轮胎属性信息只有 size，然而随着对车的需求量越来越大，个性化需求也会越来越多，这时候我们就需要加工具有多个属性的轮胎。

而以上程序的问题是：添加轮胎属性时，即最底层代码改动之后，整个调用链上的所有代码 (所有类) 都需要修改。

2.2 分析

如何解决上述问题呢？

我们可以尝试不在每个类中自己创建下级类，如果自己创建下级类就会出现当下级类发生改变操作，自己也要跟着修改。

我们只需要将原来由自己创建的下级类，改为传递的方式 (也就是注入的方式)，因为我们不需要在当前类中创建下级类了，所以下级类即使发生变化 (创建或减少参数)，当前类本身也无需修改任何代码，这样就完成了程序的解耦。

解耦指的是解决了代码的耦合性问题，耦合性换⼀种叫法为程序相关性。好的程序代码的耦合性 (代码之间的相关性) 是很低的 ~~

这就好比我们打造⼀辆完整的汽车，如果所有的配件都是自己造，那么当客户需求发⽣改变的时候，我们就要自己动手来改了；但如果我们是把轮胎外包出去，那么我们只需要向代理工厂下订单就行了，我们自身是不需要出力的。

2.3 控制反转式程序开发

基于以上思路，我们把调用汽车的程序示例改造⼀下，把创建子类的方式，改为注入传递的方式，具体实现代码如下：

package v2; public class TireV2 { private int size = 17; private String color = "黑色"; public TireV2(int size, String color) { this.size = size; this.color = color; } public void init() { System.out.println("Tire v2 size:" + size); } }

package v2; public class BottomV2 { private TireV2 tireV2; public BottomV2(TireV2 tireV2) { this.tireV2 = tireV2; } public void init() { System.out.println("Bottom v2 init."); tireV2.init(); } }

package v2; public class FrameworkV2 { private BottomV2 bottomV2; public FrameworkV2(BottomV2 bottomV2) { this.bottomV2 = bottomV2; } public void init() { System.out.println("Framework v2 init."); bottomV2.init(); } }

package v2; /** * 控制反转的车 */ public class CarV2 { private FrameworkV2 frameworkV2; // 依赖 public CarV2(FrameworkV2 frameworkV2) { //        frameworkV2 = new FrameworkV2(); // 自己创建（自己控制对象的生命周期） this.frameworkV2 = frameworkV2; // Car 构造方法不会在创建 } public void init() { System.out.println("Car v2 init."); // 依赖 framework:init() frameworkV2.init(); } }

启动类：

package v2; public class App { public static void main(String[] args) { // 程序调用 int size = 15; String color = "红色"; TireV2 tireV2 = new TireV2(size, color); BottomV2 bottomV2 = new BottomV2(tireV2); FrameworkV2 frameworkV2 = new FrameworkV2(bottomV2); CarV2 carV2 = new CarV2(frameworkV2); carV2.init(); } }

代码经过以上调整，无论底层类如何变化，整个调用链是不用做任何改变的。这样就完成了代码之间的解耦，从而实现了更加灵活、通用的程序设计！

2.4 对比总结规律

在传统的代码中对象创建顺序是：Car -> Framework -> Bottom -> Tire

改进之后解耦的代码的对象创建顺序是：Tire -> Bottom -> Framework -> Car

传统代码是 Car 创建并控制了 Framework，Framework 创建并控制了 Bottom，依次往下…而改进之后的控制权发生了反转，不再是上级对象创建并控制下级对象了，而是下级对象注入当前对象中，下级不再由上级类控制了！这样即使下级类发生任何改变，当前类都是不受影响的，这就是典型的控制反转，也就是 IoC 的实现思想。

谁调用我，就把控制权交给谁！而不是自己来控制，不用自己去new对象