RuoYi 阶段七：部门与岗位管理

NOTE
本文是 RuoYi 学习路线的阶段七，聚焦组织架构管理。学完本篇你应该能：

理解部门树的递归构建方法

掌握岗位与用户的关联关系

知道数据权限在部门中的应用

前端视角：组织架构像什么？#

RuoYi 组织架构	前端类比
`SysDept` 部门	组织树组件 (TreeSelect)
`SysPost` 岗位	职位标签 / 角色配置
部门树	级联选择器 (Cascader)
用户关联部门	用户信息中的部门字段
数据权限	根据部门过滤数据

组织架构关系#

1
        ┌─────────┐
2
        │  部门   │
3
        └────┬────┘
4
             │
5
    ┌────────┼────────┐
6
    │        │        │
7
┌───▼───┐ ┌─▼───┐ ┌─▼───┐
8
│ 岗位  │ │ 用户 │ │子部门│
9
└───────┘ └─────┘ └─────┘

部门实体类 (SysDept)#

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

3
import javax.validation.constraints.*;
4
import org.apache.commons.lang3.builder.ToStringBuilder;
5
import org.apache.commons.lang3.builder.ToStringStyle;
6
import com.ruoyi.common.core.domain.BaseEntity;
7

8
/**
9
 * 部门表 sys_dept
10
 *
11
 * @author ruoyi
12
 */
13
public class SysDept extends BaseEntity {
14
    private static final long serialVersionUID = 1L;
15

16
    /** 部门ID */
17
    private Long deptId;
18

19
    /** 父部门ID */
20
    private Long parentId;
21

22
    /** 祖级列表 */
23
    private String ancestors;
24

25
    /** 部门名称 */
26
    private String deptName;
27

28
    /** 显示顺序 */
29
    private Integer orderNum;
30

31
    /** 负责人 */
32
    private String leader;
33

34
    /** 联系电话 */
35
    private String phone;
36

37
    /** 邮箱 */
38
    private String email;
39

40
    /** 部门状态（0正常 1停用） */
41
    private String status;
42

43
    /** 删除标志（0代表存在 2代表删除） */
44
    private String delFlag;
45

46
    /** 父部门名称 */
47
    private String parentName;
48

49
    public Long getDeptId() {
50
        return deptId;
51
    }
52

53
    public void setDeptId(Long deptId) {
54
        this.deptId = deptId;
55
    }
56

57
    public Long getParentId() {
58
        return parentId;
59
    }
60

61
    public void setParentId(Long parentId) {
62
        this.parentId = parentId;
63
    }
64

65
    public String getAncestors() {
66
        return ancestors;
67
    }
68

69
    public void setAncestors(String ancestors) {
70
        this.ancestors = ancestors;
71
    }
72

73
    @NotBlank(message = "部门名称不能为空")
74
    @Size(min = 0, max = 30, message = "部门名称长度不能超过30个字符")
75
    public String getDeptName() {
76
        return deptName;
77
    }
78

79
    public void setDeptName(String deptName) {
80
        this.deptName = deptName;
81
    }
82

83
    @NotNull(message = "显示顺序不能为空")
84
    public Integer getOrderNum() {
85
        return orderNum;
86
    }
87

88
    public void setOrderNum(Integer orderNum) {
89
        this.orderNum = orderNum;
90
    }
91

92
    public String getLeader() {
93
        return leader;
94
    }
95

96
    public void setLeader(String leader) {
97
        this.leader = leader;
98
    }
99

100
    @Size(min = 0, max = 11, message = "联系电话长度不能超过11个字符")
101
    public String getPhone() {
102
        return phone;
103
    }
104

105
    public void setPhone(String phone) {
106
        this.phone = phone;
107
    }
108

109
    @Email(message = "邮箱格式不正确")
110
    @Size(min = 0, max = 50, message = "邮箱长度不能超过50个字符")
111
    public String getEmail() {
112
        return email;
113
    }
114

115
    public void setEmail(String email) {
116
        this.email = email;
117
    }
118

119
    public String getStatus() {
120
        return status;
121
    }
122

123
    public void setStatus(String status) {
124
        this.status = status;
125
    }
126

127
    public String getDelFlag() {
128
        return delFlag;
129
    }
130

131
    public void setDelFlag(String delFlag) {
132
        this.delFlag = delFlag;
133
    }
134

135
    public String getParentName() {
136
        return parentName;
137
    }
138

139
    public void setParentName(String parentName) {
140
        this.parentName = parentName;
141
    }
142

143
    @Override
144
    public String toString() {
145
        return new ToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE)
146
            .append("deptId", getDeptId())
147
            .append("parentId", getParentId())
148
            .append("deptName", getDeptName())
149
            .append("orderNum", getOrderNum())
150
            .append("leader", getLeader())
151
            .append("phone", getPhone())
152
            .append("email", getEmail())
153
            .append("status", getStatus())
154
            .append("delFlag", getDelFlag())
155
            .append("createBy", getCreateBy())
156
            .append("createTime", getCreateTime())
157
            .append("updateBy", getUpdateBy())
158
            .append("updateTime", getUpdateTime())
159
            .toString();
160
    }
