Spring核心：探索IoC容器与依赖注入的奥秘

目录

一、什么是Spring？

二、什么是 Ioc ？

2.1 控制反转的实现方式

2.1.1 依赖注入

2.1.2 依赖查找

2.1.3 优点分析

2.2 理解 Ioc

---

一、什么是Spring？

我们通常所说的 Spring 指的是 Spring Framework（Spring 框架），它是个开源框架，有着活跃的社区，这就是它之所以能久经不衰的原因。用一句话进行概括：Spring是包含了众多工具方法的 loC 容器。那什么是 loC 容器呢？🧐🧐🧐

二、什么是 Ioc ？

IoC（Inversion of Control，控制反转）英文翻译即 “控制反转” 的意思，是 Spring框架的核心概念之一， 它是一种设计原则和编程思想（设计思想），用于实现松耦合和可测试的应用程序。在传统的编程模式中，对象之间的创建、组装和管理是通过开发人员手动完成的，而在 loC模式下，则是通过一个容器来进行管理。

2.1 控制反转的实现方式

2.1.1 依赖注入

依赖注入是loC 的一种具体的实现方式，通过将依赖关系注入到对象中，实现对象之间的松耦合。容器负责查找依赖对象，并将其自动注入到相应的对象中。依赖注入可以通过构造函数、Setter方法或接口注入来完成。依赖注入的优点是减少对象之间的耦合，使代码更加灵活和可维护。

2.1.2 依赖查找

依赖查找是另一种 loC 的实现方式，它通过容器提供的API，开发人员手动查找并获取所需要的依赖对象，而不是将依赖关系委托给容器。通过容器提供的接口来获取所需要的对象实例，从而实现对象之间的解耦。

2.1.3 优点分析

loC 是Spring框架的基石，使用 loC 的好处在于：

• 降低代码之间的耦合度

• 可维护性更好，对象更易于扩展和重用

• loC 容器管理对象，简化开发的难度，节省开发时间。

2.2 理解 Ioc

假如我们需要构造一辆汽车，思路如下：车需要依赖车身(FrameWork Class)，车身需要依赖底盘（Bottom Class）， 底盘需要依赖轮胎（Tire Class）

最终程序的实现代码如下：

//轮胎类
public class Tire {//车轮大小为：10public int size=30;public void init(){System.out.println("size="+size);}
}
//底盘类：依赖轮胎
public class Bottom{public void init(){Tire tire=new Tire();System.out.println("size="+tire.size);}
}
//车身类，依赖底盘
public class FrameWork {public void init(){Bottom bottom=new Bottom();bottom.init();}
}
//汽车类，依赖车身
public class Car {public void init(){FrameWork frameWork=new FrameWork();frameWork.init();}
}
//测试程序：输入轮胎的大小
public class Test {public static void main(String[] args) {Car car=new Car();car.init();}
}

程序输出结果如下：

以上程序中，轮胎的尺寸是固定的，然而随着对汽车的需求量越来越高，个性化需求也会越来越多，这时候我们就需要加多种尺寸的轮胎，那这个时候就要对上面的程序进行修改了，修改后的代码如下所示：

public class Tire {//车轮大小为：10public int size=30;public void init(){System.out.println("size="+size);}//添加带参构造方法：方便对轮胎的大小进行设置public Tire(int size){this.size=size;}
}

public class Bottom{public void init(int size){Tire tire=new Tire(size);System.out.println("size="+tire.size);}
}

修改后代码如下：

public class Tire {//车轮大小为：10public int size=30;public void init(){System.out.println("size="+size);}public Tire(int size){this.size=size;}
}
//底盘类依赖轮胎public class Bottom{public void init(int size){Tire tire=new Tire(size);System.out.println("size="+tire.size);}
}
//车身类依赖底盘public class FrameWork {public void init(int size){Bottom bottom=new Bottom();bottom.init(size);}
}
//汽车类依赖车身public class Car {public void init(int size){FrameWork frameWork=new FrameWork();frameWork.init(size);}
}
//测试类代码public class Test {public static void main(String[] args) {//首先创建上级类对象Car car=new Car();car.init(30);}
}

 以上程序的问题是：当最底层代码改动之后，整个调用链上的所有代码都需要修改（强耦合）。

解决方案：

public class Tire {//车轮大小为：10public int size=30;public void init(){System.out.println("size="+size);}public Tire(int size){this.size=size;}
}public class Bottom{private Tire tire;public Bottom(Tire tire){this.tire=tire;}public void init(){tire.init();}
}public class FrameWork {private Bottom bottom;public FrameWork(Bottom bottom){this.bottom=bottom;}public void init(){bottom.init();}
}public class Car {private FrameWork frameWork;public Car(FrameWork frameWork){this.frameWork=frameWork;}public void init(){frameWork.init();}
}/*
模拟实现 loC容器：控制对象*/public class Test {public static void main(String[] args) {Tire tire=new Tire(100);Bottom bottom=new Bottom(tire);FrameWork frameWork=new FrameWork(bottom);Car car=new Car(frameWork);car.init();}
}

 

在传统的代码中对象创建顺序是：Car -> Framework -> Bottom -> Tire 改进之后解耦的代码的对象创建顺序是：Tire -> Bottom -> Framework -> Car

在上面的程序中，我们发现了一个规律：通用程序的实现代码，类的创建顺序是反的。改进后的控制权发生反转后，不再是上级对象创建并控制下级对象了，而是下级对象通过注入到当前对象，下级的控制权不再由上级类控制。即使下级类发生任何变化，当前类都是不受影响的，这就是 loC 的设计思想。