【Java】Spring核心与设计思想

妖狐艹你老母 2024-03-26 11:38 66阅读 0赞

#### 文章目录 ####

*  Spring核心与设计思想
 *   *  1. Spring是什么
     *   *  1.1 什么是容器
         *  1.2 什么是IOC
         *   *  1.2.1 传统程序开发
             *  1.2.2 控制反转式程序开发
             *  1.2.3 对比总结规律
     *  1.3 理解Spring IOC
     *  1.4 DI概念说明

## Spring核心与设计思想 ##

### 1. Spring是什么 ###

我们通常所说的Spring指的是Spring Framework（Spring框架），它是一个开源的框架。有着庞大而且活跃的社区，这也是长久不衰的原因。

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

那么什么是容器？什么是IOC容器？

#### 1.1 什么是容器 ####

容器就是用来容纳某种物品。

什么是IOC？

IOC翻译成中文的意思就是“控制反转”的意思，也就是说Spring是一个控制反转的容器

#### 1.2 什么是IOC ####

##### 1.2.1 传统程序开发 #####

假如，我们现在构架一辆”车“的容器，我们实现思路是这样的：

![dfa30bef789545628fa290a71be2275c.png][]

构建一辆车，然而车需要依赖车身，而车身需要依赖底盘，但是底盘有需要依赖轮胎，最终的程序如下：

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();
        }
        /**
         * 汽⻋对象
         */
        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);
            }
        }
    }

以上程序可以看出：**当底层代码改动之后，整个调用链上的所有代码都需要修改**

这种问题怎么解决那？

> 我们可以尝试不在每个类当中创建自己的下级类，如果自己创建下级类就会出现当下级类发生改变操作，自己也要跟着修改
> 
> 此时，我们只需要将原来由自己创建的下级类改为传递的方式（也就是注入的方式）因为我们不需要在当前类当中创建下级类了，所以下级类发生变化（创建或减少参数），当前类本身也无需修改任何代码，这样就完成了程序的解耦

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

##### 1.2.2 控制反转式程序开发 #####

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;
            public Tire(int size) {
        
                this.size = size;
            }
            public void init() {
        
                System.out.println("轮胎：" + size);
            }
        }
    }

代码经过以上调整，无论底层如何改变，整个调用链是不用做任何变动的，这样就完成了代码的**解耦**，从而实现了更加灵活、通用的设计程序了

![1b43afe949824fab90bfada051417350.png][]

##### 1.2.3 对比总结规律 #####

在传统的代码当中，创建顺序是`Car -> FrameWork -> Bottom -> Tire`

改进的解耦之后的代码创建对象的顺序是：`Tire -> Bottom -> FrameWork -> Car`

![d33b4be47df346f5bd3b85cc4722060e.png][]

我们发现一个规律：通用程序的实现代码，类的创建是反转的，传统代码Car控制并创建了FrameWork，依次往下。而改进之后的控制权发生反转不再是上级对象创建并控制下级对象了，而是下级对象注入到当前对象当中。下级的控制权不再由上级类控制了，这样即使下级类发生变化，当前类不受影响。这就是典型的控制反转，也就是IOC的实现思想

### 1.3 理解Spring IOC ###

Spring是包含了多个工具方法的IOC容器，这就是对Spring最核心的总结。那么如何理解Spring是一个IOC容器这句话？

它就具备两个最基础的功能：

*  将对象存入到容器
 *  从容器中取出对象

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

> 将对象存放到容器中的好处：将对象存储到IOC容器相当于以后可能用到的所有工具都放到仓库当中，需要的时候直接取就行了，用完再把它放入到仓库当中。而new对象的方式，相当于每次需要工具了才开始现做用完就扔掉也不会保存，下次用还需要重新做

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

### 1.4 DI概念说明 ###

说道IOC不得不说的一个词就是“DI”，翻译成中文就是“依赖注入”的意思

所谓依赖注入，就是IOC容器在运行期间，动态的将某种依赖关系注入到对象当中。所以依赖注入和控制反转是从不同的角度做一件事情。就是通过引入IOC容器，利用依赖注入的方式，实现对象之间的解耦

IOC是“目标”也是一种思想，而目标和思想只是一种指导原则，最终还是要有可行的落地方案，而DI就是属于具体实现

[dfa30bef789545628fa290a71be2275c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/c71cd388d0b641e6a2506d2d9e11edca.png
[1b43afe949824fab90bfada051417350.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/9293b5ddd8cb4c86aabea9c3b580bb38.png
[d33b4be47df346f5bd3b85cc4722060e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/ae5d5cf3c95c42149ce3fb3aed713208.png