Spring学习第2篇：IoC控制反转与 DI依赖注入

朴灿烈づ我的快乐病毒、 2024-04-01 13:22 62阅读 0赞

> 大家家好，我是一名网络怪咖，北漂五年。相信大家和我一样，都有一个大厂梦，作为一名资深Java选手，深知Spring重要性，现在普遍都使用SpringBoot来开发，面试的时候SpringBoot原理也是经常会问到，SpringBoot是为了简化Spring开发，但是底层仍然是Spring。如果不了解Spring源码，那就更别提SpringBoot源码了，接下来我准备用两个月时间，从基础到源码彻彻底底的学习一遍Spring。  
>   
> 学习框架一定要踏踏实实一步一个脚印的学，很多人都比较喜欢急功近利，选择跳着学，包括我有时候也是，最终会发现你不但节约不了时间，反而会更耗时，而且学着学着很容易放弃。

### 一、通过案例来引出IOC ###

有2个类，TestService 和 TestController，如下：

public class TestService {
        
    
        public void method1() {
        
            // 业务省略...
        }
        
    	public void method2() {
        
            // 业务省略...
        }
    }

业务需求：`TestController`的`method1`方法需要调用`testService`的`method1`方法，method2也需要调用`testService`的`method2`方法。

public class TestController {
        
    
        private TestService testService;
    
        public void method1(){
        
            testService.method1();
        }
    
    	public void method2(){
        
            testService.method2();
        }
    }

> 依赖注入当中的依赖指的是：TestController当中需要通过`TestService`来完成某些操作，这就叫`TestController`依赖于`TestService`。

上面的`TestController`其实是存在一个问题的，`testService`并没有赋值，我们要给成员变量赋值只有两个途径，`构造器赋值`和`set方法赋值`。那也就意味着创建`TestController`对象之前，需要先将被依赖对象通过`new`的方式创建好，然后将其传递给`TestController`，这些工作都是`TestController`的使用者自己去做的，所有对象的创建都是由使用者自己去控制的。

**`注：实际上使用反射也可以给属性赋值的，当然实际开发当中很少会这么用。`**

public class TestController {
        
    
        private TestService testService;
    
        public void method1(){
        
            testService.method1();
        }
    	
    	public void method2(){
        
            testService.method2();
        }
    
        // 构造器赋值
        public TestController(TestService testService) {
        
            this.testService = testService;
        }
    
        // set方法赋值
        public void setTestService(TestService testService) {
        
            this.testService = testService;
        }
    }

上面示例`TestController` 只是依赖了一个对象，假如他依赖了很多对象，如果用构造器赋值岂不是要写一大堆参数，如果要是用`set`岂不是创建完之后得访问一堆`set`方法来赋值呢。显然代码量也比较大，代码耦合度比较高（依赖有调整，改动也比较大），也不利于扩展。

可能有的人该说了，我可以直接new呀，要知道每次new对象之后，都要开辟新的内存空间。假如高并发下，内存很容易扛不住而OOM（内存溢出）。假如TestService 是个接口，那么就必须new一个TestService 的实现类，一旦写死了实现类，假如TestController 想要调用别的实现类呢，这就不符合面向对象当中的`多态`，并且代码耦合度较高。

public class TestController {
        
    
        private TestService testService = new TestService();
    
        public void method1(){
        
            testService.method1();
        }
    
        public void method2(){
        
            testService.method2();
        }
    }

我们应该尽量避免这种代码耦合，在实际开发中我们可以把三层（controller、service、dao）的对象都使用配置文件配置起来，当启动服务器应用加载的时候，让一个类中的方法通过读取配置文件，把这些对象创建出来并存起来。在接下来的使用的时候，直接拿过来用就好了。那么，这个读取配置文件，创建和获取三层对象的类就是工厂。

**现在有两个问题需要考虑：**

1、存哪去？

分析：由于我们是很多对象，肯定要找个集合来存。这时候有 Map 和 List 供选择。到底选 Map 还是 List 就看我们有没有查找需求。有查找需求，选 Map。所以我们的答案就是在应用加载时，创建一个 Map，用于存放三层对象。我们把这个 map 称之为容器

2、还是没解释什么是工厂？

这里的工厂就是对象工厂，主要负责创建对象，以及帮助我们获取指定的对象。

这时候我们获取对象的方式发生了改变。原来我们在获取对象时，都是采用 new 的方式。是主动的。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjEwMTgzOQ_size_16_color_FFFFFF_t_70][]

