yudaocode/ruoyi-vue-pro 系统功能模块详解

文章详细解析了ruoyi-vue-pro系统的核心功能模块，包括用户管理与权限控制、角色与菜单管理、部门与岗位管理以及租户管理与SaaS支持。系统通过Spring Security和自定义注解实现细粒度权限控制，支持多租户数据隔离，并提供灵活的角色、菜单、部门及岗位管理功能，满足企业级应用的需求。

用户管理与权限控制

在 yudaocode/ruoyi-vue-pro 系统中，用户管理与权限控制是核心功能之一，涵盖了用户信息管理、角色分配、权限校验等多个方面。通过 Spring Security 和自定义注解 @PreAuthorize，系统实现了细粒度的权限控制，确保用户只能访问其权限范围内的资源。

用户管理

用户管理模块主要包括用户信息的增删改查、角色分配等功能。以下是核心类及其功能：

1. AdminUserDO
   用户实体类，继承自 TenantBaseDO，支持多租户隔离。主要字段包括：

   • username：用户名
   • password：加密后的密码
   • nickname：用户昵称
   • deptId：所属部门ID

2. AdminUserServiceImpl
   用户服务实现类，提供用户管理的核心逻辑，包括：

   • 用户创建与更新
   • 密码加密与校验
   • 角色分配与权限校验

3. UserController
   用户管理接口，提供 RESTful API，如：

   • /admin/system/user/create：创建用户
   • /admin/system/user/update：更新用户信息
   • /admin/system/user/delete：删除用户

权限控制

权限控制通过 @PreAuthorize 注解实现，结合 Spring Security 的权限表达式，动态校验用户权限。以下是权限控制的核心实现：

1. MenuDO
   菜单实体类，定义了权限标识（permission 字段），用于与 @PreAuthorize 注解配合使用。例如：

   @PreAuthorize("@ss.hasPermission('system:user:create')")
   

2. 权限表达式
   系统通过 @ss.hasPermission 方法动态校验用户权限。例如：

   @PreAuthorize("@ss.hasPermission('system:mail-template:create')")
   public void createMailTemplate(...) {
       // 业务逻辑
   }
   

3. 权限校验流程

   • 用户登录后，系统加载其角色和权限。
   • 访问接口时，@PreAuthorize 注解触发权限校验。
   • 校验通过后，执行接口逻辑；否则返回 403 错误。

多租户支持

系统通过 TenantBaseDO 实现多租户隔离，确保用户数据按租户隔离。核心类包括：

• TenantDO：租户实体类。
• TenantServiceImpl：租户服务实现类，提供租户创建、更新、删除等功能。

示例代码

以下是一个用户创建接口的示例代码：

@RestController
@RequestMapping("/admin/system/user")
public class UserController {

    @PostMapping("/create")
    @PreAuthorize("@ss.hasPermission('system:user:create')")
    public CommonResult<Long> createUser(@Valid @RequestBody UserCreateReqVO reqVO) {
        Long userId = userService.createUser(reqVO);
        return success(userId);
    }
}

流程图

sequenceDiagram
    participant User
    participant Controller
    participant Service
    participant Security

    User->>Controller: 请求创建用户
    Controller->>Security: 校验权限
    Security-->>Controller: 权限校验结果
    alt 权限通过
        Controller->>Service: 调用创建逻辑
        Service-->>Controller: 返回用户ID
        Controller-->>User: 返回成功
    else 权限不足
        Controller-->>User: 返回403错误
    end

通过以上设计，yudaocode/ruoyi-vue-pro 系统实现了灵活、安全的用户管理与权限控制功能，满足企业级应用的需求。

角色与菜单管理

在 yudaocode/ruoyi-vue-pro 系统中，角色与菜单管理是权限控制的核心模块之一。通过角色与菜单的关联，系统能够灵活地控制不同角色的用户访问权限。以下将详细介绍角色与菜单的设计与实现。

角色管理

角色数据结构

角色信息存储在 RoleDO 类中，主要字段包括：

• id：角色唯一标识。
• name：角色名称。
• code：角色编码（如 admin）。
• type：角色类型（系统角色或自定义角色）。
• status：角色状态（启用/禁用）。
• dataScope：数据权限范围（如全部数据、本部门数据等）。

@TableName(value = "system_role", autoResultMap = true)
public class RoleDO {
    private Long id;
    private String name;
    private String code;
    private Integer type;
    private Integer status;
    private Integer dataScope;
    private Set<Long> dataScopeDeptIds;
}

角色操作

角色管理的主要操作包括：

1. 创建角色
   通过 RoleServiceImpl.createRole 方法实现，支持校验角色名称和编码的唯一性。
2. 更新角色
   通过 RoleServiceImpl.updateRole 方法实现，支持更新角色信息和数据权限范围。
3. 删除角色
   通过 RoleServiceImpl.deleteRole 方法实现，删除角色时会同步清理相关权限数据。

