后端SpringBoot学习项目-用户管理-增删改查

最终代码结构

仓库地址
在这里插入图片描述

Entity文件

数据库表设计

在这里插入图片描述

entity层实现

文件创建

● 创建entity文件夹
● 在entity层创建Java类，名字为User (关键字不可使用)

代码实现

package com.example.drhtspringboot.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;

import java.util.Date;
@Data
@TableName("user")
public class User {
    /**
     * 主键ID
     * */
    @TableId(value = "id",type = IdType.AUTO)
    private Long id;
    /**
     * 用户名
     * */
    private String username;
    /**
     * 昵称
     * */
    private String nickname;
    /**
     * 密码
     * */
    private String password;
    /**
     * 性别
     * */
    private Integer gender;
    /**
     * 头像
     * */
    private String avatar;
    /**
     * 角色
     * */
    private Integer role;
    /**
     * 学历
     * */
    private Integer education;
    /**
     * 学校
     * */
    private String school;
    /**
     * 班级
     * */
    @TableField("banjiId")
    private Integer banjiId;
    /**
     * 创建时间
     * */
    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss",timezone = "GMT+8")
    @TableField("createdAt")
    private Date createdAt;
    /**
     * 更新时间
     * */
    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss",timezone = "GMT+8")
    @TableField("updatedAt")
    private Date updatedAt;
}

注解解释

@JsonFormat

目的是为了在接口请求数据返回时修改时间的返回格式

@Data

● 由Lombok库提供
● 会自动为实体类生成getter、setter、equals、hashCode和toString方法。

@TableName

● 指定实体类映射到数据库的具体表名

@TableId

● 标记实体类中的主键字段
● 设置一个复合主键时，可以使用 @TableId 注解的属性type来指定主键生成策略

@TableField

● 标记实体类中的字段与数据库表中的字段的映射关系
● 如果字段名和数据库列名相同，可以不用写 @TableField 注解

驼峰字段

如果数据表中的字段是驼峰形式，在接口方法查询数据时候驼峰形式字段会变为下划线形式(createdAt 变为 created_at),所以需要通过@TableField注解来使其保持一致

Mapper文件

mapper层实现

文件创建

● 创建mapper文件夹
● 在mapper层创建Java接口，名字为UserMapper

代码实现

package com.example.drhtspringboot.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.drhtspringboot.entity.User;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface UserMapper extends BaseMapper<User> {
}

注解解释

BaseMapper

● MyBatis-Plus提供的一个泛型接口，包含了基础的增删改查等CRUD操作
● 可以简化对数据访问的开发

@Mapper

● 省略了xml文件的配置过程

service文件

初版实现暂不补充

controller文件

文件创建

● 创建controller文件夹
● 在controller层创建Java接口，名字为UserController

代码实现

请求结果类封装

package com.example.drhtspringboot.common;


import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Result<T> {
    private String code;
    private String msg;
    private T data;

    public Result(T data) {
        this.data = data;
    }

    public static Result success() {
        Result result = new Result<>();
        result.setCode("200");
        result.setMsg("成功");
        return result;
    }

    public static <T> Result<T> success(T data) {
        Result<T> result = new Result<>(data);
        result.setCode("200");
        result.setMsg("成功");
        result.setData(data);
        return result;
    }

    public static Result error(String code, String msg) {
        Result result = new Result<>();
        result.setCode(code);
        result.setMsg(msg);
        return result;
    }

}

查询所有

没有任何查询参数，查询表中所有数据

/**
 * 获取用户列表
 * 通过请求映射 getList，处理获取用户列表的请求
 * 此方法使用 QueryWrapper 对象查询数据库中的所有用户，并返回查询结果
 * 如果查询结果不为空，则返回成功结果和用户列表，否则返回错误信息
 */
@RequestMapping("getListAll")
public Result<?> getListAll(){
    // 使用 QueryWrapper 进行查询，获取用户列表
    List<User> userList =  userMapper.selectList(new QueryWrapper<>());
    // 判断查询结果是否为空
    if(userList != null){
        // 查询成功，返回用户列表
        return Result.success(userList);
    } else {
        // 查询失败，返回错误信息
        return Result.error("500", "查询失败");
    }
}

