Maven

Maven坐标

Maven中的坐标是资源的唯一标识,通过该坐标可以唯一定位资源位置。

  • Maven坐标的组成:
    • groupId:定义当前Maven项目隶属组织名称。
    • artifactId:定义当前Maven项目名称。
    • version:定义当前项目版本号。

依赖

依赖:指当前项目运行所需要的 jar 包,一个项目中可以引入多个依赖。

  • 配置:
    • 在 pom.xml 中编写 <dependencies> 标签。
    • 在 <dependencies> 标签中使用 <dependency> 引入坐标。
    • 定义坐标的 groupId、artifactId、version。
    • 点击刷新按钮,引入最新加入的坐标。

查找依赖坐标信息:https://mvnrepository.com/

  • 排除:

    • 在需要排除依赖的 <dependency> 中添加 <exclusions> 标签。
    • 在 <exclusions> 标签中使用 <exclusion> 指定需要排除的依赖。
    • 定义需要排除依赖的 groupId 和 artifactId。
  • 范围:
    在默认情况下,依赖的jar包可以在任何地方使用。可以通过<scope>...</scope>设置其作用范围。

    scope值 主程序 测试程序 打包(运行)
    compile(默认) Y Y Y
    test - Y -
    provided Y Y -
    runtime - Y Y

继承

  • 作用:简化依赖配置、统一管理依赖。
  • 实现:通过 <parent> ... </parent> 标签实现。

打包方式

打包方式 含义
jar 普通模块打包,Spring Boot 项目基本都是 jar 包(内嵌 Tomcat 运行)
war 普通 Web 程序打包,需要部署在外部 Tomcat 服务器中运行
pom parent工程或聚合工程,该模块不写代码,仅进行依赖管理

继承关系实现

  1. 创建 Maven 模块 xxx-parent,该工程为parent工程,设置打包方式为 pom(默认 jar)。
  2. 在子工程的 pom.xml 文件中,配置继承关系。
1
2
3
4
5
6
<parent>
<groupId>xxx</groupId>
<artifactId>xxx-parent</artifactId>
<version>1.0-SNAPSHOT</version>
<relativePath>../xxx-parent/pom.xml</relativePath>
</parent>

在子工程中,配置了继承关系之后,坐标中的 groupId 是可以省略的,因为会自动继承parent工程的。
relativePath 指定parent工程的 pom.xml 文件的相对位置(如果不指定,将从本地仓库/远程仓库查找该工程)。

  1. 在parent工程中配置各个工程共有的依赖(子工程会自动继承parent工程的依赖)。

    若parent子工程都配置了同一个依赖的不同版本,以子工程的为准。

版本锁定

统一管理依赖版本

  • 在 Maven 中,可以在parent工程的 pom.xml 文件中通过 <dependencyManagement> 统一管理依赖版本。
  • 子工程引入依赖时,无需指定 <version> 版本号,由parent工程统一管理。变更依赖版本时,只需在parent工程中统一修改。
  • dependencyManagement 配置
    • parent工程的 pom.xml :

      1
      2
      3
      4
      5
      6
      7
      8
      9
      <dependencyManagement>
      <dependencies>
      <dependency>
      <groupId>xxx</groupId>
      <artifactId>xxx</artifactId>
      <version>1.0.0</version>
      </dependency>
      </dependencies>
      </dependencyManagement>
    • 子工程引入依赖时:

      1
      2
      3
      4
      5
      6
      <dependencies>
      <dependency>
      <groupId>xxx</groupId>
      <artifactId>xxx</artifactId>
      </dependency>
      </dependencies>

自定义属性 / 引用属性

通过 <properties> 自定义属性,统一管理依赖版本。使用 ${属性名} 引用自定义属性。
参考示例:

  • parent工程配置:

    1
    2
    3
    4
    <properties>
    <lombok.version>1.18.24</lombok.version>
    <jjwt.version>0.9.0</jjwt.version>
    </properties>
  • 在 dependencyManagement 中引用:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    <dependencyManagement>
    <dependencies>
    <dependency>
    <groupId>xxx</groupId>
    <artifactId>xxx</artifactId>
    <version>${jjwt.version}</version>
    </dependency>
    </dependencies>
    </dependencyManagement>
  • 在 dependencies 中引用:

    1
    2
    3
    4
    5
    6
    7
    <dependencies>
    <dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>${lombok.version}</version>
    </dependency>
    </dependencies>

<dependencyManagement> 只负责管理依赖版本,不会自动引入依赖;子工程仍需在 <dependencies> 中声明需要使用的依赖。

聚合

  • 概念: 将多个 Maven 模块组织成一个整体,统一进行项目构建。
  • 聚合工程: 一个不包含业务功能的“空”工程,通常只有一个 pom.xml 文件。
  • 作用: 快速构建多个模块,无需根据依赖关系手动逐个构建,直接在聚合工程中执行构建即可。

配置方式

  • 在聚合工程的 pom.xml 文件中,通过 <modules> 标签指定需要聚合的子模块。
  • 每个 <module> 标签对应一个子模块的路径。
  • 示例代码:
    1
    2
    3
    4
    5
    6
    <!-- 聚合 -->
    <modules>
    <module>../模块一</module>
    <module>../模块二</module>
    <module>../模块三</module>
    </modules>

Web入门

HTTP协议

超文本传输协议,规定了浏览器和服务器之间数据传输的规则。

特点

1.基于TCP协议:面向连接,安全。
2.基于请求-响应模型:一次请求对应一次响应。
3.HTTP协议是无状态的协议,对事务处理没有记忆能力,每次请求-响应都是独立的。

  • 缺点:多次请求间不能共享数据。
  • 优点:速度快。

请求数据的格式

示例:

1
2
3
4
5
6
GET /brand/findAll?name=OPPO&status=1 HTTP/1.1
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9
Host: localhost:8080
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/...

请求行:请求数据第一行,包含请求方式、资源路径、协议及版本号。
请求头:第二行开始,格式:key:value。
请求体:只有POST请求才有的部分,用于存放请求参数。与请求行和请求头之间使用空行隔开。

  • 常见的请求头:

    请求头 说明
    Host 请求的主机名。
    User-Agent 浏览器版本,例如 Chrome 浏览器的标识类似 Mozilla/5.0 ... Chrome/79,IE 浏览器的标识类似 Mozilla/5.0 (Windows NT ...) like Gecko。
    Accept 表示浏览器能接收的资源类型,如 text/*、image/* 或 */*(表示所有类型)。
    Accept-Language 表示浏览器偏好的语言,服务器可以据此返回不同语言的网页。
    Accept-Encoding 表示浏览器支持的压缩类型,例如 gzip、deflate 等。
    Content-Type 请求主体的数据类型。
    Content-Length 请求主体的大小,单位为字节。
  • 请求方式:

    • GET:请求参数在请求行中,会使请求路径后面携带参数;没有请求体;GET请求大小有限制。
    • POST:请求参数在请求体中;POST请求大小无限制。