161
}

祖级列表 (Ancestors)#

ancestors 字段用于快速查询某个部门的所有下级部门：

1
部门层级：总公司 → 研发中心 → 前端组
2
ancestors：0,100,101
3

4
含义：该部门的所有父级ID，用逗号分隔

查询所有下级部门#

1
-- 查询研发中心（dept_id=101）的所有下级部门
2
SELECT * FROM sys_dept
3
WHERE find_in_set(101, ancestors)

岗位实体类 (SysPost)#

1
package com.ruoyi.system.domain;
2

3
import javax.validation.constraints.*;
4
import org.apache.commons.lang3.builder.ToStringBuilder;
5
import org.apache.commons.lang3.builder.ToStringStyle;
6
import com.ruoyi.common.annotation.Excel;
7
import com.ruoyi.common.annotation.Excel.ColumnType;
8
import com.ruoyi.common.core.domain.BaseEntity;
9

10
/**
11
 * 岗位表 sys_post
12
 *
13
 * @author ruoyi
14
 */
15
public class SysPost extends BaseEntity {
16
    private static final long serialVersionUID = 1L;
17

18
    /** 岗位序号 */
19
    @Excel(name = "岗位序号", cellType = ColumnType.NUMERIC)
20
    private Long postId;
21

22
    /** 岗位编码 */
23
    @Excel(name = "岗位编码")
24
    private String postCode;
25

26
    /** 岗位名称 */
27
    @Excel(name = "岗位名称")
28
    private String postName;
29

30
    /** 岗位排序 */
31
    @Excel(name = "岗位排序", cellType = ColumnType.NUMERIC)
32
    private Integer postSort;
33

34
    /** 状态（0正常 1停用） */
35
    @Excel(name = "状态", readConverterExp = "0=正常,1=停用")
36
    private String status;
37

38
    /** 用户是否存在此岗位标识 */
39
    private boolean flag = false;
40

41
    public Long getPostId() {
42
        return postId;
43
    }
44

45
    public void setPostId(Long postId) {
46
        this.postId = postId;
47
    }
48

49
    @NotBlank(message = "岗位编码不能为空")
50
    @Size(min = 0, max = 64, message = "岗位编码长度不能超过64个字符")
51
    public String getPostCode() {
52
        return postCode;
53
    }
54

55
    public void setPostCode(String postCode) {
56
        this.postCode = postCode;
57
    }
58

59
    @NotBlank(message = "岗位名称不能为空")
60
    @Size(min = 0, max = 50, message = "岗位名称长度不能超过50个字符")
61
    public String getPostName() {
62
        return postName;
63
    }
64

65
    public void setPostName(String postName) {
66
        this.postName = postName;
67
    }
68

69
    @NotNull(message = "显示顺序不能为空")
70
    public Integer getPostSort() {
71
        return postSort;
72
    }
73

74
    public void setPostSort(Integer postSort) {
75
        this.postSort = postSort;
76
    }
77

78
    public String getStatus() {
79
        return status;
80
    }
81

82
    public void setStatus(String status) {
83
        this.status = status;
84
    }
85

86
    public boolean isFlag() {
87
        return flag;
88
    }
89

90
    public void setFlag(boolean flag) {
91
        this.flag = flag;
92
    }
93

94
    @Override
95
    public String toString() {
96
        return new ToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE)
97
            .append("postId", getPostId())
98
            .append("postCode", getPostCode())
99
            .append("postName", getPostName())
100
            .append("postSort", getPostSort())
101
            .append("status", getStatus())
102
            .append("createBy", getCreateBy())
103
            .append("createTime", getCreateTime())
104
            .append("updateBy", getUpdateBy())
105
            .append("updateTime", getUpdateTime())
106
            .append("remark", getRemark())
107
            .toString();
108
    }
