RuoYi 阶段五：用户管理模块

NOTE
本文是 RuoYi 学习路线的阶段五，聚焦用户管理模块。学完本篇你应该能：

理解用户实体类的设计

掌握用户 CRUD 的完整流程

知道密码加密和用户状态管理的实现

前端视角：用户管理像什么？#

RuoYi 用户管理	前端类比
`SysUser` 实体类	User 类型定义 (TypeScript interface)
`ISysUserService`	用户 API 封装 (axios)
`SysUserController`	用户页面路由处理器
密码加密	bcrypt / crypto-js
用户状态	账户启用/禁用状态

用户实体类 (SysUser)#

1
package com.ruoyi.common.core.domain.entity;
2

3
import java.util.Date;
4
import java.util.List;
5
import javax.validation.constraints.*;
6
import org.apache.commons.lang3.builder.ToStringBuilder;
7
import org.apache.commons.lang3.builder.ToStringStyle;
8
import com.ruoyi.common.annotation.Excel;
9
import com.ruoyi.common.annotation.Excel.ColumnType;
10
import com.ruoyi.common.annotation.Excel.Type;
11
import com.ruoyi.common.core.domain.BaseEntity;
12

13
/**
14
 * 用户对象 sys_user
15
 *
16
 * @author ruoyi
17
 */
18
public class SysUser extends BaseEntity {
19
    private static final long serialVersionUID = 1L;
20

21
    /** 用户ID */
22
    @Excel(name = "用户序号", cellType = ColumnType.NUMERIC, prompt = "用户编号")
23
    private Long userId;
24

25
    /** 部门ID */
26
    @Excel(name = "部门编号", type = Type.IMPORT)
27
    private Long deptId;
28

29
    /** 部门父ID */
30
    private Long parentId;
31

32
    /** 角色ID */
33
    private Long roleId;
34

35
    /** 登录名称 */
36
    @Excel(name = "登录名称")
37
    private String loginName;
38

39
    /** 用户名称 */
40
    @Excel(name = "用户名称")
41
    private String userName;
42

43
    /** 用户邮箱 */
44
    @Excel(name = "用户邮箱")
45
    private String email;
46

47
    /** 手机号码 */
48
    @Excel(name = "手机号码")
49
    private String phonenumber;
50

51
    /** 用户性别 */
52
    @Excel(name = "用户性别", readConverterExp = "0=男,1=女,2=未知")
53
    private String sex;
54

55
    /** 用户头像 */
56
    private String avatar;
57

58
    /** 密码 */
59
    private String password;
60

61
    /** 盐加密 */
62
    private String salt;
63

64
    /** 帐号状态（0正常 1停用） */
65
    @Excel(name = "帐号状态", readConverterExp = "0=正常,1=停用")
66
    private String status;
67

68
    /** 删除标志（0代表存在 2代表删除） */
69
    private String delFlag;
70

71
    /** 最后登陆IP */
72
    @Excel(name = "最后登陆IP", type = Type.EXPORT)
73
    private String loginIp;
74

75
    /** 最后登陆时间 */
76
    @Excel(name = "最后登陆时间", width = 30, dateFormat = "yyyy-MM-dd HH:mm:ss", type = Type.EXPORT)
77
    private Date loginDate;
78

79
    /** 部门对象 */
80
    @Excel(name = "部门名称", targetAttr = "deptName", type = Type.EXPORT)
81
    private SysDept dept;
82

83
    /** 角色集合 */
84
    private List<SysRole> roles;
85

86
    /** 岗位ID列表 */
87
    private Long[] postIds;
88

89
    /** 角色ID列表 */
90
    private Long[] roleIds;
91

92
    // Getter 和 Setter 省略...
93

94
    public boolean isAdmin() {
95
        return isAdmin(this.userId);
96
    }
97

98
    public static boolean isAdmin(Long userId) {
99
        return userId != null && 1L == userId;
100
    }
101

102
    @Override
103
    public String toString() {
104
        return new ToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE)
105
            .append("userId", getUserId())
106
            .append("deptId", getDeptId())
107
            .append("loginName", getLoginName())
108
            .append("userName", getUserName())
109
            .append("email", getEmail())
110
            .append("phonenumber", getPhonenumber())
111
            .append("sex", getSex())
112
            .append("avatar", getAvatar())
113
            .append("password", getPassword())
114
            .append("salt", getSalt())
115
            .append("status", getStatus())
116
            .append("delFlag", getDelFlag())
117
            .append("loginIp", getLoginIp())
118
            .append("loginDate", getLoginDate())
119
            .append("createBy", getCreateBy())
120
            .append("createTime", getCreateTime())
121
            .append("updateBy", getUpdateBy())
122
            .append("updateTime", getUpdateTime())
123
            .append("remark", getRemark())
124
            .append("dept", getDept())
125
            .toString();
126
    }
