使用 Mybatis-Plus 实现用户管理系统_mybatisplus用户管理-优快云博客

本文链接：https://blog.youkuaiyun.com/u012561308/article/details/146010805

在 Web 开发中，用户管理系统是一个常见的模块，涉及用户信息的存储、权限控制、角色管理等功能。Mybatis-Plus 作为 MyBatis 的增强工具，可以大幅减少 SQL 代码，提高开发效率。本文将介绍如何使用 Mybatis-Plus 快速构建一个完整的用户管理系统。

1. 用户实体类与数据库设计

在用户管理系统中，我们通常需要设计以下数据库表：

用户表（user）：存储用户的基本信息，如用户名、密码、邮箱、状态等。
角色表（role）：存储系统中的角色，如管理员、普通用户等。
用户角色关联表（user_role）：用于实现多对多的角色分配。

数据库表设计

CREATE TABLE `user` (
    `id` BIGINT PRIMARY KEY AUTO_INCREMENT COMMENT '用户ID',
    `username` VARCHAR(50) NOT NULL COMMENT '用户名',
    `password` VARCHAR(255) NOT NULL COMMENT '密码',
    `email` VARCHAR(100) COMMENT '邮箱',
    `status` TINYINT DEFAULT 1 COMMENT '用户状态（1：正常，0：禁用）',
    `create_time` TIMESTAMP DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
    `update_time` TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间'
);

CREATE TABLE `role` (
    `id` BIGINT PRIMARY KEY AUTO_INCREMENT COMMENT '角色ID',
    `role_name` VARCHAR(50) NOT NULL COMMENT '角色名称',
    `description` VARCHAR(255) COMMENT '角色描述'
);

CREATE TABLE `user_role` (
    `user_id` BIGINT NOT NULL COMMENT '用户ID',
    `role_id` BIGINT NOT NULL COMMENT '角色ID',
    PRIMARY KEY (`user_id`, `role_id`),
    FOREIGN KEY (`user_id`) REFERENCES `user`(`id`) ON DELETE CASCADE,
    FOREIGN KEY (`role_id`) REFERENCES `role`(`id`) ON DELETE CASCADE
);

2. 实现常见的用户操作（增删改查）

2.1 用户实体类

@Data
@TableName("user")
public class User {
    @TableId(type = IdType.AUTO)
    private Long id;
    private String username;
    private String password;
    private String email;
    private Integer status;
    private LocalDateTime createTime;
    private LocalDateTime updateTime;
}

2.2 用户数据访问层（Mapper）

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

2.3 用户服务层（Service）

@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;

    // 查询所有用户
    public List<User> getAllUsers() {
        return userMapper.selectList(null);
    }

    // 根据ID查询用户
    public User getUserById(Long id) {
        return userMapper.selectById(id);
    }

    // 添加用户
    public boolean addUser(User user) {
        user.setPassword(encryptPassword(user.getPassword())); // 密码加密存储
        return userMapper.insert(user) > 0;
    }

    // 更新用户信息
    public boolean updateUser(User user) {
        return userMapper.updateById(user) > 0;
    }

    // 删除用户
    public boolean deleteUser(Long id) {
        return userMapper.deleteById(id) > 0;
    }

    // 密码加密方法
    private String encryptPassword(String password) {
        return new BCryptPasswordEncoder().encode(password);
    }
}

2.4 用户控制层（Controller）

@RestController
@RequestMapping("/users")
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping
    public List<User> getAllUsers() {
        return userService.getAllUsers();
    }

    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        return userService.getUserById(id);
    }

    @PostMapping
    public boolean addUser(@RequestBody User user) {
        return userService.addUser(user);
    }

    @PutMapping
    public boolean updateUser(@RequestBody User user) {
        return userService.updateUser(user);
    }

    @DeleteMapping("/{id}")
    public boolean deleteUser(@PathVariable Long id) {
        return userService.deleteUser(id);
    }
}

3. 权限管理与角色分配

在用户管理系统中，通常需要控制不同用户的访问权限。可以使用 user_role 关联表来管理用户的角色关系，并在业务逻辑中进行权限控制。

3.1 角色实体类

@Data
@TableName("role")
public class Role {
    @TableId(type = IdType.AUTO)
    private Long id;
    private String roleName;
    private String description;
}

3.2 用户角色关系实体类

