第九章：Spring Security 使用redis存储用户权限信息

ゞ浴缸里的玫瑰 2023-02-14 05:56 27阅读 0赞

前面我们使用了jwt的token来进行登录，但是只说明了它的好处，那么我们来讲一讲他不好的地方：消息体可以被base64解密为明文、不适合存放大量信息、无法作废未过期的token。显然我们准备要存储的东西非常多，用户信息+权限信息。所以我们考虑换redis来进行存储，抛弃jwt。

# 集成 #

<dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>

## reidsDao ##

import lombok.RequiredArgsConstructor;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.core.ValueOperations;
    import org.springframework.stereotype.Repository;
    import org.springframework.util.CollectionUtils;
    
    import java.util.concurrent.TimeUnit;
    
    /**
     * redis数据库工具类
     */
    @Repository
    @Slf4j
    @RequiredArgsConstructor
    public class RedisDao<K,V> {
    
        /**
         * 过期时间是3600秒，既是1个小时
         */
        private static final long EXPIRATION = 3600L;
    
    
        private final RedisTemplate<K, V> redisTemplate;
    
        /**
         * 设置key值
         * @param key
         * @param value
         */
        public void setKey(K key,V value){
            ValueOperations<K, V> ops = redisTemplate.opsForValue();
            ops.set(key,value);
        }
    
        /**
         * 设置key值
         * @param key
         * @param value
         * @param expiration 过期时间（秒）
         */
        public void setKey(K key,V value,Long expiration){
            if(expiration == null){
                expiration = EXPIRATION;
            }
            ValueOperations<K, V> ops = redisTemplate.opsForValue();
            ops.set(key,value,expiration,TimeUnit.SECONDS);
        }
    
        /**
         * 获得Key值
         * @param key
         * @return
         */
        public V getValue(K key){
            ValueOperations<K, V> ops = this.redisTemplate.opsForValue();
            return ops.get(key);
        }
    
        /**
         * 指定缓存失效时间
         * @param key 键
         * @param time 时间(秒)
         * @return
         */
        public void expire(K key,Long time){
            if(time == null){
                time = EXPIRATION;
            }
            redisTemplate.expire(key, time, TimeUnit.SECONDS);
        }
    
        /**
         * 根据key 获取过期时间
         * @param key 键 不能为null
         * @return 时间(秒) 返回0代表为永久有效
         */
        public long getExpire(K key){
            return redisTemplate.getExpire(key,TimeUnit.SECONDS);
        }
    
        /**
         * 根据key 和时间单位获取过期时间，单位{@link TimeUnit}
         * @param key 键 不能为null
         * @param timeUnit 时间单位 {@link TimeUnit}
         * @return 返回0代表为永久有效
         */
        public long getExpire(K key,TimeUnit timeUnit){
            return redisTemplate.getExpire(key,timeUnit);
        }
    
        /**
         * 删除缓存
         * @param key 可以传一个值 或多个
         */
        public void del(K ... key){
            if(key!=null&&key.length>0){
                if(key.length==1){
                    redisTemplate.delete(key[0]);
                }else{
                    redisTemplate.delete(CollectionUtils.arrayToList(key));
                }
            }
        }
    }

## redisConfig ##

import com.fasterxml.jackson.annotation.JsonAutoDetect;
    import com.fasterxml.jackson.annotation.PropertyAccessor;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    
    /**
     * redis配置
     */
    @Configuration
    public class RedisConfig {
    
        /**
         * 设置key跟value的序列化方式
         * @param factory
         * @return
         */
        @Bean
        public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory factory) {
            RedisTemplate<String,Object> template = new RedisTemplate<String,Object>();
            template.setConnectionFactory(factory);
            Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
            ObjectMapper om = new ObjectMapper();
            om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
            jackson2JsonRedisSerializer.setObjectMapper(om);
            StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
            // key采用String的序列化方式
            template.setKeySerializer(stringRedisSerializer);
            // hash的key也采用String的序列化方式
            template.setHashKeySerializer(stringRedisSerializer);
            // value序列化方式采用jackson
            // template.setValueSerializer(jackson2JsonRedisSerializer);
            // hash的value序列化方式采用jackson
            // template.setHashValueSerializer(jackson2JsonRedisSerializer);
            template.afterPropertiesSet();
            return template;
        }
    }

## 登录调整 ##

