什么是Spring？

Spring 全称 Spring Framework，它是一个目前市场上最流行、结构最庞大的开源框架，之所以如此，是因为其有独特且全面的应用场景，这样好的生态才使企业一直对青睐。

注意这句话：Spring 是包含了众多思想、工具、方法的的 IoC 容器；

什么是容器？

这里的容器本质上和我们生活中所说的容器基本是一样的，容器就是用来容纳和取出物品的，那么在编程中具体有 List、Map、Set、Vector、Tomcat（Web容器）、Spring等等，它们也可以存入程序员需要的元素，等用的时候再取出来；这一点在 Spring 中表现的淋漓尽致。

IoC控制反转：

IoC 全称 Inversion of Control 控制反转，是一种设计思想，也是 Spring 中一个核心概念；

为了更好的解释控制反转，要先从传统的程序设计思想谈起，以下需要引入一个例子：造一辆车，造一辆车需要设计好车身、车身需要建立在底盘上、底盘的设计又依赖轮子的尺寸，那么这四个因素之间相互制约，下面我们来看看具体怎么设计：

先声明好这几个元素：车（Car类）、车身（framework类）、底座（bottom类）、轮子（Tire类）

传统程序设计：

// 开始设计车子
public class Car {
    private Framework framework; // 先要有车身这个概念

    public Car() {
        framework = new Framework(); // 开始设计车时new出车身
    }
    // 造车子
    public void init() {
        System.out.println("do car");
        framework.init();
    }
    // 测试入口
    public static void main(String[] args) {
        Car car = new Car();
        car.init();
    }
}

// 车身
public class Framework {
    private Bottom bottom; // 先要有底座这个概念

    public Framework() {
        bottom = new Bottom(); //构造车身时创建轮子
    }
    // 造车身
    public void init() {
        System.out.println("do framework");
        bottom.init();
    }
}

// 底座
public class Bottom {
    private Tire tire;  // 先要有轮子的概念

    public Bottom() {
        tire = new Tire(); // 构造底座时创建轮子
    }
    // 造底座
    public void init() {
        System.out.println("do bottom");
        tire.init();
    }
}

// 轮子
public class Tire {
    private int size = 17; // 设计轮子的尺寸
    // 造轮子
    public void init() {
        System.out.println("do tire -> size = " + size);
    }
}

（重要！！！）

结合代码可以看到，当我开始设计车子的时候，发现需要先有车身，那么我new一个车身，new车身的时候又发现需要先知道底座，那么就去new一个底座，new底座的时候又发现我还需要知道轮子大小，于是再去new轮子。

这样用的时候才去创建当然很麻烦，另一方便，这种设计思想导致耦合性极强，我需要的这个类可能又受其他类的约束，放在这个例子当中，一旦我想在构造 Tire 实例时，改一下轮子的尺寸，当然需要传入参数 size，怎么传呢？只能是在 new Car(int size) 这种时候去传，那一旦这样去传，其他几个类的构造方法也需要传参了，我又得去修改其他类的代码，岂不是会产生很多麻烦。

为了降低耦合性，我们 Spring 中的 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 class Framework {
    private Bottom bottom;

    // 传入底座对象
    public Framework(Bottom bottom) {
        this.bottom = bottom;
    }

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

// 底座
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 Tire {
    private int size = 17;

    // 随时传入参数
    public Tire(int size) {
        this.size = size;
    }

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

// 测试用例
public class TestCar {
    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();
    }
}

（重要！！！！）

观察新的代码很容易发现，只是稍微调整了一下每个类的构造方法，之前是我需要时自己new，现在是我需要时别的类给我直接传对象，我自身需要的那个对象直接和传入的对象去做赋值替换即可，如此一来就降低了耦合性，即使轮子的尺寸要改变，也不需要修改其他类的代码了，实质上改变的整个调用链的关系。

再举一个例子帮助理解：上世纪最初的汽车生产车间中，一个工人可能要负责很多项目的设计、检测、监测，这样就导致工厂招人的难度较高，一个工人要会的多，对于工人可能一会忙这个，一会又要去忙那个，导致生产效率不一定高。后来随着时代发展，工厂改变了思路，实现了流水线生产模式，让一个或多个工人只负责一件事，这样每个环节的工人都各司其职，不受其他环节的影响，便于工厂管理也提高了用人成本和生产效率；