1. 🐾loC是什么？

Spring 相当于是一个容器，可以用来容纳物品。

List / Map ---- 数据存储容器

Tomcat ---- Web容器

loC 就是“控制反转” 的意思，也可以说是：Spring 是一个“控制反转”的容器，loC 可以解决程序之间的耦合问题。

1.1? 🐾改变之前的程序

🚗 一辆汽车 ---->? 依赖于车身? ---->? 依赖于底盘? ---->? 依赖于轮胎

public class L1 {
    //汽车
    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 static void main(String[] args) {
        Car car = new Car();
        car.init();
    }
}

缺点：

轮胎的尺寸固定，不能随意更改轮胎尺寸以及满足其他要求。?

1.2 🐾修改后的代码

public class L1 {
    //汽车
    static class Car{
        private Framework framework;

        public Car(int size,String type) {
            framework = new Framework(size,type);
        }
        public void init() {
            //依赖于车身
            framework.init();
        }
    }
    //车身
    static class Framework{
        private Bottom bottom;

        public Framework(int size,String type) {
            bottom = new Bottom(size,type);
        }
        public void init() {
            //依赖于底盘
            bottom.init();
        }
    }
    //底盘
    static class Bottom{
        private Tire tire;

        public Bottom(int size,String type) {
            tire = new Tire(size,type);
        }
        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);
        }
    }
    public static void main(String[] args) {
        Car car = new Car(20,"金");
        car.init();
    }
}

以上两种代码存在问题：当轮胎要求（最底层代码）发生变化时，整个调用链都需要修改。

解决该问题：?

? ? ? ? 不在每个类中创建下级类，改为传递的方式，此时当下级类发生变化，当前类无需修改任何代码，即就是解耦（解耦是指解决了代码的耦合性，也可以说是解决了程序相关性）。

就相当于，需要一辆完整的汽车，但是每个客户需求不一样，比如有的要求轮子大小，那么我们就可以将轮胎制作交给专门制作轮胎的工厂，只需要告诉他们我们需要的轮胎尺寸大小，将我们对轮胎控制权转给这个轮胎工厂，工厂拥有这个轮胎的控制权。

1.3 🐾解决上述代码耦合问题

?轮胎传递给?----> 底盘传递给 ---->?车身传递给? ? ---->??🚗一辆汽车 ?

解决代码耦合问题之前，类的创建顺序是反的，car 创建 Framework ，Framework再创建Bottom......解决代码耦合问题时，不再是上级对象创建并控制下级对象，而是把下级对象传入给上级对象，下级对象不再由上级对象控制，即使下级对象发生代码改变，也不会影响上级变化。这就是控制反转，也是loC实现的思想。

public class L1 {
    //汽车
    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);
        }
    }
    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();
    }
}

?2. 🐾理解Spring 是一个loC（控制反转）容器

Spring 是包含多个工具方法的loC容器

Spring 是一个 loC 容器：对象的创建和销毁权力都交给Spring 管理，而Spring 本身就具有存储对象和获取对象的权力。?

Spring 具备的核心功能：

💫 将对象（Bean）存入到容器中

💫 从容器中取出对象

为什么要将对象存储到容器中？

将对象存储到 loC 容器中相当于将以后可能用到的所有工具制作好放到仓库里，需要的时候直接取出，用完再放回仓库。

之前所用的 new 一个对象，每次在需要工具的时候才开始制作，用完就扔掉。

3. 🐾DI （dependency injection）依赖注入

在程序运行期间（loC容器运行期间），动态地将某个依赖注入到类中。

（MS）

loC ：将控制权反转，自己不再new一个对象，而是将控制权交给别人，将下级对象传入上级对象。

DI：在需要某个类中要使用另外一个类，不需要new，直接注入一个依赖。

从不同的角度来描述同一件事。

loC ：是一种指导思想，比如说，今天中午想吃KFC

DI：是具体的实现，比如，今天中午吃了KFC