一、功能概述

本教程将在企业知识库系统中实现完整的分类管理和用户管理功能,包括:

分类管理功能

  • 分类树结构展示
  • 分类的增删改查
  • 分类移动(调整层级)
  • 分类状态管理

用户管理功能

  • 用户列表分页展示
  • 用户的增删改查
  • 用户角色分配
  • 用户状态管理
  • 密码重置

二、技术栈

层级技术版本
前端React18+
前端框架Ant Design5.x
后端框架Spring Boot3.2.x
ORM框架MyBatis Plus3.5.x
数据库MySQL8.0+
认证JWT-

三、数据库设计

3.1 分类表(kb\_category)

CREATE TABLE `kb_category` (
  `id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键ID',
  `parent_id` bigint DEFAULT '0' COMMENT '父分类ID(0表示根分类)',
  `category_name` varchar(100) NOT NULL COMMENT '分类名称',
  `category_code` varchar(100) DEFAULT NULL COMMENT '分类编码',
  `description` varchar(500) DEFAULT NULL COMMENT '分类描述',
  `icon` varchar(50) DEFAULT '📁' COMMENT '图标',
  `sort` int DEFAULT '0' COMMENT '排序',
  `status` tinyint DEFAULT '1' COMMENT '状态(0-禁用,1-启用)',
  `document_count` int DEFAULT '0' COMMENT '文档数量',
  `remark` varchar(500) DEFAULT NULL COMMENT '备注',
  `created_at` datetime DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `updated_at` datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  `created_by` bigint DEFAULT NULL COMMENT '创建人',
  `updated_by` bigint DEFAULT NULL COMMENT '更新人',
  PRIMARY KEY (`id`),
  KEY `idx_parent_id` (`parent_id`),
  KEY `idx_status` (`status`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='文档分类表';

3.2 用户表(kb\_user)

CREATE TABLE `kb_user` (
  `id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键ID',
  `username` varchar(50) NOT NULL COMMENT '用户名',
  `password` varchar(255) NOT NULL COMMENT '密码(加密存储)',
  `email` varchar(100) DEFAULT NULL COMMENT '邮箱',
  `phone` varchar(20) DEFAULT NULL COMMENT '手机号',
  `avatar` varchar(255) DEFAULT NULL COMMENT '头像URL',
  `real_name` varchar(50) DEFAULT NULL COMMENT '真实姓名',
  `department` varchar(100) DEFAULT NULL COMMENT '部门',
  `position` varchar(100) DEFAULT NULL COMMENT '岗位',
  `status` tinyint DEFAULT '1' COMMENT '状态(0-禁用,1-启用)',
  `last_login_time` datetime DEFAULT NULL COMMENT '最后登录时间',
  `last_login_ip` varchar(50) DEFAULT NULL COMMENT '最后登录IP',
  `created_at` datetime DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `updated_at` datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  `created_by` bigint DEFAULT NULL COMMENT '创建人',
  `updated_by` bigint DEFAULT NULL COMMENT '更新人',
  PRIMARY KEY (`id`),
  UNIQUE KEY `uk_username` (`username`),
  UNIQUE KEY `uk_email` (`email`),
  KEY `idx_status` (`status`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='用户表';

3.3 用户角色关联表(kb\_user\_role)


四、后端实现

4.1 分类管理后端

4.1.1 实体类 - Category.java

package com.knowledge.base.document.entity;

import com.baomidou.mybatisplus.annotation.TableName;
import com.knowledge.base.common.config.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;

/**
 * 文档分类实体类
 */
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("kb_category")
public class Category extends BaseEntity {

    private Long parentId;
    private String categoryName;
    private String categoryCode;
    private String description;
    private String icon;
    private Integer sort;
    private Integer status;
    private Integer documentCount;
    private String remark;
}

4.1.2 DTO类 - CategoryDTO.java

package com.knowledge.base.document.dto;

import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Size;
import lombok.Data;

@Data
public class CategoryDTO {
    private Long id;
    private Long parentId;
    
    @NotBlank(message = "分类名称不能为空")
    @Size(max = 100, message = "分类名称不能超过100个字符")
    private String name;
    
    @Size(max = 100, message = "分类编码不能超过100个字符")
    private String code;
    
    @Size(max = 500, message = "分类描述不能超过500个字符")
    private String description;
    
    @Size(max = 50, message = "图标不能超过50个字符")
    private String icon;
    
    private Integer sort;
    private Integer status;
    
    @Size(max = 500, message = "备注不能超过500个字符")
    private String remark;
}

4.1.3 VO类 - CategoryVO.java

package com.knowledge.base.document.vo;

import lombok.Data;
import java.time.LocalDateTime;
import java.util.List;

@Data
public class CategoryVO {
    private String id;
    private String parentId;
    private String name;
    private String code;
    private String description;
    private String icon;
    private Integer sort;
    private Integer sortOrder;
    private Integer status;
    private Integer documentCount;
    private String remark;
    private LocalDateTime createdAt;
    private LocalDateTime updatedAt;
    private List<CategoryVO> children;
}

4.1.4 Mapper接口 - CategoryMapper.java

package com.knowledge.base.document.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.knowledge.base.document.entity.Category;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;

@Mapper
public interface CategoryMapper extends BaseMapper<Category> {
    List<Category> selectByParentId(@Param("parentId") Long parentId);
    List<Long> selectCategoryAndChildrenIds(@Param("categoryId") Long categoryId);
}

4.1.5 Service接口 - CategoryService.java

package com.knowledge.base.document.service;

import com.knowledge.base.document.dto.CategoryDTO;
import com.knowledge.base.document.vo.CategoryVO;
import java.util.List;

public interface CategoryService {
    Long createCategory(CategoryDTO categoryDTO);
    Boolean updateCategory(CategoryDTO categoryDTO);
    Boolean deleteCategory(Long categoryId);
    CategoryVO getCategoryById(Long categoryId);
    List<CategoryVO> getCategoryTree();
    List<CategoryVO> getChildren(Long parentId);
    Boolean moveCategory(Long categoryId, Long newParentId);
    List<CategoryVO> getAllCategories();
}

4.1.6 Service实现类 - CategoryServiceImpl.java

package com.knowledge.base.document.service.impl;

import com.knowledge.base.document.dto.CategoryDTO;
import com.knowledge.base.document.entity.Category;
import com.knowledge.base.document.mapper.CategoryMapper;
import com.knowledge.base.document.service.CategoryService;
import com.knowledge.base.document.vo.CategoryVO;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Slf4j
@Service
public class CategoryServiceImpl implements CategoryService {

    @Resource
    private CategoryMapper categoryMapper;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Long createCategory(CategoryDTO categoryDTO) {
        log.info("创建分类: {}", categoryDTO.getName());

        Category category = new Category();
        category.setParentId(categoryDTO.getParentId() != null ? categoryDTO.getParentId() : 0L);
        category.setCategoryName(categoryDTO.getName());
        category.setCategoryCode(categoryDTO.getCode());
        category.setDescription(categoryDTO.getDescription());
        category.setIcon(categoryDTO.getIcon() != null ? categoryDTO.getIcon() : "📁");
        category.setSort(categoryDTO.getSort() != null ? categoryDTO.getSort() : 0);
        category.setStatus(categoryDTO.getStatus() != null ? categoryDTO.getStatus() : 1);
        category.setRemark(categoryDTO.getRemark());
        category.setCreatedAt(LocalDateTime.now());
        category.setUpdatedAt(LocalDateTime.now());

        categoryMapper.insert(category);
        return category.getId();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean updateCategory(CategoryDTO categoryDTO) {
        log.info("更新分类: {}", categoryDTO.getId());

        Category category = categoryMapper.selectById(categoryDTO.getId());
        if (category == null) {
            throw new RuntimeException("分类不存在");
        }

        if (categoryDTO.getName() != null) category.setCategoryName(categoryDTO.getName());
        if (categoryDTO.getCode() != null) category.setCategoryCode(categoryDTO.getCode());
        if (categoryDTO.getDescription() != null) category.setDescription(categoryDTO.getDescription());
        if (categoryDTO.getIcon() != null) category.setIcon(categoryDTO.getIcon());
        if (categoryDTO.getSort() != null) category.setSort(categoryDTO.getSort());
        if (categoryDTO.getStatus() != null) category.setStatus(categoryDTO.getStatus());
        if (categoryDTO.getRemark() != null) category.setRemark(categoryDTO.getRemark());
        category.setUpdatedAt(LocalDateTime.now());

        return categoryMapper.updateById(category) > 0;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean deleteCategory(Long categoryId) {
        log.info("删除分类: {}", categoryId);

        Category category = categoryMapper.selectById(categoryId);
        if (category == null) {
            throw new RuntimeException("分类不存在");
        }

        List<Category> children = categoryMapper.selectByParentId(categoryId);
        if (!children.isEmpty()) {
            throw new RuntimeException("该分类下存在子分类,无法删除");
        }

        return categoryMapper.deleteById(categoryId) > 0;
    }

    @Override
    public CategoryVO getCategoryById(Long categoryId) {
        Category category = categoryMapper.selectById(categoryId);
        if (category == null) {
            throw new RuntimeException("分类不存在");
        }
        return convertToVO(category);
    }

    @Override
    public List<CategoryVO> getCategoryTree() {
        List<Category> categories = categoryMapper.selectList(null);
        return buildTree(categories);
    }

    @Override
    public List<CategoryVO> getChildren(Long parentId) {
        List<Category> categories = categoryMapper.selectByParentId(parentId);
        return categories.stream().map(this::convertToVO).collect(Collectors.toList());
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean moveCategory(Long categoryId, Long newParentId) {
        log.info("移动分类: {} -> {}", categoryId, newParentId);

        Category category = categoryMapper.selectById(categoryId);
        if (category == null) {
            throw new RuntimeException("分类不存在");
        }

        if (categoryId.equals(newParentId)) {
            throw new RuntimeException("不能将分类移动到自身下");
        }

        List<Long> childrenIds = categoryMapper.selectCategoryAndChildrenIds(categoryId);
        if (childrenIds.contains(newParentId)) {
            throw new RuntimeException("不能将分类移动到其子分类下");
        }

        category.setParentId(newParentId);
        category.setUpdatedAt(LocalDateTime.now());

        return categoryMapper.updateById(category) > 0;
    }

    @Override
    public List<CategoryVO> getAllCategories() {
        List<Category> categories = categoryMapper.selectList(null);
        return categories.stream().map(this::convertToVO).collect(Collectors.toList());
    }

    private List<CategoryVO> buildTree(List<Category> categories) {
        Map<Long, List<Category>> parentMap = categories.stream()
                .collect(Collectors.groupingBy(Category::getParentId));
        return buildTreeRecursive(0L, parentMap);
    }

    private List<CategoryVO> buildTreeRecursive(Long parentId, Map<Long, List<Category>> parentMap) {
        List<Category> children = parentMap.getOrDefault(parentId, new ArrayList<>());
        return children.stream()
                .sorted((a, b) -> (a.getSort() != null ? a.getSort() : 0) - (b.getSort() != null ? b.getSort() : 0))
                .map(category -> {
                    CategoryVO vo = convertToVO(category);
                    vo.setChildren(buildTreeRecursive(category.getId(), parentMap));
                    return vo;
                })
                .collect(Collectors.toList());
    }

    private CategoryVO convertToVO(Category category) {
        CategoryVO vo = new CategoryVO();
        vo.setId(String.valueOf(category.getId()));
        vo.setParentId(String.valueOf(category.getParentId()));
        vo.setName(category.getCategoryName());
        vo.setCode(category.getCategoryCode());
        vo.setDescription(category.getDescription());
        vo.setIcon(category.getIcon());
        vo.setSort(category.getSort());
        vo.setSortOrder(category.getSort());
        vo.setStatus(category.getStatus());
        vo.setDocumentCount(category.getDocumentCount());
        vo.setRemark(category.getRemark());
        vo.setCreatedAt(category.getCreatedAt());
        vo.setUpdatedAt(category.getUpdatedAt());
        return vo;
    }
}

4.1.7 Controller类 - CategoryController.java

package com.knowledge.base.document.controller;

import com.knowledge.base.common.result.Result;
import com.knowledge.base.document.dto.CategoryDTO;
import com.knowledge.base.document.service.CategoryService;
import com.knowledge.base.document.vo.CategoryVO;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.annotation.Resource;
import jakarta.validation.Valid;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;
import java.util.List;

@Slf4j
@RestController
@RequestMapping("/categories")
@Tag(name = "分类管理", description = "文档分类管理接口")
public class CategoryController {

    @Resource
    private CategoryService categoryService;

    @PostMapping
    @Operation(summary = "创建分类")
    public Result<Long> createCategory(@Valid @RequestBody CategoryDTO categoryDTO) {
        log.info("创建分类请求:name={}", categoryDTO.getName());
        Long categoryId = categoryService.createCategory(categoryDTO);
        return Result.success("创建分类成功", categoryId);
    }

    @PutMapping
    @Operation(summary = "更新分类")
    public Result<Boolean> updateCategory(@Valid @RequestBody CategoryDTO categoryDTO) {
        log.info("更新分类请求:categoryId={}", categoryDTO.getId());
        Boolean success = categoryService.updateCategory(categoryDTO);
        return Result.success("更新分类成功", success);
    }

    @DeleteMapping("/{categoryId}")
    @Operation(summary = "删除分类")
    public Result<Boolean> deleteCategory(@PathVariable Long categoryId) {
        log.info("删除分类请求:categoryId={}", categoryId);
        Boolean success = categoryService.deleteCategory(categoryId);
        return Result.success("删除分类成功", success);
    }

    @GetMapping("/{categoryId}")
    @Operation(summary = "查询分类")
    public Result<CategoryVO> getCategoryById(@PathVariable Long categoryId) {
        log.info("查询分类请求:categoryId={}", categoryId);
        CategoryVO categoryVO = categoryService.getCategoryById(categoryId);
        return Result.success(categoryVO);
    }

    @GetMapping("/tree")
    @Operation(summary = "获取分类树")
    public Result<List<CategoryVO>> getCategoryTree() {
        log.info("获取分类树请求");
        List<CategoryVO> tree = categoryService.getCategoryTree();
        return Result.success(tree);
    }

    @GetMapping("/children/{parentId}")
    @Operation(summary = "获取子分类")
    public Result<List<CategoryVO>> getChildren(@PathVariable Long parentId) {
        log.info("获取子分类请求:parentId={}", parentId);
        List<CategoryVO> children = categoryService.getChildren(parentId);
        return Result.success(children);
    }

    @PutMapping("/{categoryId}/move")
    @Operation(summary = "移动分类")
    public Result<Boolean> moveCategory(
        @PathVariable Long categoryId,
        @RequestParam Long newParentId) {
        log.info("移动分类请求:categoryId={}, newParentId={}", categoryId, newParentId);
        Boolean success = categoryService.moveCategory(categoryId, newParentId);
        return Result.success("移动分类成功", success);
    }

    @GetMapping("/list")
    @Operation(summary = "获取所有分类")
    public Result<List<CategoryVO>> getAllCategories() {
        log.info("获取所有分类请求");
        List<CategoryVO> categories = categoryService.getAllCategories();
        return Result.success(categories);
    }
}

4.2 用户管理后端

4.2.1 实体类 - User.java

package com.knowledge.base.userauth.entity;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import com.knowledge.base.common.config.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.time.LocalDateTime;

@Data
@EqualsAndHashCode(callSuper = true)
@TableName("kb_user")
public class User extends BaseEntity {
    private String username;
    private String password;
    private String email;
    private String phone;
    private String avatar;
    
    @TableField("real_name")
    private String realName;
    
    @TableField("department")
    private String department;
    
    @TableField("position")
    private String position;
    
    private Integer status;
    private LocalDateTime lastLoginTime;
    private String lastLoginIp;
    
    @TableField(exist = false)
    private Integer isDeleted;
}

4.2.2 DTO类 - UserDTO.java

package com.knowledge.base.userauth.dto;

import jakarta.validation.constraints.Email;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Pattern;
import jakarta.validation.constraints.Size;
import lombok.Data;
import java.util.List;

@Data
public class UserDTO {
    private Long id;
    
    @NotBlank(message = "用户名不能为空")
    @Size(min = 3, max = 50, message = "用户名长度必须在3-50之间")
    private String username;
    
    @Size(min = 6, max = 100, message = "密码长度必须在6-100之间")
    private String password;
    
    @Email(message = "邮箱格式不正确")
    private String email;
    
    @Pattern(regexp = "^1[3-9]\\d{9}$|^$", message = "手机号格式不正确")
    private String phone;
    
    private String avatar;
    private String realName;
    private String department;
    private String position;
    private Integer status;
    private List<Long> roleIds;
}

4.2.3 VO类 - UserVO.java

package com.knowledge.base.userauth.vo;

import lombok.Data;
import java.time.LocalDateTime;
import java.util.List;

@Data
public class UserVO {
    private Long id;
    private String username;
    private String email;
    private String phone;
    private String avatar;
    private String realName;
    private String department;
    private String position;
    private Integer status;
    private List<RoleInfo> roles;
    private LocalDateTime lastLoginTime;
    private String lastLoginIp;
    private LocalDateTime createdAt;
    private LocalDateTime updatedAt;
}

4.2.4 Service实现类 - UserServiceImpl.java

package com.knowledge.base.userauth.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.knowledge.base.userauth.dto.UserDTO;
import com.knowledge.base.userauth.entity.User;
import com.knowledge.base.userauth.mapper.UserMapper;
import com.knowledge.base.userauth.service.UserService;
import com.knowledge.base.userauth.vo.UserVO;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.time.LocalDateTime;
import java.util.ArrayList;

@Slf4j
@Service
public class UserServiceImpl implements UserService {

    @Resource
    private UserMapper userMapper;

    @Resource
    private BCryptPasswordEncoder passwordEncoder;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Long createUser(UserDTO userDTO) {
        log.info("创建用户: {}", userDTO.getUsername());

        if (userMapper.selectByUsername(userDTO.getUsername()) != null) {
            throw new RuntimeException("用户名已存在");
        }

        if (userDTO.getEmail() != null && userMapper.selectByEmail(userDTO.getEmail()) != null) {
            throw new RuntimeException("邮箱已被使用");
        }

        User user = new User();
        user.setUsername(userDTO.getUsername());
        user.setPassword(passwordEncoder.encode(userDTO.getPassword()));
        user.setEmail(userDTO.getEmail());
        user.setPhone(userDTO.getPhone());
        user.setAvatar(userDTO.getAvatar());
        user.setRealName(userDTO.getRealName());
        user.setDepartment(userDTO.getDepartment());
        user.setPosition(userDTO.getPosition());
        user.setStatus(userDTO.getStatus() != null ? userDTO.getStatus() : 1);
        user.setCreatedAt(LocalDateTime.now());
        user.setUpdatedAt(LocalDateTime.now());

        userMapper.insert(user);
        return user.getId();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean updateUser(UserDTO userDTO) {
        log.info("更新用户: {}", userDTO.getId());

        User user = userMapper.selectById(userDTO.getId());
        if (user == null) {
            throw new RuntimeException("用户不存在");
        }

        if (userDTO.getUsername() != null && !userDTO.getUsername().equals(user.getUsername())) {
            User existingUser = userMapper.selectByUsername(userDTO.getUsername());
            if (existingUser != null && !existingUser.getId().equals(user.getId())) {
                throw new RuntimeException("用户名已存在");
            }
            user.setUsername(userDTO.getUsername());
        }

        if (userDTO.getEmail() != null && !userDTO.getEmail().equals(user.getEmail())) {
            User existingUser = userMapper.selectByEmail(userDTO.getEmail());
            if (existingUser != null && !existingUser.getId().equals(user.getId())) {
                throw new RuntimeException("邮箱已被使用");
            }
            user.setEmail(userDTO.getEmail());
        }

        if (userDTO.getPhone() != null) user.setPhone(userDTO.getPhone());
        if (userDTO.getAvatar() != null) user.setAvatar(userDTO.getAvatar());
        if (userDTO.getRealName() != null) user.setRealName(userDTO.getRealName());
        if (userDTO.getDepartment() != null) user.setDepartment(userDTO.getDepartment());
        if (userDTO.getPosition() != null) user.setPosition(userDTO.getPosition());
        if (userDTO.getStatus() != null) user.setStatus(userDTO.getStatus());
        user.setUpdatedAt(LocalDateTime.now());

        return userMapper.updateById(user) > 0;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean deleteUser(Long userId) {
        log.info("删除用户: {}", userId);

        User user = userMapper.selectById(userId);
        if (user == null) {
            throw new RuntimeException("用户不存在");
        }

        return userMapper.deleteById(userId) > 0;
    }

    @Override
    public UserVO getUserById(Long userId) {
        User user = userMapper.selectById(userId);
        if (user == null) {
            throw new RuntimeException("用户不存在");
        }
        return convertToVO(user);
    }

    @Override
    public UserVO getUserByUsername(String username) {
        User user = userMapper.selectByUsername(username);
        if (user == null) {
            throw new RuntimeException("用户不存在");
        }
        return convertToVO(user);
    }

    @Override
    public IPage<UserVO> pageUsers(Long current, Long size, String keyword, String role, Integer status) {
        log.info("分页查询用户: current={}, size={}, keyword={}, role={}, status={}", 
                current, size, keyword, role, status);

        Page<User> page = new Page<>(current, size);
        LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();

        if (keyword != null && !keyword.isEmpty()) {
            wrapper.and(w -> w.like(User::getUsername, keyword)
                    .or().like(User::getRealName, keyword)
                    .or().like(User::getEmail, keyword)
                    .or().like(User::getPhone, keyword));
        }

        if (status != null) {
            wrapper.eq(User::getStatus, status);
        }

        IPage<User> userPage = userMapper.selectPage(page, wrapper);

        IPage<UserVO> resultPage = new Page<>();
        resultPage.setTotal(userPage.getTotal());
        resultPage.setCurrent(userPage.getCurrent());
        resultPage.setSize(userPage.getSize());
        resultPage.setRecords(userPage.getRecords().stream().map(this::convertToVO).toList());

        return resultPage;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean resetPassword(Long userId, String newPassword) {
        log.info("重置用户密码: {}", userId);

        User user = userMapper.selectById(userId);
        if (user == null) {
            throw new RuntimeException("用户不存在");
        }

        user.setPassword(passwordEncoder.encode(newPassword));
        user.setUpdatedAt(LocalDateTime.now());

        return userMapper.updateById(user) > 0;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean changePassword(String oldPassword, String newPassword) {
        log.info("修改用户密码");
        throw new RuntimeException("当前未实现获取登录用户功能");
    }

    private UserVO convertToVO(User user) {
        UserVO vo = new UserVO();
        vo.setId(user.getId());
        vo.setUsername(user.getUsername());
        vo.setEmail(user.getEmail());
        vo.setPhone(user.getPhone());
        vo.setAvatar(user.getAvatar());
        vo.setRealName(user.getRealName());
        vo.setDepartment(user.getDepartment());
        vo.setPosition(user.getPosition());
        vo.setStatus(user.getStatus());
        vo.setLastLoginTime(user.getLastLoginTime());
        vo.setLastLoginIp(user.getLastLoginIp());
        vo.setCreatedAt(user.getCreatedAt());
        vo.setUpdatedAt(user.getUpdatedAt());
        vo.setRoles(new ArrayList<>());
        return vo;
    }
}

4.2.5 Controller类 - UserController.java

package com.knowledge.base.userauth.controller;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.knowledge.base.common.result.Result;
import com.knowledge.base.userauth.dto.UserDTO;
import com.knowledge.base.userauth.service.UserService;
import com.knowledge.base.userauth.vo.UserVO;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.annotation.Resource;
import jakarta.validation.Valid;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;

@Slf4j
@RestController
@RequestMapping("/users")
@Tag(name = "用户管理", description = "用户信息管理接口")
public class UserController {

    @Resource
    private UserService userService;

    @PostMapping
    @Operation(summary = "创建用户")
    public Result<Long> createUser(@Valid @RequestBody UserDTO userDTO) {
        log.info("创建用户请求:username={}", userDTO.getUsername());
        Long userId = userService.createUser(userDTO);
        return Result.success("创建用户成功", userId);
    }

    @PutMapping
    @Operation(summary = "更新用户")
    public Result<Boolean> updateUser(@Valid @RequestBody UserDTO userDTO) {
        log.info("更新用户请求:userId={}", userDTO.getId());
        Boolean success = userService.updateUser(userDTO);
        return Result.success("更新用户成功", success);
    }

    @DeleteMapping("/{userId}")
    @Operation(summary = "删除用户")
    public Result<Boolean> deleteUser(@PathVariable Long userId) {
        log.info("删除用户请求:userId={}", userId);
        Boolean success = userService.deleteUser(userId);
        return Result.success("删除用户成功", success);
    }

    @GetMapping("/{userId}")
    @Operation(summary = "查询用户")
    public Result<UserVO> getUserById(@PathVariable Long userId) {
        log.info("查询用户请求:userId={}", userId);
        UserVO userVO = userService.getUserById(userId);
        return Result.success(userVO);
    }

    @GetMapping("/page")
    @Operation(summary = "分页查询用户")
    public Result<IPage<UserVO>> pageUsers(
        @RequestParam(defaultValue = "1") Long current,
        @RequestParam(defaultValue = "10") Long size,
        @RequestParam(required = false) String keyword,
        @RequestParam(required = false) String role,
        @RequestParam(required = false) Integer status) {
        log.info("分页查询用户请求:current={}, size={}, keyword={}, role={}, status={}", 
                current, size, keyword, role, status);
        IPage<UserVO> page = userService.pageUsers(current, size, keyword, role, status);
        return Result.success(page);
    }

    @PutMapping("/{userId}/password/reset")
    @Operation(summary = "重置密码")
    public Result<Boolean> resetPassword(
        @PathVariable Long userId,
        @RequestParam String newPassword) {
        log.info("重置用户密码请求:userId={}", userId);
        Boolean success = userService.resetPassword(userId, newPassword);
        return Result.success("重置密码成功", success);
    }

    @PutMapping("/password/change")
    @Operation(summary = "修改密码")
    public Result<Boolean> changePassword(
        @RequestParam String oldPassword,
        @RequestParam String newPassword) {
        log.info("修改密码请求");
        Boolean success = userService.changePassword(oldPassword, newPassword);
        return Result.success("修改密码成功", success);
    }
}

五、前端实现

5.1 类型定义 - types/index.ts

export interface CategoryTree {
  id: string;
  parentId: string;
  name: string;
  code?: string;
  description?: string;
  icon?: string;
  sort?: number;
  sortOrder?: number;
  status: number;
  documentCount?: number;
  remark?: string;
  createdAt?: string;
  updatedAt?: string;
  children?: CategoryTree[];
}

export interface User {
  id: number;
  username: string;
  email: string;
  phone?: string;
  avatar?: string;
  realName?: string;
  department?: string;
  position?: string;
  status: number;
  roles?: RoleInfo[];
  lastLoginTime?: string;
  lastLoginIp?: string;
  createdAt?: string;
  updatedAt?: string;
}

export interface RoleInfo {
  id: number;
  name: string;
  code: string;
}

5.2 API服务 - services/category.ts

import request from '@/utils/request';
import { CategoryTree } from '@/types';

export const categoryService = {
  getCategoryTree: async (): Promise<CategoryTree[]> => {
    const response = await request.get('/api/document/categories/tree');
    return response.data;
  },

  getCategory: async (id: string): Promise<CategoryTree> => {
    const response = await request.get(`/api/document/categories/${id}`);
    return response.data;
  },

  createCategory: async (data: {
    name: string;
    parentId?: string;
    code?: string;
    description?: string;
    icon?: string;
    sort?: number;
    status?: number;
    remark?: string;
  }): Promise<number> => {
    const response = await request.post('/api/document/categories', data);
    return response.data;
  },

  updateCategory: async (data: {
    id: string;
    name?: string;
    code?: string;
    description?: string;
    icon?: string;
    sort?: number;
    status?: number;
    remark?: string;
  }): Promise<boolean> => {
    const response = await request.put('/api/document/categories', data);
    return response.data;
  },

  deleteCategory: async (id: string): Promise<boolean> => {
    const response = await request.delete(`/api/document/categories/${id}`);
    return response.data;
  },
};

5.3 API服务 - services/user.ts

import request from '@/utils/request';
import { User } from '@/types';

export interface UserFilter {
  page?: number;
  pageSize?: number;
  keyword?: string;
  role?: string;
  status?: number;
}

export interface UserListResponse {
  list: User[];
  total: number;
}

export const userService = {
  getUsers: async (filter?: UserFilter): Promise<UserListResponse> => {
    const params: Record<string, any> = {};
    if (filter?.page) params.current = filter.page;
    if (filter?.pageSize) params.size = filter.pageSize;
    if (filter?.keyword) params.keyword = filter.keyword;
    if (filter?.role) params.role = filter.role;
    if (filter?.status !== undefined) params.status = filter.status;

    const response = await request.get('/api/user/users/page', { params });
    const data = response.data;
    return {
      list: data.records || [],
      total: data.total || 0,
    };
  },

  getUser: async (id: number): Promise<User> => {
    const response = await request.get(`/api/user/users/${id}`);
    return response.data;
  },

  createUser: async (data: {
    username: string;
    password: string;
    email?: string;
    phone?: string;
    realName?: string;
    department?: string;
    position?: string;
    status?: number;
  }): Promise<number> => {
    const response = await request.post('/api/user/users', data);
    return response.data;
  },

  updateUser: async (data: {
    id: number;
    username?: string;
    email?: string;
    phone?: string;
    realName?: string;
    department?: string;
    position?: string;
    status?: number;
  }): Promise<boolean> => {
    const response = await request.put('/api/user/users', data);
    return response.data;
  },

  deleteUser: async (id: number): Promise<boolean> => {
    const response = await request.delete(`/api/user/users/${id}`);
    return response.data;
  },
};

5.4 分类管理页面 - pages/admin/CategoriesPage.tsx

import React, { useState, useEffect } from 'react';
import {
  Tree,
  Button,
  Modal,
  Form,
  Input,
  InputNumber,
  message,
  Card,
  Space,
  Popconfirm,
  Row,
  Col,
  Typography,
  Tag,
  Tooltip,
  Divider,
  Select,
} from 'antd';
import {
  PlusOutlined,
  EditOutlined,
  DeleteOutlined,
  FolderOutlined,
  FolderOpenOutlined,
  FolderAddOutlined,
  InfoCircleOutlined,
} from '@ant-design/icons';
import type { DataNode } from 'antd/es/tree';
import { CategoryTree } from '@/types';
import { categoryService } from '@/services';

const { Title, Text } = Typography;

interface ExtendedDataNode extends DataNode {
  data?: CategoryTree;
  children?: ExtendedDataNode[];
}

export const CategoriesPage: React.FC = () => {
  const [categories, setCategories] = useState<CategoryTree[]>([]);
  const [treeData, setTreeData] = useState<ExtendedDataNode[]>([]);
  const [isModalVisible, setIsModalVisible] = useState(false);
  const [editingCategory, setEditingCategory] = useState<CategoryTree | null>(null);
  const [parentCategory, setParentCategory] = useState<string>('');
  const [selectedCategory, setSelectedCategory] = useState<string | null>(null);
  const [expandedKeys, setExpandedKeys] = useState<string[]>([]);
  const [form] = Form.useForm();

  useEffect(() => {
    fetchCategories();
  }, []);

  useEffect(() => {
    buildTreeData();
  }, [categories]);

  const fetchCategories = async () => {
    try {
      const data = await categoryService.getCategoryTree();
      setCategories(data);
    } catch (error) {
      message.error('获取分类列表失败');
    }
  };

  const buildTreeData = () => {
    const buildNode = (parentId: string = '0'): ExtendedDataNode[] => {
      return categories
        .filter((cat) => cat.parentId === parentId)
        .sort((a, b) => (a.sortOrder ?? a.sort ?? 0) - (b.sortOrder ?? b.sort ?? 0))
        .map((cat) => ({
          key: cat.id,
          title: (
            <Space>
              {cat.status === 0 ? (
                <Tag color="red">已禁用</Tag>
              ) : (
                <span>{cat.icon || '📁'}</span>
              )}
              <span>{cat.name}</span>
            </Space>
          ),
          children: buildNode(cat.id),
          data: cat,
        }));
    };
    setTreeData(buildNode());
  };

  const handleAdd = (parentId: string = '0') => {
    setEditingCategory(null);
    setParentCategory(parentId);
    form.resetFields();
    setIsModalVisible(true);
  };

  const handleEdit = (category: CategoryTree) => {
    setEditingCategory(category);
    setParentCategory(category.parentId || '0');
    form.setFieldsValue(category);
    setIsModalVisible(true);
  };

  const handleDelete = async (categoryId: string) => {
    try {
      await categoryService.deleteCategory(categoryId);
      message.success('删除成功');
      fetchCategories();
      if (selectedCategory === categoryId) {
        setSelectedCategory(null);
      }
    } catch (error: any) {
      message.error(error.message || '删除失败');
    }
  };

  const handleModalOk = async () => {
    try {
      const values = await form.validateFields();
      
      if (editingCategory) {
        await categoryService.updateCategory({
          id: editingCategory.id,
          name: values.name,
          code: values.code,
          description: values.description,
          icon: values.icon,
          sort: values.sort,
          status: values.status,
          remark: values.remark,
        });
        message.success('更新成功');
      } else {
        await categoryService.createCategory({
          name: values.name,
          parentId: parentCategory,
          code: values.code,
          description: values.description,
          icon: values.icon,
          sort: values.sort,
          status: values.status,
          remark: values.remark,
        });
        message.success('创建成功');
      }
      
      setIsModalVisible(false);
      fetchCategories();
    } catch (error: any) {
      message.error(error.message || '操作失败');
    }
  };

  const handleSelect = (selectedKeys: string[]) => {
    setSelectedCategory(selectedKeys.length > 0 ? selectedKeys[0] : null);
  };

  const getSelectedCategory = () => {
    if (!selectedCategory) return null;
    return categories.find((cat) => cat.id === selectedCategory);
  };

  const selectedCat = getSelectedCategory();

  return (
    <div style={{ padding: '8px 8px', background: '#f8fafc', minHeight: '100vh' }}>
      <div style={{ marginBottom: 32, display: 'flex', justifyContent: 'space-between', alignItems: 'center' }}>
        <div>
          <Title level={2} style={{ margin: 0, marginBottom: 8, fontSize: 28, fontWeight: 700 }}>
            分类管理
          </Title>
          <Text type="secondary">管理文档分类结构,支持树形层级展示</Text>
        </div>
        <Button
          type="primary"
          icon={<PlusOutlined />}
          onClick={() => handleAdd()}
          size="large"
        >
          新建分类
        </Button>
      </div>
      <Row gutter={16}>
        <Col span={8}>
          <Card
            title="分类树"
            styles={{ body: { padding: 16 } }}
            extra={
              <Tooltip title="新建子分类">
                <Button
                  icon={<FolderAddOutlined />}
                  onClick={() => selectedCategory && handleAdd(selectedCategory)}
                  disabled={!selectedCategory}
                />
              </Tooltip>
            }
          >
            <Tree
              treeData={treeData}
              defaultExpandAll
              expandedKeys={expandedKeys}
              selectedKeys={selectedCategory ? [selectedCategory] : []}
              onSelect={handleSelect}
              onExpand={(keys) => setExpandedKeys(keys as string[])}
              switcherIcon={({ expanded }) =>
                expanded ? <FolderOpenOutlined /> : <FolderOutlined />
              }
            />
          </Card>
        </Col>
        <Col span={16}>
          {selectedCat ? (
            <Card
              title="分类详情"
              styles={{ body: { padding: 16 } }}
              extra={
                <Space>
                  <Button
                    icon={<EditOutlined />}
                    onClick={() => handleEdit(selectedCat)}
                  >
                    编辑
                  </Button>
                  <Popconfirm
                    title="确认删除"
                    description={`确定要删除分类 "${selectedCat.name}" 吗?`}
                    onConfirm={() => handleDelete(selectedCat.id)}
                    okText="确定"
                    cancelText="取消"
                  >
                    <Button danger icon={<DeleteOutlined />}>
                      删除
                    </Button>
                  </Popconfirm>
                </Space>
              }
            >
              <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: 16 }}>
                <div>
                  <Text strong>分类名称:</Text>
                  <Text>{selectedCat.name}</Text>
                </div>
                <div>
                  <Text strong>分类编码:</Text>
                  <Text>{selectedCat.code || '-'}</Text>
                </div>
                <div>
                  <Text strong>图标:</Text>
                  <Text>{selectedCat.icon || '📁'}</Text>
                </div>
                <div>
                  <Text strong>状态:</Text>
                  <Tag color={selectedCat.status === 1 ? 'green' : 'red'}>
                    {selectedCat.status === 1 ? '启用' : '禁用'}
                  </Tag>
                </div>
                <div>
                  <Text strong>排序:</Text>
                  <Text>{selectedCat.sort || 0}</Text>
                </div>
                <div>
                  <Text strong>文档数量:</Text>
                  <Text>{selectedCat.documentCount || 0}</Text>
                </div>
                <div style={{ gridColumn: '1 / -1' }}>
                  <Text strong>描述:</Text>
                  <Text>{selectedCat.description || '-'}</Text>
                </div>
                <div style={{ gridColumn: '1 / -1' }}>
                  <Text strong>备注:</Text>
                  <Text>{selectedCat.remark || '-'}</Text>
                </div>
              </div>
              <Divider />
              <div style={{ display: 'flex', justifyContent: 'space-between', color: '#999' }}>
                <Text>创建时间:{selectedCat.createdAt?.replace('T', ' ')}</Text>
                <Text>更新时间:{selectedCat.updatedAt?.replace('T', ' ')}</Text>
              </div>
            </Card>
          ) : (
            <Card styles={{ body: { padding: 16, textAlign: 'center' } }}>
              <InfoCircleOutlined style={{ fontSize: 48, color: '#ccc', marginBottom: 16 }} />
              <Text type="secondary" style={{ fontSize: 16 }}>
                请从左侧选择一个分类查看详情
              </Text>
            </Card>
          )}
        </Col>
      </Row>
      <Modal
        title={editingCategory ? '编辑分类' : '新建分类'}
        open={isModalVisible}
        onOk={handleModalOk}
        onCancel={() => {
          setIsModalVisible(false);
          form.resetFields();
        }}
        width={600}
      >
        <Form form={form} layout="vertical">
          <Form.Item
            label="分类名称"
            name="name"
            rules={[{ required: true, message: '请输入分类名称' }]}
          >
            <Input placeholder="请输入分类名称" />
          </Form.Item>
          <Form.Item
            label="分类编码"
            name="code"
          >
            <Input placeholder="请输入分类编码" />
          </Form.Item>
          <Form.Item
            label="分类描述"
            name="description"
          >
            <Input.TextArea placeholder="请输入分类描述" rows={4} />
          </Form.Item>
          <Form.Item
            label="图标"
            name="icon"
            initialValue="📁"
          >
            <Input placeholder="请输入emoji图标" />
          </Form.Item>
          <Form.Item
            label="排序"
            name="sort"
            initialValue={0}
          >
            <InputNumber min={0} placeholder="排序序号" />
          </Form.Item>
          <Form.Item
            label="状态"
            name="status"
            initialValue={1}
          >
            <Select>
              <Select.Option value={1}>启用</Select.Option>
              <Select.Option value={0}>禁用</Select.Option>
            </Select>
          </Form.Item>
          <Form.Item
            label="备注"
            name="remark"
          >
            <Input.TextArea placeholder="请输入备注信息" rows={3} />
          </Form.Item>
        </Form>
      </Modal>
    </div>
  );
};

5.5 用户管理页面 - pages/admin/UsersManagementPage.tsx

import React, { useState, useEffect } from 'react';
import {
  Table,
  Button,
  Input,
  Select,
  Space,
  Typography,
  Tag,
  Avatar,
  Card,
  Modal,
  Form,
  message,
  Popconfirm,
  Pagination,
} from 'antd';
import {
  SearchOutlined,
  PlusOutlined,
  EditOutlined,
  DeleteOutlined,
  ReloadOutlined,
} from '@ant-design/icons';
import type { ColumnsType } from 'antd/es/table';
import { userService } from '@/services';
import { User } from '@/types';

const { Title, Text } = Typography;

interface UserFormData {
  id?: number;
  username: string;
  email: string;
  password?: string;
  realName?: string;
  department?: string;
  position?: string;
  status: number;
}

export const UsersManagementPage: React.FC = () => {
  const [users, setUsers] = useState<User[]>([]);
  const [loading, setLoading] = useState(false);
  const [searchText, setSearchText] = useState('');
  const [roleFilter, setRoleFilter] = useState<string>('all');
  const [statusFilter, setStatusFilter] = useState<string>('all');
  const [pagination, setPagination] = useState({ current: 1, pageSize: 10, total: 0 });

  const [isModalVisible, setIsModalVisible] = useState(false);
  const [editingUser, setEditingUser] = useState<User | null>(null);
  const [form] = Form.useForm<UserFormData>();

  useEffect(() => {
    fetchUsers();
  }, [pagination.current, pagination.pageSize, roleFilter, statusFilter]);

  const fetchUsers = async () => {
    setLoading(true);
    try {
      const filter: any = {
        page: pagination.current,
        pageSize: pagination.pageSize,
      };
      if (searchText) {
        filter.keyword = searchText;
      }
      if (roleFilter !== 'all') {
        filter.role = roleFilter;
      }
      if (statusFilter !== 'all') {
        filter.status = statusFilter === 'active' ? 1 : 0;
      }

      const response = await userService.getUsers(filter);
      setUsers(response.list || []);
      setPagination((prev) => ({
        ...prev,
        total: response.total || 0,
      }));
    } catch (error) {
      message.error('获取用户列表失败');
    } finally {
      setLoading(false);
    }
  };

  const handleSearch = () => {
    setPagination((prev) => ({ ...prev, current: 1 }));
  };

  const handleReset = () => {
    setSearchText('');
    setRoleFilter('all');
    setStatusFilter('all');
    setPagination((prev) => ({ ...prev, current: 1 }));
  };

  const handleAdd = () => {
    setEditingUser(null);
    form.resetFields();
    form.setFieldsValue({ status: 1 });
    setIsModalVisible(true);
  };

  const handleEdit = (user: User) => {
    setEditingUser(user);
    form.setFieldsValue({
      id: user.id,
      username: user.username,
      email: user.email,
      realName: user.realName,
      department: user.department,
      position: user.position,
      status: user.status,
    });
    setIsModalVisible(true);
  };

  const handleDelete = async (userId: number) => {
    try {
      await userService.deleteUser(userId);
      message.success('删除成功');
      fetchUsers();
    } catch (error: any) {
      message.error(error.message || '删除失败');
    }
  };

  const handleModalOk = async () => {
    try {
      const values = await form.validateFields();

      if (editingUser) {
        await userService.updateUser({
          id: editingUser.id,
          username: values.username,
          email: values.email,
          realName: values.realName,
          department: values.department,
          position: values.position,
          status: values.status,
        });
        message.success('更新成功');
      } else {
        if (!values.password) {
          message.error('请输入密码');
          return;
        }
        await userService.createUser({
          username: values.username,
          password: values.password,
          email: values.email,
          realName: values.realName,
          department: values.department,
          position: values.position,
          status: values.status,
        });
        message.success('创建成功');
      }

      setIsModalVisible(false);
      form.resetFields();
      fetchUsers();
    } catch (error: any) {
      message.error(error.message || '操作失败');
    }
  };

  const columns: ColumnsType<User> = [
    {
      title: '用户信息',
      dataIndex: 'username',
      key: 'username',
      width: 180,
      render: (username: string, record: User) => (
        <Space>
          <Avatar>{username.charAt(0).toUpperCase()}</Avatar>
          <div>
            <div style={{ fontWeight: 500 }}>{username}</div>
            <div style={{ fontSize: 12, color: '#999' }}>{record.email}</div>
          </div>
        </Space>
      ),
    },
    {
      title: '真实姓名',
      dataIndex: 'realName',
      key: 'realName',
      width: 120,
      render: (realName: string) => (
        <Text style={{ fontSize: 14, color: '#475569' }}>{realName || '-'}</Text>
      ),
    },
    {
      title: '部门',
      dataIndex: 'department',
      key: 'department',
      width: 120,
      render: (department: string) => (
        <Text style={{ fontSize: 14, color: '#475569' }}>{department || '-'}</Text>
      ),
    },
    {
      title: '岗位',
      dataIndex: 'position',
      key: 'position',
      width: 120,
      render: (position: string) => (
        <Text style={{ fontSize: 14, color: '#475569' }}>{position || '-'}</Text>
      ),
    },
    {
      title: '状态',
      dataIndex: 'status',
      key: 'status',
      width: 100,
      render: (status: number) => (
        <Tag color={status === 1 ? 'green' : 'red'}>
          {status === 1 ? '启用' : '禁用'}
        </Tag>
      ),
    },
    {
      title: '创建时间',
      dataIndex: 'createdAt',
      key: 'createdAt',
      width: 180,
      render: (createdAt: string) => (
        <Text style={{ fontSize: 13, color: '#64748b' }}>
          {createdAt ? createdAt.replace('T', ' ') : '-'}
        </Text>
      ),
    },
    {
      title: '操作',
      key: 'actions',
      width: 180,
      render: (_, record) => (
        <Space>
          <Button icon={<EditOutlined />} onClick={() => handleEdit(record)} size="small">
            编辑
          </Button>
          <Popconfirm
            title="确认删除"
            description={`确定要删除用户 "${record.username}" 吗?`}
            onConfirm={() => handleDelete(record.id)}
            okText="确定"
            cancelText="取消"
          >
            <Button danger icon={<DeleteOutlined />} size="small">
              删除
            </Button>
          </Popconfirm>
        </Space>
      ),
    },
  ];

  const styles = {
    container: {
      maxWidth: 'none',
      margin: 0,
      padding: '8px 8px',
      minHeight: '100vh',
      background: '#f8fafc',
    },
    pageHeader: {
      display: 'flex',
      justifyContent: 'space-between',
      alignItems: 'center',
      marginBottom: 24,
    },
    searchBar: {
      display: 'flex',
      gap: 12,
      alignItems: 'center',
    },
  };

  return (
    <div style={styles.container}>
      <div style={styles.pageHeader}>
        <div>
          <Title level={2} style={{ margin: 0, marginBottom: 8, fontSize: 28, fontWeight: 700 }}>
            用户管理
          </Title>
          <Text type="secondary">管理系统用户信息</Text>
        </div>
        <Button type="primary" icon={<PlusOutlined />} onClick={handleAdd} size="large">
          新建用户
        </Button>
      </div>
      <Card>
        <div style={styles.searchBar}>
          <Input
            placeholder="搜索用户名、姓名、邮箱或手机号"
            prefix={<SearchOutlined />}
            value={searchText}
            onChange={(e) => setSearchText(e.target.value)}
            onPressEnter={handleSearch}
            style={{ width: 300 }}
          />
          <Select
            value={roleFilter}
            onChange={(value) => {
              setRoleFilter(value);
              setPagination((prev) => ({ ...prev, current: 1 }));
            }}
            style={{ width: 120 }}
            placeholder="角色筛选"
          >
            <Select.Option value="all">全部角色</Select.Option>
            <Select.Option value="admin">管理员</Select.Option>
            <Select.Option value="user">普通用户</Select.Option>
          </Select>
          <Select
            value={statusFilter}
            onChange={(value) => {
              setStatusFilter(value);
              setPagination((prev) => ({ ...prev, current: 1 }));
            }}
            style={{ width: 120 }}
            placeholder="状态筛选"
          >
            <Select.Option value="all">全部状态</Select.Option>
            <Select.Option value="active">启用</Select.Option>
            <Select.Option value="inactive">禁用</Select.Option>
          </Select>
          <Button onClick={handleSearch} icon={<SearchOutlined />}>
            搜索
          </Button>
          <Button onClick={handleReset} icon={<ReloadOutlined />}>
            重置
          </Button>
        </div>
        <Table
          dataSource={users}
          columns={columns}
          loading={loading}
          rowKey="id"
          pagination={false}
          style={{ marginTop: 16 }}
        />

        <div style={{ display: 'flex', justifyContent: 'center', marginTop: 16 }}>
          <Pagination
            current={pagination.current}
            pageSize={pagination.pageSize}
            total={pagination.total}
            onChange={(page, pageSize) => {
              setPagination((prev) => ({
                ...prev,
                current: page,
                pageSize,
              }));
            }}
            showSizeChanger
            pageSizeOptions={['10', '20', '50', '100']}
            showTotal={(total) => `共 ${total} 条记录`}
          />
        </div>
      </Card>
      <Modal
        title={editingUser ? '编辑用户' : '新建用户'}
        open={isModalVisible}
        onOk={handleModalOk}
        onCancel={() => {
          setIsModalVisible(false);
          form.resetFields();
        }}
        width={500}
      >
        <Form form={form} layout="vertical">
          <Form.Item
            label="用户名"
            name="username"
            rules={[{ required: true, message: '请输入用户名' }]}
          >
            <Input placeholder="请输入用户名" />
          </Form.Item>
          {!editingUser && (
            <Form.Item
              label="密码"
              name="password"
              rules={[{ required: true, message: '请输入密码' }]}
            >
              <Input.Password placeholder="请输入密码" />
            </Form.Item>
          )}

          <Form.Item
            label="邮箱"
            name="email"
            rules={[{ required: true, message: '请输入邮箱' }, { type: 'email', message: '请输入有效的邮箱地址' }]}
          >
            <Input placeholder="请输入邮箱" />
          </Form.Item>
          <Form.Item
            label="真实姓名"
            name="realName"
          >
            <Input placeholder="请输入真实姓名" />
          </Form.Item>
          <Form.Item
            label="部门"
            name="department"
          >
            <Input placeholder="请输入部门" />
          </Form.Item>
          <Form.Item
            label="岗位"
            name="position"
          >
            <Input placeholder="请输入岗位" />
          </Form.Item>
          <Form.Item
            label="状态"
            name="status"
            initialValue={1}
          >
            <Select>
              <Select.Option value={1}>启用</Select.Option>
              <Select.Option value={0}>禁用</Select.Option>
            </Select>
          </Form.Item>
        </Form>
      </Modal>
    </div>
  );
};

六、运行验证

6.1 启动后端服务

cd knowledge-base-backend
mvn clean compile
mvn spring-boot:run -pl kb-document -am
mvn spring-boot:run -pl kb-user-auth -am

6.2 启动前端服务

cd knowledge-base-frontend
npm install
npm run dev

访问分类管理页面:http://localhost:3002/admin/categories

截屏2026-05-21 22.32.56.png

访问用户管理页面:http://localhost:3002/admin/users

截屏2026-05-21 22.33.37.png

总结

本教程详细介绍了如何在企业知识库系统中实现完整的分类管理和用户管理功能,包括:

  1. 数据库设计:设计了分类表、用户表和用户角色关联表
  2. 后端实现:基于Spring Boot + MyBatis Plus实现了完整的CRUD接口
  3. 前端实现:基于React + Ant Design实现了美观的管理页面
  4. 功能特性:

    • 分类管理:树形结构展示、分类增删改查、状态管理
    • 用户管理:分页查询、用户增删改查、角色筛选、状态筛选

按照本教程的代码实现,您将能够快速构建一个功能完整、界面美观的分类和用户管理系统。

最后修改:2026 年 10 月 24 日
如果觉得我的文章对你有用,请随意赞赏