109
}

数据库表结构#

部门表#

1
CREATE TABLE sys_dept (
2
  dept_id           BIGINT(20)      NOT NULL AUTO_INCREMENT    COMMENT '部门id',
3
  parent_id         BIGINT(20)      DEFAULT 0                  COMMENT '父部门id',
4
  ancestors         VARCHAR(50)     DEFAULT ''                 COMMENT '祖级列表',
5
  dept_name         VARCHAR(30)     DEFAULT ''                 COMMENT '部门名称',
6
  order_num         INT(4)          DEFAULT 0                  COMMENT '显示顺序',
7
  leader            VARCHAR(20)     DEFAULT NULL               COMMENT '负责人',
8
  phone             VARCHAR(11)     DEFAULT NULL               COMMENT '联系电话',
9
  email             VARCHAR(50)     DEFAULT NULL               COMMENT '邮箱',
10
  status            CHAR(1)         DEFAULT '0'                COMMENT '部门状态（0正常 1停用）',
11
  del_flag          CHAR(1)         DEFAULT '0'                COMMENT '删除标志',
12
  create_by         VARCHAR(64)     DEFAULT ''                 COMMENT '创建者',
13
  create_time       DATETIME                                   COMMENT '创建时间',
14
  update_by         VARCHAR(64)     DEFAULT ''                 COMMENT '更新者',
15
  update_time       DATETIME                                   COMMENT '更新时间',
16
  PRIMARY KEY (dept_id)
17
) ENGINE=InnoDB AUTO_INCREMENT=200 COMMENT = '部门表';

岗位表#

1
CREATE TABLE sys_post (
2
  post_id           BIGINT(20)      NOT NULL AUTO_INCREMENT    COMMENT '岗位ID',
3
  post_code         VARCHAR(64)     NOT NULL                   COMMENT '岗位编码',
4
  post_name         VARCHAR(50)     NOT NULL                   COMMENT '岗位名称',
5
  post_sort         INT(4)          NOT NULL                   COMMENT '显示顺序',
6
  status            CHAR(1)         NOT NULL                   COMMENT '状态（0正常 1停用）',
7
  create_by         VARCHAR(64)     DEFAULT ''                 COMMENT '创建者',
8
  create_time       DATETIME                                   COMMENT '创建时间',
9
  update_by         VARCHAR(64)     DEFAULT ''                 COMMENT '更新者',
10
  update_time       DATETIME                                   COMMENT '更新时间',
11
  remark            VARCHAR(500)    DEFAULT NULL               COMMENT '备注',
12
  PRIMARY KEY (post_id)
13
) ENGINE=InnoDB AUTO_INCREMENT=10 COMMENT = '岗位信息表';

用户岗位关联表#

1
CREATE TABLE sys_user_post (
2
  user_id           BIGINT(20) NOT NULL COMMENT '用户ID',
3
  post_id           BIGINT(20) NOT NULL COMMENT '岗位ID',
4
  PRIMARY KEY(user_id, post_id)
5
) ENGINE=InnoDB COMMENT = '用户与岗位关联表';

