为什么学习SpringSpring框架核心与设计思想（IOC与DI）？

川长思鸟来 2024-03-17 23:32 86阅读 0赞

![b77edba31ac041edba7a8a167ba52bca.gif][]

>  *  **博主简介：想进大厂的打工人**
>  *  **博主主页：**[@xyk:][xyk]
>  *  **所属专栏: [JavaEE进阶][JavaEE]**

##  ##

--------------------

**目录**

文章目录

一、Spring是什么？

二、为什么要学习框架？

三、Spring核心概念

3.1 什么是容器？

3.2 什么是IOC？

四、再谈Spring中的 IOC

五、理解Spring中的 DI

--------------------

## **一、Spring是什么？** ##

Spring 框架是一个用于构建企业级 Java 应用程序的开源框架—指的是Spring Framework（Spring 框架）。它提供了一种综合性的编程和配置模型，用于开发灵活、可扩展、可维护的应用程序。Spring 框架提供了许多功能和特性，帮助开发人员快速构建企业应用程序。

具体来说，Spring可以看作一个包含众多工具方法的IOC容器，Spring的出现就是让开发更简单。

那么，什么是IOC？什么又是容器？下面我们来逐渐讲解~

## 二、为什么要学习框架？ ##

因为学习框架相当于从“小作坊”到“工厂”的升级，小作坊什么都要自己做，工厂是组件式装配，特点就是高效。

框架更加易⽤、简单且高效。

之前我们使用的Servlet有以下缺点：

1.  添加外部 jar 不⽅便，容易出错，比如添加了⼀个不匹配的外部 jar 版本。
2.  运行和调试的时候需要配置 Tomcat 不⽅便。
3.  发布不方便，Servlet 项目必须依靠外置的 Tomcat（外置的 Web 容器）运行。
4.  路由配置不方便，⼀个访问地址对应⼀个 Servlet 类。
5.  …

而Spring Boot 对比 Servlet 的优点：

1.  快速添加外部 jar 包。
2.  调试项目更方便，无需配置 Tomcat，点击“运行”按钮就可以直接运行项目，因为 Spring Boot 内置了 Tomcat 容器可直接运行。
3.  发布项目更加方便，无需配置 Tomcat，使用 java -jar xxx.jar 的方式就可以发布。
4.  对象自动装配。
5.  添加路由更加方便，无需每个访问地址都添加⼀个类。
6.  …

Spring框架基本学习应用路线：Spring全家桶 -> MyBatis -> Redis ...等。

## 三、Spring核心概念 ##

### 3.1 什么是容器？ ###

通俗来理解，容器就是装某种东西的器件。

在Java开发中，容器通常是指Web容器或IOC容器。Web容器是一种用于运行Web应用程序的容器，例如Tomcat、Jetty等。IoC容器是一种反转控制容器，例如Spring框架的Bean容器，它管理了应用程序中的对象，并负责注入对象之间的依赖关系。

### 3.2 什么是IOC？ ###

IOC = Inversion of Control 翻译成中⽂是“控制反转”的意思。这是一种思想，在java的常规代码中，我们需要程序猿自己进行 new 对象来控制生命周期，而控制反转就是将对象的生命周期交给Spring来控制，不再根据程序猿来创建对象。

说到这里，有些人可能不理解，下面来举个例子：

假如，我们现在构建⼀辆“汽⻋”的程序，要有车身、底盘、轮胎等  
![89fbc0e636c248b2be2442752ae1bfa1.png][]

**传统思想的代码实现：**

package old;
    
    /**
     * 传统开发方式, 耦合性问题
     */
    // 汽车类
    public class Car {
        // 车身
        private Framework framework;
    
        public Car() {
            framework = new Framework();
        }
    
        public void init() {
            System.out.println("do car");
            // 汽车的组建依赖于车身
            framework.init();
        }
    }
    
    package old;
    
    // 车身类
    public class Framework {
        private Bottom bottom;
    
        public Framework() {
            bottom = new Bottom();
        }
    
        public void init() {
            System.out.println("do framework");
            // 车身的组建依赖于底盘
            bottom.init();
        }
    }
    
    package old;
    
    // 底盘类
    public class Bottom {
        private Tire tire;
    
        public Bottom() {
            tire = new Tire();
        }
    
        public void init() {
            System.out.println("do bottom");
            // 底盘的组建依赖于轮胎
            tire.init();
        }
    }
    
    package old;
    
    // 轮胎类
    public class Tire {
        private int size = 20;
    
        public void init() {
            System.out.println("size -> " + size);
        }
    }
    
    package old;
    
    public class Test {
        public static void main(String[] args) {
            Car car = new Car();
            car.init();
        }
    }

![f9b919ebe15c42d5ae542878bd16c4f1.png][]

此时，如果我们需要定制个性化的轮胎，就需要改动Tire类的构造方法，进行传入颜色，大小等。但是问题就来了，一旦修改了最底层的Tire，上面所有互相依赖的类，都需要修改构造方法，进行传参。牵一发而动全身！这就是最大的问题！！

![429feb10a8c14a3db451b3b1349d1339.png][]

