Spring框架概述及核心设计思想

文章目录

  • 一. Spring框架概述
    • 1. 什么是Spring框架
    • 2. 为什么要学习框架？
    • 3. Spring框架学习的难点
  • 二. Spring核心设计思想
    • 1. 容器是什么？
    • 2. IoC是什么？
    • 3. Spring是IoC容器
    • 4. DI（依赖注入）
    • 5. DL（依赖查找）

一. Spring框架概述

1. 什么是Spring框架

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

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

2. 为什么要学习框架？

因为学习框架相当于从“小作坊”到“工厂”的升级，小作坊什么都要自己做，工厂是组件式装配，特点就是高效。

框架更加易⽤、简单且高效。

Servlet有以下痛点：

  1. 添加外部 jar 不⽅便，容易出错，比如添加了⼀个不匹配的外部 jar 版本。
  2. 运行和调试的时候需要配置 Tomcat 不⽅便。
  3. 发布不方便，Servlet 项目必须依靠外置的 Tomcat（外置的 Web 容器）运行。
  4. 路由配置不方便，⼀个访问地址对应⼀个 Servlet 类。
  5. …

而 Spring Boot 相比于 Servlet 具备以下优点：

  1. 快速添加外部 jar 包。
  2. 调试项目更方便，无需配置 Tomcat，点击“运行”按钮就可以直接运行项目，因为 Spring Boot 内置了 Tomcat 容器可直接运行，但是 Servlet 需外挂 Tomcat。
  3. 发布项目更加方便，无需配置 Tomcat，使用 java -jar 方式就可以发布。
  4. 对象自动装配。
  5. 添加路由更加方便，无需每个访问地址都添加⼀个类。
  6. …

3. Spring框架学习的难点

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

Spring框架基本学习应用路线：Spring全家桶（Spring/Spring Boot/Spring MVC) -> MyBatis -> Redis 等。

二. Spring核心设计思想

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

那么这句话怎么理解呢？什么是容器？什么又是 IoC？

1. 容器是什么？

容器是用来容纳某种物品的（基本）装置。 ——来⾃：百度百科

Java 中也有一些容器，比如 List，Map，Set 等这些集合，是属于数据储存的容器，它把我们常用的操作都封装到集合中了，我们只需要知道集合为我们提供的方法就可以使用各种集合了；还有 Tomcat 是属于 Web 容器，同理 Spring 是就一个 IoC 容器，它包含了许多的工具和方法。

2. IoC是什么？

IoC 即 Inversion of Control，直译过来就是控制反转的意思，这是一种思想，控制权反转，在 Java 的常规代码中，对象的生命周期，是由当前代码（程序员自己）控制的，而控制权反转就是对象的生命周期，不再由当前代码片段来控制，而是由 Spring（IoC 容器）来控制 。

这种思想还比较抽象，我们来通过一个例子来了解它。

我们都知道汽车，它包含轮胎，底座，车身等，现在我们要造一辆汽车时，需要有车身，而车身需要有底座和轮胎，最传统的思想就是造车时，需要车身，于是就new一个车身，而车身需要底座，于是就再new一个底座，同理底座需要轮胎，那就造底座前new一个轮胎。
img

我们可以得到以下代码：

package old;

/**
 * 传统开发方式, 耦合性问题
 */
// 汽车类
public class Car {
    // 车身
    private Framework framework;

    public Car() {
        framework = new Framework();
    }

    public void init() {
        System.out.println("do car");
        // 汽车的组建依赖于车身
        framework.init();
    }
}

package old;

// 车身类
public class Framework {
    private Bottom bottom;

    public Framework() {
        bottom = new Bottom();
    }

    public void init() {
        System.out.println("do framework");
        // 车身的组建依赖于底盘
        bottom.init();
    }
}

package old;

// 底盘类
public class Bottom {
    private Tire tire;

    public Bottom() {
        tire = new Tire();
    }

    public void init() {
        System.out.println("do bottom");
        // 底盘的组建依赖于轮胎
        tire.init();
    }
}

package old;

