Oauth2 + JWT登出（一）（白名單方案）

說(shuō)明

JWT的缺點(diǎn)上一篇已經(jīng)講了，不知道的請(qǐng)看上一篇。上篇已經(jīng)說(shuō)了，同一個(gè)用戶id，調(diào)兩次登錄接口，如果這個(gè)token沒(méi)過(guò)期，那應(yīng)該返回同一個(gè)token，但是JWT是兩次返回的都不是一個(gè)token，這樣會(huì)多消耗資源，其實(shí)正常的場(chǎng)景是，只要token沒(méi)過(guò)期，不管調(diào)多少次登錄接口返回的都是同一個(gè)token。
每次登錄把token都放Redis里進(jìn)行白名單處理，資源接口去判斷是否在Redis里，如果不在白名單里的都認(rèn)為過(guò)期或不合法的token，就不讓登錄，這樣還能做在線踢人功能，而且后期的續(xù)簽功能也能在這個(gè)基礎(chǔ)上做。Redis key 這里選userId，因?yàn)閡serId是唯一的，當(dāng)然選jti也是一樣的。

方案

以下方案都是基于Redis

  1. 登錄前先判斷當(dāng)前userId的key是否在redis里，如果在，不走后續(xù)登錄鑒權(quán)流程，直接返回token。否則走后續(xù)登錄鑒權(quán)流程。
  2. 登錄后基于切面（@AfterReturning）拿到返回結(jié)果，判斷userId的key是否在redis里，如果在，則返回redis里的token。否則走原流程，返回Oauth2新生成的token。
  3. 覆蓋JwtTokenStore.storeAccessToken()方法。方法內(nèi)先判斷userId的key是否在redis里，如果在，則改變形參OAuth2AccessToken值，返回redis里的token傳到外面去（這里注意：必須redis存的是token的byte[]）

上面推薦使用方案3，成本最小

方案一

有幾種選擇，可以使用過(guò)濾器、攔截器、AOP。過(guò)濾器范圍太大，因?yàn)橹恍枰^(guò)濾登錄的接口（包含老登錄接口和新登錄接口），其他接口都不用管，所以這里選擇攔截器或者AOP，指定過(guò)濾路徑或方法。
因?yàn)槔系卿浗涌谑茾RequestBody方式傳的參數(shù)形式，所以如果用攔截器，只能通過(guò)request去拿body參數(shù)，如下：

Map<String,Object> params = new HashMap<String, Object>();
        BufferedReader br;
        try {
            br = request.getReader();
            String str, wholeStr = "";
            while((str = br.readLine()) != null){
                wholeStr += str;
            }
            if(StringUtils.isNotEmpty(wholeStr)){
                params = JSON.parseObject(wholeStr,Map.class);
            }
        } catch (IOException e1) {
            logger.error(""+e1);
        }

但是一個(gè)流不能讀兩次異常，這種異常一般出現(xiàn)在框架或者攔截器中讀取了request中的流的數(shù)據(jù)，我們?cè)跇I(yè)務(wù)代碼中再次讀取（如@requestBody），由于流中的數(shù)據(jù)已經(jīng)沒(méi)了，所以第二次讀取的時(shí)候就會(huì)拋出異常。

攔截器偽代碼如下（不考慮二次流問(wèn)題，這里直接從parameter拿出來(lái)）：

/**
 * lbj
 * 登錄之前判斷token是否存在Redis中（白名單），如果存在，則直接返回；否則進(jìn)行登錄
 */
@Component
public class BeforeLoginAuthenticationFilter extends OncePerRequestFilter {
    @Autowired
    private RedisUtil redisUtil;

    @Autowired
    private ObjectMapper objectMapper;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        String username = request.getParameter("username");
        User user = findbyUsername(username);
        String userId = user .getUserId();
        Object value = redisUtil.get(userIdRedisKey(userId));
        if (value != null) {
            ResponseUtil.responseSucceed(objectMapper, response, value);
            return;
        }
    }
    private String userIdRedisKey(String userId) {
        return SecurityConstants.CACHE_EXPIRE_TOKEN_WHITELIST + ":" + userId;
    }
}

