Skip to content

maven ​

一款用于管理和构建Java项目的工具,作用:

1.方便快捷的管理项目依赖的资源(jar 包,如第三方依赖),在 pom.xml 定义的第三方依赖包会先从本地仓库(下载的依赖包存放在本机固定目录中)关联依赖包供项目中使用,如果没有则会到中央仓库(maven 提供)下载,如果公司搭建了远程仓库(私服,解决从中央仓库下载较慢的问题),则会从远程仓库下载(私服会从中央仓库下载对应依赖包)。中央仓库地址:https://search.maven.org

2.标准化的跨平台(Linux、Windows、MacOS)的自动化项目构建方式,提供快速构建、测试等功能

3.提供标准、统一的项目结构(文件及目录)

pom.xml 中的信息

xml
<!-- maven 版本 -->
<modelVersion>4.0.0</modelVersion>

<!-- 当前项目组织名 -->
<groupId>com.example</groupId>
<!-- 当前项目名 -->
<artifactId>demo</artifactId>
<!-- 当前项目版本 -->
<version>0.0.1-SNAPSHOT</version>

<properties>
    <!-- 当前项目 jdk 版本 -->
    <java.version>17</java.version>
</properties>

<!-- 当前项目依赖信息 -->
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jdbc-test</artifactId>
        <!-- 当前依赖作用范围 -->
        <scope>test</scope>
    </dependency>
</dependencies>

生命周期 ​

Maven 的生命周期就是为了对所有的 maven 项目构建过程进行抽象和统一,分为 clean、default、site 三个生命周期。

每个生命周期又包含一些阶段,阶段是有顺序的,后面的阶段依赖于前面的阶段

常用的几个阶段:

1.clean(属于 clean 生命周期的一个阶段):移除上一次构建生成的文件

2.compile(属于 default 生命周期):编译项目源代码、

3.test(属于 default 生命周期):使用合适的单元测试框架运行测试(junit)

4.package(属于 default 生命周期):将编译后的文件打包,如:jar、war等

5.install(属于 default 生命周期):安装项目到本地仓库

shell
# 项目地址打开 cmd 可以执行对应阶段
mvn clean

单元测试 ​

JUnit:最流行的 Java 测试框架之一,提供了一些功能,方便程序进行单元测试(第三方公司提供)

具体步骤 ​

1.安装 junit-jupiter 依赖(一般项目已经内置,可以跳过)

2.在 test/java 目录下,创建测试类,并编写对应的测试方法,并在方法上声明 @Test 注解

JUnit 单元测试类名命名规范为:XxxxxTest【规范】。JUnit 单元测试的方法,必须声明为 public void【规定】

java
@SpringBootTest
class DemoApplicationTests {
	@ParameterizedTest 
    // 测试多个参数
	@ValueSource (strings = {"100000200010011011","100000200010011031","100000200010011051"})
	void contextLoads(String idCard) {
        // 引入需要测试的类方法,这里是根据身份证号计算性别
		Integer age = new UserService().getAge(idCard);
        // 断言
        Assertions.assertEquals( expected: "男", gender,"性别获取错误");
	}
}

断言 ​

JUnit 提供了一些辅助方法,用来帮我们确定被测试的方法是否按照预期的效果正常工作,这种方式称为断言

java
/*
常用方法:
Assertions.assertEquals		检查两个值是否相等,不相等就报错(测试不通过)
Assertions.assertNotEquals	检查两个值是否不相等,相等就报错
Assertions.assertNull		检查对象是否为null,不为null,就报错
Assertions.assertNotNull	检查对象是否不为null,为null,就报错
Assertions.assertTrue		检查条件是否为true,不为true,就报错
Assertions.assertFalse		检查条件是否为false,不为false,就报错
Assertions. assertThrows	检查程序运行抛出的异常,是否符合预期
*/

常用注解 ​

在 JUnit 中还提供了一些注解,还增强其功能

java
/*
常用注解:
@Test				测试类中的方法用它修饰才能成为测试方法,才能启动执行
@ParameterizedTest	参数化测试的注解(可以让单个测试运行多次,每次运行时仅参数不同)
@ValueSource		参数化测试的参数来源,赋予测试方法参数
@DisplayName		指定测试类、测试方法显示的名称(默认为类名、方法名)
@BeforeEach			用来修饰一个实例方法,该方法会在每一个测试方法执行之前执行一次
@AfterEach			用来修饰一个实例方法,该方法会在每一个测试方法执行之后执行一次
@BeforeAll			用来修饰一个静态方法,该方法会在所有测试方法之前只执行一次
@AfterAll			用来修饰一个静态方法,该方法会在所有测试方法之后只执行一次
*/

依赖范围 ​

依赖的jar包,默认情况下,可以在任何地方使用,可以通过 scope 设置其作用范围

xml
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jdbc-test</artifactId>
    <!-- 当前依赖作用范围 -->
    <scope>test</scope>
</dependency>
scope值主程序(main目录)测试程序打包(运行 不会打包到 jar 包中)范例
compile(默认)√√√log4j
test×√×junit
provided√√×servlet-api
runtime×√√jdbc驱动

分模块设计 ​

当项目庞大时,一般不会将所有功能模块都写在一个工程下,而是分多个子模块,方便项目的管理维护、扩展,也方便模块间的相互引用,资源共享

分模块开发需要先针对模块功能进行设计,再进行编码。不会先将工程开发完毕,然后进行拆分

1.抽离项目中的实体类。先创建一个空的普通 java 工程,在里面书写实体类代码,并引入对应依赖。

2.在主工程引入,就可以在主工程中使用它

xml
<!-- pom.xml -->
<dependency>
    <!-- 子模块创建时填写的组织名 -->
    <groupId>com.demo</groupId>
    <!-- 子模块根目录名 -->
    <artifactId>demo-poto</artifactId>
    <!-- 填写子模块创建时填写的版本号 -->
    <version>1.0-SNAPSHOT</version>
</dependency>

继承 ​

继承描述的是两个工程间的关系,与 java 中的继承相似,子工程可以继承父工程中的配置信息,常见于依赖关系的继承

如:当多个子模块都依赖同一个第三方包,这样如果后期想更新这个包,需要修改所有子模块的配置文件,较繁琐。

1.需要将父工程(普通 java 工程即可,无需 springBoot 工程)打包方式设置为 pom (默认 jar ),设置后此工程不再书写业务代码,仅用作配置(可只保留 pom.xml 一个文件)。

扩展:打包方式分为 jar (普通模块打包,springboot项目基本都是jar包(内嵌tomcat运行))、war (普通web程序打包,需要部署在外部的tomcat服务器中运行)、pom (父工程或聚合工程,该模块不写代码,仅进行依赖管理)

xml
<!-- pom.xml -->
<!-- 由于 maven 不支持多继承,而子工程又需要使用 springBoot 所以父工程直接继承它,然后子工程再继承父工程即可解决 -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>4.1.2</version>
    <relativePath/>
</parent>

<groupId>com.example</groupId>
<artifactId>demo</artifactId>
<version>0.0.1-SNAPSHOT</version>
<!-- 设置打包方式为 pom -->
<packaging>pom</packaging>

2.在子工程中配置继承关系

xml
<!-- pom.xml -->
<!-- 和 dependencies 标签同级 -->
<parent>
    <!-- 填写父工程坐标 -->
    <!-- 此时 <groupId>com.example</groupId> 可省略,会自动继承父工程的组织名 -->
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <!-- 填写父工程 pom.xml 文件的相对位置 -->
    <relativePath>../demo/pom.xml<relativePath/>
</parent>
    
<!-- 如果子工程基于 springBoot 那么下方配置要删除掉 -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>4.1.2</version>
    <relativePath/>
</parent>

3.在父工程中配置各个工程共有的依赖(子工程会自动继承父工程的依赖)。注意:在父工程配置公共依赖后,无论子工程是否真的依赖,都会在子工程中加入该依赖,耗费系统性能,所以不是所有子工程都依赖,建议不要直接写到父工程中

xml
<!-- 父工程 pom.xml -->
<dependencies>
    <!-- 将子工程相同依赖抽离到父工程中统一管理 -->
    <!-- 抽离后需删除对应公共依赖配置 -->
    <!-- 如子工程都依赖 lombok ,抽离后依赖它的子工程需要删除 lombok 依赖配置 -->
    <!-- 若父子工程都配置了同一个依赖的不同版本,以子工程的为准 -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

版本锁定 ​

在maven中,可以在父工程的pom文件中通过 <dependencyManagement>来统一管理依赖版本

xml
<!-- 父工程 pom.xml -->
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.13.0</version>
</dependency>
xml
<!-- 子工程 pom.xml -->
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <!-- 子工程可不指定版本,此时会跟随父工程对应依赖的版本 -->
    <!-- <version>0.13.0</version> -->
</dependency>

自定义属性 ​

当依赖非常多时,寻找某一个依赖修改版本号会比较麻烦,这时可以使用自定义属性简化

xml
<!-- 父工程 pom.xml -->
<!-- 自定义属性,将所有依赖放到一起 -->
<properties>
    <jjwt.version>0.13.0</jjwt.version>
</properties>

<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <!-- 使用上方定义好的自定义属性 -->
    <version>${jjwt.version}</version>
</dependency>

聚合 ​

当我们想打包 A 子模块,但A子模块又依赖 B子模块,B模块又依赖 C.... 这样就得按照依赖关系一层一层分别安装(否则会打包失败),项目一大就很繁琐,这时可以使用聚合

xml
<!-- 父工程 pom.xml -->
<!-- 配置完后就可以直接在父工程目录完成一键打包操作,最终所有子工程都会执行打包操作 -->
<!-- 填写聚合模块(子工程)信息 -->
<modules>
    <!-- 此处填写需要聚合的模块(子工程)的相对路径 -->
    <!-- 聚合工程中所包含的模块,在构建时,会自动根据模块间的依赖关系设置构建顺序,与聚合工程中模块的配置书写位置无关 -->
    <module>../demo-pojo</module>
    <module>../demo-utils</module>
    <module>../demo-web-management</module>
</modules>

数据库 ​

DataBase(DB),是存储和管理数据的仓库

数据库管理系统:DataBase Management System(DBMS),操纵和管理数据库的大型软件,如:Oracle、MySQL 等

SQL:Structured Query Language,操作关系型数据库的编程语言,定义了一套操作关系型数据库统一标准

安装 ​

下载 MySQL: https://dev.mysql.com/downloads/installer

可 Win + R 输入 services.msc 找到 MvSOL 服务手动启动或停止服务

配置数据库 application.yml 或者 application.properties

yaml
server:
  # 服务端口号
  port: 8080