// 轮胎类
public class Tire {
    private int size = 17; // 轮胎的尺寸
    public void init() {
        System.out.println("size -> " + size);
    }
}

package old;

public class Test {
    public static void main(String[] args) {
        Car car = new Car();
        car.init();
    }
}

但是，但上面的代码中，轮胎的大小是固定写死的， 然而随着对的车的需求量越来越大，个性化需求也会越来越多，这 时候我们就需要加⼯多种尺寸的轮胎，那这个时候就要对上面的程序进行修改了，根据我们上面写的代码，我们需要往轮胎Tire类的构造方法加上一个参数，由于底盘Bottom类控制着Tire类，那么底盘类的构造方法也需要加上一个参数，以此类推，我们的车身Framework类与汽车Car类都需要为构造方法加上参数，于是我们得到了如下的代码：

package old;

/**
 * 传统开发方式, 耦合性问题
 */
// 汽车类
public class Car {
    // 车身
    private Framework framework;

    public Car(int size) {
        framework = new Framework(size);
    }

    public void init() {
        System.out.println("do car");
        // 汽车的组建依赖于车身
        framework.init();
    }
}

package old;

// 车身类
public class Framework {
    private Bottom bottom;

    public Framework(int size) {
        bottom = new Bottom(size);
    }

    public void init() {
        System.out.println("do framework");
        // 车身的组建依赖于底盘
        bottom.init();
    }
}

package old;

// 底盘类
public class Bottom {
    private Tire tire;

    public Bottom(int size) {
        tire = new Tire(size);
    }

    public void init() {
        System.out.println("do bottom");
        // 底盘的组建依赖于轮胎
        tire.init();
    }
}

package old;

// 轮胎类
public class Tire {
    private int size = 17; // 轮胎的尺寸

    public Tire(int size) {
        this.size = size;
    }

    public void init() {
        System.out.println("size -> " + size);
    }
}

package old;

public class Test {
    public static void main(String[] args) {
        Car car = new Car(20);
        car.init();
    }
}

此时，如果需要个性化定制轮胎的大小，就可以只改动构造Car对象传入的参数就可以了；但是，如果再加上加上一个需求，还要定制轮胎的颜色，那我们又要加参数，此时就意味着像上面一样修改最底层的代码， 整个调⽤链上的所有代码都需要修改。

这样的代码耦合性就太高了，为了解决这个问题，我们可以使用loC的思想来实现代码，将控制权交出去，也就是说，IoC模式下，我们不再自己构造创建对象，当我们需要轮胎Tire类时，你就给我传一个Tire对象，我们不去new一个Tire对象了，这样的话，就算在Tire类加参数也只需要改动Tire类的构造方法与相关执行方法与属性，顶多再改一下Tire对象的创建，同理其他类也一样，将对象作为参数传入到上级类的构造方法中去就行了，但此时其他类是不需要修改的，这个过程也叫做传入或注入。
img
由于我们创建Car时需要Framework，所以先要实例一个Framework对象，同理实例一个Framework对象需要Bottom对象，那么需先实例一个Bottom对象，一样，在实例Bottom对象之前需要实例一个Tire对象，于是需要先后创建Tire对象，Bottom对象，Framework对象后才能创建一个Car对象，我们可以得到如下的代码：

package ioc;

public class Car {
    // 汽车的组建依赖于车身的组建
    private Framework franmework;

    public Car(Framework franmework) {
        this.franmework = franmework;
    }
    public void init() {
        System.out.println("do car...");
        franmework.init();
    }
}

package ioc;

public class Framework {
    // 车身的组建依赖于底盘
    private Bottom bottom;

    public Framework(Bottom bottom) {
        this.bottom = bottom;
    }
    public void init() {
        System.out.println("do franmework");
        bottom.init();
    }
}

package ioc;

public class Bottom {
    // 底盘的组建依赖于轮胎
    private Tire tire;

    public Bottom(Tire tire) {
        this.tire = tire;
    }

    public void init() {
        System.out.println("do bottom...");
        tire.init();
    }
}

package ioc;

public class Tire {
    private int size = 17;
    private String color = "黑色";

    public Tire(int size, String color) {
        this.size = size;
        this.color = color;
    }

