Spring核心和设计思想（1）

1.Spring是什么？

我们通常说的Spring指的是Spring FrameWork（Spring 框架），它是一个开源框架，有着活跃而庞大的社区，这就是它长久不衰的原因。Spring支持广泛的应用场景，它让Java企业级的应用程序开发起来更简单。在18年以前，开发大多使用的Spring框架，学会Spring框架我们就能维护公司以前写的代码。

Spring：包含了众多工具方法的IoC容器。

那么什么是容器？什么是IoC？什么是IoC容器？

1.1什么是容器？

按照我们的理解，容器是容纳某种物品的装置。

我们熟悉的有LinkedList，ArrayList等都可以被称为容器，容纳某种类型数据。

1.2什么是IoC?

IoC的全名是Inversion of Control翻译成中文“控制反转”的意思。那这句话到底什么意思呢？控制什么？反转什么呢？

1.2.1传统程序开发

假如，我们现在要构建一辆“车”的程序，我们的实现思路可能是这样的

 构建一辆车(Car Class),我们需要依赖车身（FrameWork Class)，而车身需要依赖地盘（Bottom Class)，而地盘需要依赖轮胎（Tire Class)，最终程序的代码实现如下：

/**
 * Describe:
 * User:lenovo
 * Date:2023-07-18
 * Time:10:39
 */
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);
        }
    }
}

传统的开发缺陷

在以上的程序中，轮胎的尺寸是固定的，但是随着对车需求的增大，个性化的需求也变得越来越多，这个时候我们就需要加工多种多样的轮胎，我们就对代码进行修改，如下所示：

/**
 * Describe:
 * User:lenovo
 * Date:2023-07-18
 * Time:10:39
 */
public class NewCarExample {
    public static void main(String[] args) {
        Car car = new Car(20);
        car.init();
    }

    /**
     * 汽车对象
     */
    static class Car {
        private Framework framework;
        
        public Car(int size) {
            framework = new Framework(size);
        }
        public void init() {
            //依赖车身
            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);
        }
    }
}

以上程序的问题：当最下层的代码改动以后，整个调用链上的所有代码都发生了改动。

如何解决上述问题呢？

我们可以尝试不在每个类中创建自己的下级类，如果自己创建下级类就会出现这样的连锁反应。此时我们需要将自己创建的下级类，改为传递的方式（也就是注入的方式），因为我们不需要在当前类中创建下级类，所以下级类即使发生了变化（创建或减少参数），当前类也不用修改，这样就完成了程序的解耦了

PS：解耦指的是解决了代码的耦合性，耦合性也就可以换一种叫法叫程序的相关性。好的程序代码的耦合性（代码之间的相关性）是很低的。

1.2.2控制反转式程序开发

基于上面的思路，我们把调用汽车的陈旭示例改造以下，把创建子类的方式，改为注入传递的方式，具体实现代码如下：

public class NewCarExample3 {
    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();
    }

    /**
     * 汽车对象
     */
    static class Car {
        private Framework framework;

        public Car(Framework framework) {
            this.framework = framework;
        }
        public void init() {
            //依赖车身
            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;

        public Tire(int size) {
            this.size = size;
        }
        public void init() {
            System.out.println("轮胎尺寸" + size);
        }
    }
}

代码经过上面的调整，不论底层类如何变化，整个调用链式不用做任何更改的，这样就完成了代码之间的解耦

1.2.3对比总结规律

在传统的代码种对象创建的顺序是：Car -> Framework -> Bottom -> Tire，改进之后解耦的代码的对象创建顺序是：Tire -> Bottom -> Framework -> Car.

通用代码的实现代码，类的创建是反的，传统代码种是Car控制并创建了Framework，Framework创建并创建了Bottom,依次往下，而改进后控制权发送了反转，不再是上级对象创建并控制下级对象了，而是下级对象把注入当前对象中，下级的控制权不再由上级类控制了，这样即使下级类发生了改变，当前类都是不会收到影响的，这就是经典的控制反转，也就是IoC的实现思想。

1.3理解Spring IoC 

回到刚刚说的那句话来，Spring是包含了多个工具方法的IoC容器。那它就具备两个基本的功能：

• 将对象存放到容器中
• 从容器中取出对象

也就是说学Spring最核心的功能，就是学如何将对象存入到Spring中，再从Spring中获取对象的过程。

将对象存放到容器中的好处：将对象储存在IoC容器相当于将以后可能会使用到的所用工具依次性制作好都放到仓库中，需要的时候直接取出来，用完再把它放回到仓库。而new对象的方式相当于，每次需要工具了，才现做，用完了就扔掉了，也不会保存，下次再使用的时候就需要重新做了，这就是IoC容器和普通程序开发的区别。

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

1.4DI概念说明

说到Ioc不得不提及一个词“DI”，DI的全称是Dependency Injection的缩写，翻译成中文是“依赖注入“的意思

依赖注入，就是由IoC容器在运行期间，如果需要一个对象，无须new创建，而是依赖外部的注入。

就如上面代码的例子，我们造一辆车需要车架，我们不要自己创建车架，而是传入一个车架类型的参数（相当于直接去拿一个现成的车架），这就是依赖注入

依赖注入（DI）和控制反转（IoC)是从不同地角度描述的同一件事情，就是指通过引入IoC容器，利用依赖关系注入的方式，实现对象之间的解耦。换句话来说，实现控制反转的实现方式之一是依赖注入