Spring 核心

目录

1. loC是什么？

1.1  改变之前的程序

1.2 修改后的代码

1.3 解决上述代码耦合问题

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

3. DI （dependency injection） 依赖注入

---

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