spring:
  datasource:
    # 数据库地址以及账密,mental_health_assistant 表示连接的数据库名称
    url: jdbc:mysql://localhost:3306/mental_health_assistant?useSSL=false&serverTimezone=UTC
    username: root
    password: 123456
    # driver-class-name: com.mysql.cj.jdbc.Driver

MySQL 数据模型 ​

关系型数据库:建立在关系模型基础上,由多张相互连接的二维表(类似 excel 表)组成的数据库

SQL 语句 ​

一门操作关系型数据库的编程语言,定义操作所有关系型数据库的统一标准

分类说明
DDL数据定义语言,用来定义数据库对象(数据库,表,字段)
DML数据操作语言,用来对数据库表中的数据进行增删改
DQL数据查询语言,用来查询数据库中表的记录
DCL数据控制语言,用来创建数据库用户、控制数据库的访问权限

DDL ​

sql
-- sql 语句不区分大小写
-- 查询所有数据库
show databases;

-- 查询当前数据库
select database();

-- 使用/切换数据库
use 数据库名;

-- 创建数据库
-- if not exists 可不写,表示不存在才创建
-- default charset utf8mb4 可不写,表示创建数据库选择对应的字符集,在 MySQL8 版本不写默认就是 utf8mb4 字符集
create database if not exists 数据库名 default charset utf8mb4;

-- 删除数据库
-- if exists 可不写,表示如果存在该数据库才会删除
drop database if exists 数据库名;

-- 上述语法中的 database,也可以替换成 schema。如:create schema db01;

表操作 ​

创建表 ​
sql
-- [] 这里中括号中的内容(仅用于方便说明,实际 sql 中无需书写中括号)表示可选
create table tablename(
字段1 字段类型 [约束] [comment 字段1注释],
    ...
字段2 字段类型 [约束] [comment 字段2注释]
) [comment 表注释];
约束 ​

约束是作用于表中字段上的规则,用于限制存储在表中的数据,保证数据库中数据的正确性、有效性和完整性

约束描述关键字
非空约束限制该字段值不能为nullnot null
唯一约束保证字段的所有数据都是唯一、不重复的unique
主键约束主键是一行数据的唯一标识,要求非空且唯一primary key
默认约束保存数据时,如果未指定该字段值,则采用默认值default
外键约束让两张表的数据建立连接,保证数据的一致性和完整性foreign key
sql
-- 示例
create table user(
    -- auto_increment 主键自增长
    id int primary key auto_increment comment 'ID,唯一标识', -- 主键约束 
    username varchar(50) not null unique comment '用户名', -- 非空且唯一
    name varchar(10) not null comment '姓名',-- 非空
    age int comment '年龄',
    gender char(1) default '男' comment '性别' -- 默认
) comment '用户信息表';
查、改、删表 ​
sql
-- 查询当前数据库的所有表
show tables;

-- 查询表结构
desc 表名; 

-- 查询建表语句
show create table 表名;

-- [] 这里中括号中的内容(仅用于方便说明,实际 sql 中无需书写中括号)表示可选
-- 添加字段
alter table 表名 add 字段名类型(长度) [comment 注释] [约束];

-- 修改字段类型
alter table 表名 modify 字段名新数据类型(长度);

-- 修改字段名与字段类型
alter table 表名 change 旧字段名新字段名 类型(长度) [comment 注释] [约束];

-- 删除字段
alter table 表名 drop column 字段名;

-- 修改表名
alter table 表名 rename to 新表名;

-- 删除表,在删除表时,表中的全部数据也会被删除
drop table [if exists] 表名;

DML ​

添加 ​

插入数据时,指定的字段顺序需要与值的顺序是一一对应的

字符串和日期型数据应该包含在引号中(单引号、双引号都可以)

插入的数据大小/长度,应该在字段的规定范围内

sql
-- 指定字段添加数据
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...);

-- now 方法可以获取系统当前时间 示例
insert into emp (create_time) values (now());

修改 ​

sql
-- 修改数据
-- 修改语句的条件可以有,也可以没有,如果没有条件,则会修改整张表的所有数据
update 表名 set 字段名1 = 值1 , 字段名2 = 值2,.... [ where 条件 ];

-- 示例:修改 emp 表中 id 为 1 的那条数据中 username 和 name 的值
update emp set username = 'zhangsan' , name = '张三' where id = 1;

删除 ​

DELETE 语句的条件可以有,也可以没有,如果没有条件,则会删除整张表的所有数据

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

sql
-- 删除数据
delete from 表名 [where 条件];

DQL ​

sql
-- 完整的 DQL 语句语法
select 字段列表 from 表名列表 where 条件列表 group by 分组字段列表 having 分组后条件列表 order by 排序字段列表 limit 分页参数

基本查询 ​

sql
-- 查询多个字段
select 字段1,字段2,字段3 from 表名;

-- 查询所有字段(通配符),*号代表查询所有字段,在实际开发中尽量少用(不直观、影响效率)
select * from 表名;

-- 为查询字段设置别名,as关键字可以省略
-- [] 这里中括号中的内容(仅用于方便说明,实际 sql 中无需书写中括号)表示可选
select 字段1 [as 别名1],字段2 [as 别名2] from 表名;
-- 示例:查询 emp 表中 name、entry_date 字段的所有数据并为其取别名(别名只会作用于查询结果,不会修改表中存储的原始名称)
-- 别名可以加上引号(当别名中间存在空格时必须用引号包裹,如'姓 名')也可以不加
select name as 姓名, entry_date as 入职日期 from emp;

-- 去除重复记录
select distinct 字段列表 from 表名;
case 函数 ​
sql
-- 如下表示查询员工表(emp)对应职位的人数
-- emp 表中职位保存的并不是汉字而是数字,此时需要映射
-- 如下查询后单条数据示例:班主任:1 ,左侧表示职位 id 对应的职位文本,右侧表示该职位对应的人数
select
	(case job when 1 then '班主任'
        when 2 then '讲师'
        when 3 then '学工主管'
        when 4 then '教研主管'
        when 5 then '咨询师'
        -- 当职位 id 不符合上述映射时统一映射为 “其他”
     	-- pos 表示最终查询回来该字段的别名
    	else '其他' end) pos,
   	-- num 表示最终查询回来该字段的别名
	count(*) num
from emp group by job;

查询结果示例

posnum
班主任1
if 函数 ​
sql
-- 示例:查询员工性别人数
-- 一般数据库中性别使用数字保存,对于这种简单映射可使用 if 函数
select
	-- 当数据库 gender 字段值为 1 时映射为 男性员工 否则映射为 女性员工
	-- name 表示给查询到的数据该字段取别名
    if(gender = 1, '男性员工', '女性员工') name,
    -- name 表示给查询到的数据该字段取别名
    count(*) value
from emp group by gender

查询结果示例

namevalue
男性员工10

条件查询 ​

sql
-- 条件查询
select 字段列表 from 表名 where 条件列表;
运算符 ​
运算符功能
>大于
>=大于等于
<小于
<=小于等于
=等于
<> 或 !=不等于
between ... and ...在某个范围之内(含最小、最大值)
in(...)满足括号内某一个条件
like 占位符模糊匹配( _ 匹配一个字符,% 匹配任意个字符)
is null是 null,is not null 表示非 null
and 或 &&并且(多个条件同时成立)
or 或 ll或者(多个条件任意一个成立)
not 或 !非,不是
sql
-- 示例
-- 查询 emp 库中 entry_date 字段在 2000-01-01 到 2010-01-01 之间的数据
-- 语法:between '最小值' and '最大值'
select * from emp where entry_date between '2000-01-01' and '2010-01-01';

-- 查询 emp 库中 entry_date 字段在 2000-01-01 到 2010-01-01 之间且 gender = 2 的数据
select * from emp where (entry_date between '2000-01-01' and '2010-01-01') and gender = 2;

-- 查询 emp 库中 job 字段是 2、3、4 的数据
select * from emp where job = 2 or job = 3 or job = 4;
-- 也可以使用 in 实现同样的效果
select * from emp where job in(2,3,4);

-- 查询 emp 库中 name(姓名) 字段是 2 个字符的数据,'__' 是两个下划线
select * from emp where name like '__';

-- 查询 emp 库中 name(姓名) 姓李的数据
select * from emp where name like '李%';

-- 查询 emp 库中 name(姓名) 包含 二 的数据
select * from emp where name like '%二%';

分组查询 ​

sql
-- 分组查询
select 字段列表 from 表名 [where 条件列表] group by 分组字段名 [having 分组后过滤条件];

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

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

函数功能
count统计数量
max最大值
min最小值
avg平均值
sum求和
sql
-- 示例
-- 查询 emp 库中 job 字段的数量(null 除外,所有的聚合函数都不会计算 null)
select count(job) from emp;

-- 查询 emp 库中总数据量
select count(*) from emp;

-- 查询 emp 库中 salary 字段的平均数
select avg(salary) from emp;

-- 查询 emp 库中 salary 字段的最小值
select min(salary) from emp;

-- 查询 emp 库中 salary 字段的总和
select sum(salary) from emp;
sql
-- 示例
-- 注意:分组之后,select 后的字段列表不能随意书写,能写的一般是 分组字段 + 聚合函数
-- 查询 emp 库,根据 gender(性别) 字段分组,统计男性和女性员工的数量
select gender, count(*) from emp group by gender;

-- 查询 emp 库,查询 entry_date 字段在 2015-01-01(包含)以前的数据,并对结果根据 job(职位) 字段分组,获取数量大于等于 2 的职位
select job, count(*) from emp where entry_date <= '2015-01-01' group by job having count(*) >= 2;

排序查询 ​

排序方式:升序(asc),降序(desc);默认为升序 asc,是可以不写的

注意:如果是多字段排序,当第一个字段值相同时,才会根据第二个字段进行排序

sql
-- 排序查询
select 字段列表 from 表名 [where 条件列表] [group by 分组字段名 having 分组后过滤条件] order by 排序字段 排序方式;
sql
-- 示例
-- 查询 emp 库,根据 entry_date 对数据进行升序排序,如果 entry_date 相同,再按照 update_time 字段进行降序排序
select * from emp order by entry_date , update_time desc;

分页排序 ​

起始索引从 0 开始

分页查询是数据库的方言,不同的数据库有不同的实现,MySQL 中是 limit

如果起始索引为0,起始索引可以省略,直接简写为 limit 10

sql
-- 排序查询
select 字段 from 表名 [where 条件] [group by 分组字段 having 过滤条件] [order by 排序字段] limit 起始索引,查询记录数(即每页多少条数据);

多表查询 ​

基本语法 ​

指从多张表中查询数据