127
}

实体类设计要点#

特性	说明
`@Excel`	用于导入导出 Excel
`@NotBlank`	参数校验（非空）
`@Email`	邮箱格式校验
`BaseEntity`	基类，包含 createBy、createTime 等公共字段
`delFlag`	逻辑删除标志（0 存在，2 删除）
`salt`	密码加密盐值

数据库表结构#

1
-- sys_user 用户表
2
CREATE TABLE sys_user (
3
  user_id           BIGINT(20)      NOT NULL AUTO_INCREMENT    COMMENT '用户ID',
4
  dept_id           BIGINT(20)      DEFAULT NULL               COMMENT '部门ID',
5
  login_name        VARCHAR(30)     NOT NULL                   COMMENT '登录账号',
6
  user_name         VARCHAR(30)     NOT NULL                   COMMENT '用户昵称',
7
  user_type         VARCHAR(2)      DEFAULT '00'               COMMENT '用户类型（00系统用户）',
8
  email             VARCHAR(50)     DEFAULT ''                 COMMENT '用户邮箱',
9
  phonenumber       VARCHAR(11)     DEFAULT ''                 COMMENT '手机号码',
10
  sex               CHAR(1)         DEFAULT '0'                COMMENT '用户性别（0男 1女 2未知）',
11
  avatar            VARCHAR(100)    DEFAULT ''                 COMMENT '头像路径',
12
  password          VARCHAR(50)     DEFAULT ''                 COMMENT '密码',
13
  salt              VARCHAR(20)     DEFAULT ''                 COMMENT '盐加密',
14
  status            CHAR(1)         DEFAULT '0'                COMMENT '帐号状态（0正常 1停用）',
15
  del_flag          CHAR(1)         DEFAULT '0'                COMMENT '删除标志（0代表存在 2代表删除）',
16
  login_ip          VARCHAR(100)    DEFAULT ''                 COMMENT '最后登录IP',
17
  login_date        DATETIME                                   COMMENT '最后登录时间',
18
  create_by         VARCHAR(64)     DEFAULT ''                 COMMENT '创建者',
19
  create_time       DATETIME                                   COMMENT '创建时间',
20
  update_by         VARCHAR(64)     DEFAULT ''                 COMMENT '更新者',
21
  update_time       DATETIME                                   COMMENT '更新时间',
22
  remark            VARCHAR(500)    DEFAULT NULL               COMMENT '备注',
23
  PRIMARY KEY (user_id)
24
) ENGINE=InnoDB AUTO_INCREMENT=100 COMMENT = '用户信息表';

Service 层实现#

接口定义#

1
package com.ruoyi.system.service;
2

3
import java.util.List;
4
import com.ruoyi.common.core.domain.entity.SysUser;
5

6
/**
7
 * 用户 业务层
8
 *
9
 * @author ruoyi
10
 */
11
public interface ISysUserService {
12
    /**
13
     * 根据条件分页查询用户列表
14
     */
15
    public List<SysUser> selectUserList(SysUser user);
16

17
    /**
18
     * 通过用户名查询用户
19
     */
20
    public SysUser selectUserByLoginName(String loginName);
21

22
    /**
23
     * 通过手机号码查询用户
24
     */
25
    public SysUser selectUserByPhoneNumber(String phoneNumber);
26

27
    /**
28
     * 通过邮箱查询用户
29
     */
30
    public SysUser selectUserByEmail(String email);
31

32
    /**
33
     * 通过用户ID查询用户
34
     */
35
    public SysUser selectUserById(Long userId);
36

37
    /**
38
     * 通过用户ID删除用户
39
     */
40
    public int deleteUserById(Long userId);
41

42
    /**
43
     * 批量删除用户信息
44
     */
45
    public int deleteUserByIds(String ids);
46

47
    /**
48
     * 保存用户信息
49
     */
50
    public int insertUser(SysUser user);
51

52
    /**
53
     * 保存用户信息
54
     */
55
    public int updateUser(SysUser user);
56

57
    /**
58
     * 修改用户详细信息
59
     */
60
    public int updateUserInfo(SysUser user);
61

62
    /**
63
     * 修改用户密码信息
64
     */
65
    public int resetUserPwd(SysUser user);
66

67
    /**
68
     * 校验用户名称是否唯一
69
     */
70
    public String checkLoginNameUnique(String loginName);
71

72
    /**
73
     * 校验手机号码是否唯一
74
     */
75
    public String checkPhoneUnique(SysUser user);
76

77
    /**
78
     * 校验email是否唯一
79
     */
80
    public String checkEmailUnique(SysUser user);
81

82
    /**
83
     * 导入用户数据
84
     */
85
    public String importUser(List<SysUser> userList, Boolean isUpdateSupport, String operName);
86
}