响应格式

示例:

1
2
3
4
5
6
7
8
HTTP/1.1 200 OK
Content-Type: application/json
Transfer-Encoding: chunked
Date: Tue, 10 May 2022 07:51:07 GMT
Keep-Alive: timeout=60
Connection: keep-alive

[{"id": 1, "brandName": "阿里巴巴", "companyName": "腾讯计算机系统有限公司", "description": "玩玩玩"}]

响应行:响应数据第一行,包含协议、状态码、描述。
响应头:从第二行开始,格式:key:value。
响应体:最后一部分,与响应行和响应头之间用空行隔开,存放响应数据。

  • 响应状态码:

    状态码 含义 说明
    1xx 响应中 临时状态码,表示请求已接收,告知客户端应继续请求,或者如果请求已完成则忽略它。
    2xx 成功 表示请求已被成功接收并处理完成。
    3xx 重定向 重定向到其他地方,让客户端再次发起请求以完成整个处理。
    4xx 客户端错误 处理发生错误,责任在客户端。例如:请求了不存在的资源、客户端未被授权、禁止访问等。
    5xx 服务器错误 处理发生错误,责任在服务器端。例如:程序抛出异常等。

    查找响应状态码:https://cloud.tencent.com/developer/chapter/13553

  • 常见的响应头:

    响应头 含义
    Content-Type 表示响应内容的类型,例如 text/html、application/json。
    Content-Length 表示响应内容的长度,单位为字节。
    Content-Encoding 表示响应内容使用的压缩算法,例如 gzip。
    Cache-Control 指示客户端如何缓存响应,例如 max-age=300 表示响应在新鲜度有效期内最多可缓存 300 秒。
    Set-Cookie 用于向浏览器发送 Cookie。

注意事项

HTTP协议默认端口号为80。

Web后端开发

请求响应

  • 请求HttpServletRequest:获取请求数据。
  • 响应HttpServletResponse:设置响应数据。
  • BS架构:Browser/Server,浏览器/服务器架构模式。客户端只需要浏览器,应用程序的逻辑和数据都存储在服务器。
  • CS架构:Client/Server,客户端/服务器架构模式。

请求

简单参数

  • 原始方式:在原始的Web程序中,获取请求参数,需要通过HttpServletRequest对象手动获取。
  • SpringBoot方式:参数名与形参变量名相同,定义形参即可接收参数。如果方法形参名称与请求参数名称不匹配,可以使用@RequestParam完成映射。

    @RequestParam中的require属性默认为true,代表该请求参数必须传递,如果不传递将报错。如果该参数是可选的,可以将require属性设置为false。

实体参数

  • 简单实体对象:请求参数名与形参对象属性名相同,定义POJO接收即可。
  • 复杂实体对象:请求参数名与形参对象属性名相同,按照对象层次结构关系即可接受嵌套POJO属性参数。

数组集合参数

  • 数组参数:请求参数名与形参数组名称相同且请求参数为多个,定义数组类型形参即可接收参数。
  • 集合参数:请求参数名与形参集合名称相同且请求参数为多个,使用@RequestParam绑定参数关系。

日期参数

使用@DateTimeFormat注解完成日期参数格式转换。

Json参数

JSON数据键名与形参对象属性名相同,定义POJO类型形参即可接收参数,需要使用@RequestBody标识。

路径参数

通过请求URL直接传递参数,使用{...}来标识该路径参数,需要使用@PathVariable获取路径参数。

响应

  • @ResponseBody

    • 类型:方法注解、类注解。
    • 位置:Controller方法/类上
    • 作用:将方法返回值直接响应。如果返回值类型是实体对象/集合,将会转换为JSON格式响应。
    • 说明:@RestController = @Controller + ResponseBody。
  • 统一响应结果:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    public class Result {
    private Integer code;
    private String message;
    private Object data;

    public Result() {
    }

    public Result(Integer code, String message, Object data) {
    this.code = code;
    this.message = message;
    this.data = data;
    }

    public Integer getCode() {
    return code;
    }

    public void setCode(Integer code) {
    this.code = code;
    }

    public String getMessage() {
    return message;
    }

    public void setMessage(String message) {
    this.message = message;
    }

    public Object getData() {
    return data;
    }

    public void setData(Object data) {
    this.data = data;
    }

    // 成功响应
    public static Result success(Object data) {
    return new Result(200, "success", data);
    }

    // 失败响应
    public static Result error(String message) {
    return new Result(500, message, null);
    }
    }

其他

Springboot项目的静态资源(HTML/CSS/JS等前端资源)默认存放目录为:classpath:/static、classpath:/public、classpath:/resources。

分层解耦

三层架构

  • 控制层Controller:接收前端发送的请求,对请求进行处理,并响应数据。
  • 业务逻辑层Service:处理具体的业务逻辑。
  • 数据访问层(持久层)Dao:负责数据访问操作,包括数据的增、删、改、查。

分层解耦

  • 控制反转IOC:对象的创建控制权由程序自身转移到外部(容器)。
  • 依赖注入DI:容器为应用程序提供运行时,所依赖的资源。
  • Bean对象:IOC容器中创建、管理的对象。

IOC&DI

1.将Service层及Dao层的实现类交给IOC容器管理。使用@Component注解。
2.为Controller及Service注入运行时依赖的对象。使用@Autowired注解。
3.运行测试。

Bean的声明

注解 说明 使用位置
@Component 声明 Bean 的基础注解 不属于以下三类时使用
@Controller @Component 的衍生注解 控制器类上
@Service @Component 的衍生注解 业务类上
@Repository @Component 的衍生注解 数据访问类上(由于与 MyBatis 整合,使用较少)

声明 bean 的时候,可以通过 value 属性指定 Bean 的名字,如果没有指定,默认为类名首字母小写。
使用以上四个注解都可以声明 Bean,但是在 SpringBoot 集成 Web 开发中,声明控制器 Bean 只能用 @Controller。

Bean的组件扫描

  • 声明 Bean 的注解需要被组件扫描注解 @ComponentScan 扫描后,才会生效。
  • @ComponentScan 注解虽然没有显式配置,但是实际上已经包含在了启动类声明注解 @SpringBootApplication 中,默认扫描的范围是启动类所在包及其子包。