    public void init() {
        System.out.println("size -> " + size);
        System.out.println("color->" + color);
    }
}

package ioc;

public class IOCDemo {
    // 这里的内容包含就相当于是 IoC 容器做的事情
    // 对象的生命周期控制权就翻转给 IoC 容器了, 不再由程序员控制
    private Tire tire;
    private Bottom bottom;
    private Framework framework;
    public Car car;
    public IOCDemo() {
        tire = new Tire(17, "红色");
        bottom = new Bottom(tire);
        framework = new Framework(bottom);
        car = new Car(framework);
    }
}

package ioc;

/**
 * 模拟 IoC 容器
 */
public class Test {
    public static void main(String[] args) {
        // 直接使用, 创建就交给IoC了
        IOCDemo ioc = new IOCDemo();
        Car car = ioc.car;
        car.init();
    }
}

此时如果要变需求，需要加参数或减少参数，IoC 的代码只需改动图中的两处代码即可， 整个调用链是不用做任何改变的， 达到了解耦的目的。

img
img

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

到这里我们就可以发现，传统的代码类创建顺序是反着的，Car 控制 FrameWork，FrameWork 控制着 Bottom，Bottom 控制着 Tire；而改进之后的控制权发生了反转，是下层将对象注入到当前对象当中，下级的控制权不再由上级控制了，下级在发生改变时会将改变完成后的对象注入上级，这样上级就是不受影响的，这就是 IoC 的实现思想。

所以 IoC 有以下的优点：对象（Bean）的生命周期交给 IoC 框架维护，作为程序员无需关注，说白了就是程序员不需要关注对象创建、销毁时机以及对象的依赖关系，这些工作加个 IoC 框架（也就是 Spring）做就行，实现了代码的解耦，对象的使用更加方便高效。

3. Spring是IoC容器

Spring 框架就是包含了多个工具方法的 IoC 容器，既然是容器，那它就有存和取的功能，这也是 Spring 最核心的两个功能：

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

将对象存放到容器有什么好处呢?
将对象存储到 IoC 容器相当于我们将所有可能用到的工具制作好都放到仓库，当我们需要使用时直接取即可，用完归还仓库；而 new 对象的方式相当于我们每次需要用工具的时候现场制作，制作完了扔掉，下次需要的时候重新做。

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

4. DI（依赖注入）

DI，即Dependency Injection，依赖注入。

所谓依赖注⼊，就是由 IoC 容器在运行期间，动态地将某种依赖关系注入到对象之中，在pom.xml有一个依赖项，就是用来导入外部的资源，而这里的依赖注入，导入的不是外部的资源，而是对象；当某个 Java 实例需要另一个 Java 实例时，创建被调用者的工作不是由调用者实现，而是由 Spring 容器来完成，然后注入调用者，因此称为依赖注入。

IoC 与 DI 的区别是什么？

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

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

5. DL（依赖查找）

DL，即Dependency Lookup，依赖查找，也是 IoC的一种实现。

依赖查找和依赖注入的区别在于，依赖注入是将依赖关系委托给容器，由容器来管理对象之间的依赖关系，容器外部是不关心这种依赖关系的，需要时由容器判断提供什么；而依赖查找是由对象自己来查找它所依赖的对象，容器只负责管理对象的生命周期，也就是说此时需要容器外部自己确定要容器提供哪种依赖关系；两者之间是主动和被动的区别。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/40719.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

2023-7-13-第十八式观察者模式

2023-7-13-第十八式观察者模式

🍿*★,*:.☆(￣▽￣)/$:*.★* 🍿 💥💥💥欢迎来到🤞汤姆🤞的csdn博文💥💥💥 💟💟喜欢的朋友可以关注一下&#xf…
阅读更多...
2023年iOS App Store上架流程详解（上）

2023年iOS App Store上架流程详解（上）

目录 1.注册开发者账号 2.登录并配置人员 3.申请证书和配置文件 一.证书管理​ 二.新建证书​ 三.使用appuploader服务同步证书​ 1）申请证书 2）添加Identifiers和配置App ID 3）申请配置文件 1.在Xcode项目中配置签名 2.上传应用包…
阅读更多...
谷歌和加州大学伯克利分校的“改革者”在单个GPU上运行64K序列

