Logo
开发文档
QQ频道
返回

Likeadmin配置用户权限的详细流程，Java版本

2026-01-21 23:38:01
|
浏览 27

LikeAdmin Java版用户权限配置详细流程

一、权限系统概述

LikeAdmin的权限系统基于RBAC（基于角色的访问控制）模型设计，通过用户-角色-权限的三层关系实现灵活的权限管理。Java版本通常采用Spring Security + Shiro框架实现权限控制。

二、环境准备与配置

1. 项目依赖配置

在pom.xml中添加必要依赖：

复制代码
<!-- Spring Security -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

<!-- JWT支持 -->
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>

<!-- 数据库访问 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

2. 数据库表结构设计

复制代码
-- 用户表
CREATE TABLE sys_user (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    username VARCHAR(50) UNIQUE NOT NULL,
    password VARCHAR(100) NOT NULL,
    nickname VARCHAR(50),
    status TINYINT DEFAULT 1,
    create_time DATETIME DEFAULT CURRENT_TIMESTAMP
);

-- 角色表
CREATE TABLE sys_role (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    role_code VARCHAR(50) UNIQUE NOT NULL,
    role_name VARCHAR(50) NOT NULL,
    description VARCHAR(200),
    create_time DATETIME DEFAULT CURRENT_TIMESTAMP
);

-- 权限表
CREATE TABLE sys_permission (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    perm_code VARCHAR(100) UNIQUE NOT NULL,
    perm_name VARCHAR(50) NOT NULL,
    perm_type TINYINT COMMENT '1:菜单 2:按钮 3:接口',
    parent_id BIGINT DEFAULT 0,
    path VARCHAR(200),
    component VARCHAR(200),
    icon VARCHAR(50),
    sort INT DEFAULT 0,
    visible TINYINT DEFAULT 1
);

-- 用户角色关联表
CREATE TABLE sys_user_role (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    user_id BIGINT NOT NULL,
    role_id BIGINT NOT NULL,
    UNIQUE KEY uk_user_role (user_id, role_id)
);

-- 角色权限关联表
CREATE TABLE sys_role_permission (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    role_id BIGINT NOT NULL,
    perm_id BIGINT NOT NULL,
    UNIQUE KEY uk_role_perm (role_id, perm_id)
);

三、核心配置步骤

1. Spring Security配置类

复制代码
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    
    @Autowired
    private UserDetailsService userDetailsService;
    
    @Autowired
    private JwtAuthenticationFilter jwtAuthenticationFilter;
    
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
    
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
            .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
            .and()
            .authorizeRequests()
            .antMatchers("/api/auth/**").permitAll()
            .antMatchers("/api/admin/**").hasRole("ADMIN")
            .anyRequest().authenticated();
        
        http.addFilterBefore(jwtAuthenticationFilter, 
                           UsernamePasswordAuthenticationFilter.class);
    }
    
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService)
            .passwordEncoder(passwordEncoder());
    }
}

2. 自定义UserDetailsService实现

复制代码
@Service
public class UserDetailsServiceImpl implements UserDetailsService {
    
    @Autowired
    private UserMapper userMapper;
    
    @Autowired
    private RoleMapper roleMapper;
    
    @Autowired
    private PermissionMapper permissionMapper;
    
    @Override
    public UserDetails loadUserByUsername(String username) {
        // 查询用户信息
        SysUser user = userMapper.findByUsername(username);
        if (user == null) {
            throw new UsernameNotFoundException("用户不存在");
        }
        
        // 查询用户角色
        List<SysRole> roles = roleMapper.findByUserId(user.getId());
        
        // 查询用户权限
        List<SysPermission> permissions = permissionMapper.findByUserId(user.getId());
        
        // 构建权限集合
        List<SimpleGrantedAuthority> authorities = new ArrayList<>();
        for (SysRole role : roles) {
            authorities.add(new SimpleGrantedAuthority("ROLE_" + role.getRoleCode()));
        }
        for (SysPermission perm : permissions) {
            authorities.add(new SimpleGrantedAuthority(perm.getPermCode()));
        }
        
        return new org.springframework.security.core.userdetails.User(
            user.getUsername(),
            user.getPassword(),
            user.getStatus() == 1,
            true, true, true,
            authorities
        );
    }
}

3. JWT令牌工具类

复制代码
@Component
public class JwtTokenUtil {
    
    private final String secret = "likeadmin-secret-key";
    private final Long expiration = 86400000L; // 24小时
    
