2023.10.31 关于 Spring 的基本概念-CSDN博客

本文链接：https://blog.csdn.net/weixin_63888301/article/details/134147630

Spring

Spring 的全称为 Spring Framework，是一个开源的 Java 应用程序框架
它提供了一种综合的编程和配置模型，用于构建现代化企业级的应用程序

一句话概括

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

容器

容器就是用来容纳某种物品的基本装置

实例理解

水杯 -> 用来装水的容器
List/Map -> 数据存储容器
Tomcat -> Web容器

对象生命周期

分为三个阶段

创建阶段

对象被实例化并分配内存空间
可以通过关键字 new、工厂方法、依赖注入等方式来完成
创建阶段，对象可能需要进行一些初始化操作，例如设置默认值、加载配置等

使用阶段

对象被创建后，它可以被应用程序代码使用
使用阶段，对象执行它所具有的功能、处理业务逻辑等
对象可能会被传递给其他对象，作为依赖项被引用和调用

销毁阶段

当对象不再需要时，需要进行销毁操作以释放占用的资源
销毁阶段，包括清零资源、关闭连接、保存状态等操作
对象的销毁可以由垃圾回收器自动处理，或者通过显式的销毁方法来触发

IoC

IoC 的全称为 Inversion of Control 译为控制反转
即 Spring 是一个控制反转的容器

基本概念

控制反转是一种软件设计原则，它指的是将对象的创建、依赖关系的管理、对象的生命周期的控制权从应用程序代码转移到一个外部容器或框架中
此处的外部容器就是 Spring 容器
下图是传统方式和控制反转方式对比

相比于控制反转，传统方式对象的创建和依赖关系的管理都留给了应用程序代码

实例理解

我们规定造车的依赖关系：一台完整的车 -> 车身 -> 底盘 -> 轮胎

传统方式
// 轮胎
public class Tire {
//    轮毂大小
    private int size = 17;

    public void init() {
        System.out.println("轮毂的 size 为 ——>  " + size);
    }
}
// 底盘
public class Bottom {
    private Tire tire;

//    此处控制了 tire 对象的生命周期
    public Bottom() {
        tire = new Tire();
    }
    public void init() {
        System.out.println("do Bottom");
//        装上轮胎
        tire.init();
    }
}
//车身
public class Framework {
    private Bottom bottom;

//    此处控制了 bottom 对象的生命周期
    public Framework() {
        bottom = new Bottom();
    }
    public void init() {
        System.out.println("do framework");
//        装上含轮胎的底盘
        bottom.init();
    }
}
//一台完整的车
public class Car {
    private Framework framework;
    
//    此处控制了 framework 对象的生命周期
    public Car() {
        framework = new Framework();
    }
    
    public void init() {
        System.out.println("do car");
//        装上含轮胎和底盘的车身
        framework.init();
    }

    public static void main(String[] args) {
        Car car = new Car();
        car.init();
    }
}
我们观察上述代码，其存在强依赖关系
假设不同客户需要定制不同车轮毂尺寸，那么我们便需要修改当前代码

上图绿框便是需要修改和添加的代码逻辑

与此同时也反应了传统方式的缺点

传统方式的缺点

当最底层发生变化时，即 Tire类发生变化，整个调用链都需要修改，也就是具有高耦合的缺点

IoC 方式
//轮毂
public class Tire {
    //    默认轮毂大小
    private int size = 17;

    public Tire(int size) {
        this.size = size;
    }

    public void init() {
        System.out.println("轮毂的 size 为 ——>  " + size);
    }
}
//底盘
public class Bottom {
    private Tire tire;

    public Bottom(Tire tire) {
        this.tire = tire;
    }
    public void init() {
        System.out.println("do Bottom");
//        装上轮胎
        tire.init();
    }
}
//车身
public class Framework {
    private Bottom bottom;

    public Framework(Bottom bottom) {
        this.bottom = bottom;
    }

    public void init() {
        System.out.println("do framework");
//        装上含轮胎和底盘的车身
        bottom.init();
    }
}
//完整的一台车
public class Car {
    private Framework framework;

    public Car(Framework framework) {
        this.framework = framework;
    }

    public void init() {
        System.out.println("do car");
//        装上含轮胎和底盘的车身
        framework.init();
    }
}
//最后在该类中 获取创建造车所需的所有类
public class Test {
    public static void main(String[] args) {
        Tire tire = new Tire(15);
        Bottom bottom = new Bottom(tire);
        Framework framework = new Framework(bottom);
        Car car = new Car(framework);
        car.init();
    }
}
图示区别

相比于传统方式直接在构造方法中 new 对象，由类自身控制其他类的生命周期
IoC方式体现了控制反转的思想，具体体现在以下两个个方面：

依赖注入：在类之间的依赖关系中，通过构造函数参数的方式将依赖的对象传递给依赖的类。例如，Bottom 类通过构造函数接收 Tire 对象，Framework 类通过构造函数接收 Bottom 对象， Car 类通过构造函数接收 Framework 对象。这样，对象的依赖关系由外部容器（在这里是 Test 类）负责创建和注入，实现了依赖关系的控制反转

容器管理：在 Test 类中，创建了所有需要的对象实例，并将它们组装在一起。Test 类充当了容器的角色，负责管理对象的创建和依赖关系的注入。通过创建 Tire、Bottom、 Framework 和 Car 对象，并将它们逐层传递和注入，实现了对象的创建和依赖关系的控制

优势体现

当需要增加客户自定义轮毂颜色时，此时我们仅需在 Tire 类中添加相应代码即可，从而大大降低了依赖类之间的耦合性

蓝框为新增代码，相比于传统方法，其需修改和新增的代码是要少了很多的
传统代码是 Car 控制并创建了 Framework，Framework 创建后又创建了 Bottom，依次往下，而 IoC 方式直接将控制权进行了反转，不再是上级对象创建并控制下级对象了，而是下级对象被注入到上级对象中，下级的控制权不再由上级类控制了，这样及时下级类发生任何改变，当前类都是不受影响的，这就是典型的控制反转

Spring IoC

IoC 是一个思想，控制反转，此处反转给 Spring
Spring 是包含了众多工具方法的 IoC 容器
Spring IoC 是实现了 IoC 思想的具体框架
其中的两个重要步骤为：

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

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

对象存放到容器的好处

将对象存储到 Spring IoC 中，其对象会随着框架的启动而创建，当我们想使用某个对象时，直接取就行了，使用完直接放回到 Spring IoC中即可
相比于 new 对象的方式，当需要该对象时，需要现场创建，Spring IoC 的效率肯定就要高很多了

Spring IoC 的优点

解耦
使用更加方便（不再需要手动创建和关注某个对象背后的依赖关系）
效率更高

Spring 是一个 IoC 容器
Spring 管理对象的创建和销毁
同时具有存储对象和获取对象的能力

DI

DI 全称为 Dependency Injection，译为依赖注入
即在 IoC 容器在运行期间，动态地将某种依赖关系注入到对象中
通过依赖注入，对象可以在运行时获取所需的依赖对象，而不需要在编译时硬编码依赖关系

DI 与 IoC 的关联

IoC 是一种设计思想，它强调将控制权从一个对象转移到外部容器或框架
DI 则是 IoC 的一种具体实现方式，它通过将对象所需的依赖对象从外部注入到对象中，解决了对象之间的高耦合问题