什么是IoC？什么是Spring IoC?什么是DI？

首先说明 IoC 是一种思想，IoC的全称是Inversion of Control，翻译成中文叫做**"控制反转"**

用人话来说，IoC的思想就是将一个对象对另一个对象的控制权交出去（不必关心交给谁），从而让对象之间的依赖关系降低，降低代码之间耦合程度。

我们可以写一个简单的代码来举个例子

假如说我们现在要"造一台车"，那么我们首先需要一个车框架

java 复制代码

public class Car {
    FrameWork frameWork;

    public Car(){
        frameWork.init();
    }
}

那么造好了车框架，我们需要在车框架上面安装一个底盘

java 复制代码

public class FrameWork {
    Bottom bottom;

    public FrameWork(){
        bottom = new Bottom();
        bottom.init();
    }

    public void init(){
        System.out.println("i am framework......");
    }
}

那么造好了底盘，我们需要在底盘合适的位置安装好轮胎

java 复制代码

public class Bottom {
    Tire tire;
    
    public Bottom(){
        tire = new Tire();
        tire.init();
    }
    
    public void init(){
        System.out.println("i am framework......");
    }
}

最后我们需要把轮胎造好，那么这辆车就拼装完成了

java 复制代码

public class Tire {
    public void init(){
        System.out.println("i am tire......");
    }
}

假设我们有一天想要一辆定制的车，比如我想要一辆轮胎是17寸大小的车，那么我就需要传递参数将代码进行修改

java 复制代码

//轮胎
public class Tire {
    
    int size;
    
    public Tire(int size){
        this.size = size;
    }
    
    public void init(){
        System.out.println("i am " + size + "tire......");
    }
}

//底盘
public class Bottom {
    Tire tire;

    public Bottom(int size){
        tire = new Tire(size);
        tire.init();
    }

    public void init(){
        System.out.println("i am framework......");
    }
}

//框架
public class FrameWork {
    Bottom bottom;

    public FrameWork(int size){
        bottom = new Bottom(size);
        bottom.init();
    }

    public void init(){
        System.out.println("i am framework......");
    }
}

//车
public class Car {
    FrameWork frameWork;

    public Car(int size){
        frameWork = new FrameWork(size);
        frameWork.init();
    }
}

可以看到，我们需要层层向上，不断地修改代码来传递参数，从而达到"定制化的过程"

那么如果我们使用IoC的思想来实现这个"车"，代码应该就是这样的

java 复制代码

    public class FrameWork {
        public FrameWork(Bottom bottom){
            bottom.init();
        }
        public void init(){
            System.out.println("i am framework......");
        }
    }

    public class Bottom {
        public Bottom(Tire tire){
            tire.init();
        }

        public void init(){
            System.out.println("i am bottom......");
        }
    }

    public class FrameWork {
        public FrameWork(Bottom bottom){
            bottom.init();
        }
        public void init(){
            System.out.println("i am framework......");
        }
    }    


    public class Car {
        public Car(FrameWork frameWork){
            frameWork.init();
        }
    }

    public static void main(String[] args) {
        Tire tire = new Tire(17);
        Bottom bottom = new Bottom(tire);
        FrameWork frameWork = new FrameWork(bottom);
        Car car = new Car(frameWork);
    }

我们使用IoC的思想来写代码可以发现，当我们对Tire这个类进行修改的时候，只需要在创建Tire的时候传入参数就可以完成修改了，并不需要再像以前一样层层递归的修改代码。

通过IoC的思想我们让代码的耦合程度降低，让代码更加的灵活，让程序更加的简单了

说完了IoC,那么就来谈谈什么是Spring IoC

Spring IoC就是实现了具体IoC思想的框架，在这个Spring框架中存在一个IoC容器，通过这个容器我们可以存对象，也可以取对象。等同于说我们将对象的创建与销毁都交给了IoC容器来进行管理，同时在这个容器中既可以存对象也可以取对象！

那么什么是DI呢？DI全称"Dependency Injection"，翻译成中文是依赖注入

DI实际上就是对IoC思想的具体实现方式，我们通过依赖注入的方法，从Spring容器中取出对象，注入到对象中去！由于Spring IoC容器的存在，我们在存储对象的时候就将依赖关系交给Spring IoC容器来进行托管了，当我们创建对象并使用注入的方式，就可以自动的将该对象所依赖的对象注入到该对象中。这就是DI，实现了具体的IoC思想的行为！

举个例子

在传统的编程方式中，当类A依赖于类B时，我们通常会在创建A的实例时，手动创建B的实例并将其传递给A的构造函数或者通过其他方式设置依赖关系。这样的做法在小规模项目中可能没有问题，但随着项目规模的增大，依赖关系的管理将变得复杂而且容易出错。

而在DI（依赖注入）中，Spring IoC容器会负责管理所有的bean对象的创建和依赖关系。当创建A的实例时，Spring IoC容器会自动检查A所依赖的B是否已经在容器中创建，并将B的实例自动注入到A中，无需手动介入。

这种方式的好处在于：

解耦：类A不需要关心B是如何创建的，也不需要负责B的生命周期管理。
灵活性：如果需要更换B的实现，只需在配置文件中修改B的配置即可，而不需要修改A的代码。
可测试性：在测试时，可以轻松地将虚拟的B实例注入到A中，以便进行单元测试。

总之，DI通过将对象之间的依赖关系交由IoC容器来管理，使得代码更加清晰、易于维护，同时也提高了项目的灵活性和可测试性。

我们再以厨师做菜为例子

DI的过程如下：

厨子需要准备一道菜，而这道菜需要食材。
厨子并不直接去寻找或创建食材，而是通过向食材供应商（想象成IoC容器）请求所需的食材。
食材供应商根据厨子的请求，提供相应的食材，即便如此，食材的获取和管理都是由食材供应商来完成。
厨子接收到食材后，根据食谱，进行烹饪并最终完成了一道美味的菜品。

这个例子中，厨子（我们）就是应用程序的主体，而食材供应商（DI容器，如Spring IoC容器）则负责管理和提供依赖（食材）。厨子无需关心如何获取食材（依赖），只需要向供应商（容器）说明需要什么依赖，供应商会将所需的依赖注入到厨子中。

这就是为什么DI是实现了具体IoC思想的行为，因为我们的主体不再控制依赖了，而是通过注入的方式来实现依赖！