Spring的开幕式——Spring概述与设计思想

⭐️前面的话⭐️

本篇文章介绍Spring的定义，相比于与Servlet的优势，学习难点，以及Spring基本设计思想，Ioc控制反转，DI等。

📒博客主页：未见花闻的博客主页
🎉欢迎关注🔎点赞👍收藏⭐️留言📝
📌本文由未见花闻原创，CSDN首发！
📆首发时间：🌴2022年7月21日
💭推荐书籍：📚《Spring实战》
💬参考在线编程网站：🌐牛客网🌐力扣
博主的码云gitee，平常博主写的程序代码都在里面。
博主的github，平常博主写的程序代码都在里面。
🍭作者水平很有限，如果发现错误，一定要及时告知作者哦！感谢感谢！

📌导航小助手📌

封面区

1.Spring系列框架概述

1.1什么是Spring框架

我们通常所说的 Spring 指的是 Spring Framework（Spring 框架），它是⼀个开源框架，有着活跃而庞大的社区，这就是它之所以能长久不衰的原因。Spring 支持广泛的应用场景，它可以让 Java 企业级的应用程序开发起来更简单。

⽤⼀句话概括 Spring：Spring 框架是包含了众多⼯具⽅法的 IoC 容器。

1.2为什么要学习框架？

因为学习框架相当于从“⼩作坊”到“⼯⼚”的升级，⼩作坊什么都要⾃⼰做，⼯⼚是组件式装配，特点就是⾼效。框架更加易⽤、简单且⾼效。

使⽤ Spring Boot 项⽬演示框架相⽐于 Servlet 所具备的以下优点：

⽆需配置 Tomcat，点击“运⾏”按钮就可以运⾏项⽬，因为Spring Boot 内置了 Web 容器可直接运行，但是Servlet需外挂Tomcat。
快速添加外部 jar 包。
快速发布项⽬（使⽤ java -jar ⽅式就可以发布）。
对象⾃动装配。
添加路由更加⽅便，⽆需每个访问地址都添加⼀个类。
…

或者说使用Servlet相比于Spring Boot有以下的不足：

添加外部 jar 不⽅便，容易出错，⽐如添加了⼀个不匹配的外部 jar 版本；
运⾏和调试的时候需要配置 tomcat 不⽅便；
发布不⽅便，servlet 项⽬必须依靠外置的 tomcat（外置的 web 容器）运⾏。
路由配置不⽅便，⼀个访问地址对应⼀个 Servlet 类。
…

1.3Spring框架学习的难点

配置⽐较多。
需要⼤量的外部 jar 包，在下载时容易出错。
会涉及简单的软件⼯程的设计思想（分层思想：前后端的分层思想；后端⼯程的分层思想）。
知识点相对来说⽐之前的知识更加的分散，要仔细听才能搞懂各个知识点的逻辑关系。
要记的东⻄很多，所以要⼤量地重复练习才能记住，⽐如各种注解。

Spring框架基本学习路线：Spring->Spring Boot->Spring MVC->MyBatis等

2.Spring框架设计思想

2.1Spring框架的概念

一句话： Spring 框架是包含了众多工具方法的 IoC 容器。

2.2容器是什么？

容器是用来容纳某种物品的（基本）装置。 就比如Map与Set属于数据储存的容器，Tomcat属于Web容器，同理Spring是一个Ioc容器，它包含了许多的工具和方法。

2.3Ioc是什么？

Ioc即

IoC = Inversion of Control

，直译过来就是控制反转的意思，这是一个比较抽象的概念，我们来通过一个例子来了解它。

我们都知道汽车，它包含轮胎，底座，车身等，我们造一辆汽车时，需要有车身，而车身需要有轮胎，最原始的想法就是造车时，需要车身，于是就

new

一个车身，而车身需要底座，于是就

new

一个底座，同理底座需要轮胎，那就造底座前

new

一个轮胎。

我们不难得到以下代码：