Service 层实现#

部门 Service 接口#

1
package com.ruoyi.system.service;
2

3
import java.util.List;
4
import com.ruoyi.common.core.domain.Ztree;
5
import com.ruoyi.common.core.domain.entity.SysDept;
6
import com.ruoyi.common.core.domain.entity.SysRole;
7

8
/**
9
 * 部门管理 服务层
10
 *
11
 * @author ruoyi
12
 */
13
public interface ISysDeptService {
14
    /**
15
     * 查询部门管理数据
16
     */
17
    public List<SysDept> selectDeptList(SysDept dept);
18

19
    /**
20
     * 查询部门管理树
21
     */
22
    public List<Ztree> selectDeptTree(SysDept dept);
23

24
    /**
25
     * 根据角色ID查询部门树
26
     */
27
    public List<Ztree> roleDeptTreeData(Long roleId);
28

29
    /**
30
     * 根据部门ID查询信息
31
     */
32
    public SysDept selectDeptById(Long deptId);
33

34
    /**
35
     * 根据ID查询所有子部门
36
     */
37
    public int selectDeptCount(Long deptId);
38

39
    /**
40
     * 是否存在子节点
41
     */
42
    public boolean hasChildByDeptId(Long deptId);
43

44
    /**
45
     * 查询部门是否存在用户
46
     */
47
    public boolean checkDeptExistUser(Long deptId);
48

49
    /**
50
     * 删除部门管理信息
51
     */
52
    public int deleteDeptById(Long deptId);
53

54
    /**
55
     * 新增保存部门信息
56
     */
57
    public int insertDept(SysDept dept);
58

59
    /**
60
     * 修改保存部门信息
61
     */
62
    public int updateDept(SysDept dept);
63

64
    /**
65
     * 校验部门名称是否唯一
66
     */
67
    public String checkDeptNameUnique(SysDept dept);
68

69
    /**
70
     * 根据部门ID查询角色数据权限
71
     */
72
    public List<Long> selectRoleDeptIds(Long roleId);
73
}

部门 Service 实现#

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

3
import java.util.ArrayList;
4
import java.util.Iterator;
5
import java.util.List;
6
import org.apache.commons.lang3.ArrayUtils;
7
import org.springframework.beans.factory.annotation.Autowired;
8
import org.springframework.stereotype.Service;
9
import org.springframework.transaction.annotation.Transactional;
10
import com.ruoyi.common.annotation.DataScope;
11
import com.ruoyi.common.constant.UserConstants;
12
import com.ruoyi.common.core.domain.Ztree;
13
import com.ruoyi.common.core.domain.entity.SysDept;
14
import com.ruoyi.common.core.domain.entity.SysRole;
15
import com.ruoyi.common.exception.ServiceException;
16
import com.ruoyi.common.utils.StringUtils;
17
import com.ruoyi.system.mapper.SysDeptMapper;
18
import com.ruoyi.system.mapper.SysRoleMapper;
19
import com.ruoyi.system.service.ISysDeptService;
20

21
/**
22
 * 部门管理 服务实现
23
 *
24
 * @author ruoyi
25
 */
