SpringBoot学习之路

前期准备

安装 JDK 17 以上
安装 Idea 2021.3 以上

创建项目

Idea 直接创建 springboot 或通过 Spring 官网在线创建出来导入 Idea

项目结构

基本知识

前提了解

目前在用

一种是 Mybatis
另一种是 Hibernate + JPA + Spring Data JPA

实例示例（以 Springboot 与 Hibernate + JPA + Spring Data JPA 为例）

基本结构如下

实体类
@Entity 实体类注解，表示这是一个实体类，可以被 JPA 识别
@Table 表名注解，可以指定表名
@Id 主键注解，可以指定主键
@GeneratedValue 主键生成策略注解，可以指定主键生成策略
@Column 列注解，可以指定列名，列类型，是否可空等属性
实体类(entity)

控制器层

@RestController 控制器层注解，表示这是一个控制器类，可以返回 json 数据
@RequestMapping 请求映射注解，可以指定请求路径

@Autowired 自动注入注解，可以自动注入相应的类
@PathVariable 路径参数注解，可以获取路径参数
@RequestParam 请求参数注解，可以获取请求参数
@RequestBody 请求体注解，可以获取请求体
@ResponseBody 响应体注解，可以返回响应体
@ExceptionHandler 异常处理注解，可以处理异常

@GetMapping 获取请求注解，可以指定 GET 请求路径
@PostMapping 新增请求注解，可以指定 POST 请求路径
@PutMapping 更新请求注解，可以指定 PUT 请求路径
@DeleteMapping 删除请求注解，可以指定 DELETE 请求路径
控制器层接口(controller)

数据层

@Repository 数据层注解，表示这是一个数据访问类，可以访问数据库
@Query 查询注解，可以指定查询语句
@Modifying 修改注解，可以指定修改语句
数据层实现(repository)

服务层

@Service 服务层注解，表示这是一个服务类，可以实现业务逻辑
@Autowired 自动注入注解，可以自动注入相应的类
@Transactional 事务注解，可以实现事务操作
服务层接口(service)
application.properties
pom.xml

Hibernate 整合

引入依赖

引入 Hibernate 依赖，并引入 mysql-connector-j 依赖

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


    <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <scope>runtime</scope>
        </dependency>

快速创建实体类

参考连接数据库时操作

实例示例（以 springboot 与 mybatis-plus 为例）

基本结构如下

这里只展示 mybatis-plus 多出来的几个结构

DTO

Mapper

Mapper
Mapper.xml（这个文件是 mybatis 映射文件，可以自定义 sql 语句，当自带的库不能满足需求时，可以自己写）

implement

-impl（implement）

Mybatis-plus 整合

引入依赖

并非只有单纯的 mybatis-plus，还可以引入 springboot-starter-web，lombok，validation，mysql-connector-j 依赖
lombok 用于省略 getter/setter 方法（数据库字段不规范将会在导致通信时字段名大小写不一致，badrequest 异常原因之一）
validation 用于校验
mysql-connector-j 用于连接数据库

 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


  <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

        <!-- test -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!-- Validation -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-validation</artifactId>
        </dependency>

        <!-- MyBatis-Plus Starter (这是唯一需要的 MyBatis 相关依赖) -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-spring-boot3-starter</artifactId>
            <version>3.5.7</version>
        </dependency>

        <!-- MySQL Driver -->
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <scope>runtime</scope>
        </dependency>

快速创建结构

可以通过 idea 插件（mybatis-plus）快速创建 mybatis-plus 相关结构
首先连接数据库，记得改成自己的数据库名字（此处为 soilerosion）

点击创建，会自动生成实体类，mapper 接口，mapper.xml 等文件

特殊点

需要设置 Mapper 的扫描路径(记得导入下扫描的包)

1

import org.mybatis.spring.annotation.MapperScan;

运行项目

右键项目 -> Run ‘Application’

连接数据库

idea 右侧有数据库连接插件，选择对应的服务器，这里以 mysql 为例

填写 localhost，端口号，用户名，密码，数据库名
点击测试连接，如果连接成功，则会出现一个绿色的勾（记得按提示安装驱动）

装 JPA 模块，这里以 Hibernate 为例，可以实现自动将表创建为实体类

由于上述操作是通过 idea 集成的插件做的，所以项目中其实没有配置数据源，需要在 application.properties 中配置数据源信息，同时在 pom.xml 中引入依赖
配置数据源

