『博客开发日记-后台』之获取用户列表接口的实现

本文最后更新于 2026年5月17日 晚上

获取用户列表接口的实现

获取用户列表接口的需求

根据关键字（用户名/昵称/手机号码）模糊查询用户

根据状态筛选

按部门id查询

按创建时间查询

根据创建时间降序排序

支持分页查询

查询是否为系统管理员

代码实现

生成 SysUser 

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
/**
 * 用户表(User)表实体类
 *
 * @author makejava
 * @since 2026-01-07 15:53:34
 */
@SuppressWarnings("serial")
@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName("sys_user")
public class SysUser extends Model<SysUser> {
    @TableId
    //用户ID
    private Long id;
    //用户名
    private String username;
    //密码（加密存储）
    private String password;
    //昵称
    private String nickname;
    //邮箱
    private String email;
    //账号状态（0 正常，1 停用）
    private String status;
    //部门id
    private String deptId;
    //手机号
    private String phone;
    //用户性别，（0 男，1 女，2 隐藏）
    private String sex;
    //头像URL
    private String avatar;
    //删除标志（0-未删除，1-已删除）
    private String delFlag;
    //创建人的用户id
    @TableField(fill = FieldFill.INSERT)
    private Long createBy;
    //创建时间
    @TableField(fill = FieldFill.INSERT)
    private Date createTime;
    //更新者ID
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private Long updateBy;
    //更新时间
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private Date updateTime;
    //最后登录时间
    private Date lastLoginTime;

}