sql
-- 示例
-- 查询 emp 表中 dept_id 字段 和 dept 表中 id 字段相同的数据
select * from emp, dept where emp.dept_id = dept.id;

连接查询 ​

内连接 ​

相当于查询 A、B 交集部分数据

sql
-- 1.隐式内连接(使用较多)
select 字段列表 from 表1 ,表2 where 连接条件 ...;

-- 当表名较长时可以给表起别名,来简化书写,其中 as 关键字可以省略
select 字段列表 from 表1 [as]别名1,表2 [as]别名2 where 条件...;

-- 2.显式内连接,inner 关键字可以省略
select 字段列表 from 表1 [inner] join 表2 on 连接条件...;
sql
-- 示例1
-- 查询所有员工(emp 表)的ID,姓名,及所属的部门(dept 表)名称(隐式内连接写法)
select emp.id , emp.name, dept.name from emp , dept where emp.dept_id = dept.id;

-- 查询所有员工(emp 表)的ID,姓名,及所属的部门(dept 表)名称(显式内连接写法)
-- 在显式内连接写法中 inner 关键字可以省略
select emp.id , emp.name, dept.name from emp inner join dept on emp.dept_id = dept.id;

-- 示例2
-- 查询性别为男,且工资高于8000 的员工(emp 表)的ID,姓名,及所属的部门(dept 表)名称(隐式内连接写法)
select emp.id , emp.name, dept.name from emp , dept where emp.dept_id = dept.id and emp.gender = 1 and emp.salary > 8000;

-- 查询性别为男,且工资高于8000 的员工(emp 表)的ID,姓名,及所属的部门(dept 表)名称(显式内连接写法)
select emp.id , emp.name, dept.name from emp inner join dept on emp.dept_id = dept.id where emp.gender = 1 and emp.salary > 8000;;
外连接 ​

分为两部分:

左(A 表)外连接:查询 A 表所有数据(包括两张表交集部分数据)

右(B 表)外连接:查询 B 表所有数据(包括两张表交集部分数据)

sql
-- 语法
-- 1.左外连接,其中 outer 关键字可以省略,注意会保留 表1 的所有数据
select 字段列表 from 表1 left [outer] join 表2 on 连接条件 ...;

-- 2.右外连接,其中 outer 关键字可以省略,注意会保留 表2 的所有数据
select 字段列表 from 表1 right [outer] join 表2 on 连接条件 ...;
sql
-- 示例1
-- 查询员工表(emp表) 所有 员工的姓名,和对应的部门(dept表)名称(左外连接)
select emp.name,dept.name from emp left outer join dept on emp.dpt_id = dept.id;

-- 示例2
-- 查询部门表(dept表)所有部门的名称,和对应的员工(emp表) 名称(右外连接)
select dept.name, emp.name from emp right outer join dept on emp.dept_id = dept.id;

-- 示例3
-- 查询工资高于8000 的 所有员工(emp表)的姓名,和对应的部门(dept表)名称(左外连接)
select emp.name, dept.name from emp left join dept on emp.dept_id = dept.id where emp.salary > 8000;

子查询 ​

SQL 语句中嵌套 select 语句,称为嵌套查询,又称子查询

形式: select * from t1 where column1 = (select column1 from t2 …);

子查询外部的语句可以是 insert / update / delete / select 的任何一个,最常见的是 select

分类:

1.标量子查询:子查询返回的结果为单个值

2.列子查询: 子查询返回的结果为一列

3.行子查询:子查询返回的结果为一行

4.表子查询:子查询返回的结果为多行多列

sql
-- 示例,标量子查询
-- 查询最早入职的员工(emp表)信息(标量子查询)
select * from emp where entry_date = (select min(entry_date) from emp);

-- 查询在“阮小五”入职之后入职的员工(emp表)信息(标量子查询)
select * from emp where entry_date > (select entry_date from emp where name = '阮小五');
sql
-- 示例,列子查询
-- 查询"教研部"和"咨询部"(dept表)的所有员工(emp表)信息
select * from emp where dept_id in (select id from dept where name = '教研部' or name = '咨询部');
sql
-- 示例,行子查询
-- 查询与"李忠"的薪资 及 职位都相同的员工信息(emp表),注意子查询嵌套的越多查询性能越低
select * from emp where salary = (select salary from emp where name = '李忠') and job = (select job from emp where name = '李忠');

-- 上方语句性能较差,可优化为下方性能更高的写法
select * from emp where (salary,job) = (select salary, job from emp where name = '李忠');
sql
-- 表子查询
-- 获取每个部门(dep表)中薪资最高的员工信息(emp表)
select * from emp e , (select dept_il, max(salary) max_sal from emp group by dept_id) a
where e.dept_id = a.dept_id and e.salary = a.max_sal;

数据类型 ​

MySQL 中的数据类型有很多,主要分为三类:数值类型、字符串类型、日期时间类型

数值类型 ​

数值类型的选取原则:在满足业务需求的前提下,尽可能选择占用磁盘空间小的数据类型

字符串类型 ​

日期类型 ​

事务 ​

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

当同时执行多条语句时,如果要求必须所有语句都执行成功才能存入数据时可使用

sql
-- 开启事务 或 start begin;
start transaction;
-- 1. 保存员工基本信息
insert into emp values (39, 'Tom', '123456', '汤姆', 1);
-- 2.保存员工的工作经历信息
insert into emp_expr(emp_id, begin) values (39,'2019-01-01');
-- 提交事务(全部成功)/ 回滚事务(有一个失败)
-- 提交事务,执行后会真的往数据库插入数据
commit;

-- 回滚事务,执行后之前执行的语句最终并不会往数据库插入数据
rollbac;

图形化工具 ​