Bean注入

  • @Autowired注解默认是按照类型进行的,如果存在多个相同类型的Bean将报错。
  • 解决方法:
    • @Primary
    • @Autowired+@Qualifier(“Bean的名称”)`
    • @Resource(name="Bean的名称")

@Autowired 是 Spring 框架提供的注解,而 @Resource 是 JDK 提供的注解。
@Autowired 默认是按照类型注入,而 @Resource 默认是按照名称注入。

MySQL

SQL通用语法

  • SQL 语句可以单行或多行书写,以分号结尾。
  • SQL 语句可以使用空格/缩进来增强语句的可读性。
  • MySQL 数据库的 SQL 语句不区分大小写。
  • 注释:
    • 单行注释:-- 注释内容 或 # 注释内容(MySQL 特有)
    • 多行注释:/* 注释内容 */

DDL

DDL,数据定义语言,用来定义数据库对象(数据库、表)。

数据库

  • 查询数据库:

    • 查询所有数据库:SHOW DATABASES;
    • 查询当前使用的数据库:SELECT DATABASE();
  • 使用数据库:USE 数据库名;

  • 创建数据库:CREATE DATABASE [IF NOT EXISTS] 数据库名;

    IF NOT EXISTS:如果数据库不存在,则创建;如果已存在,则不创建。

  • 删除数据库:DROP DATABASE [IF EXISTS] 数据库名;

    IF EXISTS:如果数据库存在,则删除;如果不存在,则不执行删除操作。

上述语法中的DATABESE也可以替换成SCHEMA。

表

创建表

1
2
3
4
CREATE TABLE 表名 (
字段1 字段类型 [约束] [COMMENT '字段注释'],
字段2 字段类型 [约束] [COMMENT '字段注释']
) [COMMENT '表注释'];
  • 约束:作用于表中字段上的规则,用于限制存储在表中的数据。用于保证数据库中数据的正确性、有效性和完整性。

    约束名称 作用 关键字
    非空约束 限制字段值不能为 NULL NOT NULL
    唯一约束 保证字段值唯一、不重复 UNIQUE
    主键约束 唯一标识一条记录,要求非空且唯一 PRIMARY KEY(AUTO_INCREMENT自增)
    默认约束 未指定字段值时,使用默认值 DEFAULT
    外键约束 建立两张表之间的关联,保证数据的一致性和完整性 FOREIGN KEY
  • 数据类型:

    • 数值类型:

      类型 大小(byte) 描述 备注
      tinyint 1 小整数值
      smallint 2 大整数值
      mediumint 3 大整数值
      int 4 大整数值
      bigint 8 极大整数值
      float 4 单精度浮点数值 float(5,2):5表示整个数字长度,2表示小数位个数
      double 8 双精度浮点数值 double(5,2):5表示整个数字长度,2表示小数位个数
      decimal 小数值(精度更高) decimal(5,2):5表示整个数字长度,2表示小数位个数
    • 字符串类型:

      类型 大小 描述
      char 0-255 bytes 定长字符串
      varchar 0-65535 bytes 变长字符串
      tinyblob 0-255 bytes 不超过255个字符的二进制数据
      tinytext 0-255 bytes 短文本字符串
      blob 0-65 535 bytes 二进制形式的长文本数据
      text 0-65 535 bytes 长文本数据
      mediumblob 0-16 777 215 bytes 二进制形式的中等长度文本数据
      mediumtext 0-16 777 215 bytes 中等长度文本数据
      longblob 0-4 294 967 295 bytes 二进制形式的极大文本数据
      longtext 0-4 294 967 295 bytes 极大文本数据
    • 日期时间类型:

      类型 大小(byte) 格式 描述
      date 3 YYYY-MM-DD 日期值
      time 3 HH:MM:SS 时间值或持续时间
      year 1 YYYY 年份值
      datetime 8 YYYY-MM-DD HH:MM:SS 混合日期和时间值
      timestamp 4 YYYY-MM-DD HH:MM:SS 混合日期和时间值,时间戳

查询

  • 查询当前数据库所有表:SHOW TABLES;
  • 查询表结构:DESC 表名;
  • 查询建表语句:SHOW CREATE TABLE 表名;

修改

  • 添加字段:ALTER TABLE 表名 ADD 字段名 类型(长度) [COMMENT 注释] [约束];
  • 修改字段类型:ALTER TABLE 表名 MODIFY 字段名 新数据类型(长度);
  • 修改字段名和字段类型:ALTER TABLE 表名 CHANGE 旧字段名 新字段名 类型(长度) [COMMENT 注释] [约束];
  • 删除字段:ALTER TABLE 表名 DROP COLUMN 字段名;
  • 修改表名:RENAME TABLE 表名 TO 新表名;

删除

  • 删除表:DROP TABLE [IF EXISTS] 表名;

DML

DML,数据操作语言,用来对数据库中表的数据记录进行增、删、改操作。

  • INSERT添加数据:

    • 指定字段添加数据:INSERT INTO 表名 (字段名1, 字段名2) VALUES (值1, 值2);
    • 全部字段添加数据:INSERT INTO 表名 VALUES (值1, 值2, ...);
    • 批量添加数据(指定字段):INSERT INTO 表名 (字段名1, 字段名2) VALUES (值1, 值2), (值1, 值2);
    • 批量添加数据(全部字段):INSERT INTO 表名 VALUES (值1, 值2, ...), (值1, 值2, ...);
  • UPDATE修改数据:UPDATE 表名 SET 字段名1 = 值1, 字段名2 = 值2, ... [WHERE 条件];

  • DELETE删除数据:DELETE FROM 表名 [WHERE 条件];

    DELETE语句不能删除某一个字段的值。如要操作,可以使用UPDATE将该字段的值设置为NULL。

DQL

DQL,数据查询语言,用来查询数据库表中的记录。

  • 语法:
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    SELECT 
    字段列表
    FROM
    表名
    WHERE
    条件
    GROUP BY
    分组字段
    HAVING
    分组后条件
    ORDER BY
    排序字段
    LIMIT
    分页参数;

基本查询

  • 查询多个字段:SELECT 字段1, 字段2, 字段3 FROM 表名;
  • 查询所有字段(通配符* ):SELECT * FROM 表名;
  • 设置别名(AS 可省略):SELECT 字段1 [AS 别名1], 字段2 [AS 别名2] FROM 表名;
  • 去除重复记录:SELECT DISTINCT 字段列表 FROM 表名;

条件查询

  • 语法:SELECT 字段列表 FROM 表名 WHERE 条件列表;、
  • 运算符:
    • 比较运算符

      比较运算符 功能
      > 大于
      >= 大于等于
      < 小于
      <= 小于等于
      = 等于
      <> 或 != 不等于
      BETWEEN ... AND ... 在某个范围之内(含最小值、最大值)
      IN (...) 在 IN 之后的列表中的值,多选一
      LIKE 模糊匹配(_ 匹配单个字符,% 匹配任意个字符)
      IS NULL 判断值是否为 NULL
    • 逻辑运算符

      逻辑运算符 功能
      AND 或 && 并且(多个条件同时成立)
      OR 或 || 或者(多个条件任意一个成立)
      NOT 或 ! 非、不是

分组查询

  • 聚合函数:将一列数据作为一个整体,进行纵向计算。

    • 语法:select 聚合函数(字段列表) from 表名;

    • 函数:

      函数 功能
      count 统计数量
      max 最大值
      min 最小值
      avg 平均值
      sum 求和
    • 注意事项:
      1.ull 值不参与所有聚合函数运算。 2.统计数量可以使用:count()、count(字段)、count(常量),推荐使用 count()`。

  • 分组查询语法:select 字段列表 from 表名 [where 条件] group by 分组字段名 [having 分组后过滤条件];

    where 与 having区别:

    1. 执行时机不同:where是分组之前进行过滤,不满足 where条件,不参与分组;而 having是分组之后对结果进行过滤。
    2. 判断条件不同:where不能对聚合函数进行判断,而 having可以。