现在：我们获取对象时，同时跟工厂要，有工厂为我们查找或者创建对象。是被动的。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjEwMTgzOQ_size_16_color_FFFFFF_t_70 1][]

**难道我们还要自己实现工厂吗，其实不用，spring就是一个工厂**

> 上面`TestController`对象以及`TestController`依赖的对象都是使用者自己主动去控制其创建的，能不能找一个第三方来把这个事情给做了，比如给第三方一个清单，清单中告诉第三方我需要用到`TestController`对象以及`TestController`需要依赖的对象，然后由这个第三方去负责创建和组装`TestController`对象，使用者需要使用`TestController`对象的时候，只需要向第三方发起一个查找，如果第三方那边有`TestController`对象，直接将其内部组装好的`TestController`对象返回就可以了，整个系统中所有需要用到的对象都可以列个清单，让第三方帮忙创造，用的时候只需要向第三方索取就可以了，当`TestController`中依赖的对象有新增或者删除的时候，只需要去调整一下清单就可以了，这些事情spring已经帮我们实现了。

### 二、概述 ###

**spring容器**

> 容器这个名字起的相当好，容器可以放很多东西，我们的程序启动的时候会创建spring容器，会给`spring`容器一个清单，`清单中列出了需要创建的对象以及对象依赖关系`，`spring`容器会创建和组装好清单中的对象，然后将这些对象`存放在spring容器中`，当程序中需要使用的时候，可以到容器中查找获取，然后直接使用。`spring容器`其实可以把他当做就是一个`map`，key值用来存储对象的名称，value值用来存储对象本身。

**控制反转（IoC）**

> 使用者使用`TestController`对象的时候都需要自己去创建和组装，而现在这些创建和组装都交给`TestController`容器去给完成了，使用者只需要去`spring`容器中查找需要使用的对象就可以了；`这个过程中B对象的创建和组装过程被反转了，之前是使用者自己主动去控制的，现在交给spring容器去创建和组装了，对象的构建过程被反转了，所以叫做控制反转`；IOC是是面相对象编程中的一种设计原则，主要是为了降低系统代码的耦合度，让系统利于维护和扩展。

**依赖注入（DI）**

*  依赖注入是`spring`容器中创建对象时给其设置依赖对象的方式，
 *  比如给`spring`一个清单，清单中列出了需要创建`TestController`对象以及其他的一些对象（可能包含了`TestController`类型中需要依赖对象）。
 *  此时`spring`在创建`TestController`对象的时候，会看`TestController`对象需要依赖于哪些对象，然后去查找一下清单中有没有包含这些被依赖的对象，如果有就将其创建好，然后传递给`TestController`对象；
 *  可能`TestController`需要依赖于很多对象，`TestController`创建之前完全不需要知道其他对象是否存在或者其他对象在哪里以及他们是如何创建，而spring容器会将`TestController`依赖对象主动创建好并将其注入到`TestController`中去。
 *  比如spring容器创建`TestController`的时候，发现`TestController`需要依赖于`TestService`，那么spring容器在清单中找到`TestService`的定义并将其创建好之后，注入到`TestController`对象中。

**总结**

1.  `IOC`控制反转，是一种设计理念，并不是实际存在的东西，将对象创建和组装的主动控制权利交给了`spring`容器去做，控制的动作被反转了，降低了系统的耦合度，利于系统维护和扩展，主要就是指需要使用的对象的组装控制权被反转了，之前是自己要做的，现在交给`spring`容器做了。
2.  DI依赖注入，表示spring容器中创建对象时`给其设置依赖对象的方式`，通过某些注入方式可以让系统更灵活，比如`@Autowired`自动注入等可以让系统变的很灵活，说的直白一点，`就是由框架来给成员变量自动赋值`。而并不需要我们人为的去干涉。我们只需要告诉`spring`他以哪种方式来依赖注入即可，这个后面的文章会细说。
3.  spring容器：主要负责容器中对象的创建、组装、对象查找、对象生命周期的管理等等操作。

> **`官网叙述：控制反转loC（Inversion of Control）也称为依赖注入(DI)。`**

**下一篇开始详细讲解spring的使用了！**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjEwMTgzOQ_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/bc95de1d9b444836808c7c4ec8efce07.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjEwMTgzOQ_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/4a0ec043d5ae425db2a2a2048899b4b9.png