使用命令行操作数据库比较繁琐,我们可以使用图形化工具简化操作。常用的图形化工具有:Navicat(https://www.navicat.com.cn/download/navicat-for-mysql)、`IntelliJ IDEA(内部已经集成了 DataGrip)、DataGrip`(https://www.jetbrains.com/zh-cn/datagrip/)

当然 vscode 中也有插件:SQLTools(轻量,得装对应数据库驱动,如:MySQL 装 SQLTools MySQL/MariaDB Driver)

JDBC ​

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

由于 JDBC 使用起来较为繁琐,所以现代开发会使用其他更好用的工具(如:MyBatis、MyBatisPlus、SpringDataJPA 等),这些工具一般都是基于 JDBC 的,也就是高级封装

MyBatis ​

基本使用 ​

1.创建 SpringBoot项目并安装 Lombok、MySQLDriver、mybatis-spring-boot-starter 依赖包

2.在 src\main\java\com\example\demo\pojo\User.java 中写入实体类

java
// Lombok 注解,作用在类上,会自动生成所有字段的 getter 和 setter、toString() 方法、equals() 和 hashCode() 方法、对于 final 字段,只会生成 getter
@Data
/*
Lombok 注解,自动生成一个包含所有字段的构造器。例如:
public User(Integer id, String username, String password, String name, Integer age) {
    this.id = id;
    this.username = username;
    this.password = password;
    this.name = name;
    this.age = age;
}
方便在代码中一次性初始化所有字段,例如 new User(1, "admin", "123", "张三", 20)
*/
@AllArgsConstructor
/*
Lombok 注解,自动生成一个无参构造器:
public User() {
}
MyBatis、Jackson 等框架在反射创建对象时,通常需要一个无参构造器
*/
@NoArgsConstructor
public class User {
    private Integer id;
    private String username;
    private String password;
    private String name;
    private Integer age;
}

3.在 src\main\resources\application.properties 中配置数据库连接信息

properties
spring.application.name=demo

# 配置数据库连接信息
# 数据库地址 user 表示要连接的数据库名称
spring.datasource.url=jdbc:mysql://localhost:3306/user
# 数据库驱动类的全类名
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
# 数据库用户名
spring.datasource.username=root
# 数据库密码
spring.datasource.password=1234

4.在 src\main\java\com\example\demo\mapper\UserMapper.java 中编写 Mybatis 的持久层接口,定义SQL(注解/XML)

java
// MyBatis 提供的注解,标记在接口上,表示这是一个 MyBatis 的映射器接口
// Spring Boot 启动时,MyBatis 会自动扫描带有 @Mapper 的接口,并为其生成动态代理实现类,注册到 Spring 容器中
// 这样下方就可以通过 @Autowired 注入 UserMapper 并使用它
@Mapper
public interface UserMapper {
    // MyBatis 的注解,用于直接编写 SQL 查询语句,替代 XML 映射文件
    // 除了 @Select,还有 @Insert、@Update、@Delete 等注解,分别对应增删改操作
    @Select("select * from user")
    // 这里 User 是上方定义的实体类
    public List<User> findAll();
}

5.测试查看结果

打开 src\test\java\com\example\demo\DemoApplicationTests.java 写入测试代码

java
// Spring Boot 提供的测试注解,用来启动完整的 Spring 应用上下文
// 它会扫描项目中的配置、Bean、数据源、MyBatis Mapper 等,相当于在测试时把整个 Spring Boot 应用跑起来
// 与 @Test(JUnit)配合使用,可以在测试中直接注入 Spring 容器管理的 Bean
@SpringBootTest
class DemoApplicationTests {
    // Spring 的依赖注入注解,表示从 Spring 容器中自动获取一个 UserMapper 类型的 Bean
	@Autowired
    // 这里 UserMappe 是上方定义的持久层接口
	private UserMapper userMapper;

	@Test
	void testFindAll() {
        // 这里 User 是上方定义的实体类
		List<User> userList = userMapper.findAll();
		userList.forEach(System.out::println);
	}
}

6.打开 src\main\resources\application.properties 加入如下配置,可让输出更加直观

properties
# 配置 mybatis 的日志输出
mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl
cmd
# 示例输出
==>  Preparing: select * from user
==> Parameters: 
<==    Columns: id, username, password, name, age
<==        Row: 1, daqiao, 123456, ����, 22
<==        Row: 2, xiaoqiao, 123456, ��, 18
<==        Row: 3, diaochan, 123456, ����, 24
<==        Row: 4, lvbu, 123456, ����, 28
<==        Row: 5, zhaoyun, 12345678, ����, 27
<==      Total: 5

数据库连接池 ​

Mybatis 是基于 JDBC 的

JDBC VS Mybatis

数据库连接池是个容器,负责分配、管理数据库连接(Connection)

它允许应用程序重复使用一个现有的数据库连接,而不是再重新建立一个

释放空闲时间超过最大空闲时间的连接,来避免因为没有释放连接而引起的数据库连接遗漏(占用连接不执行 sql 语句导致连接池中数据库连接越来越少,解决办法: 给每个连接设置空闲时间,超过空闲时间会自动收回占用的数据库连接)

优势:1.资源重用 2.提升系统响应速度 3.避免数据库连接遗漏

我们不用自己去实现,市面上已经有了许多解决方案,如:Druid、Hikari (SpringBoot 自带)

如果不想使用 SpringBoot 自带的Hikari可以切换数据库连接池解决方案

1.安装(这里以 Druid 示例)

xml
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.2.19</version>
</dependency>

2.配置(src\main\resources\application.properties)

properties
# 配置数据库连接池 type
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource

# 其他连接数据库必要配置
spring.datasource.url=jdbc:mysql://localhost:3306/web
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.username=root
spring.datasource.password=1234

增删改查 ​

删除 ​

打开上方 MyBatis 基本使用写好的 src\main\java\com\example\demo\mapper\UserMappe.java 添加如下代码

java
public interface UserMappe {
    // 添加删除方法
    // #{id} 表示占位符,会将 deleteById 的参数替换到占位符位置
    // 比 @Delete("delete from user where id = 5") 这样写更加灵活
    @Delete("delete from user where id = #{id}")
    public void deleteById(Integer id);
}

打开 src\test\java\com\example\demo\DemoApplicationTests.java 添加如下代码测试

java
class DemoApplicationTests {
	@Autowired
	private UserMappe userMappe;

	@Test
	void testDeleteById() {
		userMappe.deleteById(5);
	}
}

Mybatis 中的 # 号与 $ 号

符号说明使用场景优缺点
#占位符。执行时,会将#{...}替换为?,生成预编译SQL参数值传递安全、性能高(推荐)
$拼接符。直接将参数拼接在SQL语句中,存在SQL注入问题表名、字段名动态设置时使用不安全、性能低
java
// 示例
@Delete("delete from dept where id = #{id}")

@Select("select id,name,score from ${tableName} order by ${sortField}")

新增 ​

打开上方 MyBatis 基本使用写好的 src\main\java\com\example\demo\mapper\UserMappe.java 添加如下代码

java
public interface UserMappe {
    // 添加新增方法
    // 由于新增时一般需要的字段较多,因此外界调用此函数时传递一个对象较为方便,注意 values 后的字段是 传递进来的 User 对象中对应的字段
    @Insert("insert into user(username,password,name,age) values(#{username},#{password},#{name},#{age})")
    // 此处的 User 是上方 MyBatis 基本使用处写好 src\main\java\com\example\demo\pojo\User.java 中的类
    public void insert(User user);
}

打开 src\test\java\com\example\demo\DemoApplicationTests.java 添加如下代码测试

java
class DemoApplicationTests {
	@Autowired
	private UserMappe userMappe;

	@Test
	void testInsert() {
        // 由于 id 是主键且是自增的所以无需传递
		User user = new User(null, "gaoyuanyuan", "666888", "高圆圆", 18);
		userMappe.insert(user);
	}
}

修改 ​

打开上方 MyBatis 基本使用写好的 src\main\java\com\example\demo\mapper\UserMappe.java 添加如下代码

java
public interface UserMappe {
    @Insert("update user set username = #{username}, password = #{password}, name = #{name}, age = #{age} where id = #{id}")
    public void update(User user);
}

打开 src\test\java\com\example\demo\DemoApplicationTests.java 添加如下代码测试

java
class DemoApplicationTests {
	@Autowired
	private UserMappe userMappe;

	@Test
	void testUpdate() {
		User user = new User(5, "修改", "修改", "修改", 18);
		userMappe.update(user);
	}
}

查询 ​

打开上方 MyBatis 基本使用写好的 src\main\java\com\example\demo\mapper\UserMappe.java 添加如下代码

java
public interface UserMappe {
    /*
    模糊查询,如查询用户表用户姓名时可使用用如下写法
    @Select("select * from user where username like concat('%',#{username},'%')")
    public User getName(String username);
    */
    @Select("select * from user where username=#{username} and password=#{password}")
    // @Param 注解:为接口的方法形参起名字,这样 MyBatis 就知道多个参数下每个参数对应哪个 sql 参数
    // 基于官方骨架创建的 springboot 项目中,接口编译时会保留方法形参名,@Param 注解可以省略(需要函数形参名和 sql 占位符字段名一致)
    public User findByUsernameAndPassword(@Param("username") String username, @Param("password") String password);
}

打开 src\test\java\com\example\demo\DemoApplicationTests.java 添加如下代码测试

java
class DemoApplicationTests {
	@Autowired
	private UserMappe userMappe;

	@Test
	void select() {
		User user = userMappe.findByUsernameAndPassword("daqiao", "123456");
		System.out.println(user);
	}
}

XML映射配置 ​

在 MyBatis 中除了通过注解的方式(上方内容)来配置 sql 语句还可以通过 XML 配置文件配置 sql 语句

默认规则:

1.XML 映射文件的名称与 Mapper 接口名称一致,并且将 XML 映射文件和 Mapper 接口放置在相同包下(同包同名)

2.XML 映射文件的 namespace 属性为 Mapper 接口全限定名一致

3.XML 映射文件中 sql 语句的 id 与 Mapper 接口中的方法名一致,并保持返回类型一致

使用 Mybatis 的注解,主要是来完成一些简单的增删改查功能。如果需要实现复杂的 SQL 功能,建议使用XML 来配置映射语句

xml
<!-- 示例 -->
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.demo.mapper.EmpExprMapper">
    <insert id="insertBatch">

    </insert>
</mapper>

补充 ​

为了简便,上述默认规则1可以简化,打开 src\main\resources\application.properties 写入如下配置

properties
# 如果不想在 resources 目录下创建相同包名,也可以通过配置指定自定义路径
# 指定 XML 映射配置文件的位置
# mapper 是指定的自定义目录名(但还是得放在 resources 目录下),
mybatis.mapper-locations=classpath:mapper/*.xml

动态 SQL ​

随着用户的输入或外部条件的变化而变化的SQL语句,称为动态 SQL

<if>:判断条件是否成立,如果条件为 true,则拼接 SQL

xml
<!-- MyBatis 会将查询结果自动封装到 resultType 对应的类 -->
<select id="list" resultType="com.itheima.demo.Emp">
    SELECT * FROM emp e
    <!-- 根据查询条件,来生成where关键字,并会自动去除条件前面多余的and或or -->
    <!-- 
	当有多条非必填的条件时(<if>)势必可能会多出 and 关键字,此时可将 where 关键字替换为 where 标签来解决这一问题
 	-->
    <where>
        <!-- 如下这段语句只有符合 if 中的条件才会拼接进最终的 sql 语句中 -->
        <!-- 一般用于查询条件较多,但非必填的情况 -->
        <if test="name != null and name != ''">
            e.name like concat('%',#{name},'%')
        </if>
    </where> order by e.update_time desc
</select>
xml
<!-- 示例2:set 标签,会自动生成 set 关键字,以及删除掉更新字段后多余的逗号 -->
<update id="updateById">
    UPDATE emp
    <set>
        <if test="username != null and username != ''">username = #{username},</if>
        <if test="password != null and password != '">password = #{password},</if>
	</set>
	WHERE id = #{id}
</update>

当需要根据前端传递过来的数组决定插入多少条数据时可使用 <foreach> 标签

<foreach> 标签属性:

  1. collection:集合名称
  2. item:集合遍历出来的元素/项
  3. separator:每一次遍历使用的分隔符
  4. open:遍历开始前拼接的片段
  5. close:遍历结束后拼接的片段
xml
<insert id="insertBatch">
    insert into emp_expr (emp_id, begin, end, company, job) values
    <!-- 会根据 exprList 的长度动态创建对应个数的 <foreach> 标签中的语句 -->
    <foreach collection="exprList" item="expr" separator=",">
    	(#{expr.empId},#{expr.begin}, #{expr.end}, #{expr.company}, #{expr.job})
    </foreach>
</insert>
xml
<!-- 示例 -->
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.demo.mapper.EmpExprMapper">
    <insert id="insertBatch">
        insert into emp_expr(emp_id, begin, end, company, job) values
        <!-- collection 填写 Mapper 层函数形参名称 -->
        <!-- item 表示遍历出来的元素名称,可自定义 -->
        <!-- separator 表示每次遍历的分隔符,最终会添加进 sql 中 -->
        <foreach collection="exprList" item="expr" separator=",">
            (#{expr.empId},#{expr.begin},#{expr.end},#{expr.company},#{expr.job})
        </foreach>
    </insert>
</mapper>
java
// 对应 Mapper 层代码
@Mapper
public interface EmpExprMapper {
    void insertBatch(List<EmpExpr> exprList);
}

获取生成的主键 ​

一般用于插入数据后马上需要使用这条数据在数据库自动生成的主键值时

如:先往员工表插入一条员工数据,再往另一张表插入多条该员工(上一步创建的员工 id)的工作经历

java
// Mapper 层代码
@Mapper
public interface EmpMapper {

    // MyBatis 注解 useGeneratedKeys = true 表示使用 JDBC 的 getGeneratedKeys() 机制获取数据库生成的主键,前提:数据库表的 id 列必须设置了 AUTO_INCREMENT
    // keyProperty = "id" 指定把生成的主键值回填到哪个属性
    // 添加如下代码后会将生成的主键值存入 emp 的 id 属性中
    @Options(useGeneratedKeys = true,keyProperty = "id")
    @Insert("查询语句")
    public void insert(Emp emp);
}
java
// 对应 Service 层代码
@Service
public class EmpServiceImpl implements EmpService {
    @Resource
    // 这里是上方 Mapper 层定义的 EmpMapper 类
    private EmpMapper empMapper;

    @Override
    public void save(Emp emp) {
        // 调用上方 Mapper 层定义的 EmpMapper 类的 insert 方法往数据库插入数据
        empMapper.insert(emp);
        // 下方逻辑依赖刚刚插入的数据在数据库自动生成的主键值,可通过 emp.getId() 获取
        System.out.println(emp.getId());
    }
}

手动封装 ​

java
// 对应员工信息实体类
@Data
public class Emp {
    private Integer id; // ID,主键
    // 其他基本信息...
    private List<EmpExpr> exprList; // 工作经历信息
}
xml
<!-- MyBatis 会将查询结果自动封装到 resultType 对应的类 -->
<select id="list" resultType="com.itheima.demo.Emp">
    <!-- 查询语句... -->
</select>

当我们根据员工 id 查询员工信息(员工表)及该员工的工作经历(员工工作经历表)时,可能会查询出多条数据(一个员工可能有多条工作经历),此时 MyBatis 也就可能封装出多个对象,这不符合业务逻辑

xml
<!-- 可使用 resultMap 手动封装 -->
<select id="list" resultMap="empResultMap">
    <!-- 查询语句... -->
</select>

<!-- 此处的 id 值要与上方 resultMap 中一致 -->
<!-- com.itheima.pojo.Emp 是上方定义的实体类 -->
<resultMap id="empResultMap" Itype="com.itheima.pojo.Emp">
    <!-- column 表示数据库存储的字段名,property 是实体类中对应的字段名 -->
    <!-- 注意如果是 id 属性必须使用 id 标签 -->
	<id column="id" property="id" />
    <!-- com.itheima.pojo.EmpExpr 是下方定义的员工经历实体类 -->
    <collection property="exprList" ofType="com.itheima.pojo.EmpExpr">
        <id column="ee_id" property="id"/>
		<result column="ee_company" property="company"/>
    </collection>
</resultMap>
java
// 员工经历实体类
@Data
public class EmpExpr {
    private Integer id; // ID
    private String company; // 公司名称
}

这样就能返回一条数据,符合业务逻辑

事务管理 ​

当需要执行多条 sql 往数据库中插入数据,而且这些数据存在联系,一旦某一条执行出错,就会导致数据库数据缺失的问题。

如:需要往数据库中保存员工信息和员工履历,任何一步出错都会导致数据缺失问题

java
// service 层代码
@Service
public class EmpServiceImpl implements EmpService {

    @Transactional
    // spring 注解,将当前方法交给 spring 进行事务管理,方法执行前,开启事务;成功执行完毕,提交事务;出现异常,回滚事务,可以加在业务(service)层的方法上、类上、接口上,推荐加在 service 层方法上
	// 如果 save 方法执行出错,那么最终不会往数据库插入任何数据
    @Override
    public void save(Emp emp) {
        // 保存员工信息
        empMapper.insert(emp);
        // 运行后这段代码会报错
        int i = 1/0;
        
		// 保存对应员工履历信息
        empEprMapper.insertBatch(exprList);
    }
}

rollbackFor ​

java
public class EmpServiceImpl implements EmpService {

    // Transactional 默认出现运行时异常才会回滚
    // Transactional 注解的 rollbackFor 属性可以指定回滚的范围
    // rollbackFor = {Exception.class} 表示所有异常都需要回滚
    @Transactional(rollbackFor = {Exception.class})
    @Override
    public void save(Emp emp) {
        // 保存员工信息
        empMapper.insert(emp);
        // 这是运行时错误
        int i = 1/0;
        
        // 这是非运行时错误,Transactional 默认不会回滚
        throw new Exception("出错啦~~~");
        
		// 保存对应员工履历信息
        empEprMapper.insertBatch(exprList);
    }
}

propagation ​

事务传播行为:指的就是当一个事务方法被另一个事务方法调用时,这个事务方法应该如何进行事务控制

java
// 如下两个函数都加上了 Transactional
@Transactional
public void a() {
	userService.b() ;
}

// 这时可以在此方法添加 propagation 属性来控制是否新建事务
@Transactional(propagation = Propagation.REQUIRED)
public void b() {}
属性值含义
REQUIRED(使用较多)【默认值】需要事务,有则加入,无则创建新事务
REQUIRES_NEW(使用较多)需要新事务,无论有无,总是创建新事务
SUPPORTS支持事务,有则加入,无则在无事务状态中运行
NOT_SUPPORTED不支持事务,在无事务状态下运行,如果当前存在已有事务,则挂起当前事务
MANDATORY必须有事务,否则抛异常
NEVER必须没事务,否则抛异常
java
// 示例:需求无论保存员工信息和员工履历信息执行是否成功都需要记录操作日志(执行 empMapper.insertLog)
public class EmpServiceImpl implements EmpService {
    @Transactional(rollbackFor = {Exception.class})
    @Override
    public void save(Emp emp) {
        try {
            // 保存员工信息
            empMapper.insert(emp);
            // 这是运行时错误
            int i = 1/0;
            // 保存对应员工履历信息
            empEprMapper.insertBatch(exprList);
        } finally {
            // 往数据库插入操作日志信息
        	empLogMapper.insertLog(emp);
        }
    }
}
java
// 上方 empLogMapper.insertLog 对应的 Service 层代码(简化)
@Service
public class EmpLogServiceImpl implements EmpLogService {

    // 在不加入 @Transactional(propagation = Propagation.REQUIRES_NEW) 代码时上方需求并不能实现,需要加入新建一个事务才行
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void insertLog(EmpLog empLog) {
        // 往数据库插入操作日志信息
    	empLogMapper.insert(empLog);
    }
}

配置日志信息,查看 spring 事务管理的底层日志

yml
# src\main\resources\application.yml
logging:
	level:
		org.springframework.jdbc.support.JdbcTransactionManager: debug

springBoot 原理 ​

配置优先级 ​

SpringBoot 中支持三种格式的配置文件,同时存在时优先级从上到下越来越低

properties
# 优先级最高
server.port=8081
yml
# 优先级其次
server:
	port: 8082
yaml
# 优先级最低
server:
	port: 8083

当然还支持另外两种形式

bash
# 以下以运行 jar 包举例
# -Dserver.port=9000 是 Java 系统属性,用于设置运行时端口号,优先级在上方三种配置文件之上
# --server.port=10010 是命令行参数,也可以设置运行时端口号,优先级在 Java 系统属性之上
java -Dserver.port=9000 -jar demo.jar --server.port=10010

Bean 管理 ​

Bean 的作用域 ​

Spring 支持五种作用域,后三种在 web 环境才生效

作用域说明
singleton容器内同名称的 bean 只有一个实例(单例)(默认)
prototype每次使用该 bean 时会创建新的实例(非单例/多例)
request每个请求范围内会创建新的实例(web环境中,了解)
session每个会话范围内会创建新的实例(web环境中,了解)
application每个应用范围内会创建新的实例(web环境中,了解)
java
// 使用示例,@Scope("singleton") 表示在别的地方注入该类时,每次注入的都是同一个实例
@Scope("singleton")
// 可以加上 @Lazy 注解延迟创建时机到第一次使用时再创建
@RequestMapping("/depts")
@RestController
public class DeptController {}

默认 bean 是单例的 singleton:默认单例的 bean 是在项目启动时,创建的,创建完毕后,会将该 bean 存入 IOC 容器中

使用场景 ​

当是一个无状态(没有保存信息,如变量)的 bean 使用 singleton ,单例 bean 更节省资源性能更高(更常用),当有状态(如:该 bean 记录了错误数据个数)就使用 prototype

java
@Scope("singleton")
public class DeptController {}

第三方 Bean ​

如果要管理的 bean 对象来自于第三方(不是自定义的),是无法用 @Component 及衍生注解声明 bean的,就需要用到 @Bean 注解

方式一,不推荐

java
// 假如这就是一个第三方提供的类,这里是封装了阿里云文件上传的工具类
public class AliyunosSOperator {
    private final AliyunOSSProperties aliyunOSSProperties;
    // 此类又依赖别的 bean
    public AliylnOSSOperator(AliyunOSSProperties aliyunOSSProperties) {
        // 通过构造函数注入依赖的 bean
        this.aliyunOSSProperties = aliyunOSSProperties;
    }
    // 其他逻辑代码...
}
java
// 打开启动类(src\main\java\com\example\demo\DemoApplication.java),不推荐这种方式
@SpringBootApplication
public class DemoApplication {
    // 将方法返回值交给 IOC 容器管理,成为 IOC 容器的 bean 对象
    // 通过 @Bean 注解的 name 或 value 属性可以声明 bean 的名称,如果不指定,默认 bean 的名称就是方法名
    @Bean
    // 如果第三方 bean 依赖其它 bean 对象,直接在 bean 定义方法中设置形参即可,容器会根据类型自动装配
    public AliyunOSSOperator aliyunosSOperator(AliyunosSProperties ossProperties) {
    	return new AliyunosSOperator(ossProperties);
    }
}
java
// 在业务代码中使用
public class DeptController {
	@Resource
    // 注入在启动类中写好的 Bean 
    private AliyunOSSOperator aliyunOSSOperator;
    
    public void testUpload() throws Exception {
        File file = new File( pathname: "C:\\Users\\deng\\Pictures\\1.jpg");
        // 使用
        String url = aliyunOSSOperator.upload(FileUtil.readBytes(file), originalFilename: "1.jpg");
    }
}

方式二,若要管理的第三方 bean 对象,建议对这些 bean 进行集中分类配置,可以通过 @Configuration 注解声明一个配置类

java
// src\main\java\com\example\demo\config\CommonConfig.java

@Configuration
public class CommonConfig {
    // 只需将上方启动类中的代码原封不动的放到这里即可,其他代码无需改动
    @Bean
    public AliyunOSSOperator aliyunosSOperator(AliyunosSProperties ossProperties) {
    	return new AliyunosSOperator(ossProperties);
    }
}

起步依赖 ​

springBoot 是基于 Spring Framework (配置、依赖更繁琐)的,springBoot 更简单、快捷,主要原因是 springBoot 提供了两大功能:起步依赖、自动配置

springBoot内置了一系列常用依赖,无需我们再次配置,开箱即用

自动配置 ​

SpringBoot 的自动配置就是当 spring 项目启动后,一些配置类、bean对象就自动存入到了IOC容器中,不需要我们手动去声明,从而简化了开发,省去了繁琐的配置操作(如使用第三方工具类,直接使用 @Resource 注入即可直接使用)

配置文件格式 ​

SpringBoot 项目提供了多种属性配置方式(properties、yaml、yml),即默认的 src\main\resources\application.properties

properties格式适用于配置较少的情况,但配置一多就显得臃肿,这时可以使用另外两种格式(这两种格式基本一致)书写

properties
# application.properties
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/web01
spring.datasource.username=root
spring.datasource.password=1234
yml
# application.yml 或 application.yaml(yml 或 yaml 发音:耶某)
# 此格式使用缩进来区分层级,书写时注意缩进(缩进的空格数目不重要,只要相同层级的元素左侧对齐即可)。注意属性名后的冒号后是有一个空格的
spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/web01
    username: root
    password: 1234

示例

注意:在 yml 格式的配置文件中,如果配置项的值是以 0 开头的,值需要使用'引起来,因为以 0 开头在 yml 中表示 8 进制的数据

yml
# 定义对象/Map集合
user:
  name: Tom
  age: 18
  gender: 男

# 定义数组/List/Set集合、
hobby:
  - Java
  - Game
  - Sport

目录介绍 ​

由于项目中内置了 tomcat 依赖,所以运行 DemoApplication.java 的 main 方法就能直接启动服务,而无需再安装 tomcat

pom.xml:存放项目依赖信息。真正的依赖包文件不在项目中,而是统一存放在本地仓库中。

如果使用 Maven 创建则存放在 C:\Users\你的用户名\.m2\repository中

如果使用 Gradle 创建则存放在C:\Users\你的用户名\.gradle\caches\modules-2中

默认存放位置可以修改

java
.mvn
.vscode
src
 -main
 --java  // 项目代码目录
 --resources
 ---application.properties   // 项目boot配置,例如启动端口号
 -test	// 单元测试
target  // 打包后输出文件夹
HELP.md
mvnw
mvnw.cmd
pom.xml   // 项目依赖列表

接口 ​

安装依赖 ​

1.安装 spring-boot-starter-validation 用于参数校验(前端调用接口时传入的参数)

2.安装 MyBatis-Plus (MyBatis 的增强工具,自动生成通用 CRUD、简化条件查询、内置分页、逻辑删除、自动填充,让你少写大量重复 SQL 和 XML,但复杂需求还是得自己写 SQL),官网:https://baomidou.com/getting-started/install/ 根据 Spring Boot 版本下载安装

3.安装 spring-boot-starter-security Spring Boot 官方提供的安全框架启动器,主要用来做 认证(比如登录、JWT 校验、Session 校验)、授权(比如某些接口需要登录、某些接口需要管理员角色)、安全防护(默认防护 CSRF、Session 固定攻击、点击劫持等)、密码加密、过滤器链(通过一系列过滤器拦截请求,完成登录校验、权限判断等)

4.安装 hutool-all ,提供开发中常用的工具方法,如:日期时间、加密解密等

创建全局安全框架配置 ​

在 src\main\java\com\example\demo\config下创建 SecurityConfig.java ,用于书写 spring-boot-starter-security插件的配置。

java
// @Configuration:标记这是一个配置类,Spring 启动时会加载其中的 @Bean
@Configuration
// @EnableWebSecurity:启用 Spring Security 的 Web 安全功能,让配置类生效
@EnableWebSecurity
// @EnableMethodSecurity:启用方法级安全,允许在方法上用 @PreAuthorize、@PostAuthorize 等注解控制权限
@EnableMethodSecurity
public class SecurityConfig {
    // 定义一组无需登录即可访问的接口路径
    private static final String[] PUBLIC_PATHS = {
            "/",
            "/api/test",
            "/api/user/login"
    };
    @Bean
    // SecurityFilterChain 是 Spring Security 的核心过滤器链,所有 HTTP 请求都会经过这条链,链上每个过滤器负责一部分安全逻辑
    SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
                // 禁用 CSRF 保护(前后端分离、使用 JWT 的 REST API,通常不需要 CSRF),主要针对基于 Session 的传统 Web 应用,
                .csrf(AbstractHttpConfigurer::disable)
                // 配置会话管理为无状态(JWT需要)
            	// Spring Security 不创建、不使用 HttpSession,每次请求都必须自带凭证(比如 JWT Token)来证明身份,适合前后端分离、JWT 认证的服务端
                .sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
                // 配置哪些请求需要什么权限
                .authorizeHttpRequests(auth -> auth
                        // 匹配 PUBLIC_PATHS 中的路径,允许所有请求访问,不需要登录
                        .requestMatchers(PUBLIC_PATHS).permitAll()
                        // 其他请求都需要认证
                        .anyRequest().authenticated());
        // 把配置好的 HttpSecurity 构建成 SecurityFilterChain,交给 Spring 管理
        return http.build();

    }
}

创建校验 ​

在 src\main\java\com\example\demo\DTO\command下创建 UserLoginCommandDTO 文件(java 类),用于封装接口参数校验规则。

java
@Data
public class UserLoginCommandDTO {
    // 使用 spring-boot-starter-validation 提供的注解进行参数校验
    @NotBlank(message = "用户名不能为空")
    @Size(max = 100, message = "用户名长度不能超过100个字符")
    private String userName;
    @NotBlank(message = "密码不能为空")
    @Size(max = 50, min = 6, message = "密码长度必须在6-50个字符之间")
    private String passWord;
}

创建业务异常类 ​

在 src\main\java\com\example\demo\exception 下创建 BusionessException.java ,用于业务逻辑中抛出自定义异常

java
// Lombok 注解,编译时为所有字段生成 getter 方法
@Getter
// 继承 RuntimeException,属于非受检异常,适合表示业务上的错误,比如“用户不存在”“密码错误”
public class BusionessException extends RuntimeException {
    private final String code;
    private final String message;
    private final Object data;

    public BusionessException(String message) {
        super(message);
        this.code = "BUSINESS_ERROR";
        this.message = message;
        this.data = null;
    }
}

创建全局异常类 ​

在 src\main\java\com\example\demo\common下创建 GlobarExceptionHandler 文件(java 类),用于处理接口错误信息

java
// @RestControllerAdvice 是 Spring 提供的一个全局控制器增强注解,专门用来做全局异常处理、全局数据绑定等,这里捕获所有 Controller 抛出的指定异常,并统一返回 JSON 格式的结果
@RestControllerAdvice
public class GlobarExceptionHandler {
    // 处理参数校验异常
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public Result<String> handlerException(MethodArgumentNotValidException e) {
        // 取出上方定义的校验错误提示文本信息
        String msg = e.getBindingResult().getFieldErrors().stream().map(FieldError::getDefaultMessage)
                .collect(Collectors.joining(","));
        // 将错误信息(错误码和错误文本)返回
        return Result.error(ResultCode.PARAM_ERROR.getCode(), ResultCode.PARAM_ERROR.getMsg(), msg);
    }
    
    // 处理业务异常 这里的 BusionessException 是 exception\BusionessException.java
    // Spring 的注解,用在方法上,表示这个方法只处理 BusionessException 类型的异常
    @ExceptionHandler(BusionessException.class)
    public Result<?> handleBusinessException(BusionessException e) {
        return Result.error(e.getCode(), e.getMessage(), e.getData());
    }
}

创建 Result ​

在 src\main\java\com\example\demo下创建 common 文件夹再创建 Result 文件(java 类),用于封装接口固定返参。

java
// Lombok 包提供,加上后编译时会自动为所有字段生成 getter,所有非 final 字段生成 setter
@Data
public class Result<T> {
    private String code;
    private String msg;
    private T data;

	public static <T> Result<T> ok() {
        Result<T> res = new Result<>();
        res.setCode(ResultCode.SUCCESS.getCode());
        res.setMsg(ResultCode.SUCCESS.getCode());
        return res;
    }

    // 函数重载用于针对需要自定义状态码的情况
    public static <T> Result<T> ok(T data) {
        Result<T> res = ok();
        res.setData(data);
        return res;
    }

    public static <T> Result<T> error() {
        Result<T> res = new Result<>();
        res.setCode(ResultCode.ERROR.getCode());
        res.setMsg(ResultCode.ERROR.getMsg());
        return res;
    }

	public static <T> Result<T> error(String code, String msg, T data) {
        Result<T> res = new Result<>();
        res.setCode(code);
        res.setMsg(msg);
        res.setData(data);
        return res;
    }
	
    // 使用 @Data 注解后如下固定代码就不用写了
    // public String getCode() {
    // return code;
    // }

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

创建 ResultCode ​

在 src\main\java\com\example\demo\common下创建 ResultCode 文件(java 枚举类),用于定义接口固定文本(状态码以及对应提示文本)

java
// 枚举类
public enum ResultCode {
    // 枚举类第一项必须是枚举项
    SUCCESS("200", "操作成功"),
    ERROR("-1", "操作失败"),
    UNAUTHORIZED("401", "暂未登录或token已经过期"),
    SYSTEM_ERROR("500", "系统错误"),

    private String code;
    private String msg;

    ResultCode(String code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    public String getCode() {
        return code;
    }

    public String getMsg() {
        return msg;
    }
}

创建 service 层字段 ​

在 src\main\java\com\example\demo\entity 下创建 User 文件(java 类),定义接口业务代码数据库字段。

java
@Data
// MyBatis-Plus 注解,指定这个类对应数据库中的 user 表,如果表名和类名一致(比如类名 User,表名 user),可以省略
@TableName("user")
public class User {
    // TableId 代表主键,IdType.AUTO 表示主键由数据库自增生成
    @TableId(type = IdType.AUTO)
    private Long id;

    // 字段校验规则
    @NotBlank(message = "用户名不能为空")
    @Size(min = 3, max = 50, message = "用户名长度必须为3-50")
    @Pattern(regexp = "^[a-zA-Z0-9_]+$", message = "用户名只能包含数字字母下划线")
    private String username;
    // private String username = "默认名称" 设置默认值

    // 字段校验规则
    @NotBlank(message = "密码不能为空")
    @Size(min = 3, max = 50, message = "密码长度必须为3-50")
    @Pattern(regexp = "^[a-zA-Z0-9_]+$", message = "密码只能包含数字字母下划线")
    private String password;
}

创建 Mapper ​

在 src\main\java\com\example\demo\mapper 下创建 UserMapper 文件(java 接口),继承 BaseMapper 类(MyBatis-Plus 提供,方便后续调用它提供的方法)。

java
// MyBatis 的注解,告诉 Spring/MyBatis,这是一个 Mapper 接口,启动时要为它生成动态代理实现类,并注册到 Spring 容器中
@Mapper
// 这里的 User 是 entity\User.java 中的类
// BaseMapper 是 MyBatis-Plus 提供的通用 Mapper 接口,继承后,UserMapper 就自动拥有了一系列基础的 CRUD 方法,无需写实现类和重复 SQL
public interface UserMapper extends BaseMapper<User> {}

创建 service 层 ​

在 src\main\java\com\example\demo\service 下创建 userService 文件(java 类),定义接口自定义具体返参。

java
// Spring 注解,标记这个类是一个业务逻辑层组件,Spring 启动时会自动扫描并创建它的 Bean,交给容器管理
@Service
public class userService {
    // Java 标准注解,用于依赖注入。Spring 支持它,默认按名称注入,找不到再按类型注入
    @Resource
    // 这里的 UserMapper 是 mapper\UserMapper.java 的接口
    private UserMapper userMapper;
    private final BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();

    public Result<UserLoginResponseDTO> login(UserLoginCommandDTO commandDTO) {
        // 构建查询条件,这里的 User 类型是 entity\User.java 中的实体类
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        // MyBatis-Plus 提供的条件构造器,用 Lambda 方法引用的方式指定字段,避免硬编码字符串字段名
        // eq 表示等值条件,最终生成的 SQL 类似:SELECT * FROM user WHERE username = ?
        // 这里是将用户传入的信息去数据库查询对应字段的数据
        queryWrapper.eq(User::getUsername, commandDTO.getUserName());
        // MyBatis-Plus 提供的方法,根据条件查询一条记录
        User user = userMapper.selectOne(queryWrapper);
        System.out.println(user);
        if (user == null) {
            throw new BusionessException("用户不存在");
        }
        // 验证密码
        String inputPassword = commandDTO.getPassWord().trim();
        // 判断明文密码和已加密的密码是否匹配
        // 数据加密 可使用 passwordEncoder.encode(password);
        if (!passwordEncoder.matches(inputPassword, user.getPassword())) {
            throw new BusionessException("密码错误");
        }
        // 通过 demo\util\JwtTokenUtil.java 的类获取 token
        String token = JwtTokenUtil.generalIToken(user.getId(), user.getUsername());
        // UserLoginResponseDTO 是 DTO\response\UserLoginResponseDTO.java 的类
        // UserConvert 是 service\convert\UserConvert.java 的类,用于组装接口返参
        UserLoginResponseDTO.UserDetailResponseDT0 userInfo = UserConvert.entityToDetailResponse(user);
        return UserConvert.entityToLoginResponse(token, userInfo);
    }
}

接口参数类型 ​

在 src\main\java\com\example\demo\DTO\response 下创建 UserLoginResponseDTO 文件(java 类),定义单个接口返参类型及字段。

java
@Data
// Lombok 生成建造者模式,允许这样创建对象:
/*
UserLoginResponseDTO.builder()
    .token(token)
    .userInfo(userInfo)
    .build();
    方便下方 组装接口返参 中 UserConvert 快速创建对象
*/
@Builder
public class UserLoginResponseDTO {
    private String token;
    private UserDetailResponseDT0 userInfo;

    @Data
    @Builder
    public static class UserDetailResponseDT0 {
        private String userName;
        private Long userId;
    }
}

创建转换类 ​

在 src\main\java\com\example\demo\service\convert\UserConvert.java 中写入,用于组装接口返参

java
public class UserConvert {
    // UserLoginResponseDTO.UserDetailResponseDT0 是 DTO\response\UserLoginResponseDTO.java 的类
    // User 是 entity\User.java 的类
    public static UserLoginResponseDTO.UserDetailResponseDT0 entityToDetailResponse(User user) {
        return UserLoginResponseDTO.UserDetailResponseDT0.builder().userId(user.getId()).userName(user.getUsername())
                .build();
    }

    public static UserLoginResponseDTO entityToLoginResponse(String token,
            UserLoginResponseDTO.UserDetailResponseDT0 userInfo) {
        return UserLoginResponseDTO.builder().userInfo(userInfo).token(token)
                .build();
    }
}

创建接口 ​

在 src\main\java\com\example\demo 下创建 controller (命名规范)文件夹再创建 Test 文件(java 类),定义接口

java
// 这是一个组合注解,等于 @Controller + @ResponseBody,表示这个类是一个控制器,用来接收 HTTP 请求,类中所有方法的返回值都会直接作为 HTTP 响应体返回,而不是跳转到某个页面
@RestController
// 用在类上,表示这个类下所有接口的公共路径前缀
@RequestMapping("/api")
// 请求 http://127.0.0.1:8080/api/test 即可,端口号可在 src\main\resources\application.properties 中设置
public class Test {
    // 用在方法上,表示处理 GET 请求,路径是 /test,等价于 @RequestMapping(value = "/test", method = RequestMethod.GET)
    @GetMapping("/test")
    public Result<String> test() {
        // 调用 ok 方法接口返回的就是 json 数据了
        return Result.ok();
    }
}

@RestController
@RequestMapping("/api/user")
// 这里是 src\main\java\com\example\demo\controller\User.java 文件中的接口类
public class User {
    // 这里是 service 文件夹下的 userService.java 的类
    @Resource
    private userService userService;
    
    @PostMapping("/login")
    // 引入刚刚写好接口校验规则
    public Result<UserLoginResponseDTO> login(@Valid @RequestBody UserLoginCommandDTO commandDTO) {
        // 获取前端传递过来的数据
        // System.out.println(commandDTO.getPassWord());
        // System.out.println(commandDTO.getUserName());
        // 这里 UserDetailResponseDT0 是 DTO\response\UserLoginResponseDTO.java 的类
        UserLoginResponseDTO result = userService.login(commandDTO);
        return Result.ok(result);
    }
}

jwt ​

安装 java-jwt 依赖

yml
# 在 pom.xml 中添加配置
# JWT配置
jwt:
  secret: MySecretKeyForJWT2025!@#$%^&*()_+SecureKeyHere # 密钥,用来给 JWT 签名,保证 Token 不能被伪造
  expiration: 86400000 # 24小时(毫秒)
  refresh-expiration: 604800000 #7天(毫秒)
  header: Authorization # token头部名称
  token-prefix: "Bearer" # token前缀

在 src\main\java\com\example\demo\config\JwtConfig.java 中写入

java
@Data
// 把这个类注册为 Spring 容器中的 Bean,这样下方 JwtTokenUtil 中才能通过 applicationContext.getBean(JwtConfig.class) 获取到它
@Component
// Spring Boot 提供的注解,用于批量绑定配置属性,prefix = "jwt" 表示从配置文件中读取所有以 jwt. 开头的属性,并映射到该类的字段
@ConfigurationProperties(prefix = "jwt")
public class JwtConfig {
    private String secret;
    private long expiration;
    private long refreshExpiration;
    private String header;
    private String tokenPrefix;
}

在 src\main\java\com\example\demo\util\JwtTokenUtil.java 中写入 JWT 工具类,用于生成 token

java
// 把这个类注册为 Spring 容器中的 Bean
@Component
// ApplicationContextAware 是 Spring 提供的接口,实现后 Spring 会自动回调 setApplicationContext 方法
//  接口让静态方法也能从 Spring 容器中获取配置 Bean(JwtConfig)
public class JwtTokenUtil implements ApplicationContextAware {
	// 保存 Spring 应用上下文,方便静态方法使用
    private static ApplicationContext applicationContext;
    // 定义签发者
    private static final String ISSUER = "mental-health-assistant";

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) {
        JwtTokenUtil.applicationContext = applicationContext;
    }

    private static JwtConfig getJwtConfig() {
        // 这里通过应用上下文获取 src\main\java\com\example\demo\config\JwtConfig.java 中的配置
        // 当然也可以通过 @Resource 注解直接注入的方式获取,因为后续很多地方都需要它,所以放到上下文上,方便后续使用
        return applicationContext.getBean(JwtConfig.class);
    }

    public static String generalIToken(String userId, String username) {
        try {
            // 获取jwt的配置
            JwtConfig jwtConfig = getJwtConfig();
            // 生成签名的算法
            Algorithm algorithm = Algorithm.HMAC256(jwtConfig.getSecret());
            // 生成过期时间
            Date expiration = new Date(System.currentTimeMillis() + jwtConfig.getExpiration());
            String token = JWT.create()
                	// 往 token 中写入签名数据,后续解析 token 时可以读取到
                    .withClaim("userId", userId)
                    .withClaim("username", username)
                    .withExpiresAt(expiration) // 设置过期时间
                    .withIssuedAt(new Date()) // 设置签发时间
                    .withIssuer(ISSUER) // 设置签发者
                    .sign(algorithm); // 生成最终 Token 字符串
            return token;
        } catch (Exception e) {
            throw new RuntimeException("生成 token 失败!" + e);
        }
    }
}