排序查询

  • 语法:select 字段列表 from 表名 [where 条件列表] [group by 分组字段] order by 字段1 排序方式1, 字段2 排序方式2, ...;
  • 排序方式:
    • ASC:升序(默认值)
    • DESC:降序

分页查询

  • 语法:select 字段列表 from 表名 limit 起始索引, 查询记录数;
  • 注意事项:
    1. 起始索引从 0 开始,起始索引 =(查询页码 - 1)* 每页显示记录数。
    2. 分页查询是数据库的方言,不同的数据库有不同的实现,MySQL 中是 LIMIT。
    3. 如果查询的是第一页数据,起始索引可以省略,直接简写为 limit 查询记录数。

条件判断函数与表达式

IF 函数

1
IF(条件表达式, true取值, false取值)

CASE 表达式

1
2
3
4
5
6
CASE 表达式
WHEN 值1 THEN 结果1
WHEN 值2 THEN 结果2
...
ELSE ...
END

多表设计

一对多

在数据库表中多的一方添加字段来关联“一”的一方的主键。

  • 外键约束:
    1
    2
    3
    4
    5
    6
    7
    8
    9
    -- 创建表时指定
    create table 表名(
    字段名 数据类型,
    ...
    [constraint] [外键名称] foreign key (外键字段名) references 主表 (字段名)
    );

    -- 建完表后,添加外键
    alter table 表名 add constraint 外键名称 foreign key (外键字段名) references 主表(字段名);

一对一

在任意一方加入外键,关联另外一方的主键,并且设置外键为唯一的(UNIQUE)。

多对多

建立第三张中间表,中间表至少包含两个外键,分别关联两方主键。、

多表查询

分类

  • 连接查询
    • 内连接:相当于查询A、B交集部分数据。
    • 外连接
      • 左外连接:查询左表所有数据(包括两张表交集部分数据)。
      • 右外连接:查询右表所有数据(包括两张表交集部分数据)。
  • 子查询

内连接

  • 隐式内连接:SELECT 字段列表 FROM 表1, 表2 WHERE 条件 ...;
  • 显式内连接:SELECT 字段列表 FROM 表1 [INNER] JOIN 表2 ON 连接条件 ...;

外连接

  • 左外连接:SELECT 字段列表 FROM 表1 LEFT [OUTER] JOIN 表2 ON 连接条件 ...;
  • 右外连接:SELECT 字段列表 FROM 表1 RIGHT [OUTER] JOIN 表2 ON 连接条件 ...;

子查询

  • 介绍:SQL语句中嵌套SELECT语句,称为嵌套查询,又称子查询。
  • 形式:SELECT * FROM t1 WHERE column1 = (SELECT column1 FROM t2 ...);
  • 子查询外部的语句可以是INSERT / UPDATE / DELETE / SELECT的任何一个,最常见的是SELECT。
  • 分类:
    • 标量子查询:子查询返回的结果为单个值。
    • 列子查询:子查询返回的结果为一列。
    • 行子查询:子查询返回的结果为一行。
    • 表子查询:子查询返回的结果为多行多列。

标量子查询

  • 子查询返回的结果是单个值(数字、字符串、日期等)。
  • 常用的操作符:= <> > >= < <=。

列子查询

  • 子查询返回的结果是一列(可以是多行)。
  • 常用的操作符:IN、NOT IN等。

行子查询

  • 子查询返回的结果是一行(可以是多列)。
  • 常用的操作符:=、<>、IN、NOT IN。

表子查询

  • 子查询返回的结果是多行多列,常作为临时表。
  • 常用的操作符:IN。

事务

介绍

事务是一组操作的集合,它是一个不可分割的工作单位。事务会把所有的操作作为一个整体一起向系统提交或撤销操作请求,即这些操作要么同时成功,要么同时失败。

默认MySQL的事务是自动提交的,也就是说,当执行一条DML语句,MySQL会立即隐式的提交事务。

操作

  • 开启事务:START TRANSACTION; / BEGIN;
  • 提交事务:COMMIT;
  • 回滚事务:ROLLBACK;

四大特性

  • 原子性(Atomicity):事务是不可分割的最小单元,要么全部成功,要么全部失败。
  • 一致性(Consistency):事务完成时,必须使所有的数据都保持一致状态。
  • 隔离性(Isolation):数据库系统提供的隔离机制,保证事务在不受外部并发操作影响的独立环境下运行。
  • 持久性(Durability):事务一旦提交或回滚,它对数据库中的数据的改变就是永久的。

索引

结构

  • B+Tree(多路平衡搜索树)
    • 每一个节点,可以存储多个key(有n个key,就有n个指针)。
    • 所有的数据都存储在叶子节点,非叶子节点仅用于索引数据。
    • 叶子节点形成了一颗双向链表,便于数据的排序及区间范围查询。

语法

  • 创建索引:CREATE [UNIQUE] INDEX 索引名 ON 表名 (字段名,...);
  • 查看索引:SHOW INDEX FROM 表名;
  • 删除索引:DROP INDEX 索引名 ON 表名;

主键字段,在建表时,会自动创建主键索引。
添加唯一约束时,数据库实际上会添加唯一索引。

Mybatis

入门

开发流程

  1. 准备工作:创建Spring Boot工程,准备数据库表及对应的实体类。
  2. 引入依赖,配置MyBatis:配置数据库连接信息。
  3. 编写SQL语句:通过注解或XML编写SQL语句。
  4. 单元测试。

JDBC

使用Java语言操作关系型数据库的一套API。

数据库连接池

Lombok

Lombok 是一个实用的 Java 类库,能通过注解的形式自动生成构造器、getter/setter、equals、hashCode、toString 等方法,并可以自动化生成日志变量,简化 Java 开发、提高效率。

注解 作用
@Getter / @Setter 为所有的属性提供 get/set 方法
@ToString 会给类自动生成易阅读的 toString 方法
@EqualsAndHashCode 根据类所拥有的非静态字段自动重写 equals 方法和 hashCode 方法
@Data 提供了更综合的生成代码功能(@Getter + @Setter + @ToString + @EqualsAndHashCode)
@NoArgsConstructor 为实体类生成无参的构造器方法
@AllArgsConstructor 为实体类生成除了 static 修饰的字段之外带有各参数的构造器方法

Lombok会在编译时,自动生成对应的Java代码。使用Lombok时,还需要安装Lombok插件(IDEA自带)。

