什么是IoC？什么是Spring IoC?什么是DI？-Toy模板网

这篇具有很好参考价值的文章主要介绍了什么是IoC？什么是Spring IoC?什么是DI？。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

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

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

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

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

public class Car {
    FrameWork frameWork;

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

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

public class FrameWork {
    Bottom bottom;

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

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

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

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

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

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

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

//轮胎
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的思想来实现这个“车”，代码应该就是这样的

    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中，无需手动介入。

这种方式的好处在于：