**在传统的编程模式中，程序猿则需要手动创建对象，并负责它们之间的依赖关系。** 而在IOC的编程模式中，程序员只需要定义好对象及其依赖关系的配置，IOC容器则根据这些配置来自动创建和管理对象。通过 IOC编程思想，我们可以很好的解决上述问题。

> **那么，使用IOC思想的代码：**
> 
> 尝试不在每个类中⾃⼰创建下级类，我们只需要将原来由⾃⼰创建的下级类，改为传递的⽅式（也就是注⼊的⽅式），所以下级类即使发⽣变化（创建或减少参数），当前类本身也⽆需修改任何代码。
> 
> ![41ab716f8b4447fdba5cbfac047dda99.png][]

public class Car {
        private Framework framework;
    
        public Car(Framework framework) {
            this.framework = framework;
        }
    
        public void init() {
            System.out.println("执行 Car");
            // 依赖车身
            framework.init();
        }
    }
    
    public class Framework {
        private Bottom bottom;
    
        public Framework(Bottom bottom) {
            this.bottom = bottom;
        }
    
        public void init() {
            System.out.println("执行 Framework");
            // 依赖底盘
            bottom.init();
        }
    }
    
    
    public class Bottom {
        private Tire tire;
    
        public Bottom(Tire tire) {
            this.tire = tire;
        }
    
        public void init() {
            System.out.println("执行 Bottom");
            // 依赖轮胎
            tire.init();
        }
    }
    
    public class Tire {
        private int size = 20;
        private String color;
    
        public Tire(int size, String color) {
            this.size = size;
            this.color = color;
        }
    
        public void init() {
            System.out.println("轮胎——size：" + size +
                    " | color：" + color);
        }
    }
    
    
    public class App {
        public static void main(String[] args) {
            Tire tire = new Tire(30, "粉色");
            Bottom bottom = new Bottom(tire);
            Framework framework = new Framework(bottom);
            Car car = new Car(framework);
            car.init();
        }
    }

![73fa705d57dd4ca3bfb697334ebeae35.png][]

> 代码经过调整，无论底层如何变化，怎么个性化定制，都不会影响上层，整个调用链都不需要改变，这样就完成了代码之间的解耦合。

**同时，我们也能发现一些规律：** 改进之后的控制权发⽣的反转，**不再是上级对象创建并控制下级对象了，⽽是下级对象把注⼊将当前对象中，下级的控制权不再由上级类控制了，** 这样即使下级类发⽣任何改变，当前类都是不受影响的，这就是典型的控制反转，也就是 IOC 的实现思想。

## 四、再谈Spring中的 IOC ##

那么如何理解”Spring 是一个IOC容器"这句话呢？

既然 Spring 是⼀个 IoC（控制反转）容器，重点还在“容器”⼆字上，那么它就具备两个最基础的功  
能：

*  将Bean对象存⼊到容器；
 *  从容器中取出Bean对象。

也就是说学 Spring 最核⼼的功能，就是学如何将对象存⼊到 Spring 中，再从 Spring 中获取对象的过程。即Spring IOC容器就像一个仓库，需要使用的时候直接取，不使用的时候再放回仓库，而此时，对象的创建和销毁的权利都交给 Spring 来管理了。

## 五、理解Spring中的 DI ##

Spring的依赖注入（Dependency Injection，DI）是指在应用程序运行过程中，由Spring容器负责创建和管理对象，并将对象之间的依赖关系注入给它们。简单来说：所谓依赖注入，就是由 IoC 容器 在运行期间，动态地将某种依赖关系注入到对象中。DI 也是 IoC思想实现的一种方式~

> ⽐如说我今天⼼情⽐较好，吃⼀顿好的犒劳犒劳⾃⼰，那么“吃⼀顿好的”是**思想**和⽬标（是 **IoC**），但最后我是吃海底捞还是杨国福？**这就是具体的实现，就是 （DI）**

在Spring中，对象之间的依赖关系分为两种：构造器注入和属性注入。在构造器注入中，Spring容器会通过构造方法来完成对对象的依赖注入。而在属性注入中，Spring容器则会通过setter方法或者直接设置对象的属性来完成依赖注入。

![09bb8551e737497bbe2c22c2a8152553.gif][]

[b77edba31ac041edba7a8a167ba52bca.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/85f1286fcfac435393e4c22a0915e81d.png
[xyk]: https://blog.csdn.net/asad21654864?spm=1000.2115.3001.5343
[JavaEE]: http://t.csdn.cn/SpyLE
[89fbc0e636c248b2be2442752ae1bfa1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/ed838c4189d54c1aae4143986f1a4e32.png
[f9b919ebe15c42d5ae542878bd16c4f1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/ef12e07f6a33484887b27ae4721ec714.png
[429feb10a8c14a3db451b3b1349d1339.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/adc216428c284b73838816e27d3017b1.png
[41ab716f8b4447fdba5cbfac047dda99.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/0323e90c17564a11bc33ac278401394c.png
[73fa705d57dd4ca3bfb697334ebeae35.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/9db19c309a2e45b09ec69297a228d9b4.png
[09bb8551e737497bbe2c22c2a8152553.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/bd24bffabfcc4ca886ff1e4744fe5eb2.png