新建 UserListDto 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/**
 * 用户列表请求DTO
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
@ApiModel(description = "用户列表请求对象")
public class UserListDto {

    @Pattern(regexp = "^$|^[01]$", message = "状态只能为0或1")
    @ApiModelProperty(value = "状态", example = "0")
    private String status;

    @ApiModelProperty(value = "关键字（用户名/昵称/手机号）", example = "云梦泽")
    private String keywords;

    @ApiModelProperty(value = "创建时间", example = "[2026-04-01, 2026-05-15]")
    private List<String> createTime;

    @ApiModelProperty(value = "部门id", example = "1")
    private String deptId;
}

再创建 AdminUserListVo

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
/**
 * 用户列表Vo
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
@ApiModel(description = "后台用户列表响应对象")
public class AdminUserListVo
{

    @ApiModelProperty(value = "用户id", example = "1")
    private Long id;

    @ApiModelProperty(value = "头像URL", example = "https://avatars.githubusercontent.com/u/155459505?v=4")
    private String avatar;

    @ApiModelProperty(value = "创建时间", example = "2026-01-12 20:58:53")
    private Date createTime;

    @ApiModelProperty(value = "部门名称", example = "测试不")
    private String deptName;

    @ApiModelProperty(value = "用户邮箱", example = "2962933152@qq.com")
    private String email;

    @ApiModelProperty(value = "用户性别，（0 男，1 女，2 隐藏）", example = "0")
    private String sex;

    @ApiModelProperty(value = "手机号", example = "18329384753")
    @JSONField(name = "mobile")//转换成 mobile 再响应给前端
    private String phone;

    @ApiModelProperty(value = "昵称", example = "云梦泽")
    private String nickname;

    @ApiModelProperty(value = "角色名称，多个使用英文逗号(,)分割", example = "系统管理员")
    private String roleNames;

    @ApiModelProperty(value = "账号状态（0 正常，1 停用）", example = "0")
    private String status;

    @ApiModelProperty(value = "用户名", example = "云梦泽")
    private String username;
}

在 LogController 中

1
2
3
4
5
6
7
8
9
10
11
@GetMapping
@SystemLog(businessName = "分页查询用户列表")
@ApiOperation(value = "获取用户列表", notes = "分页查询用户列表", response = PageVo.class)
@ApiImplicitParams({
        @ApiImplicitParam(name = "pageNum", value = "页号", dataType = "int", paramType = "query"),
        @ApiImplicitParam(name = "pageSize", value = "每页数量", dataType = "int", paramType = "query"),
})
public ResponseResult getUserList(Integer pageNum, Integer pageSize, @Valid UserListDto userListDto)
{
    return adminUserService.getUserList(pageNum, pageSize, userListDto);
}

为了保证如果是用户id=1时返回角色名称可以只显示 系统超级管理员而不是所有角色

可以在 SysRoleServiceImpl 新建 selectRoleNameByUserId 和 selectRolesByUserId 方法来实现

这就相当于固定了系统超级管理员必须有这些权限，其他用户按自己该有的权限

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
@Override
public List<String> selectRoleNameByUserId(Long id)
{
    if (id == 1L) {
        List<String> roleNames = new ArrayList<>();
        roleNames.add("系统超级管理员");
        return roleNames;
    }
    return getBaseMapper().selectRoleNameByUserId(id);
}

//查询di为1的用户所拥有的角色列表
@Override
public List<SysRole> selectRolesByUserId(Long id)
{
    if (id == 1L) {
        SysRole sysRole = new SysRole();
        sysRole.setId(1L);
        sysRole.setRoleCode("admin");
        sysRole.setName("系统超级管理员");
        sysRole.setDataScope(1);
        return List.of(sysRole);
    }
    return getBaseMapper().selectRolesByUserId(id);
}

相对应的在 SysRoleMapper.xml 也要写上对应的sql联表查询

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<select id="selectRoleNameByUserId" resultType="java.lang.String">
        SELECT r.name
        FROM sys_user_role ur
                 LEFT JOIN sys_role r ON ur.role_id = r.id
        WHERE ur.user_id = #{userId}
          AND r.`status` = 0
          AND r.del_flag = 0
</select>

<select id="selectRolesByUserId" resultType="com.mengze.domain.entity.SysRole">
SELECT r.id,
r.role_code,
r.name,
r.data_scope
FROM sys_user_role ur
LEFT JOIN sys_role r ON ur.role_id = r.id
WHERE ur.user_id = #{userId}
AND r.`status` = 0
AND r.del_flag = 0
</select>

剩下的就是 AdminUserServiceImpl 中的实现方法了

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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
 //获取用户列表
@Override
public ResponseResult getUserList(Integer pageNum, Integer pageSize, UserListDto userListDto)
{
    //构建查询条件
    LambdaQueryWrapper<SysUser> queryWrapper = new LambdaQueryWrapper<>();

    //当前登录用户
    LoginUser loginUser = SecurityUtils.getLoginUser();
    Long currentUserId = loginUser.getSysUser().getId();

    //超级管理员直接看全部；普通用户按数据权限限制
    if (!Objects.equals(currentUserId, 1L)) {
        List<SysRole> roles = sysRoleService.selectRolesByUserId(currentUserId);
        Integer maxDataScope = roles.stream()
                .map(SysRole::getDataScope)
                .filter(Objects::nonNull)
                .min(Integer::compareTo)
                .orElse(4);

        // 1-全部数据，直接不加限制
        if (!Objects.equals(maxDataScope, 1))
        {
            if (Objects.equals(maxDataScope, 2)) {
                //部门及子部门数据
                List<Long> deptIds = sysDeptService.selectDeptAndChildrenIds(Long.valueOf(loginUser.getSysUser().getDeptId()));
                queryWrapper.in(SysUser::getDeptId, deptIds.stream().map(String::valueOf).toList());
            } else if (Objects.equals(maxDataScope, 3)) {
                //本部门数据
                queryWrapper.eq(SysUser::getDeptId, loginUser.getSysUser().getDeptId());
            } else if (Objects.equals(maxDataScope, 4)) {
                //本人数据
                queryWrapper.eq(SysUser::getCreateBy, currentUserId);
            } else if (Objects.equals(maxDataScope, 5)) {
                //自定义部门数据
                List<Long> deptIds = new ArrayList<>();
                for (SysRole role : roles) {
                    if (Objects.equals(role.getDataScope(), 5)) {
                        LambdaQueryWrapper<com.mengze.domain.entity.SysRoleDept> deptWrapper = new LambdaQueryWrapper<>();
                        deptWrapper.eq(com.mengze.domain.entity.SysRoleDept::getRoleId, role.getId())
                                .select(com.mengze.domain.entity.SysRoleDept::getDeptId);
                        List<com.mengze.domain.entity.SysRoleDept> roleDeptList = sysRoleDeptService.list(deptWrapper);
                        deptIds.addAll(roleDeptList.stream().map(com.mengze.domain.entity.SysRoleDept::getDeptId).toList());
                    }
                }
                if (!deptIds.isEmpty()) {
                    queryWrapper.in(SysUser::getDeptId, deptIds.stream().map(String::valueOf).toList());
                }
            }
        }
    }

    //根据关键子查询（用户名，昵称，手机号）
    if (StringUtils.hasText(userListDto.getKeywords())) {
        queryWrapper.and(wrapper -> wrapper
                .like(SysUser::getUsername, userListDto.getKeywords())
                .or()
                .like(SysUser::getNickname, userListDto.getKeywords())
                .or()
                .like(SysUser::getPhone, userListDto.getKeywords())
        );
    }

    //根据状态筛选
    if (StringUtils.hasText(userListDto.getStatus())){
        queryWrapper.eq(SysUser::getStatus, userListDto.getStatus());
    }

    //按部门id查询
    if (StringUtils.hasText(userListDto.getDeptId())) {
        queryWrapper.eq(SysUser::getDeptId, userListDto.getDeptId());
    }

    //按创建时间查询
    if (userListDto.getCreateTime() != null && userListDto.getCreateTime().size() == 2)
    {
        //补全当天完整时间，因为前端只传 2026-04-01 不完整
        try {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

            Date startTime = sdf.parse(userListDto.getCreateTime().get(0) + " 00:00:00");
            Date endTime = sdf.parse(userListDto.getCreateTime().get(1) + " 23:59:59");

            queryWrapper.between(SysUser::getCreateTime, startTime, endTime);
        } catch (ParseException e) {
            throw new RuntimeException("创建时间格式不正确", e);
        }
    }

    //根据创建时间降序排序
    queryWrapper.orderByDesc(SysUser::getCreateTime);

    //封装分页
    Page<SysUser> page = new Page<>(pageNum, pageSize);
    page(page, queryWrapper);

    //封装成vo返回
    List<AdminUserListVo> adminUserListVos = page.getRecords().stream()
            .map(sysUser -> {
                AdminUserListVo vo = BeanCopyUtils.copyBean(sysUser, AdminUserListVo.class);
                if (StringUtils.hasText(sysUser.getDeptId())) {
                    SysDept dept = null;
                    try {
                        dept = sysDeptService.getById(Long.valueOf(sysUser.getDeptId()));
                    } catch (NumberFormatException ignored) {
                        // 部门ID不是数字时忽略部门名称回填
                    }
                    if (dept != null) {
                        vo.setDeptName(dept.getName());
                    }
                }

                //查询是否为管理员
                List<String> roleNames = sysRoleService.selectRoleNameByUserId(sysUser.getId());
                if (roleNames != null && !roleNames.isEmpty()) {
                    vo.setRoleNames(String.join(",", roleNames));
                }
                return vo;
            })
            .collect(java.util.stream.Collectors.toList());
    PageVo pageVo = new PageVo(adminUserListVos, page.getTotal());

    return ResponseResult.okResult(pageVo);
}

PS:该系列只做为作者学习开发项目做的笔记用

不一定符合读者来学习，仅供参考

预告

后续会记录博客的开发过程

每次学习会做一份笔记来进行发表

“一花一世界，一叶一菩提”

版权所有 © 2026 云梦泽
欢迎访问我的个人网站：https://hgt12.github.io/

博客开发
#技术向 #个人博客 #前端 #后端
『博客开发日记-后台』之获取用户列表接口的实现
http://example.com/2026/05/17/『博客开发日记-后台』之获取用户列表接口的实现/
作者
云梦泽
发布于
2026年5月17日
更新于
2026年5月17日
许可协议