Spring IoC和DI深度解析
Spring 是包含了众多⼯具⽅法的 IoC 容器.
IoC
什么是IoC?
像在类上⾯添加 @RestController 和@Controller 注解, 就是把这个对象交给Spring管理, Spring 框架启动时就会加载该类. 把对象交给Spring管理, 就是IoC思想.
IoC：Inversion of Control (控制反转), 也就是说 Spring 是⼀个"控制反转"的容器.
什么是控制反转呢? 也就是控制权反转. 什么的控制权发⽣了反转? 获得依赖对象的过程被反转了也就是说, 当需要某个对象时, 传统开发模式中需要⾃⼰通过 new 创建对象, 现在不需要再进⾏创建, 把创建对象的任务交给容器, 程序中只需要依赖注⼊ (Dependency Injection,DI)就可以了.
这个容器称为：IoC容器. Spring是⼀个IoC容器, 所以有时Spring 也称为Spring 容器.
引入
传统实现思路
我们的实现思路是这样的：
先设计轮⼦(Tire)，然后根据轮⼦的⼤⼩设计底盘(Bottom)，接着根据底盘设计⻋⾝(Framework)，最后根据⻋⾝设计好整个汽⻋(Car)。这⾥就出现了⼀个"依赖"关系：汽⻋依赖⻋⾝，⻋⾝依赖底盘，底盘依赖轮⼦.
代码实现
public class Main {
public static void main(String[] args) {
Car car = new Car(21);
car.run();
Car car2 = new Car(17);
car2.run();
}
}
//汽车
class Car {
private Framework framework;
public Car(int size) {
framework = new Framework(size);
System.out.println("framework init...");
}
public void run() {
System.out.println("car run...");
}
}
//车身
class Framework {
private Bottom bottom;
public Framework(int size) {
bottom = new Bottom(size);
System.out.println("bottom init....");
}
}
//底盘
class Bottom {
private Tire tire;
public Bottom(int size) {
tire = new Tire(size);
System.out.println("tire init...");
}
}
//轮胎
class Tire {
private int size;
public Tire(int size) {
System.out.println("tire size:"+size);
}
}上面这样的设计看起来没问题，但是可维护性却很低，因为需求可能会越来越多，比如增加轮胎颜色，修改后的代码如下：
我们可以看到，修改后的代码会报错，并且需要我们继续修改
完整代码如下：
public class Main {
public static void main(String[] args) {
Car car = new Car(21,"aaa");
car.run();
Car car2 = new Car(17,"bbb");
car2.run();
}
}
//汽车
class Car {
private Framework framework;
public Car(int size,String color) {
framework = new Framework(size,color);
System.out.println("framework init...");
}
public void run() {
System.out.println("car run...");
}
}
//车身
class Framework {
private Bottom bottom;
public Framework(int size,String color) {
bottom = new Bottom(size,color);
System.out.println("bottom init....");
}
}
//底盘
class Bottom {
private Tire tire;
public Bottom(int size,String color) {
tire = new Tire(size,color);
System.out.println("tire init...");
}
}
//轮胎
class Tire {
private int size;
private String color;
public Tire(int size,String color) {
System.out.println("tire size:"+size);
}
}从以上代码可以看出，以上程序的问题是：当最底层代码改动之后，整个调⽤链上的所有代码都需要修改.
程序的耦合度⾮常⾼(修改⼀处代码, 影响其他处的代码修改)。
解决方案
我们尝试改变实现方式：轮⼦依赖底盘， 底盘依赖⻋⾝，⻋⾝依赖汽⻋。
基于以上思路，我们把调⽤汽⻋的程序⽰例改造⼀下，把创建⼦类的⽅式，改为注⼊传递的⽅式。
完整代码如下：
class Main {
public static void main(String[] args) {
Tire tire = new Tire(17, "red");
Bottom bottom = new Bottom(tire);
Framework framework = new Framework(bottom);
Car car = new Car(framework);
car.run();
}
}
//汽车
class Car {
private Framework framework;
public Car(Framework framework) {
this.framework = framework;
System.out.println("framework init...");
}
public void run() {
System.out.println("car run...");
}
}
//车身
class Framework {
private Bottom bottom;
public Framework(Bottom bottom) {
this.bottom = bottom;
System.out.println("bottom init....");
}
}
//底盘
class Bottom {
private Tire tire;
public Bottom(Tire tire) {
this.tire=tire;
System.out.println("tire init...");
}
}
//轮胎
class Tire {
private int size;
private String color;
public Tire(int size, String color) {
System.out.println("tire size:"+size+",color:"+color);
}
}代码经过以上调整，⽆论底层类如何变化，整个调⽤链是不⽤做任何改变的，这样就完成了代码之间的解耦，从⽽实现了更加灵活、通⽤的程序设计了。
IoC的优势
在传统的代码中对象创建顺序是：Car -> Framework -> Bottom -> Tire
改进之后解耦的代码的对象创建顺序是：Tire -> Bottom -> Framework -> Car
我们发现了⼀个规律，通⽤程序的实现代码，类的创建顺序是反的，传统代码是 Car 控制并创建了Framework，Framework 创建并创建了 Bottom，依次往下，⽽改进之后的控制权发⽣的反转，不再是使⽤⽅对象创建并控制依赖对象了，⽽是把依赖对象注⼊将当前对象中，依赖对象的控制权不再由当前类控制了.
这样的话, 即使依赖类发⽣任何改变，当前类都是不受影响的，这就是典型的控制反转，也就是 IoC 的实现思想。
到这⾥, 我们⼤概就知道了什么是控制反转了, 那什么是控制反转容器呢, 也就是IoC容器。
这部分代码, 就是IoC容器做的⼯作.
从上⾯也可以看出来, IoC容器具备以下优点:
资源不由使⽤资源的双⽅管理，⽽由不使⽤资源的第三⽅管理，这可以带来很多好处。
第⼀，资源集中管理，实现资源的可配置和易管理。
第⼆，降低了使⽤资源双⽅的依赖程度，也就是我们说的耦合度。
1. 资源集中管理: IoC容器会帮我们管理⼀些资源(对象等), 我们需要使⽤时, 只需要从IoC容器中去取就可以了
2. 我们在创建实例的时候不需要了解其中的细节, 降低了使⽤资源双⽅的依赖程度, 也就是耦合度.
Spring 就是⼀种IoC容器, 帮助我们来做了这些资源管理.
DI
DI: Dependency Injection(依赖注⼊)
容器在运⾏期间, 动态的为应⽤程序提供运⾏时所依赖的资源，称之为依赖注⼊。
程序运⾏时需要某个资源，此时容器就为其提供这个资源.
从这点来看, 依赖注⼊（DI）和控制反转（IoC）是从不同的⻆度的描述的同⼀件事情，就是指通过引⼊ IoC 容器，利⽤依赖关系注⼊的⽅式，实现对象之间的解耦。
前面代码中, 是通过构造函数的⽅式, 把依赖对象注⼊到需要使⽤的对象中的。
IoC 是⼀种思想，也是"⽬标", ⽽思想只是⼀种指导原则，最终还是要有可⾏的落地⽅案，⽽ DI 就属于具体的实现。所以也可以说, DI 是IoC的⼀种实现.
到此这篇关于Spring IoC和DI深度解析的文章就介绍到这了,更多相关Spring IoC和DI内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！
相关文章
wait()和notify()是直接隶属于Object类,也就是说所有对象都拥有这一对方法,下面这篇文章主要给大家介绍了关于使用wait/notify实现线程间通信的相关资料,需要的朋友可以参考下2022-12-12
Java集合框架(Java Collections Framework, JCF)也称容器,这里可以类比 C++中的 STL,在这里主要对如下部分进行源码分析,及在面试中常见的问题,例如,在阿里面试常问到的 HashMap和ConcurrentHashMap原理等等,深入源码分析是面试中必备的技能2023-08-08
关于RedisTemplate之opsForValue的使用说明
这篇文章主要介绍了关于RedisTemplate之opsForValue的使用说明，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教2022-06-06
继承就是使用已定义的类作为父类,新建一个类作为子类使用extends关键字继承这个类,这样就实现了继承关系,这篇文章主要给大家介绍了关于Java面向对象关键字extends继承的相关资料,需要的朋友可以参考下2021-08-08
SpringBoot 下集成缓存工具类 CacheManager
这篇文章主要介绍了Springboot下集成缓存工具类CacheManager，想进一步了解相关知识的同学，可以详细阅读本文2023-03-03
这篇文章主要介绍了Java 分析并解决内存泄漏的实例，帮助大家更好的理解和学习Java，感兴趣的朋友可以了解下2020-08-08
这篇文章主要介绍了Springboot之@Async不执行原因及分析,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教2023-09-09
这篇文章主要给大家介绍了关于mybatis注入Date日期值为null的解决方法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧2020-11-11
浅谈一下RabbitMQ、Kafka和RocketMQ消息中间件对比
这篇文章主要介绍了浅谈一下RabbitMQ、Kafka和RocketMQ消息中间件对比,消息中间件属于分布式系统中一个字系统，关注于数据的发送和接收，利用高效可靠的异步信息传递机制对分布式系统中的其余各个子系统进行集成,需要的朋友可以参考下2023-05-05
这篇文章主要介绍了如何使用JUnit编写Spring Boot项目中的测试单元,包括引入依赖、配置文件设置、启动文件创建以及编写测试类的步骤,文中通过代码介绍的非常详细,需要的朋友可以参考下2025-03-03
最新评论