分页查询

分页查询默认会出现一个问题: 查询出的数据records内容正常，但是total数量为0，需要进行一个插件的配置

插件配置

package com.example.drhtspringboot.common;

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


@Configuration
public class MyBatisPlusConfig {

    /**
     * 新的分页插件,一缓和二缓遵循mybatis的规则,需要设置 MybatisConfiguration#useDeprecatedExecutor = false 避免缓存出现问题(该属性会在旧插件移除后一同移除)
     */
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }
}

分页接口实现

/**
     * 根据条件获取用户列表
     *
     * @param page 页码，指定从哪一页开始查询
     * @param size 每页大小，即每页返回的记录数
     * @param username 用户名，用于模糊查询
     * @param gender 性别，用于精确查询
     * @param role 角色ID，用于精确查询
     * @return 返回一个Result对象，包含查询结果或错误信息
     */
    @RequestMapping("getList")
    public Result<?> getList(Integer page,Integer size,String username,Integer gender,Integer role){
        // 创建Page对象，用于分页查询
        Page<User> userPage = new Page<>(page,size);

        // 创建QueryWrapper对象，用于构建查询条件
        QueryWrapper<User> qw = new QueryWrapper<>();
        if(StringUtils.isNotBlank(username)) {
            qw.like("username",username); // 模糊查询用户名
        }
        if(gender != null) {
            qw.eq("gender",gender); // 精确查询性别
        }
        if(role != null) {
            qw.eq("role", role); // 精确查询角色
        }
        // 执行分页查询
        IPage<User> userPageList = userMapper.selectPage(userPage,qw);
        // 判断查询结果是否为空
        if(userPageList != null) {
            return Result.success(userPageList); // 查询成功，返回结果
        } else {
            return Result.error("500", "查询失败"); // 查询失败，返回错误信息
        }
    }

新增用户

/**
 * 添加新用户
 *
 * @param user 用户对象，包含用户的基本信息
 * @return 插入操作的结果，成功或失败
 */
@PostMapping("addUser")
public Result<?> addUser(@RequestBody User user){
    // 设置用户创建时间和更新时间为当前时间
    user.setCreatedAt(new Date());
    user.setUpdatedAt(new Date());

    // 执行用户信息的插入操作
    int i = userMapper.insert(user);

    // 根据插入结果返回成功或失败的信息
    if(i > 0) {
        return Result.success();
    } else {
        // 查询失败，返回错误信息
        return Result.error("500", "新增失败");
    }
}

更新用户

/**
 * 处理用户更新请求
 * 该方法通过POST请求接收用户数据，并尝试在数据库中更新该用户的信息
 *
 * @param user 用户对象，包含要更新的用户信息
 * @return 返回更新操作的结果，成功或失败
 */
@PostMapping("updateUser")
public Result<?> updateUser(@RequestBody User user){
    // 根据用户ID更新用户信息
    int i = userMapper.updateById(user);
    // 判断更新操作是否成功
    if(i > 0) {
        // 如果更新成功，返回成功结果
        return Result.success();
    } else {
        // 如果更新失败，返回错误信息
        return Result.error("500", "更新失败");
    }
}

删除用户

/**
 * 删除用户信息
 * 该方法通过POST请求接收用户信息，并根据用户ID删除用户
 *
 * @param user 用户对象，包含要删除的用户ID
 * @return 删除操作的结果，如果删除成功返回成功结果，否则返回错误信息
 */
@PostMapping("delUser")
public Result<?> deleteUser(@RequestBody User user){
    // 根据用户ID删除用户信息
    int i = userMapper.deleteById(user.getId());
    // 判断删除操作是否成功
    if(i > 0) {
        // 如果删除成功，返回成功结果
        return Result.success();
    } else {
        // 如果删除失败，返回错误信息
        return Result.error("500", "删除失败");
    }
}

整体代码

package com.example.drhtspringboot.contoller;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.example.drhtspringboot.common.Result;
import com.example.drhtspringboot.entity.User;
import com.example.drhtspringboot.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Date;
import java.util.List;

