🧸欢迎来到dream_ready的博客，📜相信您对这几篇博客也感兴趣o (ˉ▽ˉ；)

📜什么是SpringMVC？简单好理解！什么是应用分层？SpringMVC与应用分层的关系？ 什么是三层架构？SpringMVC与三层架构的关系？

📜SpringIOC和DI的代码实现，Spring如何存取对象？@Controller、@Service、@Repository、@Component、@Configuration、@Bean DI详解

📜Spring，SpringBoot和SpringMVC的关系以及区别 —— 超准确，可当面试题！！！也可供零基础学习-CSDN博客

🧸第二篇博客是该篇博客的下一篇哦，欢迎各位看官老爷阅读！

---

目录

1、什么是众多工具？

2、什么是容器？

3、什么是IOC？

4、IoC代码案例介绍

传统程序开发 —— 实现思路：

软件设计原则：高内聚低耦合

解决方案

IOC程序开发

IoC优势

DI讲解

什么是DI呢

IOC和DI的关系？

---

• 本质上：Spring是一个包含众多工具的IOC容器
• 应用上：它也是一个广泛使用的Java应用程序开发框架，用于构建企业级应用程序。

1、什么是众多工具？

工具"通常指的是Spring框架提供的各种辅助类、库、模块、和功能，这些帮助开发人员更轻松地构建、维护和扩展Java应用程序。这些工具是Spring框架的一部分，用于解决不同方面的开发任务和问题

比如Spring提供的依赖注入、事务管理、数据访问工具等都属于工具的范畴

2、什么是容器？

容器是用来容纳某种物品的(基本)装置

Spring这个容器存取的是对象

生活中的水杯，垃圾桶，冰箱等等这些都是容器

包括在Spring前学习的List/Map是数据存储容器，Tomcat是Web容器

既然Spring是一个IOC(控制反转)容器，作为容器，那么它就具备两个最基本的功能：

• 存
• 取

Spring容器管理的主要是对象，这些对象，我们称之为“Bean”。我们把这些对象交由Spring管理，由Spring来负责对象的创建和销毁，我们程序只需要告诉Spring，哪些需要存，以及如何从Spring中取出对象

3、什么是IOC？

IoC是Spring的核心思想，也是常见的面试题，那什么是IoC呢？

IoC就是控制反转(Inversion of Control) ，也是就说Spring是一个“控制反转”的容器

咱代码中用到的 @Controller、@Service等注解就用了IOC，加上这些注解后，就会把这个对象交给Spring管理，Spring框架启动时就会加载该类

把对象交给Spring管理，这就是IoC思想

• 什么是控制反转呢？  -  >  就是控制权反转
• 什么的控制权发生了反转？  -  >  获得依赖对象的过程被反转了

也就是说，当需要某个对象时，传统开发模式中需要自己通过 new 创建对象，现在不需要再进行创建，把创建对象的任务交给容器，程序中只需要依赖注入(Dependency Injection,DI)就可以了。

这个容器称为：IOC容器. Spring是一个IoC容器，所以有时Spring也称为Spring容器

控制反转是一种思想，在生活中也是处处体现

        比如自动驾驶，传统驾驶模式，车辆的横向和纵向驾驶控制权由驾驶员来控制，现在交给了驾驶自动化系统来控制，这也是控制反转思想在生活中的实现

        比如招聘，企业的员工招聘，入职，解雇等控制权，由老板转交给HR(人力资源)来处理

4、IoC代码案例介绍

接下来我们通过案例来了解一下什么是IOC

需求：造一辆车

传统程序开发 —— 实现思路：

先设计轮⼦(Tire)，然后根据轮⼦的⼤⼩设计底盘(Bottom)，接着根据底盘设计⻋⾝(Framework)，最 后根据⻋⾝设计好整个汽⻋(Car)。这⾥就出现了⼀个"依赖"关系：汽⻋依赖⻋⾝，⻋⾝依赖底盘，底盘依赖轮⼦

代码如下：