@Data
@TableName("user_role")
public class UserRole {
    private Long userId;
    private Long roleId;
}

3.3 角色管理 Mapper

@Mapper
public interface RoleMapper extends BaseMapper<Role> {
}

@Mapper
public interface UserRoleMapper extends BaseMapper<UserRole> {
}

3.4 角色服务层（分配角色）

@Service
public class RoleService {
    @Autowired
    private RoleMapper roleMapper;
    @Autowired
    private UserRoleMapper userRoleMapper;

    // 分配角色给用户
    public boolean assignRole(Long userId, Long roleId) {
        UserRole userRole = new UserRole();
        userRole.setUserId(userId);
        userRole.setRoleId(roleId);
        return userRoleMapper.insert(userRole) > 0;
    }

    // 获取用户的角色
    public List<Role> getUserRoles(Long userId) {
        return roleMapper.selectList(
            new QueryWrapper<Role>()
                .inSql("id", "SELECT role_id FROM user_role WHERE user_id = " + userId)
        );
    }
}

3.5 角色管理接口

@RestController
@RequestMapping("/roles")
public class RoleController {
    @Autowired
    private RoleService roleService;

    @PostMapping("/assign")
    public boolean assignRole(@RequestParam Long userId, @RequestParam Long roleId) {
        return roleService.assignRole(userId, roleId);
    }

    @GetMapping("/user/{userId}")
    public List<Role> getUserRoles(@PathVariable Long userId) {
        return roleService.getUserRoles(userId);
    }
}

4. 用户管理功能的实现与优化

4.1 增加分页查询

public Page<User> getUsersWithPagination(int pageNum, int pageSize) {
    Page<User> page = new Page<>(pageNum, pageSize);
    return userMapper.selectPage(page, null);
}

4.2 增加用户名模糊查询

public List<User> searchUsersByName(String keyword) {
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.like("username", keyword);
    return userMapper.selectList(queryWrapper);
}

4.3 软删除用户（逻辑删除）

@TableLogic
private Integer deleted;

使用逻辑删除后，删除操作将不会真正删除数据，而是修改 deleted 字段。

public boolean deleteUser(Long id) {
    return userMapper.deleteById(id) > 0;
}

4.4 Redis 缓存优化

4.4.1 查询用户时使用@Cacheable

@Cacheable 用于缓存查询结果，第一次执行时会执行数据库查询，并将结果存入 Redis，后续相同请求将直接从缓存读取，提高查询效率。

@Service
public class UserService{

    @Autowired
    private UserMapper userMapper;

    /**
     * 通过 ID 查询用户，并缓存结果
     * key:"user:{id}"
     */
    @Cacheable(value="user",key="#id")
    public User getUserById(Long id){
        return userMapper.selectById(id);
    }
}

value = “user”: 指定缓存名称，可以理解为 Redis 的 user 命名空间。
key=“#id”:缓存 key 为 user:{id},例如"user:1001"
当 getUserById被调用时 如果redis 缓存有数据，直接返回，否则查询数据库并存入缓存。

4.4.2 修改用户后清除缓存

当用户信息被更新或删除时，缓存需要被清理，否则会导致数据不一致问题。@CacheEvict 用于移除特定缓存。
更新用户

/**
 * 更新用户信息，同时清除缓存
 */
@CacheEvict(value="user",key="#user.id")
public boolean updateUser(User user){
    return userMapper.updateById(user) > 0;
}

**@CacheEvict(value=“user”,key=“#user.id”)**作用
当 updateUser(user)被调用时，会先执行数据库更新操作
然后清除 Redis 中"user:{id}"缓存，使下次查询时重新加载数据

4.4.3 删除用户

/**
 * 删除用户，同时清除缓存
 */
@CacheEvict(value="user",key="#id")
public boolean deleteUser(Long id){
    return userMapper.deleteById(id) > 0;
}

@CacheEvict 确保当用户被删除时，Redis 缓存也被移除，避免查询到已删除的数据。

总结

本文介绍了如何使用 Mybatis-Plus 实现一个用户管理系统，包括：

数据库表设计
用户管理的增删改查
角色管理与权限分配
优化用户管理功能（分页、模糊查询、缓存）

通过 Mybatis-Plus，可以简化 SQL 编写，提高开发效率，使用户管理系统更加高效和易维护。