【Spring】Spring有什么用？Spring核心与设计思想之IOC与DI

分手后的思念是犯贱 2023-10-12 19:39 86阅读 0赞

### 文章目录 ###

*  1 何为 Spring？
 *  2 什么是容器？
 *  3 理解Spring的 IOC
 *   *  3.1 传统开发的缺陷
     *  3.2 基于 IOC 思想的开发
     *  3.3 再谈Spring中的 IOC
 *  4 理解Spring中的 DI
 *  写在最后

--------------------

# 1 何为 Spring？ #

Spring是一个开源的、轻量级的、面向企业级的Java应用框架。它提供了一种基于依赖注入和面向切面编程的方式，帮助开发者构建高效、可扩展的应用程序。

![Spring][]  
 具体来说，**Spring可以看作一个包含众多工具方法的IOC容器。** Spring的出现是为了让开发更简单~ **那么问题就很明确了：**

1.  什么是容器？
2.  什么是IOC？

--------------------

# 2 什么是容器？ #

什么是容器，不能一概而论。在整个计算机领域中，容器在不同语境下有不同的含义：

*  在软件开发领域中，容器是一种运行环境，它提供了一种便捷的方式来运行和管理应用程序。容器可以将应用程序及其依赖包装在一起，形成一个可移植的运行时环境，并提供一组服务以简化应用程序的开发、部署和管理。通过容器，开发人员可以隔离和管理应用程序的依赖，从而使应用程序更加可靠和易于维护。
 *  在Java开发中，容器通常是指Web容器或IOC容器。Web容器是一种用于运行Web应用程序的容器，例如Tomcat、Jetty等。IoC容器是一种反转控制容器，例如Spring框架的Bean容器，它管理了应用程序中的对象，并负责注入对象之间的依赖关系。

简单通俗一点儿来说：**容器其实就是一个用来容纳某种物品的装置** 在正式认识Spring中的IOC容器之前，我们已经学习过如下两种容器：

1.  **数据存储容器：** List、Set、Map等；
2.  **Web容器：** Tomcat等。

![原来如此][1b27c0c528554ee98d5804ff68a5dc48.png_pic_center]

--------------------

# 3 理解Spring的 IOC #

**什么是IOC？**  
 IOC（Inversion of Control），即**控制反转**，是一个重要的编程思想和设计模式，它的核心思想是将对象的创建和依赖关系的管理从程序中独立出来，交给一个外部容器来实现。常见的IOC容器有Spring Framework中的ApplicationContext和BeanFactory。

## 3.1 传统开发的缺陷 ##

为了更好的理解 IOC 编程思想的妙处，我们从一个案例进行切入：

> 尝试通过程序构建一辆汽车(Car)，汽车依赖于车身(Framework)，车身依赖于底盘(Bottom)，底盘依赖于轮胎(Tire)。

![依赖关系][ff230bffc29346a4b7daca8c8460cb9d.png]

**完整实现代码如下：**

/**
     * 测试类
     */
    public class Application {
        
        public static void main(String[] args) {
        
            Car car = new Car();
            car.init();
        }
    }
    /**
     * 汽车类
     */
    class Car {
        
    
        private Framework framework;
    
        public Car() {
        
            framework = new Framework();
        }
    
        public void init() {
        
            // 依赖车身
            System.out.println("执行了 car 的 init 方法");
            framework.init();
        }
    }
    /**
     * 车身类
     */
     class Framework {
        
    
        private Bottom bottom;
    
        public Framework() {
        
            bottom = new Bottom();
        }
    
        public void init() {
        
            // 依赖底盘
            System.out.println("执行了 framework 的 init 方法");
            bottom.init();
        }
    }
    /**
     * 底盘类
     */
     class Bottom {
        
    
        private Tire tire;
    
        public Bottom() {
        
            tire = new Tire();
        }
    
        public void init() {
        
            // 依赖轮胎
            System.out.println("执行了 bottom 的 init 方法");
            tire.init();
        }
    }
    /**
     * 轮胎类
     */
     class Tire {
        
    
        private int size = 20;
    
        public void init() {
        
            System.out.println("执行了 tire 的 init 方法, size: " + this.size);
        }
    }

