什么是Spring

什么是Spring

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

什么是 IoC

Inversion of Control — 控制反转

在传统的开发中，假设A类依赖于B类，那么创建A对象实例就需要先new一个B类对象，也就是说A对象掌握着B对象的控制权。当实例B类时传入了不同的参数那么A类对象也会跟着改变。假设现在A类不想掌握B类的控制权，将控制权交出去，A类只需要拿到B类对象不关心是谁给的，从而完成解耦，这个过程就是IoC 过程。

以传统方法写一个造车的程序为例，首先 车需要依赖车身，车身需要依赖底盘，底盘需要依赖轮胎。那么使用代码编写出来的就需要实例构造车类前需要构造车身类，构造车身类就需要先构造底盘类，构造底盘类就需要构造轮胎类。

package IoC;

public class Car {
    private Framework framework;
    public Car(){
        framework = new Framework();
    }

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

    public static void main(String[] args) {
        Car car = new Car();
        car.init();
    }
}
class Framework {
    private Bottom bottom;
    public Framework(){
        bottom = new Bottom();
    }

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

class Bottom {
    private Tire tire;
    public Bottom(){
        tire = new Tire();
    }

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

class Tire{
    private int size = 22;
    public void init(){
        System.out.println("size -> " + size);
    }
}

传统的开发逻辑顺序就如上所示，这种代码是非常有缺陷的，例如轮胎的尺⼨固定，并不符合实际的需要。而改为 IoC 后：

package IoC;

public class Car {
    private Framework framework;
    public Car(Framework framework){
        this.framework = framework;
    }

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

    public static void main(String[] args) {
        Tire tire = new Tire(22);
        Bottom bottom = new Bottom(tire);
        Framework framework = new Framework(bottom);
        Car car = new Car(framework);
        car.init();
    }
}
class Framework {
    private Bottom bottom;
    public Framework(Bottom bottom){
        this.bottom = bottom;
    }

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

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

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

class Tire{
    private int size;
    public Tire(int size){
        this.size = size;
    }
    public void init(){
        System.out.println("size -> " + size);
    }
}

代码经过以上调整，无论底层类如何变化，整个调用链是不用做任何改变的，把创建子类的方式，改为注入传递的方式从而实现代码之间的解耦。这种把下级对象注入当前对象中，下级的控制权不再由上级类控制的思想就是 IoC实现思想。

Spring的IoC

首先Spring是一个 IoC容器，既然是个容器那么Spring具备将**对象存入和取出对象这两个核心基础功能。**也就是说学 Spring 最核心的功能，就是学如何将对象存入到 Spring 中，再从 Spring 中获取对象的过程。

这样的好处是：将对象存储在 IoC 容器相当于将以后可能用的所有工具制作好都放到仓库中，需要的时候直接取，用完再把它放回到仓库。就不需要每次都现做，用完就丢掉下次需要还得重新做。这也就是 IoC容器和普通程序的区别

因此Spring是一个 IoC 容器说的就是：对象的创建和销毁的权利都交给 Spring 来管理了，它本身又具备了存储对象和获取对象的能力。

DI的概念

Dependency Injection — 依赖注入

所谓依赖注⼊，就是由 IoC 容器在运行期间，动态地将某种依赖关系注入到对象之中

IoC容器就是利用依赖注入的方式去实现对象之间的解耦。

IoC 是“目标”也是⼀种思想，而目标和思想只是⼀种指导原则，最终还是要有可行的落地方案，而 DI 就属于具体的实现

上面所写的 IoC代码属于是一种被动的传递，需要别人去传才能够获取。而在Spring中就可以不需要别人传，自己就可以主动的获取到，这种就是 DI 也就是依赖注入