使用

java
// 直接调用上方写好的工具类方法即可
String token = JwtTokenUtil.generalIToken(user.getId(), user.getUsername());

认证 ​

添加过滤器 ​

用于拦截不在白名单下的接口(如:需要 token 鉴权的接口)

添加路径比对函数

java
// src\main\java\com\example\demo\config\SecurityConfig.java
public class SecurityConfig {
    // AntPathMatcher:Spring 提供的路径匹配工具,支持 *、**、? 等通配符,比如 /api/**
    private static final AntPathMatcher antPathMatcher = new AntPathMatcher();
    // 定义需要排除的接口地址
    private static final String[] PUBLIC_PATHS = {
            "/",
            "/api/test",
            "/api/user/login",
            "/api/user/add"
    };

    public static Boolean isPublicPATH(String requestUri) {
        // 判断是否为公开路径
        for (String publicPath : PUBLIC_PATHS) {
            if (antPathMatcher.match(publicPath, requestUri)) {
                return true;
            }
        }
        return false;
    }
    // 其他代码...
}

创建过滤器

java
// src\main\java\com\example\demo\util\JwtAuthticationFilter.java
// 继承 OncePerRequestFilter:Spring 提供的基类,保证一次请求只经过一次过滤器
public class JwtAuthticationFilter extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {
        // 获取请求的URI和方法
        String requestUri = request.getRequestURI();
        String method = request.getMethod();
        System.out.println(requestUri);
        System.out.println(method);
    }

    @Override
    protected boolean shouldNotFilter(HttpServletRequest request) {
        String url = request.getRequestURI();
        // 导入上方写好的 SecurityConfig 类中的工具函数,比对 api 路径
        return SecurityConfig.isPublicPATH(url);
    }
}

