哈喽，哈喽，大家好~ 我是你们的老朋友：保护小周ღ

谈起Java 圈子里的框架，最年长最耀眼的莫过于 Spring 框架啦，如今已成为最流行、最广泛使用的Java开发框架之一。不知道大家有没有在使用 Spring 框架的时候思考过这些问题，什么是框架？Spring 是什么？如何理解 Spring ? loC 和 DI 是什么，有什么区别？ Spring 最核心的功能是啥？ 本文将为大家讲解，一起来看看叭~

本期收录于博主的专栏：JavaEE_保护小周ღ的博客-CSDN博客

适用于编程初学者，感兴趣的朋友们可以订阅，查看其它 “JavaEE基础知识”。

更多精彩敬请期待：保护小周ღ *★,°*:.☆(￣▽￣)/$:*.°★* ‘

一、Spring 是什么？

Spring是一个开源的Java框架，有着活跃而庞大的社区（例如：Apache），Spring 提供了一系列的工具和库，可以帮助开发者构建高效、可靠、易于维护的企业级应用程序。Spring的核心模块包括IOC容器、AOP、ORM等，它还提供了许多扩展模块如Spring MVC、Spring Security、Spring Data等，可以满足不同场景下的需求。Spring最初由Rod Johnson创建于2002年，如今已成为最流行、最广泛使用的Java开发框架之一。

用一句话概括 Spring : 包含了众多工具方法的 loC 容器。

框架是一种软件架构，是一组实现某种逻辑或功能的代码和类库的集合，我们需要按照框架设计者的规则来使用，所以在框架的世界里：“约定大于配置”

“约定大于配置”（Convention over Configuration）是一种软件开发理念，通过使用一些约定过的默认设置和行为，来简化配置和编码的过程。在这种理念下，框架依据事先声明好的约定、继续一些默认设置和命名规则，自动完成一些繁琐的配置，使开发人员能够更快、更容易地构建应用程序。这样可以减少冗余代码以及重复劳动，帮助开发人员更好地专注于应用程序的功能开发。

举一个不大恰当的例子：就像我们使用的库函数一样，我们无需关注库函数的实现，我们关注的是这些库函数的应用场景是什么，有什么功能，我们怎么使用，参数是什么，函数的参数以及使用方式，就可以认为是函数与开发者的约定~

1.1 什么是 loC 容器

“容器” ：可以存储一些东西的 “器物” 就叫做容器，例如水杯。

容器的概念，其实在JavaSE(语法) 阶段就接触过了，我们的集合类，ArrayLIst , Map ，Set 都是容器，是接纳数据的容器。

loC （In）Inversion of Control 翻译成中文就是 “控制反转” 的意思，控制反转一种编程设计思想，将程序的控制流程从传统的主动调用方式转变为被动接收方式，从而实现模块之间的解耦和依赖管理。

1.1.1 传统开发模型

假设，我们站在代码的角度构建一座房子，设计思路：

构建一座房子（House Class），然而房子需要依赖房屋结构(BuildingFame Class)，而房屋构架需要依赖建筑材料（BuildingMaterials Class），而建筑材料需要依赖地基（FoundationClass），最终程序的实现代码如下：

//这是一个房子类
public class House {
    //一个房子需要依赖房屋的架构
    House() {
        System.out.println("这是一个房子");
    }

    BuildingFame buildingFame = null;
    public void init() {
        //依赖于房屋架构
        System.out.println("执行了初始化房屋架构的方法");
        this.buildingFame = new BuildingFame();
        buildingFame.init();
    }
}

//房屋构架
class BuildingFame {
    //房屋的架构依赖与建筑材料
    BuildingMaterials buildingMaterials = null;
    public void init() {
        //依赖于建筑材料
        System.out.println("执行了初始化建筑材料的方法");
        this.buildingMaterials = new BuildingMaterials();
        buildingMaterials.init();
    }
}

//建筑材料
class BuildingMaterials {
    //建筑材料依赖于地基
    Foundation foundation = null;
    public void init() {
        //依赖于地基
        System.out.println("执行了初始化地基的方法");
        this.foundation = new Foundation();
        foundation.init();
    }
}

