初识Spring
目录
1.Spring 基础
2.传统程序开发
3.IoC程序开发（解耦）
4.DI
4.1 IoC 和 DI 有什么区别
1.Spring 基础
Spring 指的是 Spring Framework（Spring 框架），它是⼀个开源框架，有着活跃⽽庞⼤的社区，这就是它之所以能⻓久不衰的原因。Spring ⽀持⼴泛的应⽤场景，它可以让 Java 企业级的应⽤程序开发起来更简单。
一句话概括：Spring 是包含了众多工具方法的 IoC 容器
容器：⽤来容纳某种物品的（基本）装置（例如：List/Map ---> 数据存储容器、Tomcat ----> Web 容器）
IoC：IoC = Inversion of Control 翻译成中⽂是“控制反转”的意思，也就是说 Spring 是⼀个“控制反转”的容器
控制（权）反转：对象的生命周期，不是由程序员（或当前代码片段）来控制，而是由 Spring（Spring 容器/ IoC容器）来控制
IoC最大的优点：可以实现解耦（松耦合）
2.传统程序开发
假如，我们现在构建⼀辆“⻋”的程序，我们的实现思路是这样的：
/**
* 传统开发：汽车对象
*/
public class Car {
private Framework framework;//依赖车声，建立车身
//在构造方法中 new
public Car() {
this.framework = new Framework();
}
public void init() {
//依赖车身
System.out.println("执行了 init 方法");
framework.init();
}
}/**
* 车身类
*/
public class Framework {
private Bottom bottom;
public Framework() {
this.bottom = new Bottom();
}
public void init() {
//依赖底盘
System.out.println("执行了 Framework init 方法");
bottom.init();
}
}/**
* 底盘类
*/
public class Bottom {
private Tire tire;
public Bottom() {
this.tire = new Tire();
}
public void init() {
//依赖轮胎
System.out.println("执行了 Bottom init 方法");
tire.init();
}
}/**
* 轮胎类
*/
public class Tire {
private int size = 15;
public void init() {
System.out.println("执行了 Tire init，Size："+ size);
}
}这个时候我们执行这段代码：
public class Test {
public static void main(String[] args) {
Car car = new Car();
car.init();
}
}
上述代码中轮胎的尺寸是固定的，然而随着对的车的需求量越来越⼤，个性化需求也会越来越多，这 时候我们就需要加工多种尺⼨的轮胎，那这个时候就要对上面的程序进行修改：
注意每一类中size的改动
/**
* 传统开发：汽车对象
*/
public class Car {
private Framework framework;
public Car(int size) {
this.framework = new Framework(size);
}
public void init() {
//依赖车身
System.out.println("执行了 init 方法");
framework.init();
}
}
/**
* 车身类
*/
public class Framework {
private Bottom bottom;
public Framework(int size) {
this.bottom = new Bottom(size);
}
public void init() {
//以来底盘
System.out.println("执行了 Framework init 方法");
bottom.init();
}
}
/**
* 底盘类
*/
public class Bottom {
private Tire tire;
//Botton 中没有size参数，继续让别人传参数
public Bottom(int size) {
this.tire = new Tire(size);
}
public void init() {
//依赖轮胎
System.out.println("执行了 Bottom init 方法");
tire.init();
}
}
/**
* 轮胎类
*/
public class Tire {
private int size = 15;
//传递 size 参数
public Tire(int size) {
this.size = size;
}
public void init() {
System.out.println("执行了 Tire init，Size："+ size);
}
}
public class Test {
public static void main(String[] args) {
Car car = new Car(20);
car.init();
}
}
这个时候我们发现，虽然我们可以改变轮胎的尺寸，但是最底层代码改动之后，整个调用链上的所有代码都需要修改——耦合性问题
需求指挥越来越多，改动的也会越来越多，这个时候我们就可以使用 IoC 进行解耦
3.IoC程序开发（解耦）
/**
* IoC：汽车对象
*/
public class Car {
private Framework framework;
//初始化（不是用传统开发）：让框架传入（不管咋样传入），声明使用Framework
//如果是一个IoC框架，运行代码，会拿到当前框架中的Framework 赋值到当前变量中就会有 framework
public Car(Framework framework) {
this.framework = framework;
}
public void init() {
System.out.println("Car init");
framework.init();
}
}
public class Framework {
private Bottom bottom;
public Framework(Bottom bottom) {
this.bottom = bottom;
}
public void init() {
System.out.println("Framework init");
bottom.init();
}
}
public class Bottom {
private Tire tire;
public Bottom(Tire tire) {
this.tire = tire;
}
public void init() {
System.out.println("Bottom init");
tire.init();
}
}
public class Tire {
private int size = 15;
public Tire() {
}
public void init() {
System.out.println("Tire init, Size:" + size);
}
}
/**
* 模拟 IoC 容器
*/
public class Test {
private Tire tire;
private Bottom bottom;
private Framework framework;
private Car car;
public Test() {
this.tire = new Tire();
this.bottom = new Bottom(this.tire);
this.framework = new Framework(this.bottom);
this.car = new Car(this.framework);
}
public static void main(String[] args) {
Test test = new Test();
test.car.init();
}
}
需要改尺寸只需要修改 Tire 类中的尺寸：
public class Tire {
private int size = 15;
public Tire(int size) {
this.size = size;
}
public void init() {
System.out.println("Tire init, Size:" + size);
}
}这个时候只需要改 IoC 容器（Spring 框架 ）即可（IoC 与用户没有关系），Spring 框架会自动设置参数
public class Test {
private Tire tire;
private Bottom bottom;
private Framework framework;
private Car car;
public Test() {
this.tire = new Tire(20);
this.bottom = new Bottom(this.tire);
this.framework = new Framework(this.bottom);
this.car = new Car(this.framework);
}
public static void main(String[] args) {
Test test = new Test();
test.car.init();
}
}
代码经过以上调整，⽆论底层类如何变化，整个调⽤链是不⽤做任何改变的，这样就完成了代码之间的解耦，从⽽实现了更加灵活、通⽤的程序设计了
对比传统：
通⽤程序的实现代码，类的创建顺序是反的，传统代码是 Car 控制并创建了Framework，Framework 创建并创建了 Bottom，依次往下，⽽改进之后的控制权发⽣的反转，不再是上级对象创建并控制下级对象了，⽽是下级对象把注⼊将当前对象中，下级的控制权不再由上级类控制了，这样即使下级类发⽣任何改变，当前类都是不受影响的，这就是典型的控制反转，也就是 IoC 的实现思想。
既然 Spring 是⼀个 IoC（控制反转）容器，重点还在“容器”⼆字上，那么它就具备两个最基础的功能：
-
将对象存入到容器
-
从容器中取出对象
也就是说学 Spring 最核心的功能，就是学如何将对象存入到 Spring 中，再从 Spring 中获取对象的过程
将对象存放到容器中的好处：将对象存储在 IoC 容器相当于将以后可能⽤的所有共具制作好都放到仓库中，需要的时候直接取就行了，用完再把它放回到仓库。而new 对象的方式相当于，每次需要工具了，才现做，用完就扔掉了也不会保存，下次再⽤的时候还得重新做，这就是 IoC 容器和普通程序开发的区别
4.DI
DI 是 Dependency Injection 的缩写，翻译成中文是“依赖注入”的意思：指的是由 IoC 容器在运行期间，动态的将依赖对象获取到的过程
public class Car {
private Framework framework;
public Car(Framework framework) {
this.framework = framework;
}
public void init() {
System.out.println("Car init");
framework.init();
}
}在运行 Car 时，动态的将 Framework 拿到当前类中的过程就叫做 依赖注入 （在运行类的时候，需要有一个依赖类，依赖类就会从容器中动态的查询出来，赋值给变量，就可以直接使用这个方法）
所以，依赖注⼊（DI）和控制反转（IoC）是从不同的⻆度的描述的同⼀件事情，就是指通过引⼊ IoC 容器，利⽤依赖关系注⼊的⽅式，实现对象之间的解耦；
IoC 是“目标”也是⼀种思想，而目标和思想只是⼀种指导原则，最终还是要有可行的落地方案，而 DI 就属于具体的实现。
比如说我今天吃⼀顿美餐，那么“美餐”是目标（是 IoC），但最后我是吃火锅还是烧烤？这就是具体的实现，就是DI
4.1 IoC 和 DI 有什么区别
IoC 和 DI 都是 Spring 框架中的核心概念，它们的区别在于:
- IoC（Inverse of Control，控制反转）：它是一种思想，主要解决程序设计中的对象依赖关系管理问题。在 IoC 思想中，对象的创建权反转给第三方容器，由容器进行对象的创建及依赖关系的管理。
- DI（Dependency Injection，依赖注入）：它是 IoC 思想的具体实现方式之一，用于实现 IoC。在 Spring 中，依赖注入是指:在对象创建时，由容器自动将依赖对象注入到需要依赖的对象中。
简单来说，它们的关系是：
- IoC 是一种思想、理念，定义了对象创建和依赖关系处理的方式。
- DI 是 IoC 思想的具体实现方式之一，实际提供对象依赖关系的注入功能。
所以 IoC 是更基础和广义的概念，DI 可以说是 IoC 的一种实现手段。大多数情况下，我们提到 IoC 的时候，其实意味着 DI，因为 DI 已经是 IoC 最常见和广泛使用的实现方式了。
例如在 Spring 框架中：
- IoC 体现为 Spring 容器承担了对象创建及依赖关系管理的控制权。
- DI 体现为 Spring 容器通过构造方法注入、Setter 方法注入等方式，将依赖对象注入到需要依赖的对象中。
所以综上，IoC 和 DI 之间的关系可以这样理解:
- IoC 是理论，DI 是实践。
- IoC 是思想，DI 是手段。
- IoC 是整体，DI 是部分。