Java 开发——（上篇）从零开始搭建后端基础项目 Spring Boot 3 + MybatisPlus

基于 Spring Boot 3 + MybatisPlus 的项目实战开发，一个基础的后端项目。

蟾宫曲

1417人浏览 · 2024-10-23 13:44:25

蟾宫曲 · 2024-10-23 13:44:25 发布

一、概述

记录时间 [2024-10-23]

本文是一个基于 Spring Boot 3 + MybatisPlus 的项目实战开发，主要涵盖以下几个方面：

从零开始的项目创建
IDEA 中开发环境的热部署
Maven、Swagger3、MybatisPlus 等的配置
路由映射知识
静态资源访问
文件上传功能实现
拦截器的配置

通过此次开发练习，我们能对 MVC 架构有一个简单的了解，会使用 Spring Boot 框架进行 Java 项目的开发，感受前后端之间是如何传递信息的。可以说，这个项目相当于一个后端基础模板，在此基础上我们可以按照需求进一步开发，若搭配 Vue 进行前端开发，便可以搭建出一个简单的前后端分离系统。

考虑到篇幅的问题，将分成两篇文章写，此为上篇。

二、开发环境搭建

1. 开发工具

此项目需要使用的开发工具如下，各种工具通过官网安装，读者可进行参考：

Windows 11 - 笔记本的系统
JDK 17 - springboot3.0 以上最低支持的 jdk 版本，官网下载
Intellij IDEA 2021.2.2 - 编写 Java 代码的开发工具
MySQL 5.7.43 - 本地数据库
Navicat 16.0 - 数据库查看 / 测试工具
Postman - API 接口测试工具
Notepad++ - 文本修改工具，会标记代码颜色

2. 配置 JDK

Java 开发环境（JDK）搭建，参考文章 - Java 开发环境搭建

（使用 IDEA 开发不需要配置系统环境变量，下载解压就行）

3. 配置 Maven

参考文章 - Maven 在 IDEA 中的配置与使用

三、创建 springboot3.0 项目

Spring Boot 项目可以通过官网创建，IDEA 集成了 Spring 官网创建项目的方式，因此，使用 IDEA 创建 Spring Boot 项目在本质上也是通过官网提供的服务 URL 创建的。

1. 新建项目 Spring Initializr

创建路径：File ==> New ==> New Project

使用 IDEA 创建 Spring Initializr 项目，开发语言选择 Java，以 Maven 的方式管理项目。

SDK 和 Java 版本选择刚才下载的 17 版本，同时选择以 jar 包的形式对项目进行打包。

然后点击 Next 继续操作。

在这里插入图片描述

2. 添加 Web 依赖

在这里我们选择 Spring Boot 的版本在 3.0 以上。

与 2.0 版本相比，3.0 版本是一次较大的升级，造成了很多不兼容更新。例如最低兼容的 Java 版本为 17，底层也切换到了 Spring 6，Swagger 的配置也有很大的不同。

然后，勾选 Web 依赖，Spring Boot 项目会内置 Tomcat，自动完成一些 xml 的相关配置。

最后点击 Finish，完成创建。

在这里插入图片描述

3. 编码设置

设置项目的编码为 UTF-8，以防出现中文乱码的情况。

直接搜索 File Encodings 进行查找。

在这里插入图片描述

4. 开发环境热部署

在实际的项目开发调试过程中，我们会频繁地修改后台类文件，导致项目需要重新编译重新启动，整个过程非常麻烦，影响开发效率。

解决办法：设置 Spring Boot 开发环境热部署。

当 IDEA 监测到主程序中的内容发生改变后，会自动对项目进行编译和重启，此方法可以带来些许便利。

使用 Spring Boot 提供的组件：spring-boot-devtools
在 IDEA 中进行相应的设置

添加 Maven 依赖

在 pom.xml 文件中添加 dev-tools 依赖