AOP偽代碼如下（跟上面效果一樣，兩種實(shí)現(xiàn)方式）：

    @Around("execution(* com.dhgate.saas.uaa.controller.Oauth2Controller.userTokenInfo(..))")
    public Object doAround(ProceedingJoinPoint pjp) throws Throwable{
        log.info("OauthTokenAspect.doAround 開(kāi)始...");
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = Objects.requireNonNull(attributes).getRequest();
        HttpServletResponse response = Objects.requireNonNull(attributes).getResponse();
        String username = request.getParameter("username");
        User user = findbyUsername(username);
        String userId = user .getUserId();
        LoginTokenDto tokenDto = (LoginTokenDto) redisUtil.get(userIdRedisKey(userId));
        if (tokenDto != null) {
            tokenDto.setExpires_in(redisUtil.getExpire(userIdRedisKey(userId)));
            ResponseUtil.responseSucceed(objectMapper, response, tokenDto);
            return true;
        }
        Object proceed = pjp.proceed();
        return proceed;
    }

實(shí)現(xiàn)JwtTokenStore重寫storeAccessToken()和removeAccessToken()方法。storeAccessToken()方法是把token存入redis；removeAccessToken()方法是把token從redis刪除（登錄接口會(huì)調(diào)這個(gè)方法），代碼如下（該類在CustomJwtTokenStore）：

    @Override
    public void storeAccessToken(OAuth2AccessToken token, OAuth2Authentication authentication) {
        LoginTokenDto loginTokenDto = (LoginTokenDto) redisUtil.get(userIdRedisKey(userId));
        if(Objects.isNull(loginTokenDto)){
            LoginTokenDto transFerToken = LoginTokenDto.builder().access_token(token.getValue())
                    .token_type(token.getTokenType())
                    .refresh_token(token.getRefreshToken().getValue())
//                    .expires_in(Long.valueOf(token.getExpiresIn()))
                    .scope(String.join(",", token.getScope()))
                    .userId(token.getAdditionalInformation().get("userId").toString())
                    .jti(token.getAdditionalInformation().get("jti").toString())
                    .build();
            redisUtil.set(userIdRedisKey(userId), transFerToken, token.getExpiresIn());
        }
        super.storeAccessToken(token, authentication);
    }

    @Override
    public void removeAccessToken(OAuth2AccessToken token) {
        if (token.getAdditionalInformation().containsKey("userId")) {
            String userId = token.getAdditionalInformation().get("userId").toString();
            RedisUtil redisUtil = Optional.ofNullable(SpringContextUtil.getBean(RedisUtil.class))
                    .orElseThrow(() -> new InnerException("internal bean acquisition failed."));
            redisUtil.del(userIdRedisKey(userId));
        }
        super.removeAccessToken(token);
    }

最后每個(gè)資源服務(wù)器拿token前，先去redis中判斷userId的key是否存在，如果白名單不存在 或者 拿到的參數(shù)map中的jti和redis中token攜帶的jti不等，標(biāo)識(shí)為不是一次token， 則直接返回"Invalid token!"異常標(biāo)識(shí)。如果userId的key在白名單內(nèi)，則繼續(xù)后續(xù)流程。

方法extractAuthentication()在ResJwtAccessTokenConverter.JwtUserAuthenticationConverter.JWTfaultUserAuthenticationConverter中，部分代碼如下：
下面用到了黑名單三種方案中的方案二，當(dāng)然按需選擇用哪個(gè)。

public Authentication extractAuthentication(Map<String, ?> map) {
                                 //白名單校驗(yàn)邏輯開(kāi)始---------------------------
                RedisUtil redisUtil = SpringContextUtil.getBean(RedisUtil.class);
                if(map.containsKey("userId") && map.containsKey("jti")){
                    String userId = (String) map.get("userId");
                    String jti = (String) map.get("jti");
                    String tokenByteStr = (String) redisUtil.get(userIdRedisKey(userId));
                    if(!StringUtils.isEmpty(tokenByteStr)){
                        byte[] tokenByte = Base64.getDecoder().decode(tokenByteStr);
                        DefaultOAuth2AccessToken token = (DefaultOAuth2AccessToken) deserializeAccessToken(tokenByte);
                        if (token == null || !Objects.equals(jti, token.getAdditionalInformation().get("jti"))) {
                            throw new InvalidTokenException("Invalid token!");
                        }
                    }else{
                        throw new InvalidTokenException("Invalid token!");
                    }
                }
                            //白名單校驗(yàn)邏輯結(jié)束（以下跟白名單無(wú)關(guān)）---------------------------

                if (map.containsKey("user_info")) {
                    Object principal = map.get("user_info");
                //  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;
            }

方案二

基于方案一反向思考，方案一是在登錄前，方案二是在調(diào)用登錄接口后，拿到Oauth2生成的token，然后去判斷是否在Redis中，如果在，則返回Redis中的，Oauth2生成的token則達(dá)到一種“胎死腹中”的效果。如果不在，返回Oauth2新生成token。

這里可以用Spring AOP去做，因?yàn)镾pring AOP能方便拿到返回值，而攔截器稍微麻煩些，代碼如下：

    @AfterReturning(value = "pointcut()", returning = "rvt")
    public void afterReturning(JoinPoint joinPoint, Object rvt) throws Throwable {
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletResponse response = Objects.requireNonNull(attributes).getResponse();
        Result result = (Result) rvt;
        if(result.getSuccess()){
            DefaultOAuth2AccessToken oAuth2AccessToken = (DefaultOAuth2AccessToken) result.getData();
            Map<String, Object> map = oAuth2AccessToken.getAdditionalInformation();
            if(map.containsKey("userId")){
                String userId = (String) map.get("userId");
                LoginTokenDto tokenDto = (LoginTokenDto) redisUtil.get(userIdRedisKey(userId));
                if (tokenDto != null) {
                    tokenDto.setExpires_in(redisUtil.getExpire(userIdRedisKey(userId)));
                    ResponseUtil.responseSucceed(objectMapper, response, tokenDto);
                    return;
                }
            }
        }
    }