publicclassNewCarExample{publicstaticvoidmain(String[] args){Car car =newCar();
        car.init();}/**
     * 汽⻋对象
     */staticclassCar{publicvoidinit(){// 依赖⻋身Framework framework =newFramework();
            framework.init();}}/**
     * ⻋身类
     */staticclassFramework{publicvoidinit(){// 依赖底盘Bottom bottom =newBottom();
            bottom.init();}}/**
     * 底盘类
     */staticclassBottom{publicvoidinit(){// 依赖轮胎Tire tire =newTire();
            tire.init();}}/**
     * 轮胎类
     */staticclassTire{// 尺⼨privateint size =30;publicvoidinit(){System.out.println("轮胎尺⼨："+ size);}}}

但是，我们的产品不是一成不变的，产品经理提出一个需求，说这个轮胎大小希望可以个性化，在产品经理眼里，这个问题的解决方案只是改一个参数而已，但是根据我们上面写的代码，我们需要往轮胎

Tire

类的构造方法加上一个参数，由于底盘

Bottom

类控制着

Tire

类，那么底盘类的构造方法也需要加上一个参数，以此类推，我们的车身

Framework

类与汽车

Car

类都需要为构造方法加上参数，于是我们得到了如下的代码：

publicclassNewCarUpdateExample{publicstaticvoidmain(String[] args){Car car =newCar(20);
        car.run();}/**
     * 汽⻋对象
     */staticclassCar{privateFramework framework;publicCar(int size){
            framework =newFramework(size);}publicvoidrun(){// 依赖⻋身
            framework.init();}}/**
     * ⻋身类
     */staticclassFramework{privateBottom bottom;publicFramework(int size){
            bottom =newBottom(size);}publicvoidinit(){// 依赖底盘
            bottom.init();}}/**
     * 底盘类
     */staticclassBottom{privateTire tire;publicBottom(int size){
            tire =newTire(size);}publicvoidinit(){// 依赖轮胎
            tire.init();}}/**
     * 轮胎类
     */staticclassTire{// 尺⼨privateint size;publicTire(int size){this.size = size;}publicvoidinit(){System.out.println("轮胎尺⼨："+ size);}}}

这样，如果需要个性化定制轮胎的大小，就可以只改动构造

Car

对象传入的参数就可以了。但是，如果产品经理又加上一个需求，说要定制轮胎的颜色，那我们又要加参数，加参数就意味着代码都得改，这样的代码耦合性太高了，为了解决这个问题，我们可以依据

loc

的思想，我们将控制权交出去，换句话说，需要轮胎

Tire

类时，你给我传一个

Tire

对象，我不去

new

一个

Tire

对象了，这样的话，就算在

Tire

类加参数也只需要改动

Tire

类的构造方法与相关执行方法与属性，顶多再改一下

Tire

对象的创建，同理其他类也一样，将对象作为参数传入到上级类的构造方法中去就行了，这个过程也叫做传入或注入。
loc
由于我们创建

Car

时需要

Framework

，所以先要实例一个

Framework

对象，同理实例一个

Framework

对象需要

Bottom

对象，那么需先实例一个

Bottom

对象，一样，在实例

Bottom

对象之前需要实例一个

Tire

对象，于是需要先后创建

Tire

对象，

Bottom

对象，

Framework

对象后才能创建一个

Car

对象，我们可以得到如下的代码：

publicclassIocCarExample{publicstaticvoidmain(String[] args){Tire tire =newTire(20);Bottom bottom =newBottom(tire);Framework framework =newFramework(bottom);Car car =newCar(framework);
        car.run();}staticclassCar{privateFramework framework;publicCar(Framework framework){this.framework = framework;}publicvoidrun(){
            framework.init();}}staticclassFramework{privateBottom bottom;publicFramework(Bottom bottom){this.bottom = bottom;}publicvoidinit(){
            bottom.init();}}staticclassBottom{privateTire tire;publicBottom(Tire tire){this.tire = tire;}publicvoidinit(){
            tire.init();}}staticclassTire{privateint size;publicTire(int size){this.size = size;}publicvoidinit(){System.out.println("轮胎："+ size);}}}

所以如果产品经理更改了需求，需要加参数或减少参数，Ioc的代码只需改动图中的两处代码即可，达到了解耦的目的。

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

所以Ioc有以下的优点：对象(Bean)的生命周期交给Ioc框架维护，作为程序员无需关注，说白点就是程序员不需要关注对象创建和销毁时机，这些工作加个Ioc框架（也就是Spring）做就行。

2.4Spring 是Ioc容器

我们知道Spring框架包含了多个工具方法放入Ioc容器，既然是容器，那它就有存于取的功能，这也是Spring最核心的功能：

将Bean（对象）存储到Spring容器中。
将Bean（对象）从Spring容器中取出来。

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

2.5DI（依赖注入）

DI，即

Dependency Injection

，依赖注入。在

pom.xml

有一个依赖项，用来导入外部的资源，而这里的依赖注入，导入的不是外部的资源，而是对象。

所谓依赖注⼊，就是由 IoC 容器在运⾏期间，动态地将某种依赖关系注⼊到对象之中。所以，依赖注⼊（DI）和控制反转（IoC）是从不同的⻆度的描述的同⼀件事情，就是指通过引⼊ IoC 容器，利⽤依赖关系注⼊的⽅式，实现对象之间的解耦。

Ioc与DI的区别是什么？

Ioc是一种思想，而DI是一种实现。

下期预告：spring 项目创建
觉得文章写得不错的老铁们，点赞评论关注走一波！谢谢啦！
1-99

标签： spring java 后端

本文转载自: https://blog.csdn.net/m0_59139260/article/details/125583700
版权归原作者 未见花闻 所有，如有侵权，请联系我们删除。