26
@Service
27
public class SysDeptServiceImpl implements ISysDeptService {
28
    @Autowired
29
    private SysDeptMapper deptMapper;
30

31
    @Autowired
32
    private SysRoleMapper roleMapper;
33

34
    /**
35
     * 查询部门管理数据
36
     */
37
    @Override
38
    @DataScope(deptAlias = "d")
39
    public List<SysDept> selectDeptList(SysDept dept) {
40
        return deptMapper.selectDeptList(dept);
41
    }
42

43
    /**
44
     * 查询部门管理树
45
     */
46
    @Override
47
    public List<Ztree> selectDeptTree(SysDept dept) {
48
        List<SysDept> deptList = deptMapper.selectDeptList(dept);
49
        List<Ztree> ztrees = initZtree(deptList);
50
        return ztrees;
51
    }
52

53
    /**
54
     * 构建前端需要的树结构
55
     */
56
    public List<Ztree> initZtree(List<SysDept> depts) {
57
        List<Ztree> ztrees = new ArrayList<Ztree>();
58
        boolean isCheck = StringUtils.isNotNull(depts) && depts.size() > 0;
59
        for (SysDept dept : depts) {
60
            Ztree ztree = new Ztree();
61
            ztree.setId(dept.getDeptId());
62
            ztree.setpId(dept.getParentId());
63
            ztree.setName(dept.getDeptName());
64
            ztree.setTitle(dept.getDeptName());
65
            ztree.setChecked(isCheck && dept.isChecked());
66
            ztrees.add(ztree);
67
        }
68
        return ztrees;
69
    }
70

71
    /**
72
     * 根据角色ID查询部门树
73
     */
74
    @Override
75
    public List<Ztree> roleDeptTreeData(Long roleId) {
76
        List<SysDept> deptList = selectDeptList(new SysDept());
77
        SysRole role = roleMapper.selectRoleById(roleId);
78
        List<Ztree> ztrees = new ArrayList<Ztree>();
79
        for (SysDept dept : deptList) {
80
            Ztree ztree = new Ztree();
81
            ztree.setId(dept.getDeptId());
82
            ztree.setpId(dept.getParentId());
83
            ztree.setName(dept.getDeptName());
84
            ztree.setTitle(dept.getDeptName());
85
            // 判断角色是否拥有该部门权限
86
            if (StringUtils.isNotNull(role.getDeptIds())
87
                    && ArrayUtils.contains(role.getDeptIds(), dept.getDeptId())) {
88
                ztree.setChecked(true);
89
            }
90
            ztrees.add(ztree);
91
        }
92
        return ztrees;
93
    }
94

95
    /**
96
     * 新增保存部门信息
97
     */
98
    @Override
99
    public int insertDept(SysDept dept) {
100
        SysDept info = deptMapper.selectDeptById(dept.getParentId());
101
        // 如果父节点不为"正常"状态,则不允许新增子节点
102
        if (!UserConstants.DEPT_NORMAL.equals(info.getStatus())) {
103
            throw new ServiceException("部门停用，不允许新增");
104
        }
105
        dept.setAncestors(info.getAncestors() + "," + dept.getParentId());
106
        return deptMapper.insertDept(dept);
107
    }
108

109
    /**
110
     * 修改保存部门信息
111
     */
112
    @Override
113
    public int updateDept(SysDept dept) {
114
        SysDept newParentDept = deptMapper.selectDeptById(dept.getParentId());
115
        SysDept oldDept = selectDeptById(dept.getDeptId());
116
        if (StringUtils.isNotNull(newParentDept) && StringUtils.isNotNull(oldDept)) {
117
            String newAncestors = newParentDept.getAncestors() + "," + newParentDept.getDeptId();
118
            String oldAncestors = oldDept.getAncestors();
119
            dept.setAncestors(newAncestors);
120
            updateDeptChildren(dept.getDeptId(), newAncestors, oldAncestors);
121
        }
122
        int result = deptMapper.updateDept(dept);
123
        if (UserConstants.DEPT_NORMAL.equals(dept.getStatus())
124
                && StringUtils.isNotEmpty(dept.getAncestors())
125
                && !StringUtils.equals("0", dept.getAncestors())) {
126
            // 如果该部门是启用状态，则启用该部门的上级部门
127
            updateParentDeptStatusNormal(dept);
128
        }
129
        return result;
130
    }
131

132
    /**
133
     * 修改该部门的父级部门状态
134
     */
135
    private void updateParentDeptStatusNormal(SysDept dept) {
136
        String ancestors = dept.getAncestors();
137
        Long[] deptIds = Convert.toLongArray(ancestors);
138
        deptMapper.updateDeptStatusNormal(deptIds);
139
    }
140

141
    /**
142
     * 修改子元素关系
143
     */
144
    private void updateDeptChildren(Long deptId, String newAncestors, String oldAncestors) {
145
        List<SysDept> children = deptMapper.selectChildrenDeptById(deptId);
146
        for (SysDept child : children) {
147
            child.setAncestors(child.getAncestors().replaceFirst(oldAncestors, newAncestors));
148
        }
149
        if (children.size() > 0) {
150
            deptMapper.updateDeptChildren(children);
151
        }
152
    }
153

154
    /**
155
     * 删除部门管理信息
156
     */
157
    @Override
158
    public int deleteDeptById(Long deptId) {
159
        return deptMapper.deleteDeptById(deptId);
160
    }
161

162
    /**
163
     * 校验部门名称是否唯一
164
     */
165
    @Override
166
    public String checkDeptNameUnique(SysDept dept) {
167
        Long deptId = StringUtils.isNull(dept.getDeptId()) ? -1L : dept.getDeptId();
168
        SysDept info = deptMapper.checkDeptNameUnique(dept.getDeptName(), dept.getParentId());
169
        if (StringUtils.isNotNull(info) && info.getDeptId().longValue() != deptId.longValue()) {
170
            return UserConstants.NOT_UNIQUE;
171
        }
172
        return UserConstants.UNIQUE;
173
    }
174

175
    /**
176
     * 是否存在子节点
177
     */
178
    @Override
179
    public boolean hasChildByDeptId(Long deptId) {
180
        int result = deptMapper.hasChildByDeptId(deptId);
181
        return result > 0;
182
    }
183

184
    /**
185
     * 查询部门是否存在用户
186
     */
187
    @Override
188
    public boolean checkDeptExistUser(Long deptId) {
189
        int result = deptMapper.checkDeptExistUser(deptId);
190
        return result > 0;
191
    }
192
}