其他地方改動(dòng)類似方案一，修改storeAccessToken()方法。

方案三

第三種方案不需要過(guò)濾器、攔截器和AOP，直接在storeAccessToken()方法判斷redis中是否有token，如果有，直接把redis中token（也是一個(gè)OAuth2AccessToken）去覆蓋老的OAuth2AccessToken即可。值得注意的是，對(duì)象默認(rèn)傳遞是引用傳遞，要改變整個(gè)對(duì)象。如果直接寫 token = tokenSource; 是不行的，因?yàn)檫@不能改變對(duì)象的指針，默認(rèn)拿到的還是之前的對(duì)象，想改變對(duì)象里面值，有兩種辦法，1.直接set屬性（但是這樣一個(gè)一個(gè)set比較麻煩） 2.直接深復(fù)制。

注意：這里存入的redis是一個(gè)byte[]流，用的是JdkSerializationStrategy的序列化方式（RedisTokenStore就是用的這種方式）。好處是時(shí)間不是存redis死的，然后最后解析反序列化也是OAuth2AccessToken對(duì)象。

    @Override
    public void storeAccessToken(OAuth2AccessToken token, OAuth2Authentication authentication) {
        // 這里token 和 accessToken 是一個(gè)東西，打斷點(diǎn)，看他們的內(nèi)存地址，都是一個(gè)
        DefaultOAuth2AccessToken accessToken = (DefaultOAuth2AccessToken) token;
        if (token.getExpiresIn() > 0 && token.getAdditionalInformation().containsKey("userId")) {
            String userId = token.getAdditionalInformation().get("userId").toString();
            RedisUtil redisUtil = Optional.ofNullable(SpringContextUtil.getBean(RedisUtil.class))
                    .orElseThrow(() -> new InnerException("internal bean acquisition failed."));

            String tokenByteStr = (String) redisUtil.get(userIdRedisKey(userId));
            if(!StringUtils.isEmpty(tokenByteStr)){
                byte[] tokenByte = Base64.getDecoder().decode(tokenByteStr);
                DefaultOAuth2AccessToken tokenSource = (DefaultOAuth2AccessToken) deserializeAccessToken(tokenByte);

                //對(duì)象默認(rèn)傳遞是引用傳遞，要改變整個(gè)對(duì)象。如果直接寫 token = tokenSource; 是不行的，因?yàn)檫@不能改變對(duì)象的指針，默認(rèn)拿到的還是之前的對(duì)象
                //想改變對(duì)象里面值，有兩種辦法，1.直接set屬性（但是這樣一個(gè)一個(gè)set比較麻煩） 2.直接深復(fù)制，就是下面這句話
                BeanUtils.copyProperties(tokenSource, accessToken);
            }else{
                byte[] serializedAccessToken = this.serialize((Object)token);
                String encoded = Base64.getEncoder().encodeToString(serializedAccessToken);
                redisUtil.set(userIdRedisKey(userId), encoded, token.getExpiresIn());
            }
        }
        super.storeAccessToken(accessToken, authentication);
    }
最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請(qǐng)聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時(shí)請(qǐng)結(jié)合常識(shí)與多方信息審慎甄別。
平臺(tái)聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點(diǎn)，簡(jiǎn)書系信息發(fā)布平臺(tái)，僅提供信息存儲(chǔ)服務(wù)。
禁止轉(zhuǎn)載，如需轉(zhuǎn)載請(qǐng)通過(guò)簡(jiǎn)信或評(píng)論聯(lián)系作者。

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容