基础操作

  • 准备:

    • 准备数据库表 emp。

    • 创建一个新的 Spring Boot 工程,选择引入对应的起步依赖(MyBatis、MySQL、Lombok)。

    • 在 application.properties 中引入数据库连接信息。
      示例:

      1
      2
      3
      4
      spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
      spring.datasource.url=jdbc:mysql://localhost:3306/mybatis
      spring.datasource.username=root
      spring.datasource.password=1234
    • 创建对应的实体类 Emp(实体类属性采用驼峰命名)。

    • 准备 Mapper 接口 EmpMapper。

  • 删除:

    • 接口方法示例:
      1
      2
      @Delete("delete from emp where id = #{id}")
      public void delete(Integer id);

      如果 Mapper 接口方法的形参只有一个普通类型的参数,#{...} 里面的属性名可以随便写,例如:#{id}、#{value}。

  • 日志输出:可以在 application.properties 中,打开 MyBatis 的日志,并指定输出到控制台。

    1
    2
    #指定 MyBatis 输出日志的位置,输出到控制台
    mybatis.configuration.log- impl=org.apache.ibatis.logging.stdout.StdOutImpl
  • 预编译 SQL优势:

    • 性能更高。
    • 更安全(防止 SQL 注入)。

      SQL 注入:通过操作输入的数据来修改事先定义好的 SQL 语句,以达到执行代码对服务器进行攻击的方法。

  • 参数占位符

    • #{...}
      • 执行 SQL 时,会将 #{...} 替换为 ?,生成预编译 SQL,会自动设置参数值。
      • 使用时机:参数传递,都使用 #{...}。
    • ${...}
      • 拼接 SQL。直接将参数拼接在 SQL 语句中,存在 SQL 注入问题。
      • 使用时机:如果对表名、列表进行动态设置时使用。
  • 新增:

    • 接口方法示例:

      1
      2
      3
      @Insert("insert into emp(username, name, gender, image, job, entrydate, dept_id, create_time, update_time) " +
      "values(#{username}, #{name}, #{gender}, #{image}, #{job}, #{entrydate}, #{deptId}, #{createTime}, #{updateTime})")
      public void insert(Emp emp);
    • 主键返回示例:

      1
      2
      3
      4
      5
      // 自动获取生成的主键值,并赋值给 emp 对象的 id 属性
      @Options(keyProperty = "id", useGeneratedKeys = true)
      @Insert("insert into emp(username, name, gender, image, job, entrydate, dept_id, create_time, update_time) " +
      "values(#{username}, #{name}, #{gender}, #{image}, #{job}, #{entrydate}, #{deptId}, #{createTime}, #{updateTime})")
      public void insert(Emp emp);
  • 更新:

    • 接口方法示例:
      1
      2
      @Update("update emp set username=#{username}, name=#{name}, gender=#{gender}, image=#{image}, job=#{job}, entrydate=#{entrydate}, dept_id=#{deptId}, update_time=#{updateTime} where id=#{id}")
      public void update(Emp emp);
  • 查询:

    • 根据ID查询,接口方法示例:

      1
      2
      @Select("select * from emp where id = #{id}")
      public Emp getById(Integer id);
    • 条件查询,接口方法示例:

      1
      2
      @Select("select * from emp where name like concat('%', #{name}, '%') and gender = #{gender} and entrydate between #{begin} and #{end} order by update_time desc")
      public List<Emp> list(String name, Short gender, LocalDate begin, LocalDate end);

      CONCAT():拼接字符串,常用于模糊查询,将 ‘%’ 与查询内容拼接。

  • 数据封装:

    • 实体类属性名和数据库表查询返回的字段名一致,MyBatis 会自动封装。
    • 如果实体类属性名和数据库表查询返回的字段名不一致,不能自动封装。
    • 解决方法:
      • 起别名:在 SQL 语句中,对不一样的列名起别名,别名和实体类属性名一样。
      • 手动结果映射: 通过 @Results 及 @Result 进行手动结果映射。
      • 开启驼峰命名: 如果字段名与属性名符合驼峰命名规则,MyBatis 会自动通过驼峰命名规则映射。
        1
        2
        # 开启驼峰命名自动映射,即从数据库字段名 a_column 映射到 Java 属性名 aColumn。
        mybatis.configuration.map-underscore-to-camel-case=true

