1.Spring是什么？

Spring指Spring Framework(Spring框架)，它是一个开源免费框架，有着活跃而庞大的社区（版本升级迭代快），支持广泛的应用场景，能让Java企业级的应用程序开发起来更简单。因此而长久不衰。

一句话概括：Spring是包含了众多工具方法的IoC容器。

2.容器是什么？

容器是用来容纳某种物品的（基本）装置。

之前接触的容器有：

List/Map->数据存储容器；
Tomcat->Web容器。

3.IoC是什么？

IoC=Inversion of Control翻译成中文是“控制反转”的意思，也就是之前需要自己去控制的东西现在交给Spring框架去控制。

3.1.传统程序开发

例：构建一辆车(Car Class)，而车需要依赖车身(Framework Class)，而车身需要依赖底盘(Bottom Class)，而底盘需要依赖轮胎(Tire Class)：

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

    /**
     * 汽车对象
     */
    static class Car {
        public void init() {
            //依赖车身
            Framework framework = new Framework();
            framework.init();
        }
    }

    /**
     * 车身类
     */
    static class Framework {
        public void init() {
            //依赖底盘
            Bottom bottom = new Bottom();
            bottom.init();
        }
    }

    /**
     * 底盘类
     */
    static class Bottom {
        public void init() {
            //依赖轮胎
            Tire tire = new Tire();
            tire.init();
        }
    }

    /**
     * 轮胎类
     */
    static class Tire {
        private int size = 30;
        public void init() {
            System.out.println("轮胎尺寸：" + size);
        }
    }
}

传统程序开发的缺陷：轮胎的尺寸是固定的，然而随着对车的需求量越来越大，个性化需求也越来越多，此时就需要加工多种尺寸的轮胎，需对以上代码进行修改：

public class NewCarUpdateExample {
    public static void main(String[] args) {
        Car car = new Car(20);
        car.run(); //和init()方法是一个意思
    }

    /**
     * 汽车对象
     */
    static class Car {
        private Framework framework;
        
        public Car(int size) {
            framework = new Framework(size);
        }
        
        public void run() {
            //依赖车身
            framework.init();
        }
    }

    /**
     * 车身类
     */
    static class Framework {
        private Bottom bottom;
        
        public Framework(int size) {
            bottom = new Bottom(size);
        }
        
        public void init() {
            //依赖底盘
            bottom.init();
        }
    }

    /**
     * 底盘类
     */
    static class Bottom {
        private Tire tire;
        
        public Bottom(int size) {
            tire = new Tire(size);
        }
        
        public void init() {
            //依赖轮胎
            tire.init();
        }
    }

    /**
     * 轮胎类
     */
    static class Tire {
        //尺寸
        private int size;
        
        public Tire(int size) {
            this.size = size;
        }

        public void init() {
            System.out.println("轮胎尺寸：" + size);
        }
    }
}

以上程序的问题：由于在每个类中自己创建下级类，当最底层的代码改动之后，整个调用链上的所有代码都需要修改。

3.2.控制反转式程序开发

为解决传统开发中的缺陷，便不在每个类中自己创建下级类，而是将原来由自己创建的下级类，改为传递（注入）的方式，这样下级类即使发生变化（创建或减少参数），当前类本身也无需修改任何代码，就完成了程序的解耦。

PS:解耦指的是解决了代码的耦合性/程序相关性。好程序代码的耦合性是很低的。

好比：打造一辆完整的汽车，如果所有的配件都是自己造，那么当客户需求发生改变时，比如轮胎尺寸不再是原来尺寸了，那就要自己动手来改了；但如果把轮胎外包出去，那即使轮胎尺寸改变，也只需向代理工厂下订单就行，自身不需要出力。

基于以上思想，对以上代码进行修改，修改轮胎尺寸并添加材质，创建子类的方式->注入传递的方式：

public class IocCarExample {
    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.run();
    }

    static class Car {
        private Framework framework;

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

        public void run() {
            framework.init();
        }
    }

    static class Framework {
        private Bottom bottom;

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

        public void init() {
            bottom.init();
        }
    }

    static class Bottom {
        private Tire tire;

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

        public void init() {
            tire.init();
        }
    }

    static class Tire {
        //尺寸
        private int size;
        //材质
        private String type;

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

        public void init() {
            System.out.println("轮胎尺寸：" + size + " | 材质：" + type);
        }
    }
}