实现类#

1
package com.ruoyi.system.service.impl;
2

3
import java.util.ArrayList;
4
import java.util.List;
5
import java.util.stream.Collectors;
6
import javax.validation.Validator;
7
import org.slf4j.Logger;
8
import org.slf4j.LoggerFactory;
9
import org.springframework.beans.factory.annotation.Autowired;
10
import org.springframework.stereotype.Service;
11
import org.springframework.transaction.annotation.Transactional;
12
import org.springframework.util.CollectionUtils;
13
import com.ruoyi.common.annotation.DataScope;
14
import com.ruoyi.common.constant.ShiroConstants;
15
import com.ruoyi.common.constant.UserConstants;
16
import com.ruoyi.common.core.domain.entity.SysRole;
17
import com.ruoyi.common.core.domain.entity.SysUser;
18
import com.ruoyi.common.core.text.Convert;
19
import com.ruoyi.common.exception.ServiceException;
20
import com.ruoyi.common.utils.StringUtils;
21
import com.ruoyi.common.utils.spring.SpringUtils;
22
import com.ruoyi.system.mapper.*;
23
import com.ruoyi.system.service.ISysConfigService;
24
import com.ruoyi.system.service.ISysUserService;
25

26
/**
27
 * 用户 业务层处理
28
 *
29
 * @author ruoyi
30
 */
