Oauth2 + JWT登出（黑名单方案）

推荐关注

以下文章来源Java后端栈，回复”面试“获面试宝典

哈喽，各位新来的小伙伴们，大家好！由于公众号做了改版，为了保证公众号的资源能准时推送到你手里，大家记得将后端君的公众号 加星标置顶 ，在此真诚的表示感谢～

编辑：后端妹 | 来源：blog.csdn.net/lbjfish/article/details/109321044

上一篇：做一个不崩溃的核酸系统有多难？

正文

 大家好，我是栈哥。

说明

首先说一下，本人不建议用JWT这种token方式，还是建议大家用RedisTokenStore方案，比较成熟。因为JWT是无状态的，这是它的优点，如果强行给它加状态，那还不如用Session方案。

为什么要写这篇主要是因目前公司使用JWT这种登录方式，如果换成其它token方式，可能改动比较大，还可能有其他隐藏bug。当然，既然要使用JWT，就要接受它的坑，比如不能控制登出功能，因为官方的JwtTokenStore.removeAccessToken是个空方法；比如不能实现续签功能，因为同一个用户id，每次调刷新接口，返回JWT的token都是不一样的（主要是jwt算法，时间不一致，jwt就会变）。

Oauth2官方提供JWT这种方式摆明就是告诉你，不要做也不建议做登出和续签，它适合那种后台内部管理系统的登录系统，几乎很少需要退出和续签场景，如果需要退出，也很简单，可以直接清掉浏览器上的token cookie。

目前总结黑名单方案有三种实现方式（都是基于Redis去做）：

• ResJwtAccessTokenConverter中新建子类RedisJwtClaimsSetVerifier并实现JwtClaimsSetVerifier接口。主要是重写verify()方法。

• ResJwtAccessTokenConverter中子类JWTfaultUserAuthenticationConverter并继承DefaultAccessTokenConverter类。主要是重写extractAuthentication()方法取得jti（map.get(“jti”)）。

• 实现过滤器LogoutAuthenticationFilter，在调登录接口实现前，判断jti。

以上三种实现方式，我更倾向于第三种，效率会比其它两种高，因为第三种是登录前就判断好，其它两种是已经走了Oauth2的登录逻辑代码，所以效率稍低，选择还是看自己，实现难度都很简单。

当然黑名单方式是不适合扩展续签功能的，后面一篇我将实现白名单登录方式，并解决续签方案，还能实现在线踢人功能。

扩展JwtTokenStore

如果是白名单需要重写storeAccessToken方法，如果是黑名单需要重写removeAccessToken方法，这里是黑名单，所以需要在removeAccessToken方法把jti当key，把token当value放入redis内。另外，搜索公众号顶级科技后台回复“物联网平台”，获取一份惊喜礼包。

@Slf4j
public class CustomJwtTokenStore extends JwtTokenStore {
    private RedisUtil redisUtil;

    public CustomJwtTokenStore(JwtAccessTokenConverter jwtTokenEnhancer, RedisUtil redisUtil) {
        super(jwtTokenEnhancer);
        this.redisUtil = redisUtil;
    }


    /**
     * 这个暂时没用，因为我用的黑名单， 白名单需要
     * @param token
     * @param authentication
     */
    @Override
    public void storeAccessToken(OAuth2AccessToken token, OAuth2Authentication authentication) {
        super.storeAccessToken(token, authentication);
    }

    @Override
    public void removeAccessToken(OAuth2AccessToken token) {
        if (token.getAdditionalInformation().containsKey("jti")) {
            String jti = token.getAdditionalInformation().get("jti").toString();
//            redisUtil.del(jtiRedisKey(jti));
            int expire = token.getExpiresIn();
            if(expire < 0){
                expire = 1;
            }
            redisUtil.set(jtiRedisKey(jti), token.getValue(), expire);
        }
        super.removeAccessToken(token);
    }

    private String jtiRedisKey(String jti) {
        return SecurityConstants.CACHE_EXPIRE_TOKEN_BLACKLIST + ":" + jti;
    }
}

上面把token放入redis内后，需要校验redis的key是否存在，存在则提示前端该token已登出。校验有三种方式，如下：

以下我来实现三种登出方式并分析三种方式优缺点。扩展：快速开发平台

方案一（重写verify()方法）

该类在ResJwtAccessTokenConverter中的子类RedisJwtClaimsSetVerifier 。代码如下：