岗位 Service 实现#

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

3
import java.util.List;
4
import org.springframework.beans.factory.annotation.Autowired;
5
import org.springframework.stereotype.Service;
6
import com.ruoyi.common.constant.UserConstants;
7
import com.ruoyi.common.core.text.Convert;
8
import com.ruoyi.common.exception.ServiceException;
9
import com.ruoyi.common.utils.StringUtils;
10
import com.ruoyi.system.domain.SysPost;
11
import com.ruoyi.system.mapper.SysPostMapper;
12
import com.ruoyi.system.mapper.SysUserPostMapper;
13
import com.ruoyi.system.service.ISysPostService;
14

15
/**
16
 * 岗位信息 服务层实现
17
 *
18
 * @author ruoyi
19
 */
20
@Service
21
public class SysPostServiceImpl implements ISysPostService {
22
    @Autowired
23
    private SysPostMapper postMapper;
24

25
    @Autowired
26
    private SysUserPostMapper userPostMapper;
27

28
    /**
29
     * 查询岗位信息集合
30
     */
31
    @Override
32
    public List<SysPost> selectPostList(SysPost post) {
33
        return postMapper.selectPostList(post);
34
    }
35

36
    /**
37
     * 查询所有岗位
38
     */
39
    @Override
40
    public List<SysPost> selectPostAll() {
41
        return postMapper.selectPostAll();
42
    }
43

44
    /**
45
     * 根据用户ID查询岗位
46
     */
47
    @Override
48
    public List<SysPost> selectPostsByUserId(Long userId) {
49
        List<SysPost> userPosts = postMapper.selectPostsByUserId(userId);
50
        List<SysPost> posts = postMapper.selectPostAll();
51
        for (SysPost post : posts) {
52
            for (SysPost userPost : userPosts) {
53
                if (post.getPostId().longValue() == userPost.getPostId().longValue()) {
54
                    post.setFlag(true);
55
                    break;
56
                }
57
            }
58
        }
59
        return posts;
60
    }
61

62
    /**
63
     * 新增保存岗位信息
64
     */
65
    @Override
66
    public int insertPost(SysPost post) {
67
        return postMapper.insertPost(post);
68
    }
69

70
    /**
71
     * 修改保存岗位信息
72
     */
73
    @Override
74
    public int updatePost(SysPost post) {
75
        return postMapper.updatePost(post);
76
    }
77

78
    /**
79
     * 批量删除岗位信息
80
     */
81
    @Override
82
    public int deletePostByIds(String ids) {
83
        Long[] postIds = Convert.toLongArray(ids);
84
        for (Long postId : postIds) {
85
            SysPost post = selectPostById(postId);
86
            if (countUserPostById(postId) > 0) {
87
                throw new ServiceException(String.format("%1$s已分配,不能删除", post.getPostName()));
88
            }
89
        }
90
        return postMapper.deletePostByIds(postIds);
91
    }
92

93
    /**
94
     * 查询岗位绑定用户数
95
     */
96
    public int countUserPostById(Long postId) {
97
        return userPostMapper.countUserPostById(postId);
98
    }
99

100
    /**
101
     * 校验岗位名称是否唯一
102
     */
103
    @Override
104
    public String checkPostNameUnique(SysPost post) {
105
        Long postId = StringUtils.isNull(post.getPostId()) ? -1L : post.getPostId();
106
        SysPost info = postMapper.checkPostNameUnique(post.getPostName());
107
        if (StringUtils.isNotNull(info) && info.getPostId().longValue() != postId.longValue()) {
108
            return UserConstants.NOT_UNIQUE;
109
        }
110
        return UserConstants.UNIQUE;
111
    }
112

113
    /**
114
     * 校验岗位编码是否唯一
115
     */
116
    @Override
117
    public String checkPostCodeUnique(SysPost post) {
118
        Long postId = StringUtils.isNull(post.getPostId()) ? -1L : post.getPostId();
119
        SysPost info = postMapper.checkPostCodeUnique(post.getPostCode());
120
        if (StringUtils.isNotNull(info) && info.getPostId().longValue() != postId.longValue()) {
121
            return UserConstants.NOT_UNIQUE;
122
        }
123
        return UserConstants.UNIQUE;
124
    }
125
}

