Spring IoC & DI

什么是Spring？

一句话总结来说，就是包含众多工具方法的 IoC 容器。

什么是IoC？

IoC 即 Inversion of Control，也就是控制反转。在之前的情况下，我们想要使用一个类，就需要先 new 出来一个对象，这也就是我们来自己管理这个对象，但是当我们使用 IoC 之后，就相当于将这个对象交给 Spring 进行管理，我们不需要去手动 new 出来一个对象。

IoC 是一种思想，下面通过一个例子来体现使用 IoC 的好处。

现在我们有 A，B，C，D四个零件，D通过组装后变成C零件，C零件通过组装后编程B零件，B零件通过组装后变成A零件，即D -> C -> B -> A，下面通过代码进行实现：

//组装D零件
public class D {

    public D() {
        System.out.println("D init...");
    }
}

//组装C零件
public class C {
    private D d;

    public C() {
        this.d = new D();
        System.out.println("C init...");
    }
}

//组装B零件
public class B {
    private C c;

    public B() {
        this.c = new C();
        System.out.println("B init...");
    }
}

//组装A零件
public class A {
    private B b;

    public A() {
        this.b = new B();
        System.out.println("A init...");
    }
}

//零件组装完成
public class Main {

    public static void main(String[] args) {
        A a = new A();
        System.out.println("零件组装完成");
    }
}

零件从D到A一次组装完成，现在我们需要对D零件加上尺寸这一个属性，接下来就需要修改代码：

//组装D零件
public class D {

    //尺寸
    private Integer size;

    public D(Integer size) {
        this.size = size;
        System.out.println("D零件尺寸为: " + this.size);
        System.out.println("D init...");
    }
}

//组装C零件
public class C {
    private D d;

    public C(Integer size) {
        this.d = new D(size);
        System.out.println("C init...");
    }
}

//组装B零件
public class B {
    private C c;

    public B(Integer size) {
        this.c = new C(size);
        System.out.println("B init...");
    }
}

//组装A零件
public class A {
    private B b;

    public A(Integer size) {
        this.b = new B(size);
        System.out.println("A init...");
    }
}

//零件组装完成
public class Main {

    public static void main(String[] args) {
        A a = new A(12);
        System.out.println("零件组装完成");
    }
}

对比上下代码就可以知道，若使用当前方案来编写代码，代码与代码之间的耦合度就太高了，仅仅只是对D增加了一个属性，就需要将所有的代码进行修改，在正常开发中，这种情况不符合高内聚低耦合的需求。于是，就需要使用 IoC 的思想来编写代码。

下面是使用 IoC 思想编写出来的代码：

//组装D零件
public class D {

    //尺寸
    private Integer size;

    public D(Integer size) {
        this.size = size;
        System.out.println("D零件尺寸为: " + this.size);
        System.out.println("D init...");
    }
}

//组装C零件
public class C {
    private D d;

    public C(D d) {
        this.d = d;
        System.out.println("C init...");
    }
}

//组装B零件
public class B {
    private C c;

    public B(C c) {
        this.c = c;
        System.out.println("B init...");
    }
}

//组装A零件
public class A {
    private B b;

    public A(B b) {
        this.b = b;
        System.out.println("A init...");
    }
}

//零件组装完毕
public class Main {

    public static void main(String[] args) {
        D d = new D(12);
        C c = new C(d);
        B b = new B(c);
        A a = new A(b);
        System.out.println("零件组装完成");
    }
}

现在当某个类需要进行改变时，就不会涉及到其它的类，就使得各个类之间的耦合度减小。

分析这两种代码可以发现，第一种是将依赖对象通过该类的某个方法创造出来（如C依赖D，在第一种方法中是在C的构造方法中创建了D对象），而第二种代码是将依赖的对象注入了当前对象中（在C的构造方法中传入了D对象），实现了控制权反转，即依赖对象（D）不受这个类（C）控制，于是当某个类发生改变时，不会影响到其他类。

在第二种的main方法中，

D d = new D(12);
C c = new C(d);
B b = new B(c);
A a = new A(b);

这一段代码就相当于将这四个对象放入了一个容器当中，这个容器就是 IoC 容器。

IoC 容器的优点

1.资源集中管理，从上面的代码可以看出，对象a，b，c，d被集中管理，当我们需要使用时，就从 IoC 容器中获取就行了；

2.降低耦合度，这在上面也进行了解释。

DI 是什么？

DI，即Dependency Injection，也就是依赖注入，在上面的代码中，就已经使用了 DI，即在创建C对象时，就将D注入给了C，在创建B对象时，就将C注入给了B。其实，DI 是 IoC 的一种实现方式。