添加过滤器

java
// src\main\java\com\example\demo\config\SecurityConfig.java
public class SecurityConfig {
    // 其他代码...
    // 导入刚刚写好的过滤类
    @Bean
    public JwtAuthticationFilter jwtAuthticationFilter() {
        // 注册 JWT 过滤器 Bean
        return new JwtAuthticationFilter();
    }
    
    SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            // 其他代码...
                        .anyRequest().authenticated())
            // 添加JWT认证过滤器
                .addFilterBefore(jwtAuthticationFilter(), UsernamePasswordAuthenticationFilter.class);
        return http.build();
    }
}

提取 token ​

读取请求头 token 信息

java
// src\main\java\com\example\demo\util\JwtTokenUtil.java
@Component
public class JwtTokenUtil implements ApplicationContextAware {
    // 其他代码...
    public static String extractTokenFromRequest(HttpServletRequest request) {
        if (request == null)
            return null;
        // 获取请求头 token 字段对应的信息
        String tokenHeader = request.getHeader("token");
        // hasText(String) 是 Spring 框架 提供的方法,用于判断是否非空且包含实际字符(不是全空格)
        if (StringUtils.hasText(tokenHeader))
            return tokenHeader;
        return null;
    }
}

解析 token ​

java
// src\main\java\com\example\demo\util\JwtAuthticationFilter.java
public class JwtAuthticationFilter extends OncePerRequestFilter {

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {
        // 获取请求的URI和方法
        String requestUri = request.getRequestURI();
        String method = request.getMethod();
        // 调用上方 extractTokenFromRequest 方法提取 JWT token
        String token = JwtTokenUtil.extractTokenFromRequest(request);
        if (StringUtils.hasText(token)) {

        } else {
            // 清理 Spring Security 上下文
            clearSecurityContext();
            // 调用下方写好的 ResponseUtil 类抛出异常
            // ResultCode 是上方 common\ResultCode.java 中定义的状态码信息
            ResponseUtil.writeError(response, ResultCode.ACCESS_UNAUTHORIZED);
            return;
        }
        // 放行 继续过滤器链执行,否则请求会卡住
        filterChain.doFilter(request, response);
    }