//地基
class Foundation {
    public void init() {
        String size = "100m*m";
        //依赖于地基
        System.out.println("地基：" + size);
    }
}

执行结果：

传统开发的缺陷：

以上程序中，房屋地基的大小（平方）的固定的，随着对的房屋的需求量越来越⼤，个性化需求也会越来越多，一个家庭人口多的可能需要 200 个平方的房子，对于新婚的夫妻来说也许 100 个平方的房子就够了，这时候我们针对房屋地基的大小进行处理了，同时也需要对上面的程序进⾏修改了，修改后的代码如下所示：

//这是一个房子类
public class House {
    //一个房子需要依赖房屋的架构
    House() {
        System.out.println("这是一个房子");
    }

    BuildingFame buildingFame = null;
    public void init(String size) {
        //依赖于房屋架构
        System.out.println("执行了初始化房屋架构的方法");
        this.buildingFame = new BuildingFame();
        buildingFame.init(size);
    }
}

//房屋构架
class BuildingFame {
    //房屋的架构依赖与建筑材料
    BuildingMaterials buildingMaterials = null;
    public void init(String size) {
        //依赖于建筑材料
        System.out.println("执行了初始化建筑材料的方法");
        this.buildingMaterials = new BuildingMaterials();
        buildingMaterials.init(size);
    }
}

//建筑材料
class BuildingMaterials {
    //建筑材料依赖于地基
    Foundation foundation = null;
    public void init(String size) {
        //依赖于地基
        System.out.println("执行了初始化地基的方法");
        this.foundation = new Foundation();
        foundation.init(size);
    }
}

//地基
class Foundation {
    String size = "100 m*m";
    public void init(String size) {
        this.size = size;
        //依赖于地基
        System.out.println("地基：" + size);
    }
}

从上诉代码中可以看出的问题是：当最底层的代码需要改动时，整个 House 类调用链上的所有依赖类都需要进行修改，而且类于类之间的依赖性极高。

上述程序设计存在一定的缺陷，我们该如何解决呢？

1.1.2 loC 控制反转式程序开发

我们可以尝试不在每个类中创建下级类，如果创建的类出现当下级类发⽣改变操作，自己也要跟着修改的这种情况。这个时候，我们只需要将原来创建的下级类，改为传参的方式（也就是注⼊的方式），因为我们不需要在当前类中创建下级类了，当前类只是向外描述了我需要一个什么类，所以下级类即使发⽣变化（创建或减少参数），当前类本身也无需修改任何代码，这样就完成了程序的解耦。

说到这里儿，就不得不提一下啥是 “解耦”

高内聚低耦合（high cohesion and low coupling）是一种软件设计思想，可以有效地提高软件的可维护性和灵活性。

高内聚：指的是一个模块内部的元素彼此之间紧密相关，完成一个特定的、明确的任务，而不与其他外部元素产生过多的交互。

低耦合：指的是模块之间的相互依赖尽可能地低，模块之间只是完成部分纯粹的任务时才会进行互动，以减少相互影响，提高软件的灵活性和可扩展性。

使用高内聚低耦合的原则可以让软件系统更加灵活和易于维护。高内聚能够使得模块内部的逻辑更加清晰明确，每个模块都有特定的职责，易于理解和维护；低耦合能够降低模块之间的相互依赖，当需要修改或重构时，减少了对其他模块的影响，提高了软件的可维护性和可扩展性。

基于上述思路，我们把构建房屋的程序示例改造⼀下，把创建子类的方式，改为注入传递（传参）的方式，具体实现代码如下：

//这是一个房子类
public class House {
    BuildingFame buildingFame = null;
    //一个房子需要依赖房屋的架构
    public House(BuildingFame buildingFame) {
        this.buildingFame = buildingFame;
        System.out.println("这是一个房子");
    }

    public void init() {
        //依赖于房屋架构
        System.out.println("执行了初始化房屋架构的方法");
        buildingFame.init();
    }
}