31
@Service
32
public class SysUserServiceImpl implements ISysUserService {
33
    private static final Logger log = LoggerFactory.getLogger(SysUserServiceImpl.class);
34

35
    @Autowired
36
    private SysUserMapper userMapper;
37

38
    @Autowired
39
    private SysRoleMapper roleMapper;
40

41
    @Autowired
42
    private SysPostMapper postMapper;
43

44
    @Autowired
45
    private SysUserPostMapper userPostMapper;
46

47
    @Autowired
48
    private SysUserRoleMapper userRoleMapper;
49

50
    @Autowired
51
    private ISysConfigService configService;
52

53
    @Autowired
54
    protected Validator validator;
55

56
    /**
57
     * 根据条件分页查询用户列表
58
     */
59
    @Override
60
    @DataScope(deptAlias = "d", userAlias = "u")
61
    public List<SysUser> selectUserList(SysUser user) {
62
        return userMapper.selectUserList(user);
63
    }
64

65
    /**
66
     * 通过用户名查询用户
67
     */
68
    @Override
69
    public SysUser selectUserByLoginName(String userName) {
70
        return userMapper.selectUserByLoginName(userName);
71
    }
72

73
    /**
74
     * 通过用户ID查询用户
75
     */
76
    @Override
77
    public SysUser selectUserById(Long userId) {
78
        return userMapper.selectUserById(userId);
79
    }
80

81
    /**
82
     * 新增保存用户信息
83
     */
84
    @Override
85
    @Transactional
86
    public int insertUser(SysUser user) {
87
        // 新增用户信息
88
        int rows = userMapper.insertUser(user);
89
        // 新增用户岗位关联
90
        insertUserPost(user);
91
        // 新增用户与角色管理
92
        insertUserRole(user.getUserId(), user.getRoleIds());
93
        return rows;
94
    }
95

96
    /**
97
     * 修改保存用户信息
98
     */
99
    @Override
100
    @Transactional
101
    public int updateUser(SysUser user) {
102
        Long userId = user.getUserId();
103
        // 删除用户与角色关联
104
        userRoleMapper.deleteUserRoleByUserId(userId);
105
        // 新增用户和角色管理
106
        insertUserRole(user.getUserId(), user.getRoleIds());
107
        // 删除用户与岗位关联
108
        userPostMapper.deleteUserPostByUserId(userId);
109
        // 新增用户与岗位管理
110
        insertUserPost(user);
111
        return userMapper.updateUser(user);
112
    }
113

114
    /**
115
     * 修改用户个人详细信息
116
     */
117
    @Override
118
    public int updateUserInfo(SysUser user) {
119
        return userMapper.updateUser(user);
120
    }
121

122
    /**
123
     * 重置用户密码
124
     */
125
    @Override
126
    public int resetUserPwd(SysUser user) {
127
        return updateUserInfo(user);
128
    }
129

130
    /**
131
     * 新增用户角色信息
132
     */
133
    public void insertUserRole(Long userId, Long[] roleIds) {
134
        if (StringUtils.isNotNull(roleIds)) {
135
            // 新增用户与角色管理
136
            List<SysUserRole> list = new ArrayList<SysUserRole>();
137
            for (Long roleId : roleIds) {
138
                SysUserRole ur = new SysUserRole();
139
                ur.setUserId(userId);
140
                ur.setRoleId(roleId);
141
                list.add(ur);
142
            }
143
            if (list.size() > 0) {
144
                userRoleMapper.batchUserRole(list);
145
            }
146
        }
147
    }
148

149
    /**
150
     * 新增用户岗位信息
151
     */
152
    public void insertUserPost(SysUser user) {
153
        Long[] posts = user.getPostIds();
154
        if (StringUtils.isNotNull(posts)) {
155
            // 新增用户与岗位管理
156
            List<SysUserPost> list = new ArrayList<SysUserPost>();
157
            for (Long postId : posts) {
158
                SysUserPost up = new SysUserPost();
159
                up.setUserId(user.getUserId());
160
                up.setPostId(postId);
161
                list.add(up);
162
            }
163
            if (list.size() > 0) {
164
                userPostMapper.batchUserPost(list);
165
            }
166
        }
167
    }
168

169
    /**
170
     * 校验登录名称是否唯一
171
     */
172
    @Override
173
    public String checkLoginNameUnique(String loginName) {
174
        int count = userMapper.checkLoginNameUnique(loginName);
175
        if (count > 0) {
176
            return UserConstants.NOT_UNIQUE;
177
        }
178
        return UserConstants.UNIQUE;
179
    }
180

181
    /**
182
     * 校验手机号码是否唯一
183
     */
184
    @Override
185
    public String checkPhoneUnique(SysUser user) {
186
        Long userId = StringUtils.isNull(user.getUserId()) ? -1L : user.getUserId();
187
        SysUser info = userMapper.checkPhoneUnique(user.getPhonenumber());
188
        if (StringUtils.isNotNull(info) && info.getUserId().longValue() != userId.longValue()) {
189
            return UserConstants.NOT_UNIQUE;
190
        }
191
        return UserConstants.UNIQUE;
192
    }
193

194
    /**
195
     * 校验邮箱是否唯一
196
     */
197
    @Override
198
    public String checkEmailUnique(SysUser user) {
199
        Long userId = StringUtils.isNull(user.getUserId()) ? -1L : user.getUserId();
200
        SysUser info = userMapper.checkEmailUnique(user.getEmail());
201
        if (StringUtils.isNotNull(info) && info.getUserId().longValue() != userId.longValue()) {
202
            return UserConstants.NOT_UNIQUE;
203
        }
204
        return UserConstants.UNIQUE;
205
    }
206

207
    /**
208
     * 删除用户信息
209
     */
210
    @Override
211
    public int deleteUserById(Long userId) {
212
        // 删除用户与角色关联
213
        userRoleMapper.deleteUserRoleByUserId(userId);
214
        // 删除用户与岗位表
215
        userPostMapper.deleteUserPostByUserId(userId);
216
        return userMapper.deleteUserById(userId);
217
    }
218

219
    /**
220
     * 批量删除用户信息
221
     */
222
    @Override
223
    public int deleteUserByIds(String ids) {
224
        Long[] userIds = Convert.toLongArray(ids);
225
        // 校验用户是否有数据权限
226
        checkUserAllowed(new SysUser(userIds[0]));
227
        // 删除用户与角色关联
228
        userRoleMapper.deleteUserRole(userIds);
229
        // 删除用户与岗位关联
230
        userPostMapper.deleteUserPost(userIds);
231
        return userMapper.deleteUserByIds(userIds);
232
    }
233

234
    /**
235
     * 校验用户是否允许操作
236
     */
237
    public void checkUserAllowed(SysUser user) {
238
        if (StringUtils.isNotNull(user.getUserId()) && user.isAdmin()) {
239
            throw new ServiceException("不允许操作超级管理员用户");
240
        }
241
    }
242
}