    private void clearSecurityContext() {
        // 清理 Spring Security 上下文
        // SecurityContextHolder 是 Spring Security 用来存储当前请求认证信息的容器
        // 清除当前线程中的认证信息,防止上一个请求的认证状态残留,避免安全问题
        // 通常在认证失败、登出、请求结束时调用
        SecurityContextHolder.clearContext();
    }
}

处理异常 ​

当解析token异常时需要抛出异常,由于这里不能使用(代码还未执行到)之前写的异常函数(common\Result.java)因此需要单独处理

java
// src\main\java\com\example\demo\util\ResponseUtil.java
public class ResponseUtil {
    // ResultCode 是上方 common\ResultCode.java 中定义的状态码信息
    public static void writeError(HttpServletResponse response, ResultCode resultCode) {
        // 根据不同结果码返回不同的响应
        // 这里是 Java 17 的 switch 表达式(箭头语法)
        int status = switch (resultCode) {
            // token 过期 HttpStatus 是 springframework 提供的 api
            case UNAUTHORIZED, ACCESS_UNAUTHORIZED, TOKEN_INVALID, TOKEN_EXPIRED, TOKEN_BLOCKED ->
                HttpStatus.UNAUTHORIZED.value();
            // token 被禁用
            case TOKEN_ACCESS_FORBIDDEN -> HttpStatus.FORBIDDEN.value();
            default -> HttpStatus.BAD_REQUEST.value();
        };
        // 构建响应体参数
        // 设置 HTTP 状态码
        response.setStatus(status);
        // MediaType 是 springframework 提供的 api,告诉浏览器返回的是 JSON
        response.setContentType(MediaType.APPLICATION_JSON_VALUE);
        // StandardCharsets 是 StandardCharsets 提供的 api,防止中文乱码
        response.setCharacterEncoding(StandardCharsets.UTF_8.name());
        try (PrintWriter writer = response.getWriter()) {
            // Result 是上方写好的 common\Result.java 中的类
            // JSONUtil.toJsonStr 转换为 json 格式
            String jsonResponse = JSONUtil.toJsonStr(Result.error(resultCode.getCode(), resultCode.getMsg(), null));
            // 写入响应体
            writer.print(jsonResponse);
            writer.flush();
        } catch (IOException e) {
            System.out.println("写入响应体失败" + e.getMessage());
        }
    }
}