**实现结果如下：**  
![实现结果1述][1]  
 以上程序中，轮胎的尺⼨的固定的，然⽽随着对的⻋的需求量越来越⼤，个性化需求也会越来越多，比如：需要更改轮胎的颜色等，那这个时候就要对上⾯的程序进⾏修改了。**牵一发而动全身！**  
 例如，我们给轮胎类添加一个属性color，用于控制车胎的颜色。由于Tire为最底层的代码，**当底层代码修改后，其整个调用链上的代码都需要修改，这便是程序最大的问题！**  
![弊端][ca85ab3a4af94c759882bc65ee7cb831.png_pic_center]

**在传统的编程模式中，程序员需要手动创建对象，并负责它们之间的依赖关系。** 而在IOC的编程模式中，程序员只需要定义好对象及其依赖关系的配置，IOC容器则根据这些配置来自动创建和管理对象。通过 IOC编程思想，我们可以很好的解决上述问题。

## 3.2 基于 IOC 思想的开发 ##

通过IOC容器，我们可以实现应用程序的松耦合，提高程序的可维护性和可扩展性，也方便了程序员的开发工作。  
 上述案例问题产生的原因，是代码间的耦合度太高，也就是解决问题的过程实际上应该是一个 **“松耦合、解耦合”** 的过程。下面给出上述案例的 IOC实现方式。

> 尝试不在每个类中⾃⼰创建下级类，我们只需要将原来由⾃⼰创建的下级类，改为传递的⽅式（也就是注⼊的⽅式），所以下级类即使发⽣变化（创建或减少参数），当前类本身也⽆需修改任何代码。

![传递关系][6b0a239fe3ed44c98ac27302b595c782.png]

**完整代码如下：**

/**
     * 测试类
     */
    public class Application {
        
        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();
        }
    }
    /**
     * 汽车类
     */
    class Car {
        
    
        private Framework framework;
    
        public Car(Framework framework) {
        
            this.framework = framework;
        }
    
        public void init() {
        
            System.out.println("调用了 car 的 init");
            framework.init();
        }
    }
    /**
     * 车身类
     */
     class Framework {
        
    
        private Bottom bottom;
    
        public Framework(Bottom bottom) {
        
            this.bottom = bottom;
        }
    
        public void init() {
        
            System.out.println("调用了 framework 的 init");
            bottom.init();
        }
    }
     /**
     * 底盘类
     */
     class Bottom {
        
    
        private Tire tire;
    
        public Bottom(Tire tire) {
        
            this.tire = tire;
        }
    
        public void init() {
        
            System.out.println("调用了 bottom 的 init");
            tire.init();
        }
    }
     /**
     * 轮胎类
     */
     class Tire {
        
    
        private int size = 20;
    
        public Tire(int size) {
        
            this.size = size;
        }
    
        public void init() {
        
            System.out.println("当前轮胎的 size: " + size);
        }
    }

**实现结果如下：**  
![实现结果2][2]  
 代码经过以上调整，⽆论底层类如何变化，整个调⽤链是不⽤做任何改变的，这样就完成了代码之间的解耦。

**同时，我们也能发现一些规律：** 改进之后的控制权发⽣的反转，**不再是上级对象创建并控制下级对象了，⽽是下级对象把注⼊将当前对象中，下级的控制权不再由上级类控制了，** 这样即使下级类发⽣任何改变，当前类都是不受影响的，这就是典型的控制反转，也就是 IOC 的实现思想。

## 3.3 再谈Spring中的 IOC ##

通过上述案例的分析，可以了解到，IOC实质上是一种编程思想。而要想理解 Spring中的IOC，我们还要回到文章一开始所说的：**Spring本身是一个包含众多工具方法的IOC容器** 上。