//房屋构架
class BuildingFame {
    //房屋的架构依赖与建筑材料
    BuildingMaterials buildingMaterials = null;
    public BuildingFame(BuildingMaterials buildingMaterials) {
        this.buildingMaterials = buildingMaterials;
    }

    public void init() {
        //依赖于建筑材料
        System.out.println("执行了初始化建筑材料的方法");
        buildingMaterials.init();
    }
}

//建筑材料
class BuildingMaterials {
    //建筑材料依赖于地基
    Foundation foundation = null;
    public BuildingMaterials(Foundation foundation) {
        this.foundation = foundation;
    }

    public void init() {
        //依赖于地基
        System.out.println("执行了初始化地基的方法");
        foundation.init();
    }
}

//地基
class Foundation {
    String size = "100 m*m";
    public Foundation(String size) {
        this.size = size;
    }

    public void init() {
        //依赖于地基
        System.out.println("地基：" + size);
    }
}

使用 loC 控制反转思想后, 无论被依赖类如何变化，对于整个调用链的影响是微乎其微的，这样就完成了代码之间的解耦，提高程序的灵活性和可扩展性。

小结：

通过以上两个实例，我们可以发现，两个实例类创建的顺序是反着的，传统的代码 House 控制并创建了 BuildingFame , BuildingFame 创建了 BuildingMaterials …… 依次往下创建，使用 loC 控制反转后，不再是上层对象创建并控制下层对象，而是把下层对象注入到当前对象中，这样下级类发生任何改变，也不会对当前类产生任何影响，这就是 loC 的实现思想。

1.2 Spring 是一个 loC 容器

上文讲到，用一句话概括 Spring : 包含了多个工具方法的 loC 容器。博主也通过示例给大家阐述了什么是 loC （控制反转）思想。

重点还是在 “容器” 上，既然是一个容器，那么它就具备两个最基础的功能：

将对象存入容器中；
从容器中取出对象；

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

将创建好的对象放在容器中的好处：对象存储在 loC 容器中，就好比将工具放在工具箱内，需要的时候直接从工具中取就好了，用完工具之后再放回工具箱中， new 对象的方式就好比，每次需要使用工具的时候发现没有，只能现场去“买一个”，用完之后也不保存，下次再需要的时候还得去“买”，这就是 loC 容器和普通程序开发的本质区别。

如何将对象存入到 Spring 中，如何从 Spring 中获取对象，将是下一期的核心，尽请期待。

1.3 DI 的概念

提起 loC 设计思想，就不得不提到 “DI” （Dependency Injection 的缩写——“依赖注入”）

“依赖注入” 指的就是由 IoC 容器在运行期间（程序运行期间），动态地将某种依赖关系注入到对象之中。传统的做法是由程序主动去找他所依赖的对象然后进行实例化，而DI则是由容器主动地将依赖关系注入到对象中。这样做的好处是对象之间解耦，提高了代码的复用性和可维护性。通过DI可以统一控制对象的生命周期，减少了资源的浪费。

站在广义的角度 loC 与 DI 描述的同一个东西，站在不同的角度 loC 是一种设计思想（控制反转）、指导原则，DI 则是 loC 思想的具体实现——IoC 容器在运⾏期间（程序运行期间），动态地将某种依赖关系注入到对象之中。

存放在 Spring 中的对象也被称之为 “Bean 对象”。

举个例子：我需要房子，

loC ：我觉得盖一座房子需要先打基地，在去买建筑材料，再把整个房子构架搭起来，装修慢慢搞，那么这是一种盖房子设计思想以及目的。

DI : 喂喂，张老板我想盖房子，你派挖掘机过来帮我挖一下地基，喂喂，李老板，我想盖房子，你帮我运些沙石，钢筋混泥土过来…… ，喂喂，王老板，是这样的，我想盖个房子，你安排一下工人帮我盖房子呗，地基和建筑材料都已经到位了，价钱好商量。DI 是指导思想的具体是实现。

好了，到这里，【Spring】核心与设计思想 博主已经分享完了，希望对大家有所帮助，如有不妥之处欢迎批评指正。