验证 token ​

java
// src\main\java\com\example\demo\util\JwtTokenUtil.java 中写入
@Component
public class JwtTokenUtil implements ApplicationContextAware {
	// 其他代码...
    private static final String ISSUR = "mental-health-assistant";
    
    private static JwtConfig getJwtConfig() {
        return applicationContext.getBean(JwtConfig.class);
    }
    
    // 验证token
    public static TokenVerificationResult validateToken(String token) {
        DecodedJWT jwt = verifyToken(token);
        // 获取 token 中保存的用户信息
        Long userId = jwt.getClaim("userId").asLong();
        String username = jwt.getClaim("username").asString();
        if (userId != null && StringUtils.hasText(username)) {
            // 使用下方定义的 TokenVerificationResult 类创建返回对象
            return new TokenVerificationResult(userId, username, true);
        }
        return null;
    }
    
    // 验证 token 有效性
    public static DecodedJWT verifyToken(String token) {
        if (!StringUtils.hasText(token)) {
            throw new JWTVerificationException("Token不能为空");
        }
        // token 解码 getJwtConfig 上方定义的获取 jwt 配置的方法
        JwtConfig jwtConfig = getJwtConfig();
        Algorithm algorithm = Algorithm.HMAC256(jwtConfig.getSecret());
        // ISSUR 上方定义的签发者信息
        JWTVerifier verifier = JWT.require(algorithm).withIssuer(ISSUR).build();
        // 验证 token
        return verifier.verify(token);
    }

    // token 验证结果封装类
    @Getter
    public class TokenVerificationResult {
        private final Long userId;
        private final String username;
        private final boolean valid;

        public TokenVerificationResult(Long userId, String username, boolean valid) {
            this.userId = userId;
            this.username = username;
            this.valid = valid;
        }
    }
}

回到上方 JwtAuthticationFilter 中doFilterInternal函数完善逻辑

java
// src\main\java\com\example\demo\util\JwtAuthticationFilter.java
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {
		// 其他代码...
        // 1. 提取 JWT token
        String token = JwtTokenUtil.extractTokenFromRequest(request);
    	// 当 token 格式无效(如:空字符串)时抛出异常
        if (!StringUtils.hasText(token)) {
            clearSecurityContext();
            ResponseUtil.writeError(response, ResultCode.ACCESS_UNAUTHORIZED);
            return;
        }
    	// 解析 token 时可能会出错,比如 token 过期、签名错误,所以得 try catch 捕获异常
        try {
            // 2. 引入上方写好的 TokenVerificationResult 方法验证token并获取用户信息
            JwtTokenUtil.TokenVerificationResult validationResult = JwtTokenUtil.validateToken(token);
            if (validationResult != null && validationResult.isValid()) {
				// 验证成功后的业务逻辑...
                // 下方补充...
            } else {
                // 验证失败清理 Spring Security 上下文并抛出 token 无效的异常
                clearSecurityContext();
                // ResultCode 是上方 common\ResultCode.java 中的枚举类
                ResponseUtil.writeError(response, ResultCode.TOKEN_INVALID);
                return;
            }
        } catch (JWTVerificationException e) {
            clearSecurityContext();
            ResponseUtil.writeError(response, ResultCode.TOKEN_INVALID);
        }
    	// 其他代码...
}
java
// 补充上方验证成功后的业务逻辑
if (validationResult != null && validationResult.isValid()) {
    // 使用 userMapper.selectById() 根据 id (上方从 token 中解析出来的 id 信息)查询数据库对应数据,具体实现逻辑可以查看下方代码
UserLoginResponseDTO.UserDetailResponseDTO user = userService.getUserById(validationResult.getUserId());
                if (user != null) {
                    // 4.SimpleGrantedAuthority 是 Spring Security 的权限对象
                    List<SimpleGrantedAuthority> authorities = Collections.singletonList(
                        // "ROLE_" + userId:这里拼接的是用户 ID,作为权限名
                        // 这里仅做演示,通常是用户角色来作为权限名
                        new SimpleGrantedAuthority("ROLE_" + validationResult.getUserId()));
                    // 创建UsernamePasswordAuthenticationToken对象
                    UsernamePasswordAuthenticationToken authcation = new UsernamePasswordAuthenticationToken(
                            validationResult.getUsername(), // 用户名作为主体
                            null,// 凭证,通常是密码 JWT 认证不需要密码,传 null
                            authorities);// 权限列表
                    // 设置认证信息到Spring Securtity上下文
                    // 后续的 authorizeHttpRequests 会从这里读取认证状态,判断是否放行
                    // 设置之后,anyRequest().authenticated() 才会通过
                    SecurityContextHolder.getContext().setAuthentication(authcation);
                    // 将token存储到请求属性中
                    request.setAttribute("jwtToken", token);
                }
}
java
// 上方 userService 类中 selectById 方法代码
public UserLoginResponseDTO.UserDetailResponseDTO getUserById(Long userId) {
    User user = userMapper.selectById(userId);
    if (user == null) {
        throw new BusionessException("用户不存在");
    }
    // UserConvert 是上方 service\convert\UserConvert.java 中定义的转换类
    // 将查询到的用户信息组装为指定类型
    return UserConvert.entityToDetailResponse(user);
}

地址 ​

上述所有源码:https://gitee.com/master-dog/java_project

hutool-all ​

java
// parseObj:打印对象
// {"userName":"admin","passWord":"123456"}
System.out.println(JSONUtil.parseObj(commandDTO));

MyBatis-Plus ​

java
// 构建查询条件
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
// eq 根据用户传递的信息去数据库对应字段查询数据
queryWrapper.eq(User::getUsername, commandDTO.getUserName());
// 查询一条
User user = userMapper.selectOne(queryWrapper);
// 查询符合条件数据的数量
userMapper.selectCount(queryWrapper)
// 插入数据库
userMapper.insert();
// 根据传入的 id 查询数据库对应 id 的信息
userMapper.selectById()
java
这是src\main\java\com\example\demo\config\SecurityConfig.java的代码:
    @Configuration
@EnableWebSecurity
@EnableMethodSecurity
public class SecurityConfig {
    private static final AntPathMatcher antPathMatcher = new AntPathMatcher();
    // 定义需要排除的接口地址
    private static final String[] PUBLIC_PATHS = {
            "/",
            "/api/test",
            "/api/user/login",
            "/api/user/add"
    };

    @Bean
    public JwtAuthticationFilter jwtAuthticationFilter() {
        return new JwtAuthticationFilter();
    }

    public static Boolean isPublicPATH(String requestUri) {
        for (String publicPath : PUBLIC_PATHS) {
            if (antPathMatcher.match(publicPath, requestUri)) {
                return true;
            }
        }
        return false;
    }

    @Bean
    SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
                // 禁用 CSRF 保护(API服务通常不需要)
                .csrf(AbstractHttpConfigurer::disable)
                // 配置会话管理为无状态(JWT需要)
                .sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
                // 配置请求的授权规则
                .authorizeHttpRequests(auth -> auth
                        // 公开的路径,无需登录即可访问
                        .requestMatchers(PUBLIC_PATHS).permitAll()
                        // 其他请求都需要认证
                        .anyRequest().authenticated())
                        // 添加JWT认证过滤器
                .addFilterBefore(jwtAuthticationFilter(), UsernamePasswordAuthenticationFilter.class);
        return http.build();

    }
}
这是src\main\java\com\example\demo\util\JwtAuthticationFilter.java的代码:
    public class JwtAuthticationFilter extends OncePerRequestFilter {

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {
        // 获取请求的URI和方法
        String requestUri = request.getRequestURI();
        String method = request.getMethod();
        System.out.println(requestUri);
        System.out.println(method);
    }

    @Override
    protected boolean shouldNotFilter(HttpServletRequest request) {
        String url = request.getRequestURI();
        // 导入上方写好的 SecurityConfig 类中的工具函数,比对 api 路径
        return SecurityConfig.isPublicPATH(url);
    }

}
解释一下代码