【JavaEE】Spring + IoC + DI

目录

Spring概念

IoC

DI

---

Spring概念

Spring是包含众多工具方法的IoC容器。

IoC

IoC：Inversion of Control 控制权反转

        它是一种思想，是面向对象的一种设计原则。这种思想为了实现类与类之间的解耦。

        比如当一个对象要使用另一个对象时，不再需要创建出来，而是直接从其他地方拿就              行。

Spring IoC：

    是Spring框架的核心功能之一。它是一种设计模式，把对象的创建和管理的控制权反转给      容器。

        核心操作：存对象，取对象

        优点：解耦

                   使用方便，不再需要手动创建了，而是直接使用即可。

                   更加高效。

Spring IoC是IoC思想中的具体实现，

通过以下的代码来理解IoC： 

当前我们想简单的实现一辆车：由车身、底盘和轮胎组成。其中车身依赖底盘，底盘依赖轮胎。

// 车
public class Car {
    // 车身
    private Body body;

    public Car() {
        body = new Body();
    }
    public void init() {
        System.out.println("车身造好了！");
        body.init();
    }
}

// 车身
public class Body {
    // 底盘
    private Bottom bottom;
    public Body() {
        bottom = new Bottom();
    }

    public void init() {
        System.out.println("底盘造好了！");
        bottom.init();
    }
}

// 底盘
public class Bottom {
    // 轮胎
    private Wheel wheel;

    public Bottom() {
        wheel = new Wheel();
    }
    
    public void init() {
        System.out.println("轮胎造好了！");
        wheel.init();
    }
}

// 轮子
public class Wheel {
    // 轮子大小统一为 15寸
    private int size = 15;

    public void init() {
        System.out.println("size : " + this.size);
    }
}

// 测试车
public class TestCar {
    public static void main(String[] args) {
        Car car = new Car();
        car.init();
    }
}

当轮胎尺寸大小固定不变的时候，这个代码正常运行。但是当要改变轮胎大小的时候，此时就会出现一个麻烦的事情：当轮胎变了，依赖轮胎的底盘要变，依赖底盘的车身要变，从而导致从下到上都要改动。修改部分代码如下：

由于每个类之间都是层层依赖的关系，并且都是本类创建出所需的类，然后使用。这就导致了，所有的代码都要大改动。而有了IoC的思想后，每个类对于所要使用的类，仅仅停留在使用阶段，不需要自己创建，直接从拿到注入给所需的类即可。修改代码如下：

// 轮子
public class Wheel {
    private int size = 15;

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

    public void init() {
        System.out.println("size : " + this.size);
    }
}

// 底盘
public class Bottom {
    private Wheel wheel;
    
//  这里不是通过new来创建出轮胎，而是直接给底盘使用
//  这里可以看成从Spring容器中直接取(注入)，但这不是Spring代码，可以看成这样的思想
//  后面的代码也都是这样改的
    public Bottom(Wheel wheel) {
        this.wheel = wheel;
    }

    public void init() {
        System.out.println("轮胎造好了！");
        wheel.init();
    }
}

// 车身
public class Body {
    private Bottom bottom;

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

    public void init() {
        System.out.println("底盘造好了！");
        bottom.init();
    }
}

// 车
public class NewCar {
    private Body body;

    public NewCar(Body body) {
        this.body = body;
    }

    public void init() {
        System.out.println("车身造好了！");
        body.init();
    }
}

public class TestNewCar {
    public static void main(String[] args) {
//        这里目前写起来是非常复杂的，如果是Spring项目的话，
//        存储了这些对象后，想拿到是很简单的
        Wheel wheel = new Wheel(18);
        Bottom bottom = new Bottom(wheel);
        Body body = new Body(bottom);
        NewCar newCar = new NewCar(body);
        newCar.init();
    }
}

DI

Dependence Injection  注入依赖

上面提到了IoC，它是一种反转控制权思想，而DI则是它的实现方式。

它从Spring容器中取出已经注册的对象，比如上面的车身、底盘和轮胎，哪个类需要，直接从容器中取出使用即可。

在Spring框架中，DI通过@Autowire注解、构造函数注入、Setter方法注入等方式来实现。其中，@Autowire注解是最常用的方式，它可以自动装配对象，并且可以根据类型、名称、注解等条件进行注入。

---

有什么错误评论区指出。希望可以帮到你。