文章目录

• 一、Spring 是什么
• • 1、什么是容器
  • 2、什么是 IoC
  • • ① 传统程序开发
    • • Ⅰ 轮胎尺寸固定
      • • a. 代码
        • b. 缺陷
      • Ⅱ 轮胎尺寸改变
      • • a. 代码
        • b. 缺陷
    • ② 控制反转式程序开发
    • • Ⅰ 控制反转
      • Ⅱ 需求增加
      • Ⅲ 优点
    • ③ 对⽐总结规律
  • 3、理解 Spring IoC
  • 4、DI 概念说明

一、Spring 是什么

Spring是当前Java开发的行业标准，第一框架。

我们通常所说的 Spring 指的是 Spring Framework（Spring 框架），它是⼀个开源框架。
⽤⼀句话概括 Spring：Spring 是包含了众多⼯具⽅法的 IoC 容器。

1、什么是容器

容器是⽤来容纳某种物品的（基本）装置。

我们之前接触的容器有：

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

2、什么是 IoC

我们之前提到 Spring 也是⼀个容器。
那么 Spring 是什么容器呢？Spring 是⼀个 IoC 容器。

什么是 IoC？
IoC = Inversion of Control 翻译成中⽂是“控制反转”的意思，也就是说 Spring 是⼀个“控制反转”的容器。

那么什么是 控制反转 呢？

① 传统程序开发

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

构建⼀辆⻋（Car Class），然⽽⻋需要依赖⻋身(FrameWork Class)，⽽⻋身需要依赖底盘（Bottom Class），⽽底盘需要依赖轮胎（Tire Class）。

Ⅰ 轮胎尺寸固定

a. 代码

1. 先创建一个 old 包：

2. Car：

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

3. Framework：

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

4. Bottom：

package old;/**1. 底盘*/
public class Bottom {private Tire tire;public Bottom() {tire = new Tire();}public void init() {System.out.println("Bottom init.");// 依赖 tire.init() 方法tire.init();}
}

5. Tire：

package old;/**1. 轮胎*/
public class Tire {// 尺寸private int size = 17;public void init() {System.out.println("Tire size:" + size);}
}

6. 运行结果为：
   

b. 缺陷

以上程序中，轮胎的尺⼨的固定的，然⽽随着对的⻋的需求量越来越⼤，个性化需求也会越来越多，这时候我们就需要加⼯多种尺⼨的轮胎，那这个时候就要对上⾯的程序进⾏修改了。

Ⅱ 轮胎尺寸改变

a. 代码

1. Car：

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();}
}

2. Framework：

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();}
}

3. Bottom：

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();}
}

4. Tire：

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

5. 运行结果为：
   

b. 缺陷

当底层类发生改变时，整个调⽤链上的所有代码都需要进行相应的修改！！！

需求是一直变换的，如果是通过传统的传参方式，每次修改都会导致整个调用类都要跟着一起修改！

② 控制反转式程序开发

Ⅰ 控制反转

1. 先创建一个 v2 包：
   
2. CarV2：

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.");frameworkV2.init();}
}

3. FrameworkV2：

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();}
}

4. BottomV2：

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();}
}

5. TireV2：

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

6. App：

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

7. 运行结果为：
   

Ⅱ 需求增加

当需求增加时，例如需要增加车轮的颜色：

1. TireV2：

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);System.out.println("Tire v2 color:" + color);}
}

2. App：

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

• 运行结果为：
  

Ⅲ 优点

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

③ 对⽐总结规律

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

改进之后的控制权发⽣的反转，不再是上级对象创建并控制下级对象了，⽽是下级对象把注⼊将当前对象中，下级的控制权不再由上级类控制了，这样即使下级类发⽣任何改变，当前类都是不受影响的，这就是典型的控制反转，也就是 IoC 的实现思想。

3、理解 Spring IoC

回到我们的主题：Spring，本⽂刚开始咱们就讲：Spring 是包含了多个⼯具⽅法的 IoC 容器，这就是对 Spring 最核⼼的总结。“集成多个⼯具⽅法”这事咱们以后慢慢再讲，那如何理解“Spring 是⼀个 IoC容器”这句话呢？

既然 Spring 是⼀个 IoC（控制反转）容器，重点还在“容器”⼆字上，那么它就具备两个最基础的功能：

• 将对象存⼊到容器；
• 从容器中取出对象。

也就是说学 Spring 最核⼼的功能，就是学如何将对象存⼊到 Spring 中，再从 Spring 中获取对象的过程。

将对象存放到容器中的好处：将对象存储在 IoC 容器相当于将以后可能⽤的所有⼯具制作好都放到仓库中，需要的时候直接取就⾏了，⽤完再把它放回到仓库。⽽ new 对象的⽅式相当于，每次需要⼯具了，才现做，⽤完就扔掉了也不会保存，下次再⽤的时候还得重新做，这就是 IoC 容器和普通程序开发的区别。

Spring 是⼀个 IoC 容器，说的是对象的创建和销毁的权利都交给 Spring 来管理了，它本身⼜具备了存储对象和获取对象的能⼒。

4、DI 概念说明

说到 IoC 不得不提的⼀个词就是“DI”。
DI（Dependency Injection ）：依赖注入，即将依赖的类注入到当前类中。

所谓依赖注⼊，就是由 IoC 容器在运⾏期间，动态地将某种依赖关系注⼊到对象之中。所以，依
赖注⼊（DI）和控制反转（IoC）是从不同的⻆度的描述的同⼀件事情，就是指通过引⼊ IoC 容
器，利⽤依赖关系注⼊的⽅式，实现对象之间的解耦。

IoC 是“⽬标”也是⼀种思想，⽽⽬标和思想只是⼀种指导原则，最终还是要有可⾏的落地⽅案，⽽ DI 就属于具体的实现。