关键注解说明#

注解	说明
`@DataScope`	数据权限过滤（只能看到自己部门的数据）
`@Transactional`	事务管理（失败时回滚）
`@Service`	标注为 Service 层组件

Controller 层实现#

1
package com.ruoyi.web.controller.system;
2

3
import java.util.List;
4
import javax.servlet.http.HttpServletResponse;
5
import org.apache.shiro.authz.annotation.RequiresPermissions;
6
import org.springframework.beans.factory.annotation.Autowired;
7
import org.springframework.stereotype.Controller;
8
import org.springframework.ui.ModelMap;
9
import org.springframework.validation.annotation.Validated;
10
import org.springframework.web.bind.annotation.*;
11
import org.springframework.web.multipart.MultipartFile;
12
import com.ruoyi.common.annotation.Log;
13
import com.ruoyi.common.core.controller.BaseController;
14
import com.ruoyi.common.core.domain.AjaxResult;
15
import com.ruoyi.common.core.domain.entity.SysRole;
16
import com.ruoyi.common.core.domain.entity.SysUser;
17
import com.ruoyi.common.core.page.TableDataInfo;
18
import com.ruoyi.common.enums.BusinessType;
19
import com.ruoyi.common.utils.ShiroUtils;
20
import com.ruoyi.common.utils.poi.ExcelUtil;
21
import com.ruoyi.framework.shiro.service.PasswordService;
22
import com.ruoyi.framework.shiro.util.AuthorizationUtils;
23
import com.ruoyi.system.service.ISysPostService;
24
import com.ruoyi.system.service.ISysRoleService;
25
import com.ruoyi.system.service.ISysUserService;
26

27
/**
28
 * 用户信息
29
 *
30
 * @author ruoyi
31
 */