sequenceDiagram
    participant User
    participant RoleService
    participant RoleMapper
    User->>RoleService: 创建角色请求
    RoleService->>RoleMapper: 插入角色数据
    RoleMapper-->>RoleService: 返回角色ID
    RoleService-->>User: 返回创建结果

角色缓存

角色信息通过 Redis 缓存，缓存的 Key 格式为 role:{id}，以提高查询性能。

@Cacheable(value = RedisKeyConstants.ROLE, key = "#id", unless = "#result == null")
public RoleDO getRoleFromCache(Long id) {
    return roleMapper.selectById(id);
}

菜单管理

菜单数据结构

菜单信息存储在 MenuDO 类中，主要字段包括：

• id：菜单唯一标识。
• parentId：父菜单ID。
• name：菜单名称。
• path：路由地址。
• component：组件路径。
• visible：是否可见。

@TableName("system_menu")
public class MenuDO {
    private Long id;
    private Long parentId;
    private String name;
    private String path;
    private String component;
    private Boolean visible;
}

菜单操作

菜单管理的主要操作包括：

1. 查询菜单列表
   通过 MenuMapper.selectList 方法实现，支持按条件筛选。
2. 关联角色与菜单
   通过 RoleMenuMapper 实现角色与菜单的多对多关联。

classDiagram
    class RoleDO {
        +Long id
        +String name
        +String code
    }
    class MenuDO {
        +Long id
        +String name
        +String path
    }
    class RoleMenuDO {
        +Long roleId
        +Long menuId
    }
    RoleDO "1" -- "*" RoleMenuDO
    MenuDO "1" -- "*" RoleMenuDO

菜单缓存

菜单信息通过 Redis 缓存，缓存的 Key 格式为 menu:{id}，以提高查询性能。

@Cacheable(value = RedisKeyConstants.MENU, key = "#id", unless = "#result == null")
public MenuDO getMenuFromCache(Long id) {
    return menuMapper.selectById(id);
}

角色与菜单关联

关联操作

角色与菜单的关联通过 RoleMenuDO 实现，主要字段包括：

• roleId：角色ID。
• menuId：菜单ID。

@TableName("system_role_menu")
public class RoleMenuDO {
    private Long roleId;
    private Long menuId;
}

权限校验

系统通过 PermissionService 校验用户是否具有访问某菜单的权限。

public boolean hasPermission(Long userId, String permission) {
    Set<String> permissions = permissionService.getUserPermissionList(userId);
    return permissions.contains(permission);
}

动态菜单

用户登录后，系统动态加载其角色关联的菜单，生成前端路由。

public List<AuthMenuRespVO> getMenuList(Long userId) {
    Set<Long> roleIds = permissionService.getUserRoleIdList(userId);
    Set<Long> menuIds = permissionService.getRoleMenuList(roleIds);
    return menuMapper.selectListByIds(menuIds);
}

总结

通过角色与菜单的灵活配置，yudaocode/ruoyi-vue-pro 实现了细粒度的权限控制，满足不同业务场景的需求。

部门与岗位管理

在 yudao-module-system 模块中，部门与岗位管理是核心功能之一，主要用于组织架构的管理和权限分配。以下将详细介绍其实现逻辑和关键代码。

部门管理

部门管理功能通过 DepartmentController、DepartmentService 和 DeptMapper 实现。以下是一个典型的部门管理流程：

1. 部门列表查询

   @GetMapping("/list")
   @PreAuthorize("@ss.hasPermission('system:dept:query')")
   public CommonResult<List<DeptDO>> listDepts() {
       return success(deptService.listDepts());
   }
   

2. 部门新增

   @PostMapping("/create")
   @PreAuthorize("@ss.hasPermission('system:dept:create')")
   public CommonResult<Long> createDept(@Valid @RequestBody DeptCreateReqVO reqVO) {
       return success(deptService.createDept(reqVO));
   }
   

3. 部门更新

   @PutMapping("/update")
   @PreAuthorize("@ss.hasPermission('system:dept:update')")
   public CommonResult<Boolean> updateDept(@Valid @RequestBody DeptUpdateReqVO reqVO) {
       deptService.updateDept(reqVO);
       return success(true);
   }
   

4. 部门删除

   @DeleteMapping("/delete")
   @PreAuthorize("@ss.hasPermission('system:dept:delete')")
   public CommonResult<Boolean> deleteDept(@RequestParam("id") Long id) {
       deptService.deleteDept(id);
       return success(true);
   }
   

岗位管理

岗位管理功能通过 JobController、JobService 和 PostMapper 实现。以下是一个典型的岗位管理流程：

1. 岗位列表查询

   @GetMapping("/list")
   @PreAuthorize("@ss.hasPermission('system:job:query')")
   public CommonResult<List<PostDO>> listJobs() {
       return success(jobService.listJobs());
   }
   

2. 岗位新增

   @PostMapping("/create")
   @PreAuthorize("@ss.hasPermission('system:job:create')")
   public CommonResult<Long> createJob(@Valid @RequestBody JobCreateReqVO reqVO) {
       return success(jobService.createJob(reqVO));
   }
   

