?Spring是什么

通常所说的 Spring 指的是 Spring Framework(Spring 框架)

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

• 将众多工具方法的 IOC 容器拆解为三部分
  • 众多工具方法
  • IOC
  • 容器

众多工具方法

• 将扳手?理解为一个工具
  • 扳手?可以用来打螺丝(方法)
  • 扳手?可以用来敲核桃(方法)
  • …

容器

• 将水杯理解为容器
  • 可以用水杯装水
  • 可以用水杯装果汁
  • 可以用水杯装牛奶

IOC(Inversion Of Control)

IOC(Inversion Of Control)控制反转

控制反转的内容是啥?
对象的生命周期

为什么需要控制反转?(控制反转的作用)
解耦合

举个栗子?

现在需要编写一段代码来模拟实现一辆"车"?

• 划分为4个部分
  • 轮胎
  • 底座
  • 车身
  • 车

实现思路?

定义Car类

public class Car {
    private Framework framework;

    public Car() {
        framework = new Framework();
    }

    public void init() {
        framework.init();
    }
}

定义Framework类

public class Framework {
    private Bottom bottom;

    public Framework() {
        bottom = new Bottom();
    }

    public void init() {
        bottom.init();
    }
}

定义Bottom类

public class Bottom {
    private Tyre tyre;

    public Bottom() {
        tyre = new Tyre();
    }

    public void init() {
        tyre.init();
    }
}

定义Tyre类

public class Tyre {
    private int size = 20;

    public Tyre() {

    }

    public void init() {
        System.out.println("执行 Init() 方法, 轮胎的尺寸为 : " + this.size);
    }
}

定义启动类

public class Application {

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

}

可以看到, 上述代码描述的"车"的轮胎大小是固定的
如果需要修改轮子的大小, 就需要对代码进行改动

• 两种方式
  • 传统实现思路
  • IOC实现思路

传统实现思路?

定义Car类

public class Car {
    private Framework framework;

    public Car(int size) {
        framework = new Framework(size);
    }

    public void init() {
        framework.init();
    }
}

定义Framework类

public class Framework {
    private Bottom bottom;

    public Framework(int size) {
        bottom = new Bottom(size);
    }

    public void init() {
        bottom.init();
    }
}

定义Bottom类

public class Bottom {
    private Tyre tyre;

    public Bottom(int size) {
        tyre = new Tyre(size);
    }

    public void init() {
        tyre.init();
    }
}

定义Tyre类

public class Tyre {
    private int size = 20;

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

    public void init() {
        System.out.println("执行 Init() 方法, 轮胎的尺寸为 : " + this.size);
    }
}

定义启动类

public class Application {

    public static void main(String[] args) {
        int size = 12;

        Car car = new Car(size);
        car.init();
    }

}

IOC实现思路?

定义Car类

public class Car {
    private Framework framework;

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

    public void init() {
        framework.init();
    }
}

定义Framework类

public class Framework {
    private Bottom bottom;

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

    public void init() {
        bottom.init();
    }
}

定义Bottom类

public class Bottom {
    private Tyre tyre;

    public Bottom(Tyre tyre) {
        this.tyre = tyre;
    }

    public void init() {
        tyre.init();
    }
}

定义Tyre类

public class Tyre {
    private int size = 20;

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

    public void init() {
        System.out.println("执行 Init() 方法, 轮胎的尺寸为 : " + this.size);
    }
}

定义启动类

public class Application {
    
    public static void main(String[] args) {
        Tyre tyre = new Tyre(30);
        Bottom bottom = new Bottom(tyre);
        Framework framework = new Framework(bottom);
        Car car = new Car(framework);
        car.init();
    }
    
}

对比传统实现思路与IOC实现思路?

控制反转的内容是啥?

• 传统实现思路
  • 自己控制对象的生命周期
  • this.tyre = new Tyre(size);
• IOC实现思路
  • 将对象生命周期的控制权转交给他人(控制反转, 自己控制 → 他人控制)
  • this.tyre = tyre;

为什么需要控制反转?(控制反转的作用)

• 传统实现思路
  • 对车子的需求修改时, 需要对每个方法都进行修改(耦合度较高)
• IOC实现思路
  • 对车子的需求修改时, 只需要修改对应的方法即可(解耦合)

A类引用B类, B类引用C类, C类引用D类…

传统实现思路是 new
但这样的实现耦合度较高(当被引用的类的构造方法发生变化, 则整个调用链都需要进行改变)

IOC(控制反转)
不再 new, 而是传入当前对象
此时的调用链仍然是A类引用B类, B类引用C类, C类引用D类…
但当D发生改变时, 整个调用链的代码不用全部进行修改, 从而解决了耦合度较高的问题

Spring的基本功能

Spring 的本质是一个容器
容器的基本功能有两个

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

举个栗子?

水杯是一个容器

• 用水杯来存水(将对象存入到容器)
• 喝水杯中的水(从容器中取出对象)

谈一谈IOC与DI

IOC(Inversion Of control)控制反转
将对象的生命周期托管给他人

DI(Dependency Injection)依赖注入
在程序运行期间, 动态的将某个对象引入到当前的一种机制

public Bottom(Tyre tyre) {
    this.tyre = tyre;
}

以这段代码为例

• 将对象的生命周期托管给他人(IOC, this.tyre = new Tyre() → this.tyre = tyre)
• 在程序运行期间, 将 tyre 引入到当前(DI)

IOC 与 DI 没有本质上的区别, 只是从不同的角度来去描述同一个问题

• IOC 侧重的是想法
• DI 侧重的是具体的实现

举个栗子?

我今天中午想去外面吃(IOC → 想法)
我去外面吃了隆江猪脚饭(DI → 具体实现)

?结尾

创作不易,如果对您有帮助,希望您能点个免费的赞?
大家有什么不太理解的，可以私信或者评论区留言，一起加油