<!-- 使用 optional=true 表示依赖不会传递，即该项目依赖 devtools;
	其他项目如果引入此项目生成的 JAR 包，则不会包含 devtools -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <optional>true</optional>
</dependency>

修改配置文件

在 application.properties 中配置 dev-tools

# 设置热部署生效
spring.devtools.restart.enabled=true

# 设置重启目录
spring.devtools.restart.additional-paths=src/main/java

# 设置 classpath 目录下的 WEB-INF 文件夹内容修改不重启
# spring.devtools.restart.exclude=static/**

修改 IDEA 的设置

修改路径：File ==> Settings ==> Build ==> Compiler

勾选 Build project automatically，点击 Apply 进行应用，使其能自动编译构建项目。

在这里插入图片描述

同时勾选上 auto-make，点击 Apply 进行应用，确保热部署配置成功。

修改路径：File ==> Settings ==> Advanced Settings ==> Compiler

在这里插入图片描述

5. 运行主程序

找到 Spring Boot 项目的主程序入口，后缀名为 xxxApplication，点击运行即可启动整个项目。

在这里插入图片描述

四、接收 / 处理 HTTP 请求

1. 控制器 @RestController

Spring Boot 中提供了两种注解来标识控制器的类负责接收和处理 HTTP 请求，分别是 @Controller 和 @RestController。

@Controller：返回页面和数据；
@RestController：只返回数据，默认情况下，该注解会将返回的对象数据转换成 JSON 格式。

在前后端分离模式中，一般由前端发送 HTTP 请求给后端，后端响应请求并返回数据，故使用 @RestController 注解。

在 com.example.demo 目录下新建 package controller，这个包下面放的是控制器类，添加上相应的注解后，可以接收和处理 HTTP 请求。

2. 路由映射 @RequestMapping

路由映射指的是后端（服务端）规定前端以何种方式发送请求。后端的控制类中的一个方法对应一种请求方式。

或者说是后端给前端规定了一条路径，通过这条路径，前端发送的消息才能被后端接收到。

这条路径会写在注解 @RequestMapping 中。

@RequestMapping 可以写在控制类或者具体的方法中，也可以两个地方都写，整体的路径就是两个拼接起来。如请求 hello1 方法的整体路由为 http://localhost:后端端口号/hello/hello1
当注解中只有一个路径参数时，可以省略变量名 value，但如果还有其他的参数，就不可以省略。

// 以下是一个控制类
@RestController
@RequestMapping("/hello")
public class HelloController {
    
    @RequestMapping (value = "/hello1")
    public String hello1() {
        return "hello "
    }
}

HTTP 请求的类型多样，如 Get、Post 等，在注解中可以规定请求的类型。如果后端规定了请求的类型，那么前端要发送相应类型的请求。
后端有两种方式规定请求的类型。
- 第一种，修改注解，如 Get 请求，就把注解修改成 @GetMapping，以此类推还有 @PostMapping、@PutMapping 等。
- 第二种，在注解中用 method 参数进行标识。

// 以下是一个控制类
@RestController
@RequestMapping("/hello")
public class HelloController {
    
    // 这是一个 get 请求
    @RequestMapping (value = "/hello1",method = RequestMethod.GET)
    public String hello1() {
        return "hello "
    }
    
    // 这是一个 post 请求
    @PostMapping("/hello2")
    public String hello2() {
        return "login OK";
    }
    
}

3. 测试工具 Postman

浏览器只能发送简单的 Get 请求，其他请求可以通过测试工具 Postman 进行测试。

在这里插入图片描述

4. 参数传递

前端在发送请求时，可以在请求中添加一些参数，这些参数会一起发送给后端。

后端通过某种方式可以获取这些参数。

方式一（Query Params）