3. 岗位更新

   @PutMapping("/update")
   @PreAuthorize("@ss.hasPermission('system:job:update')")
   public CommonResult<Boolean> updateJob(@Valid @RequestBody JobUpdateReqVO reqVO) {
       jobService.updateJob(reqVO);
       return success(true);
   }
   

4. 岗位删除

   @DeleteMapping("/delete")
   @PreAuthorize("@ss.hasPermission('system:job:delete')")
   public CommonResult<Boolean> deleteJob(@RequestParam("id") Long id) {
       jobService.deleteJob(id);
       return success(true);
   }
   

数据模型

部门与岗位的数据模型如下：

部门模型 (DeptDO)

public class DeptDO {
    private Long id;
    private String name;
    private Long parentId;
    private Integer sort;
    private Integer status;
    private LocalDateTime createTime;
}

岗位模型 (PostDO)

public class PostDO {
    private Long id;
    private String name;
    private String code;
    private Integer sort;
    private Integer status;
    private LocalDateTime createTime;
}

流程图

以下是部门与岗位管理的流程图：

flowchart TD
    A[用户请求] --> B{权限校验}
    B -->|通过| C[业务逻辑处理]
    B -->|拒绝| D[返回无权限]
    C --> E[数据库操作]
    E --> F[返回结果]

总结

部门与岗位管理功能通过清晰的模块划分和权限控制，实现了组织架构的高效管理。开发者可以根据业务需求扩展或修改相关逻辑。

租户管理与SaaS支持

在现代企业级应用中，多租户（Multi-Tenancy）架构是实现SaaS（Software as a Service）的核心技术之一。yudaocode/ruoyi-vue-pro通过yudao-spring-boot-starter-biz-tenant模块提供了完善的租户管理功能，支持多租户的数据隔离、权限控制以及灵活的配置选项。本文将深入解析该模块的设计与实现。

租户核心概念

在ruoyi-vue-pro中，租户（Tenant）是指一组共享相同应用实例但数据完全隔离的用户群体。每个租户拥有独立的数据空间和配置，确保数据安全性和业务独立性。以下是租户管理的核心组件：

1. TenantDO：租户实体类，包含租户的基本信息（如名称、联系人、状态等）。
2. TenantPackageDO：租户套餐实体类，定义租户可使用的功能模块和资源配额。
3. TenantProperties：租户配置类，用于动态控制租户功能的开启与关闭。

数据隔离实现

ruoyi-vue-pro通过以下方式实现多租户数据隔离：

1. 数据库层面

• TenantBaseDO：所有需要支持多租户的实体类需继承此类，自动添加tenant_id字段。
• SQL拦截器：通过MyBatis拦截器动态注入tenant_id条件，确保查询仅返回当前租户的数据。

// 示例：TenantBaseDO
public class TenantBaseDO extends BaseDO {
    private Long tenantId; // 租户ID
}

2. 缓存层面

• Redis缓存隔离：通过为缓存键添加租户前缀（如tenant:1:user:100），实现缓存数据的隔离。

3. 忽略机制

部分表或接口可能需要忽略租户隔离，例如全局配置表或开放API。通过TenantProperties配置忽略项：

yudao:
  tenant:
    ignore-tables: sys_config, sys_dict # 忽略多租户的表
    ignore-urls: /api/callback/**      # 忽略多租户的请求

租户功能模块

1. 租户管理

• 创建与更新：支持动态创建租户，并关联套餐（TenantPackage）。
• 状态控制：租户可启用或禁用，禁用后无法访问系统。

sequenceDiagram
    participant Admin
    participant System
    Admin->>System: 创建租户
    System->>System: 生成tenant_id
    System->>System: 初始化数据
    System-->>Admin: 返回租户ID

2. 套餐管理

• 功能配额：定义租户可使用的模块（如用户数、存储空间等）。
• 动态绑定：租户可随时切换套餐，系统自动调整资源配额。

classDiagram
    class TenantPackageDO {
        +Long id
        +String name
        +Integer status
        +String remark
    }
    class TenantDO {
        +Long packageId
    }
    TenantDO "1" --> "1" TenantPackageDO

动态配置与扩展

通过TenantProperties，开发者可以灵活配置租户功能：

@Data
@ConfigurationProperties(prefix = "yudao.tenant")
public class TenantProperties {
    private Boolean enable = true; // 是否开启多租户
    private Set<String> ignoreUrls = new HashSet<>(); // 忽略的URL
}

总结

ruoyi-vue-pro的租户管理模块通过数据隔离、动态配置和套餐管理，为SaaS应用提供了强大的支持。开发者可以根据业务需求灵活扩展，实现更复杂的多租户场景。

ruoyi-vue-pro系统通过模块化设计实现了完善的用户权限体系和多租户支持。其核心优势在于：1) 基于Spring Security的细粒度权限控制；2) 灵活可扩展的角色菜单关联机制；3) 清晰的组织架构管理；4) 强大的SaaS多租户能力。该系统设计合理，代码规范，是企业级后台管理系统的优秀解决方案，开发者可基于此快速构建安全可靠的管理平台。