既然是容器，就应该具备如下两个最基本的功能~

*  将对象存储到容器中
 *  从容器中取出对象使用

也就是说，Spring的核心功能，就是可以将对象存入到 Spring 中，再从 Spring 中取出对象~ 即：**将需要用到的对象都创建好存储到 IOC容器中，需要的时候再直接取用。而此时，对象创建和销毁的权利都交给了 Spring 来管理。**  
![表情包][a4db2bed611145579d2cdd8f141302df.png_pic_center]

--------------------

# 4 理解Spring中的 DI #

Spring的依赖注入（Dependency Injection，DI）是指在应用程序运行过程中，由Spring容器负责创建和管理对象，并将对象之间的依赖关系注入给它们。通过DI，我们可以让对象之间的关系松耦合，从而提高代码的复用性、可维护性、可测试性。简单来说：**所谓依赖注入，就是由 IoC 容器 在运行期间，动态地将某种依赖关系注入到对象中。DI 也是 IoC思想实现落地的一种方式~**

> 比如：我要好好coding，为做一个勤勤恳恳的程序员而奋斗。我想成为什么是目的，而我今天是学Java，学中间件，是学微服务还是写项目刷算法是具体的实现。正如 IoC与DI 的关系一样，前者是思想，后者是具体实现的方式~

![表情包][720b76bcf8b645149b4212661a6b767b.png_pic_center]

在Spring中，对象之间的依赖关系分为两种：构造器注入和属性注入。在构造器注入中，Spring容器会通过构造方法来完成对对象的依赖注入。而在属性注入中，Spring容器则会通过setter方法或者直接设置对象的属性来完成依赖注入。

**通过DI，我们可以将应用程序的配置与代码分离，使得代码更加清晰可读，便于维护和扩展。**

--------------------

# 写在最后 #

**本文被 [JavaEE编程之路][JavaEE] 收录[点击订阅专栏][JavaEE]** ， 持续更新中。  
 以上便是本文的全部内容啦！创作不易，如果你有任何问题，欢迎私信，感谢您的支持！

![在这里插入图片描述][7e0ff0501697426a84cd0a1f4eecfdc1.gif_pic_center]

[Spring]: https://img-blog.csdnimg.cn/9bb21344c251424cba35007aeac85042.png#pic_center
[1b27c0c528554ee98d5804ff68a5dc48.png_pic_center]: https://img-blog.csdnimg.cn/1b27c0c528554ee98d5804ff68a5dc48.png#pic_center
[ff230bffc29346a4b7daca8c8460cb9d.png]: https://img-blog.csdnimg.cn/ff230bffc29346a4b7daca8c8460cb9d.png
[1]: https://img-blog.csdnimg.cn/3e1b5e54f9ed45e88fd8b025f89305e7.png
[ca85ab3a4af94c759882bc65ee7cb831.png_pic_center]: https://img-blog.csdnimg.cn/ca85ab3a4af94c759882bc65ee7cb831.png#pic_center
[6b0a239fe3ed44c98ac27302b595c782.png]: https://img-blog.csdnimg.cn/6b0a239fe3ed44c98ac27302b595c782.png
[2]: https://img-blog.csdnimg.cn/e75e028b60f8438896c0bdfd80cadc02.png
[a4db2bed611145579d2cdd8f141302df.png_pic_center]: https://img-blog.csdnimg.cn/a4db2bed611145579d2cdd8f141302df.png#pic_center
[720b76bcf8b645149b4212661a6b767b.png_pic_center]: https://img-blog.csdnimg.cn/720b76bcf8b645149b4212661a6b767b.png#pic_center
[JavaEE]: https://blog.csdn.net/m0_60353039/category_12174411.html
[7e0ff0501697426a84cd0a1f4eecfdc1.gif_pic_center]: https://img-blog.csdnimg.cn/7e0ff0501697426a84cd0a1f4eecfdc1.gif#pic_center