32
@Controller
33
@RequestMapping("/system/user")
34
public class SysUserController extends BaseController {
35
    private String prefix = "system/user";
36

37
    @Autowired
38
    private ISysUserService userService;
39

40
    @Autowired
41
    private ISysRoleService roleService;
42

43
    @Autowired
44
    private ISysPostService postService;
45

46
    @Autowired
47
    private PasswordService passwordService;
48

49
    @RequiresPermissions("system:user:view")
50
    @GetMapping()
51
    public String user() {
52
        return prefix + "/user";
53
    }
54

55
    @RequiresPermissions("system:user:list")
56
    @PostMapping("/list")
57
    @ResponseBody
58
    public TableDataInfo list(SysUser user) {
59
        startPage();
60
        List<SysUser> list = userService.selectUserList(user);
61
        return getDataTable(list);
62
    }
63

64
    @Log(title = "用户管理", businessType = BusinessType.EXPORT)
65
    @RequiresPermissions("system:user:export")
66
    @PostMapping("/export")
67
    @ResponseBody
68
    public AjaxResult export(HttpServletResponse response, SysUser user) {
69
        List<SysUser> list = userService.selectUserList(user);
70
        ExcelUtil<SysUser> util = new ExcelUtil<SysUser>(SysUser.class);
71
        return util.exportExcel(response, list, "用户数据");
72
    }
73

74
    @Log(title = "用户管理", businessType = BusinessType.IMPORT)
75
    @RequiresPermissions("system:user:import")
76
    @PostMapping("/importData")
77
    @ResponseBody
78
    public AjaxResult importData(MultipartFile file, boolean updateSupport) throws Exception {
79
        ExcelUtil<SysUser> util = new ExcelUtil<SysUser>(SysUser.class);
80
        List<SysUser> userList = util.importExcel(file.getInputStream());
81
        String operName = ShiroUtils.getLoginName();
82
        String message = userService.importUser(userList, updateSupport, operName);
83
        return success(message);
84
    }
85

86
    @GetMapping("/importTemplate")
87
    @ResponseBody
88
    public AjaxResult importTemplate(HttpServletResponse response) {
89
        ExcelUtil<SysUser> util = new ExcelUtil<SysUser>(SysUser.class);
90
        return util.importTemplateExcel(response, "用户数据");
91
    }
92

93
    /**
94
     * 新增用户
95
     */
96
    @GetMapping("/add")
97
    public String add(ModelMap mmap) {
98
        mmap.put("roles", roleService.selectRoleAll().stream()
99
                .filter(r -> !r.isAdmin()).collect(Collectors.toList()));
100
        mmap.put("posts", postService.selectPostAll());
101
        return prefix + "/add";
102
    }
103

104
    /**
105
     * 新增保存用户
106
     */
107
    @RequiresPermissions("system:user:add")
108
    @Log(title = "用户管理", businessType = BusinessType.INSERT)
109
    @PostMapping("/add")
110
    @ResponseBody
111
    public AjaxResult addSave(@Validated SysUser user) {
112
        if (UserConstants.NOT_UNIQUE.equals(userService.checkLoginNameUnique(user.getLoginName()))) {
113
            return error("新增用户'" + user.getLoginName() + "'失败，登录账号已存在");
114
        }
115
        if (StringUtils.isNotEmpty(user.getPhonenumber())
116
                && UserConstants.NOT_UNIQUE.equals(userService.checkPhoneUnique(user))) {
117
            return error("新增用户'" + user.getLoginName() + "'失败，手机号码已存在");
118
        }
119
        if (StringUtils.isNotEmpty(user.getEmail())
120
                && UserConstants.NOT_UNIQUE.equals(userService.checkEmailUnique(user))) {
121
            return error("新增用户'" + user.getLoginName() + "'失败，邮箱账号已存在");
122
        }
123

124
        // 密码加密
125
        user.setSalt(ShiroUtils.randomSalt());
126
        user.setPassword(passwordService.encryptPassword(user.getLoginName(),
127
                user.getPassword(), user.getSalt()));
128
        user.setPwdUpdateDate(DateUtils.getNowDate());
129
        user.setCreateBy(getLoginName());
130

131
        return toAjax(userService.insertUser(user));
132
    }
133

134
    /**
135
     * 修改用户
136
     */
137
    @GetMapping("/edit/{userId}")
138
    public String edit(@PathVariable("userId") Long userId, ModelMap mmap) {
139
        userService.checkUserDataScope(userId);
140
        List<SysRole> roles = roleService.selectRolesByUserId(userId);
141
        mmap.put("user", userService.selectUserById(userId));
142
        mmap.put("roles", roles.stream().filter(r -> !r.isAdmin()).collect(Collectors.toList()));
143
        mmap.put("posts", postService.selectPostsByUserId(userId));
144
        return prefix + "/edit";
145
    }
146

147
    /**
148
     * 修改保存用户
149
     */
150
    @RequiresPermissions("system:user:edit")
151
    @Log(title = "用户管理", businessType = BusinessType.UPDATE)
152
    @PostMapping("/edit")
153
    @ResponseBody
154
    public AjaxResult editSave(@Validated SysUser user) {
155
        userService.checkUserAllowed(user);
156
        userService.checkUserDataScope(user.getUserId());
157

158
        if (StringUtils.isNotEmpty(user.getPhonenumber())
159
                && UserConstants.NOT_UNIQUE.equals(userService.checkPhoneUnique(user))) {
160
            return error("修改用户'" + user.getLoginName() + "'失败，手机号码已存在");
161
        }
162
        if (StringUtils.isNotEmpty(user.getEmail())
163
                && UserConstants.NOT_UNIQUE.equals(userService.checkEmailUnique(user))) {
164
            return error("修改用户'" + user.getLoginName() + "'失败，邮箱账号已存在");
165
        }
166

167
        user.setUpdateBy(getLoginName());
168
        AuthorizationUtils.clearAllCachedAuthorizationInfo();
169

170
        return toAjax(userService.updateUser(user));
171
    }
172

173
    /**
174
     * 重置密码
175
     */
176
    @GetMapping("/resetPwd/{userId}")
177
    public String resetPwd(@PathVariable("userId") Long userId, ModelMap mmap) {
178
        mmap.put("user", userService.selectUserById(userId));
179
        return prefix + "/resetPwd";
180
    }
181

182
    /**
183
     * 重置密码提交
184
     */
185
    @RequiresPermissions("system:user:resetPwd")
186
    @Log(title = "用户管理", businessType = BusinessType.UPDATE)
187
    @PostMapping("/resetPwd")
188
    @ResponseBody
189
    public AjaxResult resetPwdSave(SysUser user) {
190
        userService.checkUserAllowed(user);
191
        userService.checkUserDataScope(user.getUserId());
192
        user.setSalt(ShiroUtils.randomSalt());
193
        user.setPassword(passwordService.encryptPassword(user.getLoginName(),
194
                user.getPassword(), user.getSalt()));
195
        if (userService.resetUserPwd(user) > 0) {
196
            // 更新缓存中的密码
197
            ShiroUtils.setSysUser(userService.selectUserById(user.getUserId()));
198
            return success();
199
        }
200
        return error();
201
    }
202

203
    /**
204
     * 修改状态
205
     */
206
    @RequiresPermissions("system:user:edit")
207
    @Log(title = "用户管理", businessType = BusinessType.UPDATE)
208
    @PostMapping("/changeStatus")
209
    @ResponseBody
210
    public AjaxResult changeStatus(SysUser user) {
211
        userService.checkUserAllowed(user);
212
        userService.checkUserDataScope(user.getUserId());
213
        return toAjax(userService.updateUser(user));
214
    }
215

216
    /**
217
     * 删除用户
218
     */
219
    @RequiresPermissions("system:user:remove")
220
    @Log(title = "用户管理", businessType = BusinessType.DELETE)
221
    @PostMapping("/remove")
222
    @ResponseBody
223
    public AjaxResult remove(String ids) {
224
        return toAjax(userService.deleteUserByIds(ids));
225
    }
226

227
    /**
228
     * 校验登录名
229
     */
230
    @PostMapping("/checkLoginNameUnique")
231
    @ResponseBody
232
    public boolean checkLoginNameUnique(SysUser user) {
233
        return userService.checkLoginNameUnique(user.getLoginName())
234
                .equals(UserConstants.UNIQUE);
235
    }
236
}