1
2
3
4


spring.datasource.url=jdbc:mysql://localhost:3306/soilerosion
spring.datasource.username=root
spring.datasource.password=123321
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

引入依赖(也可以通过 idea 集成的插件快速引入，搜名字就行)

1
2
3
4
5
6
7
8
9


        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <scope>runtime</scope>
        </dependency>

测试

下面是各层的代码实现简单增删改查

实体类

 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


package com.example.springboottest3.entity;

import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import java.io.Serializable;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;

/**
 * <p>
 *
 * </p>
 *
 * @author author
 * @since 2025-10-31
 */
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("user")
public class User implements Serializable {

    private static final long serialVersionUID = 1L;

    @TableId(value = "id", type = IdType.AUTO)
    private Integer id;

    private String uName;

    private String uPassword;


}

DTO

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


// src/main/java/com/example/springboottest2/dto/UserDTO.java
package com.example.springboottest3.dto;

import lombok.Data;

@Data
public class UserDTO {
    private Integer id;
    private String uName;
    // 注意：这里不包含 uPassword，保护敏感信息
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


// src/main/java/com/example/springboottest2/dto/UserCreateDTO.java
package com.example.springboottest3.dto;

import jakarta.validation.constraints.NotBlank;
import com.fasterxml.jackson.annotation.JsonProperty; // 需导入依赖（spring-boot-starter-web已包含）
import lombok.Data;

@Data
public class UserCreateDTO {
    @NotBlank(message = "用户名不能为空")
    @JsonProperty("uName") // 强制绑定JSON的uName键
    private String uName;

    @NotBlank(message = "密码不能为空")
    @JsonProperty("uPassword") // 强制绑定JSON的uPassword键
    private String uPassword;

    // 临时添加，测试Lombok是否生效
    public void printFields() {
        System.out.println("uName: " + uName);
        System.out.println("uPassword: " + uPassword);
    }
}

Mapper

1
2
3
4
5
6
7
8


// src/main/java/com/example/springboottest2/mapper/UserMapper.java
package com.example.springboottest3.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.springboottest3.entity.User;

public interface UserMapper extends BaseMapper<User> {
}

impl

 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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82


// src/main/java/com/example/springboottest2/service/impl/UserServiceImpl.java
package com.example.springboottest3.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.springboottest3.dto.UserCreateDTO;
import com.example.springboottest3.dto.UserDTO;
import com.example.springboottest3.entity.User;
import com.example.springboottest3.mapper.UserMapper;
import com.example.springboottest3.service.UserService;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import java.util.List;
import java.util.stream.Collectors;

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {

    /**
     * 将 User Entity 转换为 UserDTO
     */
    private UserDTO convertToDTO(User user) {
        UserDTO userDTO = new UserDTO();
        BeanUtils.copyProperties(user, userDTO);
        return userDTO;
    }

    /**
     * 将 UserCreateDTO 转换为 User Entity
     */
    private User convertToEntity(UserCreateDTO createDTO) {
        User user = new User();
        BeanUtils.copyProperties(createDTO, user);
        return user;
    }

    @Override
    public UserDTO createUser(UserCreateDTO createDTO) {
        User user = convertToEntity(createDTO);
        // ✅ 使用父类 ServiceImpl 提供的 save() 方法
        this.save(user);
        return convertToDTO(user);
    }

    @Override
    public UserDTO getUserById(Integer id) {
        // ✅ 使用父类 ServiceImpl 提供的 getById() 方法
        User user = this.getById(id);
        return user != null ? convertToDTO(user) : null;
    }

    @Override
    public List<UserDTO> listAllUsers() {
        // ✅ 使用父类 ServiceImpl 提供的 list() 方法
        List<User> users = this.list();
        return users.stream().map(this::convertToDTO).collect(Collectors.toList());
    }

    @Override
    public UserDTO updateUser(Integer id, UserCreateDTO updateDTO) {
        User existingUser = this.getById(id);
        if (existingUser == null) {
            return null;
        }
        if (StringUtils.hasText(updateDTO.getUName())) {
            existingUser.setUName(updateDTO.getUName());
        }
        if (StringUtils.hasText(updateDTO.getUPassword())) {
            existingUser.setUPassword(updateDTO.getUPassword());
        }
        // ✅ 使用父类 ServiceImpl 提供的 updateById() 方法
        this.updateById(existingUser);
        return convertToDTO(existingUser);
    }

    @Override
    public boolean deleteUser(Integer id) {
        // ✅ 使用父类 ServiceImpl 提供的 removeById() 方法
        return this.removeById(id);
    }
}

service

 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


// src/main/java/com/example/springboottest2/service/UserService.java
package com.example.springboottest3.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.example.springboottest3.dto.UserDTO;
import com.example.springboottest3.dto.UserCreateDTO;
import com.example.springboottest3.entity.User;
import java.util.List;


public interface UserService extends IService<User> { // 注意，IService的泛型仍然是Entity
    /**
     * 创建用户
     */
    UserDTO createUser(UserCreateDTO createDTO);