XML映射文件

  • 规范:

    • XML 映射文件的名称与 Mapper 接口名称一致,并且将 XML 映射文件和 Mapper 接口放置在相同包下(同包同名)。
    • XML 映射文件的 namespace 属性与 Mapper 接口全限定名一致。
    • XML 映射文件中 SQL 语句的 id 与 Mapper 接口中的方法名一致,并保持返回类型一致。
  • 代码示例:

    • Mapper 接口

      1
      2
      3
      4
      @Mapper
      public interface EmpMapper {
      public List<Emp> list(String name, Short gender, LocalDate begin, LocalDate end);
      }
    • XML 映射文件

      1
      2
      3
      4
      5
      6
      <mapper namespace="com.itheima.mapper.EmpMapper">
      <select id="list" resultType="com.itheima.pojo.Emp">
      select * from emp where name like concat('%', #{name}, '%') and gender = #{gender}
      and entrydate between #{begin} and #{end} order by update_time desc
      </select>
      </mapper>
  • 使用 MyBatis 的注解,主要是来完成一些简单的增删改查功能。如果需要实现复杂的 SQL 功能,建议使用 XML 来配置映射语句。

    官方说明:https://mybatis.net.cn/getting-started.html

动态SQL

<if>

  • <if>:用于判断条件是否成立。使用 test 属性进行条件判断,如果条件为 true,则拼接 SQL。
  • <where>:where 元素只会在子元素有内容的情况下才插入 where 子句,而且会自动去除子句开头的 AND 或 OR。
  • <set>:动态地在行首插入 SET 关键字,并会删除额外的逗号。(用于 update 语句中)

<foreach>

  • XML 映射文件示例:

    1
    2
    3
    4
    5
    6
    <delete id="deleteByIds">
    delete from emp where id in
    <foreach collection="ids" item="id" separator="," open="(" close=")">
    #{id}
    </foreach>
    </delete>
  • 属性:

    • collection:集合名称。
    • item:集合遍历出来的元素/项。
    • separator:每一次遍历使用的分隔符。
    • open:遍历开始前拼接的片段。
    • close:遍历结束后拼接的片段。

<sql> <include>

  • <sql>:定义可重用的 SQL 片段。
  • <include>:通过属性 refid,指定包含的 SQL 片段。

项目开发

环境搭建

  • 准备项目所需的数据库及相关数据表。
  • 创建 Spring Boot 工程,引入项目所需的起步依赖。
  • 配置 application.properties 文件,包括数据库连接、持久层框架等相关配置信息。
  • 创建实体类(Entity),用于封装数据。
  • 搭建基础分层结构,包括 Mapper 层、Service 层(接口与实现类)和 Controller 层。

开发规范

Restful

  • REST,表述性状态转换是一种软件架构风格。通过 URL 定位资源,通过 HTTP 请求方法表示对资源的操作。
  • HTTP 请求方法
    请求方法 作用
    GET 查询资源
    POST 新增资源
    PUT 更新资源,通常表示整体替换
    PATCH 更新资源的部分内容
    DELETE 删除资源

1.REST 是风格,是约定方式,约定不是规定,可以打破。
2.描述模块的功能通常使用复数,也就是加 s 的格式来描述,表示此类资源,而非单个资源。如:users。

统一响应结果

  • 前后端交互统一响应结果 Result。

文件上传

服务端接收文件

  • 代码示例:
    1
    2
    3
    4
    5
    6
    7
    @RestController
    public class UploadController {
    @PostMapping("/upload")
    public Result upload() {
    return Result.success();
    }
    }

本地存储

  • 代码示例:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    @RestController
    public class UploadController {
    @PostMapping("/upload")
    public Result upload(MultipartFile image) throws IOException {
    // 获取原始文件名
    String originalFileName = image.getOriginalFilename();
    // 构建新的文件名
    String newFileName = UUID.randomUUID().toString()+ originalFileName.substring(originalFileName.lastIndexOf("."));
    // 将文件保存在服务端 E:/images/ 目录下
    image.transferTo(new File("E:/images/" + newFileName));
    return Result.success();
    }
    }

    SpringBoot 中文件上传默认单个文件最大允许大小为 1MB,如果需要上传大文件,可以进行如下配置:

    1
    2
    3
    4
    # 配置单个文件最大上传大小
    spring.servlet.multipart.max-file-size=10MB
    # 配置单个请求最大上传大小(一次请求可以上传多个文件)
    spring.servlet.multipart.max-request-size=100MB
  • MultipartFile 常用方法:

    • String getOriginalFilename();:获取原始文件名。
    • void transferTo(File dest);:将接收的文件转存到磁盘文件中。
    • long getSize();:获取文件的大小,单位:字节。
    • byte[] getBytes();:获取文件内容的字节数组。
    • InputStream getInputStream();:获取接收到的文件内容的输入流。

阿里云OSS

  • 第三方服务-通用思路
    1. 准备工作。

    2. 参照官方 SDK 编写入门程序。

      SDK:软件开发工具包,包括辅助软件开发的依赖(jar 包)、代码示例等。

    3. 集成使用。

配置文件

参数配置化

  • @Value 注解:@Value(“${配置文件中的key}”)

    • 作用:将外部配置文件中的属性值注入到 Java 类的成员变量中。
  • 代码示例:

    • 配置文件(application.properties)

      1
      2
      3
      4
      # 自定义配置信息
      app.name=demo
      app.version=1.0
      app.description=SpringBoot项目
    • Java 类

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      @Component
      public class AppConfig {
      @Value("${app.name}")
      private String name;

      @Value("${app.version}")
      private String version;

      @Value("${app.description}")
      private String description;
      }
  • @ConfigurationProperties与@Value的不同点:

    • @Value 注解只能一个一个地进行外部属性的注入。
    • @ConfigurationProperties 可以批量地将外部的属性配置注入到 Bean 对象的属性中。

SpringBoot 配置文件格式

  1. application.properties
1
2
server.port=8080
server.address=127.0.0.1
  1. application.xml
1
2
3
4
<server>
<port>8080</port>
<address>127.0.0.1</address>
</server>
  1. application.yml/yaml
1
2
3
server:
port: 8080
address: 127.0.0.1

yml

  • 基本语法
    • 大小写敏感。
    • 数值前边必须有空格,作为分隔符。
    • 使用缩进表示层级关系,缩进时,不允许使用 Tab 键,只能用空格(IDEA 中会自动将 Tab 转换为空格)。
    • 缩进的空格数目不重要,只要相同层级的元素左侧对齐即可。
    • # 表示注释,从这个字符一直到行尾,都会被解析器忽略。

登录认证

登录业务处理流程

  • 登录思路
    1. LoginController(控制层)

      • 接收并封装参数。
      • 调用 Service 方法进行登录。
      • 响应结果。
      • 使用注解:@PostMapping、@RequestBody。
    2. EmpService(业务层)

      • 调用 Mapper 接口查询用户信息。
    3. EmpMapper(持久层)

      • 根据用户名和密码查询员工信息。
      • SQL 语句:
        1
        2
        SELECT * FROM emp
        WHERE username = ? AND password = ?;
    4. 数据库

      • 根据 SQL 语句查询员工信息,并将查询结果返回。

登录校验

会话技术

  • 会话(Session)

    • 用户打开浏览器,访问 Web 服务器的资源,会话建立,直到有一方断开连接,会话结束。
    • 在一次会话中可以包含多次请求和响应。
  • 会话跟踪

    • 一种维护浏览器状态的方法。
    • 服务器需要识别多次请求是否来自于同一浏览器,以便在同一次会话的多次请求间共享数据。
  • 会话跟踪方案

    • 客户端会话跟踪技术:Cookie
    • 服务端会话跟踪技术:Session
    • 令牌技术:Token

会话跟踪方案对比

  • 工作原理

    • 浏览器向服务器发送请求时携带 Cookie(name=value)。
    • 服务器通过响应头 Set-Cookie 将 Cookie 返回给浏览器。
    • 后续请求中,浏览器会自动携带 Cookie。
  • 优点

    • HTTP 协议中支持的技术。
  • 缺点

    • 移动端 APP 无法使用 Cookie。
    • 不安全,用户可以自己禁用 Cookie。
    • Cookie 不能跨域。

Session

  • 工作原理

    • Session 数据存储在服务器端。
    • 浏览器通过 Cookie 携带 JSESSIONID,服务器根据该 ID 找到对应的 Session。
  • 优点

    • 存储在服务端,安全。
  • 缺点

    • 服务器集群环境下无法直接使用 Session。
    • 存在 Cookie 的缺点。

令牌技术(Token)

  • 工作原理

    • 用户登录成功后,服务器生成令牌并返回给客户端。
    • 客户端保存令牌。
    • 后续请求携带令牌,服务器通过统一拦截机制验证令牌的有效性。
  • 优点

    • 支持 PC 端、移动端。
    • 解决集群环境下的认证问题。
    • 减轻服务器端存储压力。
  • 缺点

    • 需要自己实现。

JWT

一种简洁的、自包含的格式,用于在通信双方以 JSON 数据格式安全地传输信息。由于数字签名的存在,这些信息是可靠的( https://jwt.io/ )

  • 组成
    • 第一部分:Header(头):记录令牌类型、签名算法等。
    • 第二部分:Payload(有效载荷):携带一些自定义信息、默认信息等。
    • 第三部分:Signature(签名):防止 Token 被篡改,确保安全性。将 Header、Payload 和指定密钥结合,通过指定签名算法计算而来。

JWT 生成

  • 添加 Maven 依赖:

    1
    2
    3
    4
    5
    <dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
    </dependency>
  • 生成 JWT 令牌:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    @Test
    public void genJwt() {
    Map<String, Object> claims = new HashMap<>();
    claims.put("id", 1);
    claims.put("username", "Tom");

    String jwt = Jwts.builder()
    .setClaims(claims) // 自定义内容(载荷)
    .signWith(SignatureAlgorithm.HS256, "itheima") // 签名算法
    .setExpiration(new Date(System.currentTimeMillis() + 12 * 3600 * 1000)) // 有效期
    .compact();

    System.out.println(jwt);
    }
  • 主要方法:

    • setClaims():设置自定义载荷信息。
    • signWith():指定签名算法和签名密钥。
    • setExpiration():设置令牌过期时间。
    • compact():生成 JWT 字符串。

JWT 校验

  • 解析并校验 JWT 令牌:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    @Test
    public void parseJwt() {
    Claims claims = Jwts.parser()
    .setSigningKey("itheima") // 指定签名密钥
    .parseClaimsJws("JWT令牌") // 解析令牌
    .getBody();

    System.out.println(claims);
    }
  • 主要方法:

    • setSigningKey():指定签名密钥。
    • parseClaimsJws():解析 JWT 令牌,并校验签名及有效期。
    • getBody():获取 Payload(有效载荷)中的信息。

JWT 校验时使用的签名秘钥,必须和生成 JWT 令牌时使用的秘钥是配套的。
如果 JWT 令牌解析校验时报错,则说明 JWT 令牌被篡改或失效了,令牌非法。

过滤器Filter

  • 概述:

    • 过滤器可以把对资源的请求拦截下来,从而实现一些特殊的功能。
    • 过滤器一般完成一些通用的操作,例如:登录校验、统一编码处理、敏感字符处理等。
  • Filter 实现步骤:

    1. 定义 Filter:定义一个类,实现 Filter 接口,并重写其所有方法。
    2. 配置 Filter:
    • 在 Filter 类上添加 @WebFilter 注解,配置拦截资源的路径。
    • 在启动类上添加 @ServletComponentScan 注解,开启 Servlet 组件支持。
  • Filter 生命周期方法:

    • init():初始化方法

      • Web 服务器启动时,创建 Filter 时调用,只调用一次。
    • doFilter():过滤方法

      • 拦截到请求时调用,可以调用多次。
      • 通过 chain.doFilter(request, response) 放行请求。
    • destroy():销毁方法

      • Web 服务器关闭时调用,只调用一次。
  • Filter 配置示例

    • Filter 类
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      @WebFilter(urlPatterns = "/*")
      public class DemoFilter implements Filter {
      @Override
      public void init(FilterConfig filterConfig) throws ServletException {
      Filter.super.init(filterConfig);
      }

      @Override
      public void doFilter(ServletRequest request, ServletResponse response,FilterChain chain) throws IOException, ServletException {
      System.out.println("拦截方法执行,拦截到了请求 ...");
      chain.doFilter(request, response);
      }

      @Override
      public void destroy() {
      Filter.super.destroy();
      }
      }
    • 启动类配置
      1
      2
      3
      4
      5
      6
      7
      @ServletComponentScan
      @SpringBootApplication
      public class TliasWebManagementApplication {
      public static void main(String[] args) {
      SpringApplication.run(TliasWebManagementApplication.class, args);
      }
      }
  • 过滤器链:一个 Web 应用中可以配置多个过滤器,这多个过滤器就形成了一个过滤器链。注解配置的 Filter,优先级是按照过滤器类名(字符串)的自然排序。

  • Filter执行流程:

    • 放行后访问对应资源,资源访问完成后,会返回 Filter。
    • 返回 Filter 后,不会重新执行放行前的逻辑,而是继续执行放行后的逻辑。
  • Filter 拦截路径配置:

    拦截路径 urlPatterns 值 含义
    拦截具体路径 /login 只有访问 /login 路径时,才会被拦截
    目录拦截 /emps/* 访问 /emps 下的所有资源,都会被拦截
    拦截所有 /* 访问所有资源,都会被拦截
  • 登录校验 Filter 流程:

    • 获取请求 URL。
    • 判断请求 URL 中是否包含 login,如果包含,说明是登录操作,放行。
    • 获取请求头中的令牌(Token)。
    • 判断令牌是否存在,如果不存在,返回错误结果(未登录)。
    • 解析 Token,如果解析失败,返回错误结果(未登录)。
    • 放行。

拦截器Interceptor

一种动态拦截方法调用的机制,类似于过滤器。由 Spring 框架提供,用来动态拦截控制器方法的执行。用于拦截请求,在指定的方法调用前后,根据业务需要执行预先设定的代码。

  • 步骤:

    1. 定义拦截器:定义一个类,实现 HandlerInterceptor 接口,并重写其所有方法。
    • 代码示例:
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      @Component
      public class LoginCheckInterceptor implements HandlerInterceptor {
      @Override
      // preHandle():目标资源方法执行前执行,返回 true 表示放行,返回 false 表示不放行
      public boolean preHandle(HttpServletRequest req, HttpServletResponse resp, Object handler) throws Exception {
      System.out.println("preHandle ...");
      return true;
      }

      @Override
      // postHandle():目标资源方法执行后执行
      public void postHandle(HttpServletRequest req, HttpServletResponse resp, Object handler, ModelAndView modelAndView) throws Exception {
      System.out.println("postHandle ...");
      }

      @Override
      // afterCompletion():视图渲染完毕后执行,最后执行
      public void afterCompletion(HttpServletRequest req, HttpServletResponse resp, Object handler, Exception ex) throws Exception {
      System.out.println("afterCompletion ...");
      }
      }
    1. 注册拦截器:将拦截器注册到 Spring MVC 中。
    • 代码示例:
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      @Configuration
      public class WebConfig implements WebMvcConfigurer {
      @Autowired
      private LoginCheckInterceptor loginCheckInterceptor;

      @Override
      public void addInterceptors(InterceptorRegistry registry) {
      registry.addInterceptor(loginCheckInterceptor).addPathPatterns("/**");
      }
      }
  • 拦截器拦截路径配置:

    拦截路径 含义 举例
    /* 一级路径 能匹配 /depts、/emps、/login,不能匹配 /depts/1
    /** 任意级路径 能匹配 /depts、/depts/1、/depts/1/2
    /depts/* /depts 下的一级路径 能匹配 /depts/1,不能匹配 /depts/1/2、/depts
    /depts/** /depts 下的任意级路径 能匹配 /depts、/depts/1、/depts/1/2,不能匹配 /emps/1

    常用方法:
    1.addPathPatterns():配置需要拦截的资源路径。
    2.excludePathPatterns():配置不需要拦截的资源路径。

  • 登录校验Interceptor步骤:

    1. 获取请求 URL。
    2. 判断请求 URL 中是否包含 login,如果包含,说明是登录操作,放行。
    3. 获取请求头中的令牌(Token)。
    4. 判断令牌是否存在,如果不存在,返回错误结果(未登录)。
    5. 解析 Token,如果解析失败,返回错误结果(未登录)。
    6. 放行。

Filter 与 Interceptor 的区别

  • 接口规范不同:过滤器需要实现 Filter 接口,而拦截器需要实现 HandlerInterceptor 接口。
  • 拦截范围不同:过滤器 Filter 会拦截所有的资源,而拦截器 Interceptor 只会拦截 Spring 环境中的资源。

异常处理

  • 相关注解:

    • @RestControllerAdvice:声明全局异常处理类,对 Controller 层进行增强,并将返回结果转换为 JSON 格式。
    • @ExceptionHandler:指定需要处理的异常类型。
  • 代码示例:

    1
    2
    3
    4
    5
    6
    7
    8
    @RestControllerAdvice
    public class GlobalExceptionHandler {
    @ExceptionHandler(Exception.class)
    public Result ex(Exception ex) {
    ex.printStackTrace();
    return Result.error("对不起,操作失败,请联系管理员");
    }
    }
  • 注解关系:@RestControllerAdvice = @ControllerAdvice + @ResponseBody。

事务管理

  • 注解:@Transactional

  • 位置:业务(Service)层的方法上、类上、接口上。

  • 作用:将当前方法交给 Spring 进行事务管理,方法执行前开启事务;成功执行完毕,提交事务;出现异常,回滚事务。

  • 开启事务管理日志:

    1
    2
    3
    logging:
    level:
    org.springframework.jdbc.support.JdbcTransactionManager: debug

事务属性

回滚

  • rollbackFor:

    • 默认情况下,只有出现 RuntimeException 才回滚事务。
    • rollbackFor 属性用于控制出现何种异常类型时,回滚事务。
  • 代码示例:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    @Transactional(rollbackFor = Exception.class)
    @Override
    public void delete(Integer id) throws Exception {
    deptMapper.deleteById(id); // 删除部门
    if (true) {
    throw new Exception("出错啦...");
    }
    empMapper.deleteByDeptId(id); // 删除部门下的员工
    }

传播属性

  • 指的是当一个事务方法被另一个事务方法调用时,被调用的事务方法应该如何进行事务控制。
  • 事务传播行为属性值:
    属性值 含义
    REQUIRED 【默认值】需要事务,有则加入,无则创建新事务
    REQUIRES_NEW 需要新事务,无论有无,总是创建新事务
    SUPPORTS 支持事务,有则加入,无则在无事务状态中运行
    NOT_SUPPORTED 不支持事务,在无事务状态下运行,如果当前存在已有事务,则挂起当前事务
    MANDATORY 必须有事务,否则抛异常
    NEVER 必须没事务,否则抛异常

传播行为

  • 使用场景:
    • REQUIRED:大部分情况下都是用该传播行为即可。
    • REQUIRES_NEW:当我们不希望事务之间相互影响时,可以使用该传播行为。

SpringBoot

配置优先级

按照优先级从高到低的顺序,依次是:

  1. 命令行参数(--xxx=xxx)
  2. Java 系统属性(-Dxxx=xxx)
  3. application.properties
  4. application.yml
  5. application.yaml

Bean

获取Bean

默认情况下,Spring 项目启动时,会将 Bean 都创建好并放在 IOC 容器中。如果想要主动获取这些 Bean,可以通过以下方式:

  • 根据 name 获取 Bean:

    1
    Object getBean(String name)
  • 根据类型获取 Bean:

    1
    <T> T getBean(Class<T> requiredType)
  • 根据 name 获取 Bean(带类型转换):

    1
    <T> T getBean(String name, Class<T> requiredType)

Bean 作用域

作用域 说明
singleton 容器内同名的 Bean 只有一个实例(单例)(默认)
prototype 每次使用该 Bean 时都会创建新的实例(非单例)
request 每个请求范围内会创建新的实例(Web 环境中)
session 每个会话范围内会创建新的实例(Web 环境中)
application 每个应用范围内会创建新的实例(Web 环境中)
  • 可以通过 @Scope 注解来配置作用域。

    注意事项:

    • 默认 singleton 的 Bean,在容器启动时被创建,可以使用 @Lazy 注解来延迟初始化(延迟到第一次使用时)。
    • prototype 的 Bean,每一次使用该 Bean 的时候都会创建一个新的实例。
    • 实际开发中,绝大部分的 Bean 是单例的,也就是说绝大部分 Bean 不需要配置 scope 属性。

第三方 Bean

  • 如果要管理的 Bean 对象来自于第三方(不是自定义的),是无法用 @Component 及衍生注解声明 Bean 的,需要用到 @Bean 注解。
  • 若要管理的第三方 Bean 对象,建议对这些 Bean 进行集中分类配置,可以通过 @Configuration 注解声明一个配置类。
  • 注意事项:
    • 通过 @Bean 注解的 name 或 value 属性可以声明 Bean 的名称,如果不指定,默认 Bean 的名称就是方法名。
    • 如果第三方 Bean 需要依赖其它 Bean 对象,直接在 @Bean 定义方法中设置形参即可,容器会根据类型自动装配。

原理

自动配置

  • SpringBoot 的自动配置就是当 Spring 容器启动后,一些配置类、Bean 对象就自动存入到了 IOC 容器中,不需要手动声明。

  • 方案一:@ComponentScan 组件扫描。

  • 方案二:@Import 导入。使用 @Import 导入的类会被 Spring 加载到 IOC 容器中,导入形式主要有以下几种:

    • 导入普通类。
    • 导入配置类。
    • 导入 ImportSelector 接口实现类。
    • @EnableXxxx 注解,封装 @Import 注解。
  • @Conditional:在方法、类中,按照一定的条件进行判断,满足给定条件后才会注册对应的 Bean 对象到 Spring IOC 容器中。@Conditional 的派生注解有:

    • @ConditionalOnClass:判断环境中是否有对应字节码文件,才注册 Bean 到 IOC 容器。
    • @ConditionalOnMissingBean:判断环境中没有对应的 Bean(类型或名称),才注册 Bean 到 IOC 容器。
    • @ConditionalOnProperty:判断配置文件中有对应属性和值,才注册 Bean 到 IOC 容器。

自定义 Starter

自定义 Spring Boot Starter,实现某个功能模块的自动配置。引入 Starter 依赖后,无需手动配置,即可直接使用自动配置提供的功能。

  • 步骤:

    • 创建 xxx-spring-boot-starter 模块,负责依赖管理。
    • 创建 xxx-spring-boot-autoconfigure 模块,在 Starter 中引入该模块。
    • 在 xxx-spring-boot-autoconfigure 模块中定义自动配置类。
    • 定义自动配置文件 META-INF/spring/xxxx.imports,使自动配置类生效。
  • 模块功能:

    模块 功能
    xxx-spring-boot-starter 依赖管理
    xxx-spring-boot-autoconfigure 自动配置