1，Spring是什么？
我们通常所说的Spring指的是 Spring Framework（Spring 框架），它是一个轻量级的 Java 开源框架，有着活跃庞⼤的社区。Spring 是为了解决企业应用开发的复杂性而创建的，不仅⽀持⼴泛的应⽤场景，还让 Java 企业级的应⽤程序开发更加简单。
如何简单地使⽤⼀句话概括 Spring：Spring 是包含了众多工具方法的 IoC 容器。
上述这句话中的有两个重点，其一是包含众多工具方法，其二是IoC容器。
工具方法我们不难理解，但是IoC容器是什么？而对于IoC容器这个问题，我们将其划分为两个子问题，何为IoC？何为容器？
1.1，何为容器？
容器是用来容纳某种物品的（基本）装置。 ——来自：百度百科
在日常生活中，容器随处可见。例如，我们使用的水杯就是容器，其是用来容纳水的装置；书架也是容器，其是用来容纳书本的装置 …
而在编程中，容器也随处可见。例如，我们使用的整型数组是容器，其是用来存放整型数据的装置；map也是容器，其是用来存放键值对的装置 …
Spring 也是⼀个容器，那 Spring 是什么容器呢？ Spring 是⼀个 IoC 容器。
1.2，何为IoC？
IoC 是Inversion of Control 的缩写，翻译成中⽂是控制反转的意思，也就是说 Spring 是⼀个控制反转的容器。
那如何理解这控制反转呢？我们从下面这个示例进行理解。
示例前提：构建⼀辆车（Car Class），然而车需要依赖车身（FrameWork Class），而车身需要依赖底盘（Bottom Class），而底盘需要依赖轮胎（Tire Class），轮胎尺寸规定为17
实现上述示例，有两种方式，分别为传统程序开发和控制反转式程序开发。
1）传统式程序开发
传统程序开发的原理是在每个当前类中创建下级类，从而实现类与类之间的依赖关系。
传统程序开发–>最终程序的实现代码如下：
1，Car(车)类
public class Car {
private Framework framework;
public Car(){
framework = new Framework();
}
public void init(){
System.out.println("do car ...");
framework.init();
}
}
2，Framework(车身)类
public class Framework {
private Bottom bottom;
public Framework(){
bottom = new Bottom();
}
public void init(){
System.out.println("do framework ...");
bottom.init();
}
}
3，Bottom(底盘)类
public class Bottom {
private Tire tire;
public Bottom(){
tire = new Tire();
}
public void init(){
System.out.println("do bottom ...");
tire.init();
}
}
4，Tire(轮胎)类
public class Tire {
private int size = 17;
public Tire(){
}
public void init(){
System.out.println("do tire >> size = " + size);
}
}
5，Test(测试)类
public class Test {
public static void main(String[] args) {
Car car = new Car();
car.init();
}
}
6，测试运行结果
2）控制反转式程序开发
控制反转式程序开发的原理是将在每个当前类中创建下级类改为在当前类中传递注入下级类，从而实现类与类之间的依赖关系。
控制反转式程序开发–>最终程序的实现代码如下：
1，Car(车)类
public class Car {
private Framework framework;
public Car(Framework framework){
this.framework = framework;
}
public void init(){
System.out.println("do car ...");
framework.init();
}
}
2，Framework(车身)类
public class Framework {
private Bottom bottom;
public Framework(Bottom bottom){
this.bottom = bottom;
}
public void init(){
System.out.println("do framework ...");
bottom.init();
}
}
3，Bottom(底盘)类
public class Bottom {
private Tire tire;
public Bottom(Tire tire){
this.tire = tire;
}
public void init(){
System.out.println("do bottom ...");
tire.init();
}
}
4，Tire(轮胎)类
public class Tire {
private int size = 17;
public Tire(){
}
public void init(){
System.out.println("do tire ... >> size = " + size);
}
}
5，Test(测试)类
public class Test {
public static void main(String[] args) {
Tire tire = new Tire();
Bottom bottom = new Bottom(tire);
Framework framework = new Framework(bottom);
Car car = new Car(framework);
car.init();
}
}
6，测试运行结果
3）传统式程序开发缺陷
在上述程序中，轮胎尺⼨的固定的，然而随着对的车的需求量越来越⼤，个性化需求也会越来越多，这时候我们就需要加工多种尺寸的轮胎。那这时就需要对上述程序代码进行更改，修改后代码如下：
1，Car(车)类
public class Car {
private Framework framework;
public Car(int size){
framework = new Framework(size);
}
public void init(){
System.out.println("do car ...");
framework.init();
}
}
2，Framework(车身)类
public class Framework {
private Bottom bottom;
public Framework(int size){
bottom = new Bottom(size);
}
public void init(){
System.out.println("do framework ...");
bottom.init();
}
}
3，Bottom(底盘)类
public class Bottom {
private Tire tire;
public Bottom(int size){
tire = new Tire(size);
}
public void init(){
System.out.println("do bottom ...");
tire.init();
}
}
4，Tire(轮胎)类
public class Tire {
private int size = 17;
public Tire(int size){
this.size = size;
}
public void init(){
System.out.println("do tire >> size = " + size);
}
}
5，Test(测试)类
public class Test {
public static void main(String[] args) {
Car car = new Car(20);
car.init();
}
}
6，测试运行结果
根据上述修改后的代码不难看出，传统式程序开发存在的问题是：当最底层类改动之后，整个调用链上的所有代码都需要经过修改。
而控制反转式程序开发就可以很好地解决上述这个问题，⽆论底层类如何改动和变化，整个调用链是不用做任何改变的。
4）开发方式对比总结
传统式程序开发中的对象创建顺序是：Car -> Framework -> Bottom -> Tire
控制反转式程序开发中的对象创建顺序是：Tire -> Bottom -> Framework -> Car
两种方式的对比效果图：
从上面的对比中，不难看出：程序开发的实现代码，类的创建顺序是相反的。
传统式程序开发的实现代码是 Car 控制并创建了Framework，Framework 创建并创建了 Bottom，依次往下。
而控制反转式程序开发的控制权发生了反转，不再是上级对象创建并控制下级对象，而是把下级对象注⼊当前对象中，这时下级的控制权不再由上级类控制。这样无论下级类发⽣何种改变，当前类都是不受影响的，这就是典型的控制反转，也就是 IoC 的实现思想。
5）IoC归纳总结
从上面这个示例中，我们知道了什么是控制反转，以及其的实现思想。
IoC是一种思想，而不是一种技术，它的实现思想是将下级对象通过传递的方式注入到当前类当中，从而实现控制权的反转。
IoC这种思想实现了解耦合的功能，减少模块之间的依赖性，提高程序的独立性，极大地降低了程序代码的维护和调试难度。
耦合性也可被称为程序相关性，一个好的程序代码的耦合性（代码之间的相关性）是很低的，也就是说程序之间的依赖性比较弱。
IoC控制反转的深层理解：
在传统式程序开发中，我们直接在对象内部通过new方式进行创建对象，是程序主动创建并直接获取依赖对象，对象是主动地接收依赖对象，这也就是正转。
而在控制反转式程序开发中，IoC是有专门一个容器来创建并存储这些对象，也就是使用Ioc容器来控制对象的创建存储，并且帮我们查找和注入依赖对象，对象是被动的接受依赖对象，这也就是反转。
2，Spring IoC 的理解
理解清楚了什么是容器？以及什么是IoC？这两个问题，那接下来我们就接着往下讲讲如何理解Spring是一个IoC容器这句话呢？
IoC容器具备的最基本的两个功能为：将对象存储到容器中，从容器中取出对象。
也就是说学 Spring 最核心的功能，就是学如何将对象存入到 Spring 中，再从 Spring 中获取对象的过程。
IoC是通过IoC容器把对象的创建和调用过程交给Spring进行管理，省去了使用 “new 类名” 的方式创建对象的步骤。
归纳：Spring 是⼀个 IoC 容器，说的是对象的创建和销毁的权利都交给 Spring 来管理了，它本身又具备了存储对象和获取对象的能力。
归纳：控制反转式程序开发和传统式程序开发的区别：
控制反转式程序开发是将以后操作可能使用到的所有工具类创建好并存储到IoC容器中，需要的时候直接从IoC容器中获取，使用完后放回到IoC容器中；而传统式程序开发是在每次需要的时候直接创建并使用，使用完后直接舍弃不进行保存，下次使用时需重新创建和调用。
由此可归纳出Spring IoC 的优点：
- 解耦合，减少类与类之间的依赖性，提高程序的独立性，降低了程序代码的维护难度。
- 使用更加方便，不需要再手动创建对象，也不需要关注这个对象背后的依赖关系。
- 效率更加高效，需要使用时直接从IoC容器中获取，使用后放回IoC容器，不需要每次使用时都重新创建。
3，DI 是什么？
DI 是Dependency Injection的缩写，翻译成中文是依赖注入的意思。
所谓依赖注入，就是 IoC 容器在运行期间，动态地将某种依赖关系注入到对象之中的行为。
依赖注入（DI）和控制反转（IoC）是从不同的角度来描述同⼀件事情。
而这件事情就是指通过引入 IoC 容器，利用依赖关系注入的方式，实现对象之间的解耦。
loC是一种思想目标，属于指导原则，要想实现该思想目标，最终还是要有可行的落地方案，而DI就属于具体的实现方式。
核心总结
1，Spring 是什么？如何理解 Spring？
解答：Spring是个流行的框架，用一句话概括Spring，Spring是包含众多方法工具的IoC容器。他有两大功能：将对象存储到容器中以及从容器中获取对象。
2，IoC 和 DI 是啥？有什么区别？
解答：IoC是Inversion of Control的缩写，译为控制反转，DI是Dependency Injection的缩写，译为依赖注入，两者是从不同的角度来描述同⼀件事情。两者区别为IoC是一种思想，而DI是IoC的一种具体实现，是动态将某种依赖注入到对象的行为。
3，Spring 最核心的功能是啥？
解答：Spring最核心的部分是IoC容器， 学Spring最核心的功能，就是学如何将对象存入到 Spring 中，再从 Spring 中获取对象的过程。
结语
这就是本期博客的全部内容啦！如果有什么其他的问题无法自己解决，可以在评论区留言哦！
最后，如果你觉得这篇文章写的还不错的话或者有所收获的话，麻烦小伙伴们动动你们的小手，给个三连呗（点赞👍，评论✍，收藏📖），多多支持一下！各位的支持是我最大的动力，后期不断更新优质的内容来帮助大家，一起进步。那我们下期见！文章来源：https://www.toymoban.com/news/detail-541004.html
文章来源地址https://www.toymoban.com/news/detail-541004.html
到了这里，关于【JavaEE进阶】Spring核心与设计思想的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