谷歌和加州大学伯克利分校的“改革者”在单个GPU上运行64K序列

转换器模型是自然语言处理（NLP）研究领域越来越流行的神经网络架构，大型变压器可以在许多任务上实现最先进的性能。代价是转换器过多的计算消耗和成本，尤其是对于长序列上的训练模型。 谷歌和加州大学伯克利分校的研究人员最近发表…
阅读更多...
设计模式——解释器模式

设计模式——解释器模式

解释器模式 定义 解释器模式（Interpreter Pattern）是一种按照规定语法进行解析的模式，现实项目中用得较少。 给定一门语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句…
阅读更多...
Java 设计模式——观察者模式

Java 设计模式——观察者模式

目录 1.概述2.结构3.案例实现3.1.抽象观察者3.2.观察对象3.3.具体观察者3.4.具体观察对象3.5.测试 4.优缺点5.使用场景6.JDK 源码解析——Observable / Observer6.1.Observable 类6.2.Observer 接口6.3.案例 1.概述 观察者模式 (Observer Pattern) 是一种行为型设计模式&#…
阅读更多...
HP惠普暗影精灵9笔记本原装出厂Win11系统预装专用OEM系统镜像

HP惠普暗影精灵9笔记本原装出厂Win11系统预装专用OEM系统镜像

暗影9笔记本电脑原厂Windows11系统包 OMEN by HP 16.1英寸游戏本16-wf0000,16-wf0001,16-wf0003,16-wf0004,16-wf0006,16-wf0008,16-wf0009,16-wf0010,16-wf0011,16-wf0012,16-wf0028,16-wf0029,16-wf0007,16-wf0032,16-wf0036,16-wf0043 链接：https://pan.baidu.…
阅读更多...
[SQL系列] 从头开始学PostgreSQL Union Null 别名 触发器

[SQL系列] 从头开始学PostgreSQL Union Null 别名 触发器

初级的操作就是CRUD，但是高级的操作也是CRUD，只是语句写的更加复杂，不再是select * from table；这样简单，这次咱们学一些稍微高级点的。下面是上一篇文章。 [SQL系列] 从头开始学PostgreSQL 约束连接_Edward.W的博客-…
阅读更多...
划片机的作用将晶圆分割成独立的芯片

划片机的作用将晶圆分割成独立的芯片

划片机是将晶圆分割成独立芯片的关键设备之一。在半导体制造过程中，晶圆划片机用于将整个晶圆切割成单个的芯片，这个过程被称为“晶圆分割”或“晶圆切割”。 晶圆划片机通常采用精密的机械传动系统、高精度的切割刀具和先进的控制系统，以确保…
阅读更多...
【C++ 重要知识点总结】表达式

【C++ 重要知识点总结】表达式

表达式 1 基础 组合运算 优先级结合律 类型转换 运算符重载 左值和右值 2 算数运算符 3 逻辑和关系运算法 短路求值 逻辑与，当第一个判定为否的时候，不再执行第二个判定，可以用来屏蔽第二步的计算，代替条件判断&#xff0…
阅读更多...
rabbitmq延时队列自动解锁库存

rabbitmq延时队列自动解锁库存

一、库存服务自动解锁库存 使用了最终一致性来解决分布式事务 当order服务出现异常回滚，此时ware服务无法回滚，怎么办？ 使用seata全局事务虽然能在order服务出现异常导致回滚时使其他服务的也能同时回滚，但在流量大的情况下是使用…
阅读更多...
【SpringBoot】从零开始封装自己的starter并且引入到其他项目中使用

【SpringBoot】从零开始封装自己的starter并且引入到其他项目中使用

从零开始封装自己的starter并且引入到其他项目中使用 简介 本文将介绍如何从零开始封装自己的starter并且引入到其他项目中使用 为什么要自己封装starter？ 这样可以对spring以及其他第三方提供的starter做二次封装或者封装一些自己需要的内容提供给其他项目使用&…
阅读更多...
【milvus】向量数据库，用来做以图搜图+人脸识别的特征向量