public class RedisJwtClaimsSetVerifier implements JwtClaimsSetVerifier {
 /**
  * 检查jti是否在Redis中存在（即是否过期），如过期则抛异常
  */
 @Override
 public void verify(Map<String, Object> claims) throws InvalidTokenException {
  if (claims.containsKey("jti")) {
   String jti = claims.get("jti").toString();
   Object value = redisUtil.get(jtiRedisKey(jti));
   if (value != null) {
                  //最好继承InvalidTokenException重新封装一个异常
    throw new BusinessException("Invalid token!");
   }
  }
 }

 private String jtiRedisKey(String jti) {
  return SecurityConstants.CACHE_EXPIRE_TOKEN_BLACKLIST + ":" + jti;
 }
}

上述发现该token在黑名单内，则会返回一个BusinessException(“Invalid token!”)异常，但是有个问题，看Oauth2源码，JwtAccessTokenConverter.decode(String token)方法内最终会调我上述的verify()方法，但是无论我verify()方法返回什么异常，都会被decode方法捕获，并不会返回我想要的异常信息（上面我的异常返回Invalid token!），会返回decode方法自定义异常信息（Cannot convert access token to JSON），该源码如下：

//源码：
protected Map<String, Object> decode(String token) {
        try {
            Jwt jwt = JwtHelper.decodeAndVerify(token, this.verifier);
            String claimsStr = jwt.getClaims();
            Map<String, Object> claims = this.objectMapper.parseMap(claimsStr);
            if (claims.containsKey("exp") && claims.get("exp") instanceof Integer) {
                Integer intValue = (Integer)claims.get("exp");
                claims.put("exp", new Long((long)intValue));
            }

            this.getJwtClaimsSetVerifier().verify(claims);
            return claims;
        } catch (Exception var6) {
           //这里会捕获我的异常，返回它的异常信息
            throw new InvalidTokenException("Cannot convert access token to JSON", var6);  
        }
    }

要解决上述不返回我抛出异常信息问题，只需要在全局异常捕获类中判断特定异常信息返回即可，即在CustomAuthenticationEntryPoint类中单独判断异常（这种方法并不是很好，最好不要用BusinessException异常，可能会把别的业务异常也捕获，最好继承InvalidTokenException重新封装一个异常。

@Slf4j
public class CustomAuthenticationEntryPoint extends OAuth2AuthenticationEntryPoint {

    @Autowired
    private ObjectMapper objectMapper;

    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException e) throws IOException, ServletException {
       //判断我的异常信息（BusinessException("Invalid token!")） start -------
        if(e.getCause().getCause() instanceof BusinessException){  //最好继承InvalidTokenException重新封装一个异常
            ResponseUtil.responseWriter(false, objectMapper, response, e.getCause().getCause().getMessage(), HttpStatus.UNAUTHORIZED.value());
        }
       //判断我的异常信息（BusinessException("Invalid token!")） end -------
        ResponseUtil.responseWriter(false, objectMapper, response, e.getMessage(), HttpStatus.UNAUTHORIZED.value());
    }

}

该方案并不是很好，redis校验是在鉴权中去做，性能会稍稍下降。扩展：最全的java面试题库

方案二

该类在ResJwtAccessTokenConverter中子类的子类JWTfaultUserAuthenticationConverter。代码如下：

public class JWTfaultUserAuthenticationConverter extends DefaultUserAuthenticationConverter {
   private Collection<? extends GrantedAuthority> defaultAuthorities;

   @Override
   public Authentication extractAuthentication(Map<String, ?> map) {
                //黑名单代码开始
    if(map.containsKey("jti")){
     String jti = (String) map.get("jti");
     Object value = redisUtil.get(jtiRedisKey(jti));
     if (value != null) {
      throw new InvalidTokenException("Invalid token!");
     }
    }
                //黑名单代码结束
    if (map.containsKey(USERNAME)) {
     Object principal = map.get(USERNAME);
    // Collection<? extends GrantedAuthority> authorities = getAuthorities(map);
     LoginAppUser loginUser = new LoginAppUser();
     if (principal instanceof Map) {

      loginUser = BeanUtil.mapToBean((Map) principal, LoginAppUser.class, true);
       

     }
     return new UsernamePasswordAuthenticationToken(loginUser, "N/A", loginUser.getAuthorities());
    }
    return null;
   }
  }

该方案性能甚至不如第一种方案，但是至少比第一种方案合理些。

方案三（全局过滤器）