    /**
     * 根据ID获取用户信息
     */
    UserDTO getUserById(Integer id);

    /**
     * 获取所有用户
     */
    List<UserDTO> listAllUsers();

    /**
     * 更新用户
     */
    UserDTO updateUser(Integer id, UserCreateDTO updateDTO);

    /**
     * 删除用户
     */
    boolean deleteUser(Integer id);
}

controller

 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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69


// src/main/java/com/example/springboottest2/controller/UserController.java
package com.example.springboottest3.controller;

import com.example.springboottest3.dto.UserCreateDTO;
import com.example.springboottest3.dto.UserDTO;
import com.example.springboottest3.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import jakarta.validation.Valid;
import java.util.List;

@RestController
@RequestMapping("/api/users")
@Validated // 开启参数校验
public class UserController {

    @Autowired
    private UserService userService;

    // 创建用户
    @PostMapping
    public ResponseEntity<UserDTO> createUser(@Valid @RequestBody UserCreateDTO userCreateDTO) {
        userCreateDTO.printFields(); // 打印参数

        UserDTO createdUser = userService.createUser(userCreateDTO);
        return new ResponseEntity<>(createdUser, HttpStatus.CREATED);
    }

    // 根据 ID 获取用户
    @GetMapping("/{id}")
    public ResponseEntity<UserDTO> getUserById(@PathVariable Integer id) {
        UserDTO user = userService.getUserById(id);
        if (user != null) {
            return ResponseEntity.ok(user);
        }
        return ResponseEntity.notFound().build();
    }

    // 获取所有用户
    @GetMapping
    public ResponseEntity<List<UserDTO>> getAllUsers() {
        List<UserDTO> users = userService.listAllUsers();
        return ResponseEntity.ok(users);
    }

    // 更新用户
    @PutMapping("/{id}")
    public ResponseEntity<UserDTO> updateUser(@PathVariable Integer id, @Valid @RequestBody UserCreateDTO userUpdateDTO) {
        UserDTO updatedUser = userService.updateUser(id, userUpdateDTO);
        if (updatedUser != null) {
            return ResponseEntity.ok(updatedUser);
        }
        return ResponseEntity.notFound().build();
    }

    // 删除用户
    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteUser(@PathVariable Integer id) {
        boolean deleted = userService.deleteUser(id);
        if (deleted) {
            return ResponseEntity.noContent().build();
        }
        return ResponseEntity.notFound().build();
    }
}

问题汇总

整合 mybatis-plus 时需注意 springboot3 应引入对应的 boot3 版本，学习网站上的 boot4 并非和他说一样 springboot3.5 后面用
lombok 可能会导致通信时字段名大小写不匹配从而出现空赋值，如果有 validation 检验的话，会直接被拦截,该接口直接就是不会执行，在调试时可以发现接口处断点是禁止的白色符号，代表该接口未被调用，可以通过此排查问题

LOADING

- 系统启动中

SpringBoot学习之路

前期准备

创建项目

项目结构

基本知识

前提了解

目前在用

实例示例（以 Springboot 与 Hibernate + JPA + Spring Data JPA 为例）

实体类

控制器层

数据层

服务层

Hibernate 整合

引入依赖

快速创建实体类

实例示例（以 springboot 与 mybatis-plus 为例）

这里只展示 mybatis-plus 多出来的几个结构

DTO

Mapper

implement

Mybatis-plus 整合

引入依赖

快速创建结构

特殊点

运行项目

连接数据库

测试

实体类

DTO

Mapper

impl

service

controller

问题汇总