友情提示：尽量自己复制代码线下试一下，此处为了方便讲解将其放到同一个文件下了，你写的时候可以改一下，每一个类单独放一个文件下，不过我的写法也没有错误

public class NewCarExample {
    public static void main(String[] args) {
        Car car = new Car();
        car.run();
    }
    /**
     * 汽⻋对象
     */
    static class Car {
        private Framework framework;

        public Car() {
            framework = new Framework();
            System.out.println("Car init....");
        }
        public void run(){
            System.out.println("Car run...");
        }
    }
    /**
     * ⻋⾝类
     */
    static class Framework {
        private Bottom bottom;
        public Framework() {
            bottom = new Bottom();
            System.out.println("Framework init...");
        }
    }
    /**
     * 底盘类
     */
    static class Bottom {
        private Tire tire;
        public Bottom() {
            this.tire = new Tire();
            System.out.println("Bottom init...");
        }
    }
    /**
     * 轮胎类
     */
    static class Tire {
        // 尺⼨
        private int size;
        public Tire(){
            this.size = 17;
            System.out.println("轮胎尺⼨：" + size);
        }
    }
}

问题分析：

这样的设计看起来没问题，但是可维护性却很低

如果接下来需求有了变更：随着对车的需求量越来越大，个性化需求也会越来越多，我们需要加工多种尺寸的轮胎

那这个时候就要对上面的程序进行修改了，修改后的代码如下:

我们的本意是想着只修改Tire这一个类的代码的，但是我们发现修改之后，其他调用程序也会报错，我们需要继续修改

完整代码如下：

public class NewCarExample {
    public static void main(String[] args) {
        Car car = new Car(20);
        car.run();
    }
    /**
     * 汽⻋对象
     */
    static class Car {
        private Framework framework;
        public Car(int size) {
            framework = new Framework(size);
            System.out.println("Car init....");
        }
        public void run(){
            System.out.println("Car run...");
        }
    }
    /**
     * ⻋⾝类
     */
    static class Framework {
        private Bottom bottom;
        public Framework(int size) {
            bottom = new Bottom(size);
            System.out.println("Framework init...");
        }
    }
    /**
     * 底盘类
     */
    static class Bottom {
        private Tire tire;
        public Bottom(int size) {
            this.tire = new Tire(size);
            System.out.println("Bottom init...");
        }
    }
    /**
     * 轮胎类
     */
    static class Tire {
        // 尺⼨
        private int size;
        public Tire(int size){
            this.size = size;
            System.out.println("轮胎尺⼨：" + size);
        }
    }
}

从以上代码可以看出，以上程序的问题是：当最底层代码改动之后，整个调用链上的所有代码都需要修改

修改一处代码，影响其他处的代码修改，就叫耦合

软件设计原则：高内聚低耦合

高内聚指的是：一个模块中各个元素之间的联系的紧密程度，如果各个元素(语句、程序段)之间的联系程度越高，则内聚性越高，即“高内聚”

低耦合指的是：软件中各个层、模块之间的依赖关联程序越低越好。修改一处代码，其他模块的代码改动越少越好

高内聚低耦合矛盾么？

不矛盾，高内聚指的是一个模块中各个元素之间联系的紧密程度，低耦合指的是各个模块之间的紧密程度

这就好比一个企业，包含很多部门，各个部门之间的关联关系要尽可能的小，一个部门发生问题，要尽可能降低对其他部门的影响，就是低耦合。但是部门内部员工关系要尽量紧密，遇到问题一起解决，克服，这就叫做高内聚

比如邻里邻居，楼上漏水，楼下遭殃，就是耦合。家庭一个成员生病，其他成员帮忙照顾，就叫内聚

一个家庭内部的关系越紧密越好，一个家庭尽可能少的影响另一个家庭，就是低耦合