    public String generateToken(UserDetails userDetails) {
        Map<String, Object> claims = new HashMap<>();
        claims.put("username", userDetails.getUsername());
        claims.put("authorities", userDetails.getAuthorities()
            .stream()
            .map(GrantedAuthority::getAuthority)
            .collect(Collectors.toList()));
        
        return Jwts.builder()
            .setClaims(claims)
            .setSubject(userDetails.getUsername())
            .setIssuedAt(new Date())
            .setExpiration(new Date(System.currentTimeMillis() + expiration))
            .signWith(SignatureAlgorithm.HS512, secret)
            .compact();
    }
    
    public Boolean validateToken(String token, UserDetails userDetails) {
        final String username = getUsernameFromToken(token);
        return (username.equals(userDetails.getUsername()) 
                && !isTokenExpired(token));
    }
    
    private Boolean isTokenExpired(String token) {
        final Date expiration = getExpirationDateFromToken(token);
        return expiration.before(new Date());
    }
}

四、权限配置管理实现

1. 权限管理服务类

复制代码
@Service
public class PermissionService {
    
    @Autowired
    private PermissionMapper permissionMapper;
    
    @Autowired
    private RolePermissionMapper rolePermissionMapper;
    
    /**
     * 分配权限给角色
     */
    @Transactional
    public void assignPermissionsToRole(Long roleId, List<Long> permissionIds) {
        // 删除原有权限
        rolePermissionMapper.deleteByRoleId(roleId);
        
        // 添加新权限
        for (Long permId : permissionIds) {
            SysRolePermission rolePerm = new SysRolePermission();
            rolePerm.setRoleId(roleId);
            rolePerm.setPermId(permId);
            rolePermissionMapper.insert(rolePerm);
        }
        
        // 清除相关用户的权限缓存
        clearUserPermissionCache(roleId);
    }
    
    /**
     * 获取用户的菜单权限树
     */
    public List<PermissionTreeVO> getUserMenuTree(Long userId) {
        List<SysPermission> permissions = permissionMapper.findByUserIdAndType(userId, 1);
        return buildPermissionTree(permissions, 0L);
    }
    
    /**
     * 构建权限树
     */
    private List<PermissionTreeVO> buildPermissionTree(List<SysPermission> permissions, Long parentId) {
        List<PermissionTreeVO> tree = new ArrayList<>();
        
        for (SysPermission perm : permissions) {
            if (perm.getParentId().equals(parentId)) {
                PermissionTreeVO node = new PermissionTreeVO();
                node.setId(perm.getId());
                node.setName(perm.getPermName());
                node.setCode(perm.getPermCode());
                node.setPath(perm.getPath());
                node.setIcon(perm.getIcon());
                node.setChildren(buildPermissionTree(permissions, perm.getId()));
                tree.add(node);
            }
        }
        
        return tree;
    }
}

2. 权限控制注解使用

复制代码
@RestController
@RequestMapping("/api/admin")
public class AdminController {
    
    /**
     * 需要管理员角色
     */
    @PreAuthorize("hasRole('ADMIN')")
    @GetMapping("/users")
    public Result listUsers() {
        // 用户列表查询逻辑
        return Result.success(userService.listUsers());
    }
    
    /**
     * 需要特定权限
     */
    @PreAuthorize("hasAuthority('user:delete')")
    @DeleteMapping("/user/{id}")
    public Result deleteUser(@PathVariable Long id) {
        userService.deleteUser(id);
        return Result.success();
    }
    
    /**
     * 需要多个权限中的任意一个
     */
    @PreAuthorize("hasAnyAuthority('user:add', 'user:edit')")
    @PostMapping("/user")
    public Result saveUser(@RequestBody UserDTO userDTO) {
        userService.saveUser(userDTO);
        return Result.success();
    }
}

3. 动态权限配置接口

复制代码
@RestController
@RequestMapping("/api/system/permission")
public class PermissionController {
    
    @Autowired
    private PermissionService permissionService;
    
    /**
     * 获取所有权限树
     */
    @GetMapping("/tree")
    public Result getPermissionTree() {
        List<SysPermission> allPermissions = permissionService.getAllPermissions();
        List<PermissionTreeVO> tree = permissionService.buildPermissionTree(allPermissions, 0L);
        return Result.success(tree);
    }
    
    /**
     * 获取角色权限ID列表
     */
    @GetMapping("/role/{roleId}")
    public Result getRolePermissions(@PathVariable Long roleId) {
        List<Long> permIds = permissionService.getPermissionIdsByRoleId(roleId);
        return Result.success(permIds);
    }
    