该方案主要是在鉴权之前先判断Redis中有没有jti的token，如果有，说明在黑名单里，直接返回给前端，无需走后续鉴权流程，性能比较高。

该方案分为两种情况，如果你项目中没有使用网关（Spring Cloud Gateway）鉴权，则走普通过滤器，如果使用网关鉴权，则走网关WebFlux鉴权。

普通服务过滤器

/**
 * lbj
 * 各微服务 获取token时，先判断此token是否在黑名单（退出会保存在redis）中，如果在，则抛异常，否则不做处理
 */
@Slf4j
//@ConditionalOnProperty(name = "myyshop.logoutFilter.enabled", havingValue = "true")
public class LogoutAuthenticationFilter extends OncePerRequestFilter {

    @Autowired
    private RedisUtil redisUtil;

    @Autowired
    private TokenStore tokenStore;

    @Autowired
    private ObjectMapper objectMapper;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        String token = request.getHeader("Authorization");
        if(Strings.isBlank(token) || !token.startsWith(CommonConstant.BEARER_TYPE)){
            filterChain.doFilter(request, response);
        }

        String authHeaderValue = AuthUtils.extractToken(request);
        log.info("authHeaderValue={}", authHeaderValue);
        OAuth2AccessToken accessToken = tokenStore.readAccessToken(authHeaderValue);
        if (accessToken.getAdditionalInformation().containsKey("jti")) {
            String jti = accessToken.getAdditionalInformation().get("jti").toString();
            Object value = redisUtil.get(jtiRedisKey(jti));
            if (value != null) {
                ResponseUtil.responseWriter(false, objectMapper, response, "this is Invalid token!", HttpStatus.UNAUTHORIZED.value());
                return;
            }
        }
        filterChain.doFilter(request, response);
    }

    private String jtiRedisKey(String jti) {
        return SecurityConstants.CACHE_EXPIRE_TOKEN_BLACKLIST + ":" + jti;
    }
}

Spring Cloud Gateway过滤器

/**
 * lbj
 * Webflux 各微服务 获取token时，先判断此token是否在黑名单（退出会保存在redis）中，如果在，则抛异常，否则不做处理
 */
public class LogoutAuthenticationWebFilter implements WebFilter {

    @Autowired
    private RedisTemplate redisTemplate;

    @Autowired
    private TokenStore tokenStore;


    @Override
    public Mono<Void> filter(ServerWebExchange serverWebExchange, WebFilterChain webFilterChain) {

        ServerHttpRequest request = serverWebExchange.getRequest();
        String token = request.getHeaders().getFirst("Authorization");
        if(Strings.isBlank(token) || !token.startsWith(CommonConstant.BEARER_TYPE)){
            return webFilterChain.filter(serverWebExchange);
        }

        String authHeaderValue = token.substring(CommonConstant.BEARER_TYPE.length()).trim();
        OAuth2AccessToken accessToken = tokenStore.readAccessToken(authHeaderValue);
        if (accessToken.getAdditionalInformation().containsKey("jti")) {
            String jti = accessToken.getAdditionalInformation().get("jti").toString();
            Object value = redisTemplate.opsForValue().get(jtiRedisKey(jti));
            if (value != null) {
                return WebfluxResponseUtil.responseFailed(serverWebExchange, HttpStatus.UNAUTHORIZED.value(), "Webflux this is Invalid token!");
            }
        }
        return webFilterChain.filter(serverWebExchange);
    }

    private String jtiRedisKey(String jti) {
        return SecurityConstants.CACHE_EXPIRE_TOKEN_BLACKLIST + ":" + jti;
    }
}

欢迎有需要的同学试试，如果本文对您有帮助，也请帮忙点个 赞 + 在看 啦！❤️ 

在 GitHub猿 还有更多优质项目系统学习资源，欢迎分享给其他同学吧！

最后给读者整理了一份BAT大厂面试真题，需要的可扫码加微信备注：“面试”获取。

◆  ◆  ◆  ◆  ◆ 

（放到你圈子里，朋友们会感激您）PS：如果觉得我的分享不错，欢迎大家随手点赞、在看。本文仅供交流学习 , 版权归属原作者。温馨提示：《Java后端栈》推文内容如有侵权请您告知我们会在第一时间处理或撤销；互联网是一个资源共享的生态圈，我们崇尚分享。好文推荐：

---

欢迎添加栈哥个人微信 ysle007  进粉丝群或围观朋友圈

扫码关注带你吊爆Java后端技术