【IoC】【DI】一文全知道！

Spring

Spring是包含了众多方法的IoC容器

什么是IoC？

IoC的意思是控制反转 (Inversion Of Control)
通常我们得到对象是通过new的方式，而IoC是把对象的创建和对象的依赖关系交给Spring容器或各种框架
可以说IoC是一个把对象控制权交出去的思想
举例说明，造车时需要车身，车身需要底盘，底盘需要轮胎，就构成了这样一种依赖关系

而IoC的思想是不用new，是通过把对象控制权交出去的方式来造车

是被动地进行接收从控制对象的地方过来的对象

通过new的方式来造车

//在轮胎类中存储车的信息
//颜色、轮胎尺寸、选装内容
public class Tire {
    private int size = 17;

    public Tire(int size) {
        this.size = size;
    }

    public void init() {
        System.out.println("size -> " + size);
    }
}

//因为是通过new的方式，只要Tire类中添加了成员属性
//就要把Bottom类中的构造方法更改
public class Bottom {
    private Tire tire;

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

    public void init() {
        System.out.println("do bottom");
        tire.init();
    }
}

public class Framework {
    private Bottom bottom;

    public Framework(int size) {
        bottom = new Bottom(size);
    }

    public void init() {
        System.out.println("do framework");
        bottom.init();
    }
}

public class Car {
    private Framework framework;

    public Car(int size) {
        framework = new Framework(size);
    }

    public void init() {
        System.out.println("do car");
        framework.init();
    }

    public static void main(String[] args) {
        Car car = new Car(20);
        car.init();
    }
}

通过IoC思想来造车

//在轮胎类中存储车的信息
//颜色、轮胎尺寸、选装内容
public class Tire {
    private int size = 17;
    private String color = "红色";

    public Tire(int size, String color) {
        this.size = size;
    }

    public void init() {
        System.out.println("size -> " + size + " | color -> " + color);
    }
}
// 因为是从控制对象的地方来被动传入对象
//所以不需要更改依赖关系中的任何信息
public class Bottom {
    private Tire tire;

    public Bottom(Tire tire) {
        this.tire = tire;
    }

    public void init() {
        System.out.println("do bottom...");
        tire.init();
    }
}
public class Framework {
    private Bottom bottom;

    public Framework(Bottom bottom) {
        this.bottom = bottom;
    }

    public void init() {
        System.out.println("do framework...");
        bottom.init();
    }
}
public class Car {
    private Framework framework;

    public Car(Framework framework) {
        this.framework = framework;
//        framework = new Framework();
    }

    public void init() {
        System.out.println("do car...");
        framework.init();
    }
}
// 在测试类中
// 只需要创建依赖的类就行
public class Test {
    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.init();
    }
}

什么是Spring IoC？

Spring IoC是Spring框架中的一部分，它实现了IOC思想，通过容器管理和控制对象的创建和依赖关系，提供了代码解耦和灵活性。

什么是DI？

DI是依赖注入(Dependency Injection),是IoC思想的一种具体实现的技术

想通过B得到A（通过创建一个B的对象，并将其赋值给A）有三种方法，如上图

1. 通过A=new B（）的方式
2. 通过从spring容器中被动获得类对象
3. 通过主动地依赖注入的方式来获得对象A

下面来讲怎么样是依赖注入（DI）.
把依赖的某个对象注入到当前类中的这个行为就叫做依赖注入

就是这样 添加@AutoWired注解，动态地将Tire从Spring中获取到的方式就叫作依赖注入