数据权限实现#

@DataScope 注解处理#

1
package com.ruoyi.framework.aspectj;
2

3
import org.aspectj.lang.JoinPoint;
4
import org.aspectj.lang.annotation.Aspect;
5
import org.aspectj.lang.annotation.Before;
6
import org.springframework.stereotype.Component;
7
import com.ruoyi.common.annotation.DataScope;
8
import com.ruoyi.common.constant.UserConstants;
9
import com.ruoyi.common.core.domain.BaseEntity;
10
import com.ruoyi.common.core.domain.entity.SysRole;
11
import com.ruoyi.common.core.domain.entity.SysUser;
12
import com.ruoyi.common.utils.ShiroUtils;
13
import com.ruoyi.common.utils.StringUtils;
14

15
/**
16
 * 数据过滤处理
17
 *
18
 * @author ruoyi
19
 */
20
@Aspect
21
@Component
22
public class DataScopeAspect {
23
    /**
24
     * 全部数据权限
25
     */
26
    public static final String DATA_SCOPE_ALL = "1";
27

28
    /**
29
     * 自定义数据权限
30
     */
31
    public static final String DATA_SCOPE_CUSTOM = "2";
32

33
    /**
34
     * 部门数据权限
35
     */
36
    public static final String DATA_SCOPE_DEPT = "3";
37

38
    /**
39
     * 部门及以下数据权限
40
     */
41
    public static final String DATA_SCOPE_DEPT_AND_CHILD = "4";
42

43
    /**
44
     * 仅本人数据权限
45
     */
46
    public static final String DATA_SCOPE_SELF = "5";
47

48
    @Before("@annotation(dataScope)")
49
    public void doBefore(JoinPoint point, DataScope dataScope) {
50
        handleDataScope(point, dataScope);
51
    }
52

53
    protected void handleDataScope(JoinPoint joinPoint, DataScope dataScope) {
54
        // 获取当前的用户
55
        SysUser currentUser = ShiroUtils.getSysUser();
56
        if (StringUtils.isNotNull(currentUser)) {
57
            // 如果是超级管理员，则不过滤数据
58
            if (!currentUser.isAdmin()) {
59
                filterDataScope(joinPoint, currentUser, dataScope);
60
            }
61
        }
62
    }
63

64
    /**
65
     * 数据范围过滤
66
     */
67
    private void filterDataScope(JoinPoint joinPoint, SysUser user, DataScope dataScope) {
68
        StringBuilder sqlString = new StringBuilder();
69
        List<SysRole> roles = user.getRoles();
70
        for (SysRole role : roles) {
71
            String scopeType = role.getDataScope();
72
            if (DATA_SCOPE_ALL.equals(scopeType)) {
73
                sqlString = new StringBuilder();
74
                break;
75
            } else if (DATA_SCOPE_CUSTOM.equals(scopeType)) {
76
                sqlString.append(StringUtils.format(
77
                    " OR {}.dept_id IN ( SELECT dept_id FROM sys_role_dept WHERE role_id = {} )",
78
                    dataScope.deptAlias(), role.getRoleId()));
79
            } else if (DATA_SCOPE_DEPT.equals(scopeType)) {
80
                sqlString.append(StringUtils.format(
81
                    " OR {}.dept_id = {}", dataScope.deptAlias(), user.getDeptId()));
82
            } else if (DATA_SCOPE_DEPT_AND_CHILD.equals(scopeType)) {
83
                String deptChild = user.getDeptId() + "";
84
                sqlString.append(StringUtils.format(
85
                    " OR {}.dept_id IN ( SELECT dept_id FROM sys_dept WHERE dept_id = {} or find_in_set( {} , ancestors ) )",
86
                    dataScope.deptAlias(), user.getDeptId(), deptChild));
87
            } else if (DATA_SCOPE_SELF.equals(scopeType)) {
88
                sqlString.append(StringUtils.format(
89
                    " OR {}.user_id = {}", dataScope.userAlias(), user.getUserId()));
90
            }
91
        }
92
        if (StringUtils.isEmpty(sqlString.toString())) {
93
            sqlString = new StringBuilder(StringUtils.format(" OR {}.user_id = {}",
94
                    dataScope.userAlias(), user.getUserId()));
95
        }
96
        // 将sql拼接到BaseEntity的params中
97
        BaseEntity baseEntity = (BaseEntity) joinPoint.getArgs()[0];
98
        baseEntity.getParams().put("dataScope", sqlString.toString());
99
    }
100
}