private final RedisDao<String,CustomUserDetails> userRedisDao;
    
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        // 随机字符串（用于区分同一账号多次登录时，缓存的key不重复）
        String uuidKey = UUID.randomUUID().toString();
        String userTokenKey = BaseConstant.USER_KEY+username + ":" + uuidKey;
        CustomUserDetails details = userService.getUserByUsername(username);
        if(details == null){
            String errorMsg = "账号 " + username + "不存在";
            log.error(errorMsg);
            throw new UsernameNotFoundException(errorMsg);
        }
        details.setUuidKey(uuidKey);
        // 设置权限
        Collection<GrantedAuthority> grantedAuthorities = new ArrayList<>();
        List<SysRoleModel> roleList = roleService.getRoleCodeByUserId(details.getUserId());
        if(roleList == null || roleList.size() <= 0){
            details.setAuthorities(grantedAuthorities);
            userRedisDao.setKey(userTokenKey,details,null);
            return details;
        }
    
        // 角色
        List<String> roleStrs = Lists.newArrayList();
        for(SysRoleModel role : roleList){
            grantedAuthorities.add(new SimpleGrantedAuthority(role.getRoleCode()));
            roleStrs.add(role.getRoleId());
        }
    
        // 菜单
        List<String> codeArr = menuService.getMenuByRoles(roleStrs);
        if(codeArr != null && codeArr.size() > 0){
            for (String code: codeArr) {
                grantedAuthorities.add(new SimpleGrantedAuthority(code));
            }
        }
    
        details.setAuthorities(grantedAuthorities);
        userRedisDao.setKey(userTokenKey,details,null);
        return details;
    }

## 过滤器调整 ##

/**
     * description: 登录验证成功后调用，验证成功后将生成Token，并重定向到用户主页home
     * 与AuthenticationSuccessHandler作用相同
     *
     * @param request
     * @param response
     * @param chain
     * @param authResult
     * @return void
     */
    @Override
    protected void successfulAuthentication(HttpServletRequest request,
                                            HttpServletResponse response,
                                            FilterChain chain,
                                            Authentication authResult) throws IOException, ServletException {
    
        // 查看源代码会发现调用getPrincipal()方法会返回一个实现了`UserDetails`接口的对象，这里是CustomUserDetails
        CustomUserDetails user = (CustomUserDetails) authResult.getPrincipal();
        String userKey = BaseConstant.USER_KEY + user.getUsername() + ":" + user.getUuidKey();
        // 多生成一个KEY，用于返回给前端，确保用户信息不暴露出去
        String tokenKey = UUID.randomUUID().toString() + ":" + UUID.randomUUID().toString();
        // 存储后，可以通过tokenKey，拿到userKey，在通过userKey拿到用户的信息
        tokenRedis.setKey(BaseConstant.TOKEN_KEY + tokenKey,userKey,null);
    
        // 登录成功
        response.setCharacterEncoding("UTF-8");
        response.setContentType("application/json; charset=utf-8");
        ActionResult<String> result = new ActionResult<>(ResultCodeEnum.SUCCESS);
        result.setMessage("登录成功");
        result.setData(tokenKey);
        response.getWriter().write(JSON.toJSONString(result));
    }