@RestController
@RequestMapping("user")
public class UserController {
    @Autowired
    private UserMapper userMapper;

    /**
     * 根据条件获取用户列表
     *
     * @param page 页码，指定从哪一页开始查询
     * @param size 每页大小，即每页返回的记录数
     * @param username 用户名，用于模糊查询
     * @param gender 性别，用于精确查询
     * @param role 角色ID，用于精确查询
     * @return 返回一个Result对象，包含查询结果或错误信息
     */
    @RequestMapping("getList")
    public Result<?> getList(Integer page,Integer size,String username,Integer gender,Integer role){
        // 创建Page对象，用于分页查询
        Page<User> userPage = new Page<>(page,size);

        // 创建QueryWrapper对象，用于构建查询条件
        QueryWrapper<User> qw = new QueryWrapper<>();
        if(StringUtils.isNotBlank(username)) {
            qw.like("username",username); // 模糊查询用户名
        }
        if(gender != null) {
            qw.eq("gender",gender); // 精确查询性别
        }
        if(role != null) {
            qw.eq("role", role); // 精确查询角色
        }
        // 执行分页查询
        IPage<User> userPageList = userMapper.selectPage(userPage,qw);
        // 判断查询结果是否为空
        if(userPageList != null) {
            return Result.success(userPageList); // 查询成功，返回结果
        } else {
            return Result.error("500", "查询失败"); // 查询失败，返回错误信息
        }
    }
    /**
     * 获取用户列表
     * 通过请求映射 getList，处理获取用户列表的请求
     * 此方法使用 QueryWrapper 对象查询数据库中的所有用户，并返回查询结果
     * 如果查询结果不为空，则返回成功结果和用户列表，否则返回错误信息
     */
    @RequestMapping("getListAll")
    public Result<?> getListAll(){
        // 使用 QueryWrapper 进行查询，获取用户列表
        List<User> userList =  userMapper.selectList(new QueryWrapper<>());
        // 判断查询结果是否为空
        if(userList != null){
            // 查询成功，返回用户列表
            return Result.success(userList);
        } else {
            // 查询失败，返回错误信息
            return Result.error("500", "查询失败");
        }
    }


    /**
     * 添加新用户
     *
     * @param user 用户对象，包含用户的基本信息
     * @return 插入操作的结果，成功或失败
     */
    @PostMapping("addUser")
    public Result<?> addUser(@RequestBody User user){
        // 设置用户创建时间和更新时间为当前时间
        user.setCreatedAt(new Date());
        user.setUpdatedAt(new Date());

        // 执行用户信息的插入操作
        int i = userMapper.insert(user);

        // 根据插入结果返回成功或失败的信息
        if(i > 0) {
            return Result.success();
        } else {
            // 查询失败，返回错误信息
            return Result.error("500", "新增失败");
        }
    }

    /**
     * 删除用户信息
     * 该方法通过POST请求接收用户信息，并根据用户ID删除用户
     *
     * @param user 用户对象，包含要删除的用户ID
     * @return 删除操作的结果，如果删除成功返回成功结果，否则返回错误信息
     */
    @PostMapping("delUser")
    public Result<?> deleteUser(@RequestBody User user){
        // 根据用户ID删除用户信息
        int i = userMapper.deleteById(user.getId());
        // 判断删除操作是否成功
        if(i > 0) {
            // 如果删除成功，返回成功结果
            return Result.success();
        } else {
            // 如果删除失败，返回错误信息
            return Result.error("500", "删除失败");
        }
    }

    /**
     * 处理用户更新请求
     * 该方法通过POST请求接收用户数据，并尝试在数据库中更新该用户的信息
     *
     * @param user 用户对象，包含要更新的用户信息
     * @return 返回更新操作的结果，成功或失败
     */
    @PostMapping("updateUser")
    public Result<?> updateUser(@RequestBody User user){
        // 根据用户ID更新用户信息
        int i = userMapper.updateById(user);
        // 判断更新操作是否成功
        if(i > 0) {
            // 如果更新成功，返回成功结果
            return Result.success();
        } else {
            // 如果更新失败，返回错误信息
            return Result.error("500", "更新失败");
        }
    }
}