解决方案

        在上⾯的程序中, 我们是根据轮⼦的尺⼨设计的底盘，轮⼦的尺⼨⼀改，底盘的设计就得修改. 同样因为我们是根据底盘设计的⻋⾝，那么⻋⾝也得改，同理汽⻋设计也得改, 也就是整个设计⼏乎都得改~

        我们尝试换⼀种思路, 我们先设计汽⻋的⼤概样⼦，然后根据汽⻋的样⼦来设计⻋⾝，根据⻋⾝来设计 底盘，最后根据底盘来设计轮⼦. 这时候，依赖关系就倒置过来了：轮⼦依赖底盘， 底盘依赖⻋⾝， ⻋⾝依赖汽⻋

        这就类似我们打造⼀辆完整的汽⻋, 如果所有的配件都是⾃⼰造，那么当客⼾需求发⽣改变的时候， ⽐如轮胎的尺⼨不再是原来的尺⼨了，那我们要⾃⼰动⼿来改了，但如果我们是把轮胎外包出去，那 么即使是轮胎的尺⼨发⽣变变了，我们只需要向代理⼯⼚下订单就⾏了，我们⾃⾝是不需要出⼒的.

如何来实现呢:

        我们可以尝试不在每个类中⾃⼰创建下级类，如果⾃⼰创建下级类就会出现当下级类发⽣改变操作， ⾃⼰也要跟着修改.

        此时，我们只需要将原来由⾃⼰创建的下级类，改为传递的⽅式（也就是注⼊的⽅式），因为我们不 需要在当前类中创建下级类了，所以下级类即使发⽣变化（创建或减少参数），当前类本⾝也⽆需修 改任何代码，这样就完成了程序的解耦.

IOC程序开发

基于以上思路，我们把调⽤汽⻋的程序⽰例改造⼀下，把创建⼦类的⽅式，改为注⼊传递的⽅式. 具体实现代码如下：

public class IocCarExample {
    public static void main(String[] args) {
        Tire tire = new Tire(20);
        Bottom bottom = new Bottom(tire);
        Framework framework = new Framework(bottom);
        Car car = new Car(framework);
        car.run();
    }
    static class Car {
        private Framework framework;
        public Car(Framework framework) {
            this.framework = framework;
            System.out.println("Car init....");
        }
        public void run() {
            System.out.println("Car run...");
        }
    }
    static class Framework {
        private Bottom bottom;
        public Framework(Bottom bottom) {
            this.bottom = bottom;
            System.out.println("Framework init...");
        }
    }
    static class Bottom {
        private Tire tire;
        public Bottom(Tire tire) {
            this.tire = tire;
            System.out.println("Bottom init...");
        }
    }
    static class Tire {
        private int size;
        public Tire(int size) {
            this.size = size;
            System.out.println("轮胎尺⼨：" + size);
        }
    }
}

代码经过以上调整，⽆论底层类如何变化，整个调⽤链是不⽤做任何改变的，这样就完成了代码之间 的解耦，从⽽实现了更加灵活、通⽤的程序设计了。

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呢

DI：依赖注入(Dependency Injection) 

容器在运行期间，动态的为应用程序提供运行时所依赖的资源，称之为依赖注入

程序运行时需要某个资源，此时容器就为其提供这个资源

从这点看，依赖注入(DI)和控制反转(IoC)是从不同的角度来描述同一件事情，就是指通过引入IOC容器，利用依赖关系注入的方式，实现对象之间的解耦

上述代码中，是通过构造函数的方式，把依赖对象注入到需要使用的对象中的

IOC和DI的关系？

        IOC是一种思想，也是“目标”，而思想只是一种指导原则，最终还是要有可行的落地方案，而DI就属于具体的实现。所以也可以说，DI是IOC的一种实现

        比如说我今天心情比较好，吃一顿好的犒劳犒劳自己，那么“吃一顿好的”是思想和目标(是IOC)，但最后我是吃海底捞还是杨国福？这就是具体的实现，就是DI

该篇博客的下一篇博客，无缝衔接：

📜SpringIOC和DI的代码实现，Spring如何存取对象？@Controller、@Service、@Repository、@Component、@Configuration、@Bean DI详解

🧸欢迎您于百忙之中阅读这篇博客，📜希望这篇博客给您带来了一些帮助，祝您生活愉快！