Spring核心思想
Spring核心思想
- Spring是什么
-
- IOC(Inversion Of Control)
- Spring的基本功能
- 谈一谈IOC与DI
- 结尾
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 → 具体实现)
结尾
创作不易,如果对您有帮助,希望您能点个免费的赞
大家有什么不太理解的，可以私信或者评论区留言，一起加油