密码加密机制#

加密流程#

1
用户输入密码
2
    ↓
3
生成随机盐值 (Salt)
4
    ↓
5
MD5(密码 + 盐值)
6
    ↓
7
迭代加密 2 次
8
    ↓
9
存入数据库

密码服务#

1
package com.ruoyi.framework.shiro.service;
2

3
import java.util.concurrent.atomic.AtomicInteger;
4
import javax.annotation.PostConstruct;
5
import org.apache.shiro.cache.Cache;
6
import org.apache.shiro.cache.CacheManager;
7
import org.apache.shiro.crypto.hash.Md5Hash;
8
import org.springframework.beans.factory.annotation.Autowired;
9
import org.springframework.beans.factory.annotation.Value;
10
import org.springframework.stereotype.Component;
11
import com.ruoyi.common.constant.Constants;
12
import com.ruoyi.common.constant.ShiroConstants;
13
import com.ruoyi.common.core.domain.entity.SysUser;
14
import com.ruoyi.common.utils.MessageUtils;
15
import com.ruoyi.common.utils.StringUtils;
16
import com.ruoyi.common.exception.user.*;
17

18
/**
19
 * 登录密码方法
20
 *
21
 * @author ruoyi
22
 */
23
@Component
24
public class PasswordService {
25
    @Autowired
26
    private CacheManager cacheManager;
27

28
    private Cache<String, AtomicInteger> loginRecordCache;
29

30
    @Value("${user.password.maxRetryCount}")
31
    private int maxRetryCount;
32

33
    @Value("${user.password.lockTime}")
34
    private int lockTime;
35

36
    @PostConstruct
37
    public void init() {
38
        loginRecordCache = cacheManager.getCache(ShiroConstants.LOGIN_RECORD_CACHE);
39
    }
40

41
    /**
42
     * 加密密码
43
     */
44
    public String encryptPassword(String loginName, String password, String salt) {
45
        return new Md5Hash(loginName + password, salt, 2).toString();
46
    }
47

48
    /**
49
     * 验证密码
50
     */
51
    public boolean matches(SysUser user, String newPassword) {
52
        String encryptedPassword = encryptPassword(user.getLoginName(),
53
                newPassword, user.getSalt());
54
        return user.getPassword().equals(encryptedPassword);
55
    }
56

57
    /**
58
     * 登录前检查
59
     */
60
    public SysUser loginPreCheck(String username, String password) {
61
        // 1. 检查用户是否存在
62
        SysUser user = userService.selectUserByLoginName(username);
63
        if (StringUtils.isNull(user)) {
64
            throw new UserNotExistsException();
65
        }
66

67
        // 2. 检查用户状态
68
        if (UserStatus.DELETED.getCode().equals(user.getDelFlag())) {
69
            throw new UserPasswordDeleteException();
70
        }
71
        if (UserStatus.DISABLE.getCode().equals(user.getStatus())) {
72
            throw new UserBlockedException();
73
        }
74

75
        // 3. 检查密码错误次数
76
        AtomicInteger retryCount = loginRecordCache.get(username);
77
        if (retryCount != null && retryCount.get() >= maxRetryCount) {
78
            throw new UserPasswordNotMatchException();
79
        }
80

81
        return user;
82
    }
83

84
    /**
85
     * 记录登录失败次数
86
     */
87
    public void recordLoginInfo(SysUser user) {
88
        String loginName = user.getLoginName();
89
        AtomicInteger retryCount = loginRecordCache.get(loginName);
90
        if (retryCount == null) {
91
            retryCount = new AtomicInteger(0);
92
        }
93
        retryCount.incrementAndGet();
94
        loginRecordCache.put(loginName, retryCount);
95
    }
96

97
    /**
98
     * 清除登录失败次数
99
     */
100
    public void clearLoginRecordCache(String loginName) {
101
        if (loginRecordCache.containsKey(loginName)) {
102
            loginRecordCache.remove(loginName);
103
        }
104
    }
105
}