前端直接把参数写在请求路径上，格式为 参数名=参数内容，如果有多个参数，则使用 & 字符进行拼接。如 http://localhost:8080/hello?nickname=zhangsan&phone=123
后端可以在方法中添加参数类型，来接收参数，如 hello(String nickname, String phone)
当请求中的参数名称与方法中的参数名称一致时，自动识别参数内容。
这里的参数传递不是必须的，如果前端没传参数，但是后端设置了接收，则参数的内容为默认的（String 类型为 null）。

// 测试用 http://localhost:8080/hello
// 测试用 http://localhost:8080/hello?nickname=zhangsan&phone=123
@GetMapping("/hello")
public String hello(String nickname, String phone) {
    // 参数传递
    // 当请求中的参数名称与方法中的参数名称一致时，自动识别参数内容
    System.out.println(phone);
    return "hello " + nickname;
}

当请求中的参数名称与方法中的参数名称不一致时，后端不会自动识别参数内容，需要添加参数映射。
参数映射使用注解 @RequestParam 来实现，作用是把这两个参数名称对应起来。如请求中的参数名称为 nickname，方法中的参数名称为 name，则需要映射 @RequestParam(value = "nickname") String name
默认情况下，用了参数映射，则这个参数必须传递。解决方式是更改 required = false。

// 参数映射
// 当加了参数映射，参数必须传递，否则报错 (除非加参数 required = false)
// 不加映射，值可为空
@RequestMapping (value = "/hello1",method = RequestMethod.GET)
public String hello1(@RequestParam(value = "nickname",required = false) String name) {
    // 参数传递
    // 当请求中的参数名称与方法中的参数名称一致时，自动识别参数内容
    // 不一致时，添加参数映射
    System.out.println("hello1....");
    return "hello " + name;
}

参考测试

先确定路由映射的路径，方法，需要传递的参数。

在这里插入图片描述

方式二（动态获取）

这种方式一般搭配 RESTful API 使用。
将请求 URL 中的模板变量映射到方法参数上，@GetMapping 中写请求路径，需要传递的参数用大括号包裹，如 /user/{id}，这表示前端要传递的参数是 id = 10，前端的写法是 http://localhost:8080/user/10
后端想要获取这个参数值，需要在对应的参数前加注解 @PathVariable

// 动态方式获取 {id}，需要添加注解 @PathVariable
@GetMapping("/user/{id}")
public String getUserById(@PathVariable int id) {
    return "根据 ID 获取用户信息：" + id;
}

参考测试

先确定路由映射的路径，方法，需要传递的参数。

在这里插入图片描述

方式三（请求体 Body + 封装类）

当请求传递的参数数量较多时，可以将参数封装到实体类中。
在 Spring Boot 项目中编写一个 User 实体类，里面有两个参数 username 和 password，给它们生成 Getter / Setter + toString() 方法。

// 用于封装参数的实体类
public class User {

    private String username;
    private String password;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

前端要传递的参数就是 User 类中的这两个参数 username 和 password，注意名字不要写错
后端会自动把这些参数封装到 user 对象中去。

// 把对象封装到类里，注意参数名称相同
@PostMapping("/hello2")
public String hello2(User user) {

    System.out.println(user.toString());

    return "login OK" + user.getUsername();
}

如果前端用 JSON 格式请求，则对象前需要加上请求体 @RequestBody
注意 JSON 格式的参数是有数据类型的，如，用双引号表示的是字符串类 "zhangsan"，对应 User 类中的参数类型 String。

// 如果前端用 JSON 格式请求，则对象前需要加上请求体 @RequestBody
@PostMapping("/hello3")
public String hello3(@RequestBody User user) {

    System.out.println(user.toString());

    return "login OK" + user.getUsername();
}

参考测试

先确定路由映射的路径，方法，需要传递的参数。

在这里插入图片描述

前端用 JSON 格式请求

在这里插入图片描述

方式四（通配符）

浅看一下

// 通配符请求
// * 一个目录  http://localhost:8080/text/*
// ** 多个目录 http://localhost:8080/text/**/****
@GetMapping("/text/**")
public String text() {
    return "通配符请求";
}