复习卡片#

1
// 部门管理核心流程
2
// 1. 新增部门
3
dept.setAncestors(parentDept.getAncestors() + "," + parentId);
4
deptMapper.insertDept(dept);
5

6
// 2. 修改部门（更新子部门的 ancestors）
7
updateDeptChildren(deptId, newAncestors, oldAncestors);
8

9
// 3. 查询所有下级部门
10
SELECT * FROM sys_dept WHERE find_in_set(101, ancestors);
11

12
// 4. 数据权限过滤
13
@DataScope(deptAlias = "d")
14
public List<SysDept> selectDeptList(SysDept dept);
15

16
// 5. 岗位关联用户
17
List<SysPost> posts = postService.selectPostsByUserId(userId);

类名	职责
`SysDept`	部门实体类
`SysPost`	岗位实体类
`SysUserPost`	用户岗位关联
`ISysDeptService`	部门服务接口
`ISysPostService`	岗位服务接口
`DataScopeAspect`	数据权限切面
`Ztree`	树形结构数据

数据权限类型	值	说明
全部数据	1	超级管理员
自定义数据	2	指定部门
本部门数据	3	当前部门
本部门及以下	4	当前部门及子部门
仅本人数据	5	只能看自己的

TIP
下一步：阶段八：字典与参数管理
在阶段八中，我们将学习系统配置管理，包括数据字典和参数配置。