基于spring boot的spring security的权限系统的设计

权限系统

权限是在任何应用中都有的系统。例如用户，常见的有管理员，普通用户。管理员是可以操作普通用户的。那么这里就必定有操作用户的接口公开给前端访问。但是这个接口只有管理员才能访问。

security给我们提供了对应的解决方案使用@PreAuthorize()注解，传入一个字符串表达式。

这个注解需要在security的配置中标上@EnableGlobalMethodSecurity(prePostEnabled = true)注解开启权限认证。

这个注解会在方法执行之前去校验用户是否有权限。

@GetMapping("/userList")
// 这个接口只有拥有这个system:admin特殊字符串的用户才能访问
@PreAuthorize("hasAuthority('system:admin')") 
public List<User> selectUser() {
    return userService.selectUser();
}

问题1：security怎么知道这个用户是否拥有system:admin这个权限呢

这就需要编写一个类继承 security 提供的 UserDetails 类他提供了一个重写的方法 用于返回用户的权限。

这里主要关注：GrantedAuthority方法 返回了一个集合Collection<? extends GrantedAuthority>他的值就是一个字符串。@PreAuthorize("hasAuthority('system:admin')") 这个注解就会拿这个字符串去GrantedAuthority返回的集合中查找是否有这个字符串。

这里有两个局部变量：

// security 需要的类型

private List<SimpleGrantedAuthority> authorities;

// 我们传入的类型

private List<String> permissions;

所以我们就需要重写这个方法返回security需要的类型

问题2：permissions是我们传入的那么这个哪里来的呢。实际上这个就是我们在数据库中查询到的用户权限注入进来的。

package com.example.springbootsecurity.domain;

import com.alibaba.fastjson2.annotation.JSONField;
import com.example.springbootsecurity.pojo.User;
import com.fasterxml.jackson.annotation.JsonFilter;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

@Data
@NoArgsConstructor
public class LoginUser implements UserDetails {

    private User user;

    private List<SimpleGrantedAuthority> authorities;
    private List<String> permissions;

    public LoginUser(User user, List<String> permissions) {
        this.user = user;
        this.permissions = permissions;
    }

    /**
     * 获取权限信息
     *
     * @return
     */
    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        if (authorities != null) {
            return authorities;
        }
        authorities = permissions.stream()
                .map(SimpleGrantedAuthority::new)
                .collect(Collectors.toList());
        return authorities;
    }

    /**
     * 获取user的密码
     *
     * @return
     */
    @Override
    public String getPassword() {
        return user.getPassword();
    }

    /**
     * 获取user的用户名
     *
     * @return
     */
    @Override
    public String getUsername() {
        return user.getUser_name();
    }

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return true;
    }
}

权限系统表的设计

注：本文内容仅限参考，属于在学习中做的笔记，如有不对的地方，提前感谢各位大佬的纠正。

这里设计到五张表（后台管理系统）:

• sys_user 用户表
• sys_menu 菜单表
• sys_role 权限表
• sys_role_menu 权限菜单关联表 （表示 该权限能够 访问的 菜单）
• sys_user_role 用户权限关联表

注：一个用户可以有多个权限。

将五张表用join关联起来 使用userid就可以查出当前用户的权限字段。

在用户登陆的时候查询出来保存到redis或者token中。这里保存到了redis。key为user:userid

@Override
public ServerResponse login(User user) {
UsernamePasswordAuthenticationToken authenticationToken =
new UsernamePasswordAuthenticationToken(user.getUser_name(), user.getPassword());
Authentication authenticate = authenticationManager.authenticate(authenticationToken);

LoginUser loginUser = (LoginUser) authenticate.getPrincipal();
// 将用户的权限保存到redis中
redisTemplate.opsForValue().set("user:" + loginUser.getUser().getUserId(),loginUser.getPermissions());

Map<String, Object> userToken = new HashMap();
userToken.put("userid",loginUser.getUser().getUserId());
String jwt = JwtUtil.createJWT(Const.TOKEN_KEY, 1000000l, userToken);

Map tokenMap = new HashMap<>();
tokenMap.put("token",jwt);
return ServerResponse.creatrBySuccess("登录成功",tokenMap);
}

在非登陆请求过来时在认证token的过滤器中 取出 redis 中的 userid的权限 然后注入到 UsernamePasswordAuthenticationToken 中。然后在执行到controller时就会去校验当前用户的权限是否满足当前接口的权限。

package com.example.springbootsecurity.filter;

import com.example.springbootsecurity.config.Const;
import com.example.springbootsecurity.domain.LoginUser;
import com.example.springbootsecurity.pojo.User;
import com.example.springbootsecurity.utils.JwtUtil;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.ExpiredJwtException;
import io.netty.util.internal.StringUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;

/**
 * jwt的过滤器
 * 过滤器会在请求进来之前和响应回去之前执行
 */
@Component
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {

    @Autowired
    private RedisTemplate redisTemplate;
    /**
     * 校验tokne的过滤器
     *
     * @param httpServletRequest
     * @param httpServletResponse
     * @param filterChain
     * @throws ServletException
     * @throws IOException
     */
    @Override
    protected void doFilterInternal(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, FilterChain filterChain) throws ServletException, IOException {
        String token = httpServletRequest.getHeader("token");
        if (StringUtil.isNullOrEmpty(token)) {
            filterChain.doFilter(httpServletRequest, httpServletResponse);
            return;
        }
        // 解析tokena
        try {
            Claims currUser = JwtUtil.parseJWT(Const.TOKEN_KEY, token);

            LoginUser currentUser = new LoginUser();
            // 取出redis中用户的权限 注入到 currentUser 中
            currentUser.setPermissions((List<String>) redisTemplate.opsForValue().get("user:" + currUser.get("userid")));
            // UsernamePasswordAuthenticationToken的第三个参数就是传入权限信息的 所以这里把currentUser.getAuthorities()传入
            UsernamePasswordAuthenticationToken authenticationToken =
            new UsernamePasswordAuthenticationToken(currUser, null, currentUser.getAuthorities());
            SecurityContextHolder.getContext().setAuthentication(authenticationToken);
            filterChain.doFilter(httpServletRequest, httpServletResponse);
        } catch (Exception e) {
            System.out.println("token解析失败" + e.getMessage());
            throw new RuntimeException("用户未登录");
        }
    }

}

注入权限信息应该在认证的过滤器中注入。这里省略。本文在学习中记录的，有不对的地方感谢大佬多指导指导。