用户状态管理#

状态枚举#

1
package com.ruoyi.common.enums;
2

3
/**
4
 * 用户状态
5
 *
6
 * @author ruoyi
7
 */
8
public enum UserStatus {
9
    OK("0", "正常"),
10
    DISABLE("1", "停用"),
11
    DELETED("2", "删除");
12

13
    private final String code;
14
    private final String info;
15

16
    UserStatus(String code, String info) {
17
        this.code = code;
18
        this.info = info;
19
    }
20

21
    public String getCode() {
22
        return code;
23
    }
24

25
    public String getInfo() {
26
        return info;
27
    }
28
}

状态流转#

1
正常 (0) ←→ 停用 (1)
2
    ↓
3
删除 (2)  [逻辑删除]

数据权限 (@DataScope)#

RuoYi 实现了灵活的数据权限控制：

1
package com.ruoyi.common.annotation;
2

3
import java.lang.annotation.*;
4

5
/**
6
 * 数据权限过滤注解
7
 *
8
 * @author ruoyi
9
 */
10
@Target(ElementType.METHOD)
11
@Retention(RetentionPolicy.RUNTIME)
12
@Documented
13
public @interface DataScope {
14
    /**
15
     * 部门表的别名
16
     */
17
    public String deptAlias() default "";
18

19
    /**
20
     * 用户表的别名
21
     */
22
    public String userAlias() default "";
23
}

数据权限类型#

类型	说明
全部数据权限	可以看到所有数据
自定义数据权限	只能看到指定部门的数据
本部门数据权限	只能看到本部门的数据
本部门及以下数据权限	可以看到本部门及下级部门的数据
仅本人数据权限	只能看到自己的数据

复习卡片#

1
// 用户管理核心流程
2
// 1. 新增用户
3
user.setSalt(ShiroUtils.randomSalt());
4
user.setPassword(passwordService.encryptPassword(...));
5
userService.insertUser(user);
6

7
// 2. 验证密码
8
passwordService.matches(user, inputPassword);
9

10
// 3. 数据权限
11
@DataScope(deptAlias = "d", userAlias = "u")
12
public List<SysUser> selectUserList(SysUser user);
13

14
// 4. 用户状态
15
// 0 = 正常
16
// 1 = 停用
17
// 2 = 删除（逻辑删除）
18

19
// 5. 密码加密
20
// MD5(loginName + password + salt) 迭代 2 次

类名	职责
`SysUser`	用户实体类
`ISysUserService`	用户服务接口
`SysUserServiceImpl`	用户服务实现
`SysUserController`	用户控制器
`PasswordService`	密码加密服务
`UserStatus`	用户状态枚举

TIP
下一步：阶段六：角色与菜单管理
在阶段六中，我们将深入理解 RBAC 权限模型，以及角色和菜单的关联关系。