【milvus】向量数据库，用来做以图搜图+人脸识别的特征向量

1. 安装milvus ref:https://milvus.io/docs 第一次装东西，要把遇到的问题和成功经验都记录下来。 1.Download the YAML file wget https://github.com/milvus-io/milvus/releases/download/v2.2.11/milvus-standalone-docker-compose.yml -O docker-compose.yml看…
阅读更多...
行为型模式 - 策略模式

行为型模式 - 策略模式

概述 先看下面的图片，我们去旅游选择出行模式有很多种，可以骑自行车、可以坐汽车、可以坐火车、可以坐飞机。 作为一个程序猿，开发需要选择一款开发工具，当然可以进行代码开发的工具有很多，可以选择Idea进行开发&…
阅读更多...
准备WebUI自动化测试面试？这30个问题你必须掌握（二）

准备WebUI自动化测试面试？这30个问题你必须掌握（二）

本文共有11000字，包含了后十五个问题，如需要前十五个问题，可查看文末链接~ 16. 在WebUI自动化测试中，你如何处理验证码或图像识别的问题？ 1. 人工识别：一种简单但费时费力的方法是使用人工手动识别验证码。…
阅读更多...
libbpf-bootstrap 开发指南：概念与如何安装

libbpf-bootstrap 开发指南：概念与如何安装

目录 概念 如何安装& 使用 git 地址 使用git clone 下载代码 安装依赖环境 安装libbpf 编译example 概念 libbpf-bootstrap 是一个项目，旨在帮助开发者快速启动和开发使用 eBPF (Extended Berkeley Packet Filter) 和 libbpf 的程序。eBPF 是一种可以在…
阅读更多...
如何用Three.js + Blender打造一个web 3D展览馆

如何用Three.js + Blender打造一个web 3D展览馆

作者：vivo 互联网前端团队- Wei Xing 运营活动新玩法层出不穷，web 3D炙手可热，本文将一步步带大家了解如何利用Three.js和Blender来打造一个沉浸式web 3D展览馆。 一、前言 3D展览馆是什么，先来预览下效果： 看起来像…
阅读更多...
element-ui message消息提示组件 ①延长提示消息在页面停留时间②提示消息换行

element-ui message消息提示组件 ①延长提示消息在页面停留时间②提示消息换行

以实现下面的效果为示例 完整代码&#xff1a; let msgList ["数据1被引用", "数据2被引用"];// 使用html的换行标签拼接信息&#xff0c;默认行距太小&#xff0c;此处用两个<br/><br/>let message 以下数据不能删除&#xff0c;原因是&…
阅读更多...
为什么很多公司都开始使用Go语言了？

为什么很多公司都开始使用Go语言了？

越来越多的互联网大厂开始使用Go语言了&#xff0c;譬如腾讯、美团、滴滴、百度、Google、bilibili... 还有最初使用Python的字节跳动&#xff0c;甚至已经全面拥向Go了。这么多国内外首屈一指的公司&#xff0c;都在开始使用它了&#xff0c;它到底有什么优势呢&#xff1f;这…
阅读更多...
Redis进阶底层原理-主从复制

Redis进阶底层原理-主从复制

Redis的主从节点都会记录对方的信息&#xff0c;核心还包括ReplicationID 和 offset &#xff0c; ReplicationID &#xff1a; 主从节点实例的ID &#xff0c;redis内部就是通过这个id去识别主从节点。offset&#xff1a;数据同步偏移量&#xff0c;也就是从节点每次从主节点同…
阅读更多...
硬中断、软中断详解

硬中断、软中断详解

文章目录 什么是中断&#xff1f; 什么是计算机的中断&#xff1f; 什么叫硬中断、什么叫软中断&#xff1f; 怎么查看硬中断、软中断 查看硬中断的运行情况 cat /proc/interrupts 查看软中断的运行情况 cat /proc/softirqs 怎么排查软中断过高的问题&#xff1f; 软中断注意事…
阅读更多...
最新文章

Copyright @ 2022~2023