import com.hzw.code.common.constant.BaseConstant;
    import com.hzw.code.common.utils.ActionException;
    import com.hzw.code.redis.dao.RedisDao;
    import com.hzw.code.security.model.CustomUserDetails;
    import org.apache.commons.lang3.StringUtils;
    import org.springframework.security.authentication.AuthenticationManager;
    import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
    import org.springframework.security.core.context.SecurityContextHolder;
    import org.springframework.security.web.authentication.www.BasicAuthenticationFilter;
    
    import javax.servlet.FilterChain;
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    
    /**
     * @author: 胡汉三
     * @date: 2020/5/26 10:20
     * @description: 对所有请求进行过滤
     * BasicAuthenticationFilter继承于OncePerRequestFilter==》确保在一次请求只通过一次filter，而不需要重复执行。
     */
    public class PreAuthFilter extends BasicAuthenticationFilter {
        private RedisDao<String, CustomUserDetails> userRedis;
        private RedisDao<String,String> tokenRedis;
        public PreAuthFilter(AuthenticationManager authenticationManager,
                             RedisDao<String, CustomUserDetails> userRedis,
                             RedisDao<String,String> tokenRedis) {
            super(authenticationManager);
            this.userRedis = userRedis;
            this.tokenRedis = tokenRedis;
        }
    
        /**
         * description: 从request的header部分读取Token
         *
         * @param request
         * @param response
         * @param chain
         * @return void
         */
        @Override
        protected void doFilterInternal(HttpServletRequest request,
                                        HttpServletResponse response,
                                        FilterChain chain) throws IOException, ServletException {
            String tokenHeader = request.getHeader(BaseConstant.TOKEN_HEADER);
            // 如果请求头中没有Authorization信息则直接放行了
            if (tokenHeader == null || !tokenHeader.startsWith(BaseConstant.TOKEN_PREFIX)) {
                chain.doFilter(request, response);
                return;
            }
            // 如果请求头中有token，则进行解析，并且设置认证信息
            SecurityContextHolder.getContext().setAuthentication(getAuthentication(tokenHeader));
            super.doFilterInternal(request, response, chain);
        }
    
        /**
         * description: 读取Token信息，创建UsernamePasswordAuthenticationToken对象
         *
         * @param tokenHeader
         * @return org.springframework.security.authentication.UsernamePasswordAuthenticationToken
         */
        private UsernamePasswordAuthenticationToken getAuthentication(String tokenHeader) {
            //解析Token时将“Bearer ”前缀去掉
            String token = tokenHeader.replace(BaseConstant.TOKEN_PREFIX, "");
            String userKey = tokenRedis.getValue(BaseConstant.TOKEN_KEY + token);
            if(StringUtils.isBlank(userKey)){
                throw new ActionException("token无效");
            }
            CustomUserDetails userDetails = userRedis.getValue(userKey);
            if (userDetails != null){
                // 刷新token
                tokenRedis.expire(BaseConstant.TOKEN_KEY + token,null);
                tokenRedis.expire(userKey,null);
                return new UsernamePasswordAuthenticationToken(userDetails.getUsername(), null, userDetails.getAuthorities());
            }
            return null;
        }
    }

# 测试 #

## 登录 ##

## ![format_png][]接口验证 ##

![format_png 1][]

![format_png 2][]

这里我们在登录的时候，就把用户的信息存储到了redis，并且使用用户名+UUID（userKey）的形式来做key保证同一个用户登录多个客户端的时候不会影响到。然后在登录成功后的过滤器中套上一个外层的key（tokenKey），用来确保我们不会把用户的关键信息暴露出来。这个key存储了用户的信息的key。这样我们就可以在用户请求的时候在过滤器中取出token来判断他是否登录过，以及token是否还有效。

在判断token有效的同时，在刷新一下token的存活时间。

这样，我们的token跟用户信息都存储到redis里面去了！

在选择序列化类型的时候，我们只是针对key做的处理，没有对value进行处理。所以我们看到key没有\\xac\\xed\\x00这样的字符串，而value都是这样的字符串。

下一步我们要开始做前端的内容了。因为后端到这里，基本的框架已经弄得差不多了！我们接下来开始使用vue + element ui来做我们的前端架构。

\----------------------------------------------------------

项目的源码地址：[https://gitee.com/gzsjd/fast][https_gitee.com_gzsjd_fast]

\----------------------------------------------------------

[format_png]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9ub3RlLnlvdWRhby5jb20veXdzL3B1YmxpYy9yZXNvdXJjZS9kNGYyOWY3Nzk3ZmI4Yzg2NmUzZGUwMjYzYzZkOTBiMi94bWxub3RlL0QxNjVCQkM3QTRCQzQwMTVBNEQ1MTJBQjRGQzlFRjgzLzE3MjM?x-oss-process=image/format,png
[format_png 1]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9ub3RlLnlvdWRhby5jb20veXdzL3B1YmxpYy9yZXNvdXJjZS9kNGYyOWY3Nzk3ZmI4Yzg2NmUzZGUwMjYzYzZkOTBiMi94bWxub3RlLzlGRjk0NTUwMzUzODRCNzg4N0E0RjAxNjA1OTcwNjVDLzE3MjY?x-oss-process=image/format,png
[format_png 2]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9ub3RlLnlvdWRhby5jb20veXdzL3B1YmxpYy9yZXNvdXJjZS9kNGYyOWY3Nzk3ZmI4Yzg2NmUzZGUwMjYzYzZkOTBiMi94bWxub3RlLzcxQkExNUYxQkQ1NDQ5RDE5MkMzNThEMzRDNTExRTgyLzE3Mjg?x-oss-process=image/format,png
[https_gitee.com_gzsjd_fast]: https://gitee.com/gzsjd/fast