    /**
     * 更新角色权限
     */
    @PostMapping("/assign")
    public Result assignPermissions(@RequestBody RolePermissionDTO dto) {
        permissionService.assignPermissionsToRole(dto.getRoleId(), dto.getPermissionIds());
        return Result.success();
    }
}

五、前端权限控制集成

1. Vue前端路由权限控制

复制代码
// 路由守卫
router.beforeEach((to, from, next) => {
  // 获取用户权限列表
  const permissions = store.getters.permissions;
  
  // 检查路由是否需要权限
  if (to.meta.requiresAuth) {
    if (!store.getters.token) {
      next('/login');
      return;
    }
    
    // 检查是否有权限访问该路由
    if (to.meta.permission && !hasPermission(permissions, to.meta.permission)) {
      next('/403'); // 无权限页面
      return;
    }
  }
  
  next();
});

// 权限检查函数
function hasPermission(permissions, requiredPermission) {
  return permissions.includes(requiredPermission);
}

// 动态生成菜单
function generateMenus(permissions) {
  const menuMap = {
    'system:view': {
      path: '/system',
      name: 'System',
      meta: { title: '系统管理', icon: 'setting' },
      children: []
    },
    'user:view': {
      path: 'user',
      name: 'User',
      component: () => import('@/views/system/user'),
      meta: { title: '用户管理' }
    }
  };
  
  return permissions
    .filter(perm => menuMap[perm])
    .map(perm => menuMap[perm]);
}

六、权限配置操作流程

1. 后台管理操作步骤

  1. 创建权限项

    • 进入系统管理 → 权限管理
    • 点击"新增权限"
    • 填写权限编码、名称、类型（菜单/按钮/接口）
    • 设置父级权限（构建树形结构）

  2. 创建角色

    • 进入系统管理 → 角色管理
    • 点击"新增角色"
    • 填写角色编码、名称、描述

  3. 分配权限给角色

    • 在角色列表点击"权限分配"
    • 勾选需要分配的权限项
    • 保存配置

  4. 分配角色给用户

    • 进入系统管理 → 用户管理
    • 编辑用户信息
    • 在角色分配中选择角色
    • 保存配置

2. 权限验证流程

复制代码
用户登录 → 验证凭证 → 查询用户权限 → 生成JWT令牌
    ↓
访问资源 → 拦截请求 → 验证令牌 → 检查权限
    ↓
有权限 → 允许访问 → 返回数据
    ↓
无权限 → 拒绝访问 → 返回403错误

七、常见问题与解决方案

1. 权限缓存问题

复制代码
// 使用Redis缓存用户权限
@Cacheable(value = "userPermissions", key = "#userId")
public List<String> getUserPermissions(Long userId) {
    return permissionMapper.findPermCodesByUserId(userId);
}

// 权限变更时清除缓存
@CacheEvict(value = "userPermissions", key = "#userId")
public void clearUserPermissionCache(Long userId) {
    // 清除缓存逻辑
}

2. 权限同步问题

  • 使用消息队列同步多节点权限变更
  • 设置权限版本号，客户端定期检查更新

3. 超级管理员特殊处理

复制代码
// 在权限检查时跳过超级管理员
public boolean hasPermission(User user, String permission) {
    if (user.isSuperAdmin()) {
        return true; // 超级管理员拥有所有权限
    }
    return user.getPermissions().contains(permission);
}

八、最佳实践建议

  1. 权限编码规范

    • 使用模块:操作:资源的命名方式，如system:user:add
    • 保持编码唯一性和可读性

  2. 最小权限原则

    • 只分配必要的权限
    • 定期审查权限分配

  3. 权限日志记录

    • 记录所有权限变更操作
    • 记录敏感操作日志

  4. 定期权限审计

    • 每月审查权限分配情况
    • 清理未使用的权限和角色

通过以上配置流程，LikeAdmin Java版可以实现完整的用户权限管理系统，满足企业级应用的权限控制需求。系统支持细粒度的权限控制，同时保持足够的灵活性和扩展性。

我要提问
复制内容
分享给好友
AI编程问答网 免责声明：
以上内容除特别注明外均来源于网友提问，AI编程问答网回答，权益归原著者所有；
 
上一篇：Likeadmin配置用户权限的详细流程
下一篇：编译后台且覆盖后，访问后台菜单点不动