1. Spring 核心与设计思想

目录

[1. Spring 是什么？](#1. Spring 是什么？)

[1.1 什么是容器？](#1.1 什么是容器？)

[1.2 什么是 Ioc ？](#1.2 什么是 Ioc ？)

[1.2.1 传统程序开发](#1.2.1 传统程序开发)

[1.2.2 解决传统开发的缺陷](#1.2.2 解决传统开发的缺陷)

[1.2.3 控制反转式程序开发](#1.2.3 控制反转式程序开发)

[1.2.4 IoC 的实现思想（重点）](#1.2.4 IoC 的实现思想（重点）)

[1.3 理解 Spring Ioc](#1.3 理解 Spring Ioc)

[1.4 DI 概念说明](#1.4 DI 概念说明)

---

1. Spring 是什么？

Spring 指的是 Spring Framework （spring 框架），它是一个开源框架，有着活跃而庞大的社区，这就是它之所以能长久不衰的原因。

Spring 是包含了众多工具方法的 IoC 容器。

1.1 什么是容器？

容器是用来容纳某种物品的装置。

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

1.2 什么是 Ioc ？

IoC = Inversion of Control 即 控制反转，也就是说 Spring 是一个"控制反转"的容器。

1.2.1 传统程序开发

是通过一层一层的依赖实现的。比如我们要构建一辆车，需要依赖车身，车身进而需要依赖底盘，底盘又需要依赖轮胎。因此一般的实现代码如下：

在 NewCarUpateExample 类中：

public class NewCarUpateExample {
    public static void main(String[] args) {
        Car car = new Car();
        car.init();
    }
}

首先，我们先创建一个汽车对象：

/**
 * 汽车对象
 */
public class Car {
    public void init(){
        // 依赖车身
        Framework framework = new Framework();
        framework.init();
    }
}

由于汽车对象需要依赖车身，因此我们创建一个车身类：

/**
 * 车身类
 */
public class Framework {
    public void init(){
        // 依赖底盘
        Bottom bottom = new Bottom();
        bottom.init();
    }
}

又因为车身依赖于底盘，因此创建底盘类：

/**
 * 底盘类
 */
public class Bottom {
    public void init(){
        // 依赖轮胎
        Tire tire = new Tire();
        tire.init();
    }
}

最后，因为底盘依赖于轮胎，因此创建轮胎类：

/**
 * 轮胎类
 */
public class Tire {
    // 轮胎尺寸
    private int size = 30;

    public void init(){
        System.out.println("轮胎尺寸" + size);
    }
}

在以上程序中，轮胎的尺寸是固定的，但是实际中根据各种需求，轮胎的尺寸也会发生变化，因此修改代码如下：

在 NewCarUpateExample 类中：

public class NewCarUpateExample {
    public static void main(String[] args) {
        Car car = new Car(20);
        car.run();
    }
}

/**
 * 汽车对象
 */
public class Car {
    private Framework framework;

    public Car(int size){
        framework = new Framework(size);
    }
    public void run(){
        // 依赖车身
        framework.init();
    }
}

/**
 * 车身类
 */
public class Framework {
    private Bottom bottom;

    public Framework(int size){
        bottom = new Bottom(size);
    }
    public void init(){
        // 依赖底盘
        bottom.init();
    }
}

/**
 * 底盘类
 */
public class Bottom {
    private Tire tire;
    public Bottom(int size){
        tire = new Tire(size);
    }
    public void init(){
        // 依赖轮胎
        tire.init();
    }
}

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

从以上代码可以看出：当最底层的代码修改后，其他层的代码均需要进行修改。

1.2.2 解决传统开发的缺陷

如何解决代码之间的耦合性过高的问题呢？

我们只需要将原来自己创建的下级类，改为传递的方式（也就是注入 ），因为我们不需要在当前类中创建下级类，所以下级类发生变化时，当前类本身就无需再进行修改，这样就完成了程序的解耦。

1.2.3 控制反转式程序开发

接下来，在上述程序的基础上，我们将创建子类的方式改为注入传递的方式。

public class IocCarExample {
    public static void main(String[] args) {
        Tire tire = new Tire(20);
        Bottom bottom = new Bottom(tire);
        Framework framework = new Framework(bottom);
        Car car = new Car(framework);
        car.run();
    }
}

/**
 * 汽车对象
 */
public class Car {
    private Framework framework;

    public Car(Framework framework){
        this.framework = framework;
    }
    public void run(){
        // 依赖车身
        framework.init();
    }
}

/**
 * 车身类
 */
public class Framework {
    private Bottom bottom;

    public Framework(Bottom bottom){
        this.bottom = bottom;
    }
    public void init(){
        // 依赖底盘
        bottom.init();
    }
}

/**
 * 底盘类
 */
public class Bottom {
    private Tire tire;
    public Bottom(Tire tire){
        this.tire = tire;
    }
    public void init(){
        // 依赖轮胎
        tire.init();
    }
}

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

代码经过以上调整之后，无论底层如何变化，整个调用链是不用做任何改变的，这样就完成了代码之间的解耦。

1.2.4 IoC 的实现思想（重点）

在传统代码中对象创建的规律是：Car -> Framework -> Bottom -> TIre

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

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

（对于依赖对象的管理的控制权反转，通过 Spring 来管理对象的生命周期。不是所有的对象都交给 Spring 管理，需要程序来告诉 Spring 管理哪些对象）。

1.3 理解 Spring Ioc

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

能：

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

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

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

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

1.4 DI 概念说明

DI 是 Dependency Injection 的缩写，即 依赖注入。

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

IoC 是"目标"也是⼀种思想，而目标和思想只是⼀种指导原则，最终还是要有可行的落地⽅案，而 DI就属于具体的实现（即 IoC 是思想，DI 是具体实现）。