2. 程式人生 > >spring oauth2+JWT後端自動重新整理access_token

spring oauth2+JWT後端自動重新整理access_token

阿新 • • 發佈：2020-07-24

這段時間在學習搭建基於spring boot的spring oauth2 和jwt整合。

說實話挺折騰的。使用jwt做使用者鑑權，難點在於token的重新整理和登出。

當然登出的難度更大，網上的一些方案也沒有很出色的。這個功能基本讓我放棄了jwt（滑稽笑~）。

所以今天我單純的先記錄jwt token的重新整理。

Token重新整理

jwt token重新整理方案可以分為兩種：一種是校驗token前重新整理，第二種是校驗失敗後重新整理。

我們先來說說第二種方案

驗證失效後，Oauth2框架會把異常資訊傳送到OAuth2AuthenticationEntryPoint類裡處理。這時候我們可以在這裡做jwt token重新整理並跳轉。

網上大部分方案也是這種：失效後，使用refresh_token獲取新的access_token。並將新的access_token設定到response.header然後跳轉，前端接收並無感更新新的access_token。

這裡就不多做描述，可以參考這兩篇：

https://www.cnblogs.com/xuchao0506/p/13073913.html

https://blog.csdn.net/m0_37834471/article/details/83213002

 

接著說第一種，其實兩種方案的程式碼我都寫過，最終使用了第一種。原因是相容其他token重新整理方案。

我在使用第二種方案並且jwt token重新整理功能正常使用後，想換一種token方案做相容。

切換成memory token的時候，發現OAuth2AuthenticationEntryPoint裡面拿不到舊的token資訊導致重新整理失敗。

我們翻一下原始碼

DefaultTokenServices.java

public OAuth2Authentication loadAuthentication(String accessTokenValue) throws AuthenticationException,
			InvalidTokenException {
		OAuth2AccessToken accessToken = tokenStore.readAccessToken(accessTokenValue);
		if (accessToken == null) {
			throw new InvalidTokenException("Invalid access token: " + accessTokenValue);
		}
		else if (accessToken.isExpired()) {
			// 失效後accessToken即被刪除
			tokenStore.removeAccessToken(accessToken);
			throw new InvalidTokenException("Access token expired: " + accessTokenValue);
		}

		// 忽略部分程式碼
		return result;
	}

　　

可以看到JwtTokenStore的removeAccessToken：它是一個空方法，什麼也沒做。所以我們在OAuth2AuthenticationEntryPoint依然能拿到舊的token並作處理。

 

但是其他的token策略在token過期後，被remove掉了。一點資訊都沒留下，巧婦難為無米之炊。所以，我之後選擇選擇了第一種方案，在token校驗remove前做重新整理處理。

jwt token重新整理的方案是這樣的：

客戶端傳送請求大部分只攜帶access_token，並不攜帶refresh_token、client_id及client_secret等資訊。所以我是先把refresh_token、client_id等資訊放到access_token裡面。

因為jwt並不具有續期的功能，所以在判斷token過期後，立刻使用refresh_token重新整理。並且在response的header裡面新增標識告訴前端你的token實際上已經過期了需要更新。

當然，其他的類似memory token、redis token可以延期的，更新策略就沒這麼複雜：直接延長過期時間並且不需要更新token。

 

說了這麼多，放token重新整理相關程式碼：

首先，我們需要把refresh_token、client_id、client_secret放入到access_token中，以便重新整理。所以我們需要重寫JwtAccessTokenConverter的enhance方法。

OauthJwtAccessTokenConverter.java

public class OauthJwtAccessTokenConverter extends JwtAccessTokenConverter {
    private JsonParser objectMapper = JsonParserFactory.create();

    public OauthJwtAccessTokenConverter(SecurityUserService userService) {
        // 使用SecurityContextHolder.getContext().getAuthentication()能獲取到User資訊
        super.setAccessTokenConverter(new OauthAccessTokenConverter(userService));
    }

    @Override
    public OAuth2AccessToken enhance(OAuth2AccessToken accessToken, OAuth2Authentication authentication) {
        DefaultOAuth2AccessToken result = new DefaultOAuth2AccessToken(accessToken);
        Map<String, Object> info = new LinkedHashMap<String, Object>(accessToken.getAdditionalInformation());
        String tokenId = result.getValue();
        if (!info.containsKey(TOKEN_ID)) {
            info.put(TOKEN_ID, tokenId);
        } else {
            tokenId = (String) info.get(TOKEN_ID);
        }

        // access_token 包含自動重新整理過期token需要的資料(client_id/secret/refresh_token)
        Map<String, Object> details = (Map<String, Object>) authentication.getUserAuthentication().getDetails();
        if (!Objects.isNull(details) && details.size() > 0) {
            info.put(OauthConstant.OAUTH_CLIENT_ID,
                    details.getOrDefault("client_id", details.get(OauthConstant.OAUTH_CLIENT_ID)));

            info.put(OauthConstant.OAUTH_CLIENT_SECRET,
                    details.getOrDefault("client_secret", details.get(OauthConstant.OAUTH_CLIENT_SECRET)));
        }

        OAuth2RefreshToken refreshToken = result.getRefreshToken();
        if (refreshToken != null) {
            DefaultOAuth2AccessToken encodedRefreshToken = new DefaultOAuth2AccessToken(accessToken);
            encodedRefreshToken.setValue(refreshToken.getValue());
            // Refresh tokens do not expire unless explicitly of the right type
            encodedRefreshToken.setExpiration(null);
            try {
                Map<String, Object> claims = objectMapper
                        .parseMap(JwtHelper.decode(refreshToken.getValue()).getClaims());
                if (claims.containsKey(TOKEN_ID)) {
                    encodedRefreshToken.setValue(claims.get(TOKEN_ID).toString());
                }
            } catch (IllegalArgumentException e) {
            }
            Map<String, Object> refreshTokenInfo = new LinkedHashMap<String, Object>(
                    accessToken.getAdditionalInformation());
            refreshTokenInfo.put(TOKEN_ID, encodedRefreshToken.getValue());
            // refresh token包含client id/secret, 自動重新整理過期token時用到。
            if (!Objects.isNull(details) && details.size() > 0) {
                refreshTokenInfo.put(OauthConstant.OAUTH_CLIENT_ID,
                        details.getOrDefault("client_id", details.get(OauthConstant.OAUTH_CLIENT_ID)));

                refreshTokenInfo.put(OauthConstant.OAUTH_CLIENT_SECRET,
                        details.getOrDefault("client_secret", details.get(OauthConstant.OAUTH_CLIENT_SECRET)));
            }
            refreshTokenInfo.put(ACCESS_TOKEN_ID, tokenId);
            encodedRefreshToken.setAdditionalInformation(refreshTokenInfo);
            DefaultOAuth2RefreshToken token = new DefaultOAuth2RefreshToken(
                    encode(encodedRefreshToken, authentication));
            if (refreshToken instanceof ExpiringOAuth2RefreshToken) {
                Date expiration = ((ExpiringOAuth2RefreshToken) refreshToken).getExpiration();
                encodedRefreshToken.setExpiration(expiration);
                token = new DefaultExpiringOAuth2RefreshToken(encode(encodedRefreshToken, authentication), expiration);
            }
            result.setRefreshToken(token);
            info.put(OauthConstant.OAUTH_REFRESH_TOKEN, token.getValue());
        }
        result.setAdditionalInformation(info);
        result.setValue(encode(result, authentication));
        return result;
    }
}

　　

資訊準備好了，就要開始處理重新整理。就是改寫DefaultTokenServices的loadAuthentication方法。

OauthTokenServices.java

public class OauthTokenServices extends DefaultTokenServices {
    private static final Logger logger = LoggerFactory.getLogger(OauthTokenServices.class);

    private TokenStore tokenStore;
    // 自定義的token重新整理處理器
    private TokenRefreshExecutor executor;

    public OauthTokenServices(TokenStore tokenStore, TokenRefreshExecutor executor) {
        super.setTokenStore(tokenStore);
        this.tokenStore = tokenStore;
        this.executor = executor;
    }

    @Override
    public OAuth2Authentication loadAuthentication(String accessTokenValue) throws AuthenticationException, InvalidTokenException {
        OAuth2AccessToken accessToken = tokenStore.readAccessToken(accessTokenValue);
        executor.setAccessToken(accessToken);
        // 是否重新整理token
        if (executor.shouldRefresh()) {
            try {
                logger.info("refresh token.");
                String newAccessTokenValue = executor.refresh();
                // token如果是續期不做remove操作，如果是重新生成則刪除舊的token
                if (!newAccessTokenValue.equals(accessTokenValue)) {
                    tokenStore.removeAccessToken(accessToken);
                }
                accessTokenValue = newAccessTokenValue;
            } catch (Exception e) {
                logger.error("token refresh failed.", e);
            }
        }

        return super.loadAuthentication(accessTokenValue);
    }
}

　　

類裡面的TokenRefreshExecutor就是我們的重點。這個類定義了兩個比較重要的介面。

shouldRefresh：是否需要重新整理

refresh：重新整理

TokenRefreshExecutor.java

public interface TokenRefreshExecutor {

    /**
     * 執行重新整理
     * @return
     * @throws Exception
     */
    String refresh() throws Exception;

    /**
     * 是否需要重新整理
     * @return
     */
    boolean shouldRefresh();

    void setTokenStore(TokenStore tokenStore);

    void setAccessToken(OAuth2AccessToken accessToken);

    void setClientService(ClientDetailsService clientService);
}

　

然後我們來看看jwt重新整理器，

OauthJwtTokenRefreshExecutor.java

public class OauthJwtTokenRefreshExecutor extends AbstractTokenRefreshExecutor {

    private static final Logger logger = LoggerFactory.getLogger(OauthJwtTokenRefreshExecutor.class);

    @Override
    public boolean shouldRefresh() {
        // 舊token過期才重新整理
        return getAccessToken() != null && getAccessToken().isExpired();
    }

    @Override
    public String refresh() throws Exception{
        HttpServletRequest request = ServletUtil.getRequest();
        HttpServletResponse response = ServletUtil.getResponse();
        MultiValueMap<String, Object> parameters = new LinkedMultiValueMap<>();
        // OauthJwtAccessTokenConverter中存入access_token中的資料，在這裡使用
        parameters.add("client_id", TokenUtil.getStringInfo(getAccessToken(), OauthConstant.OAUTH_CLIENT_ID));
        parameters.add("client_secret", TokenUtil.getStringInfo(getAccessToken(), OauthConstant.OAUTH_CLIENT_SECRET));
        parameters.add("refresh_token", TokenUtil.getStringInfo(getAccessToken(), OauthConstant.OAUTH_REFRESH_TOKEN));
        parameters.add("grant_type", "refresh_token");
        // 傳送重新整理的http請求
        Map result = RestfulUtil.post(getOauthTokenUrl(request), parameters);

        if (Objects.isNull(result) || result.size() <= 0 || !result.containsKey("access_token")) {
            throw new IllegalStateException("refresh token failed.");
        }

        String accessToken = result.get("access_token").toString();
        OAuth2AccessToken oAuth2AccessToken = getTokenStore().readAccessToken(accessToken);
        OAuth2Authentication auth2Authentication = getTokenStore().readAuthentication(oAuth2AccessToken);
        // 儲存授權資訊，以便全域性呼叫
        SecurityContextHolder.getContext().setAuthentication(auth2Authentication);

        // 前端收到該event事件時，更新access_token
        response.setHeader("event", "token-refreshed");
        response.setHeader("access_token", accessToken);
        // 返回新的token資訊
        return accessToken;
    }

    private String getOauthTokenUrl(HttpServletRequest request) {
        return String.format("%s://%s:%s%s%s",
                request.getScheme(),
                request.getLocalAddr(),
                request.getLocalPort(),
                Strings.isNotBlank(request.getContextPath()) ? "/" + request.getContextPath() : "",
                "/oauth/token");
    }
}

　　

類寫完了，開始使用。

@Configuration
public class TokenConfig {

    @Bean
    public TokenStore tokenStore(AccessTokenConverter converter) {
        return new JwtTokenStore((JwtAccessTokenConverter) converter);
        // return new InMemoryTokenStore();
    }

    @Bean
    public AccessTokenConverter accessTokenConverter(SecurityUserService userService) {
        JwtAccessTokenConverter accessTokenConverter = new OauthJwtAccessTokenConverter(userService);
        accessTokenConverter.setSigningKey("sign_key");
        return accessTokenConverter;
        /*DefaultAccessTokenConverter converter = new DefaultAccessTokenConverter();
        DefaultUserAuthenticationConverter userTokenConverter = new DefaultUserAuthenticationConverter();
        userTokenConverter.setUserDetailsService(userService);
        converter.setUserTokenConverter(userTokenConverter);
        return converter;*/
    }
    @Bean
    public TokenRefreshExecutor tokenRefreshExecutor(TokenStore tokenStore,
                                                     ClientDetailsService clientService) {
        TokenRefreshExecutor executor = new OauthJwtTokenRefreshExecutor();
        // TokenRefreshExecutor executor = new OauthTokenRefreshExecutor();
        executor.setTokenStore(tokenStore);
        executor.setClientService(clientService);
        return executor;
    }

    @Bean
    public AuthorizationServerTokenServices tokenServices(TokenStore tokenstore,
                                                          AccessTokenConverter accessTokenConverter,
                                                          ClientDetailsService clientService,
                                                          TokenRefreshExecutor executor) {

        OauthTokenServices tokenServices = new OauthTokenServices(tokenstore, executor);
        // 非jwtConverter可註釋setTokenEnhancer
        tokenServices.setTokenEnhancer((TokenEnhancer) accessTokenConverter);
        tokenServices.setSupportRefreshToken(true);
        tokenServices.setClientDetailsService(clientService);
        tokenServices.setReuseRefreshToken(true);
        return tokenServices;
    }
}

　　

然後是認證伺服器相關程式碼

@Configuration
@EnableAuthorizationServer
public class AuthorizationServerConfiguration extends AuthorizationServerConfigurerAdapter {

    @Autowired
    private AuthenticationManager manager;
    @Autowired
    private SecurityUserService userService;
    @Autowired
    private TokenStore tokenStore;
    @Autowired
    private AccessTokenConverter tokenConverter;
    @Autowired
    private AuthorizationServerTokenServices tokenServices;

    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        endpoints.tokenStore(tokenStore)
                .authenticationManager(manager)
                .allowedTokenEndpointRequestMethods(HttpMethod.GET, HttpMethod.POST)
                .userDetailsService(userService)
                .accessTokenConverter(tokenConverter)
                .tokenServices(tokenServices);
    }

    @Override
    public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
        security.tokenKeyAccess("permitAll()") //url:/oauth/token_key,exposes public key for token verification if using JWT tokens
                .checkTokenAccess("isAuthenticated()") //url:/oauth/check_token allow check token
                .allowFormAuthenticationForClients();
    }

    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        clients.withClientDetails(clientDetailsService());
    }

    public ClientDetailsService clientDetailsService() {
        return new OauthClientService();
    }
}

　　

接著是前端處理, 用的axios。

service.interceptors.response.use(res => {
    // 快取自動重新整理生成的新token
    if (res.headers['event'] && "token-refreshed" === res.headers['event']) {
      setToken(res.headers['access_token'])
      store.commit('SET_TOKEN', res.headers['access_token'])
    }
    // 忽略部分程式碼
}

　　

這樣就做到了jwt無感重新整理。

講完了jwt的token重新整理，多嘴說說memory token的重新整理。

上面講了，memory token重新整理策略比較簡單，每次請求過來直接給token延期即可。

OauthTokenRefreshExecutor.java

public class OauthTokenRefreshExecutor extends AbstractTokenRefreshExecutor {
    private int accessTokenValiditySeconds = 60 * 60 * 12;

    @Override
    public boolean shouldRefresh() {
        // 與jwt不同，因為每次請求都需要延長token失效時間，所以這裡是token未過期時就需要重新整理
        return getAccessToken() != null && !getAccessToken().isExpired();
    }

    @Override
    public String refresh() {
        int seconds;
        if (getAccessToken() instanceof DefaultOAuth2AccessToken) {
            // 獲取client中的過期時間, 沒有則預設12小時
            if (getClientService() != null) {
                OAuth2Authentication auth2Authentication = getTokenStore().readAuthentication(getAccessToken());
                String clientId = auth2Authentication.getOAuth2Request().getClientId();
                ClientDetails client = getClientService().loadClientByClientId(clientId);
                seconds = client.getAccessTokenValiditySeconds();
            } else {
                seconds = accessTokenValiditySeconds;
            }
            // 只修改token失效時間
            ((DefaultOAuth2AccessToken) getAccessToken()).setExpiration(new Date(System.currentTimeMillis() + (seconds * 1000l)));
        }
        // 返回的還是舊的token
        return getAccessToken().getValue();
    }
}

　　　　

然後修改TokenConfig相關bean註冊即可。

 

好了，Token重新整理這塊差不多就這樣了。Token登出暫時沒有好的思路。

如果Token重新整理有更好的方案可以告知，也歡迎分享Token登出方案。

&n

相關推薦

spring oauth2+JWT後端自動重新整理access_token

這段時間在學習搭建基於spring boot的spring oauth2 和jwt整合。 說實話挺折騰的。使用jwt做使用者鑑權，難點在於token的重新整理和登出。 當然登出的難度更大，網上的一些方案也沒有很出色的。這個功能基本讓我放棄了jwt（滑稽笑~）。 所以今天我單純的先記錄jwt token的重新整

Spring Cloud Config 之svn配置倉庫與動態重新整理（客戶端自動重新整理）

終於進入正文了，上篇完成了手動重新整理，貌似這種手動重新整理不是太好，因為你怎麼知道什麼時候去更新配置？我們的初衷是隻要配置檔案目錄下的檔案改變了，就要重新載入配置，也就是在svn倉庫的config目錄下的配置檔案改動自動重新整理 目前來看就兩個問題： 1：我怎麼確定是哪個

spring boot security oauth2 jwt 服務端實現

最近在寫提供給第三方的登入和獲取資源，老大說要使用oauth2 協議，因此最近在啃這一塊。一下是個人的配置。 首先要理解什麼是OAUTH2協議。 以下是阮一峰大大的文章：http://www.ruanyifeng.com/blog/2014/05/oauth_2_0.htm

後端自動驗證與錯誤提示

ces UC color ges log reat uniq use play 驗證錯誤提示：控制器裏調取模型中的方法 $this->error($cate->getError()); 模型裏CateModel.class.php： <?php

入坑Java，開始Spring boot 的後端開發之路

也有 得來 中間 調用 代碼 行記錄 廣泛 隨手記 domain 換了工作，從遊戲行業的大坑中走了出來，走向互聯網的大世界。新的公司是電商方向，電商行業萬變不離其宗，java，spring是最廣泛的技術。當然也有過一些特立獨行的，也做得很大，不過現在都基本切換到了這個方向。

使用 Kotlin + Spring Boot 進行後端開發

Kotlin Kotlin 是一個基於 JVM 的程式語言，它的簡潔、便利早已不言而喻。Kotlin 能夠勝任 Java 做的所有事。目前，我們公司 C 端 的 Android 產品全部採用 Kotlin 編寫。公司的後端專案也可能會使用 Kotlin，所以我給他們做一些 demo 進行演

layui form表單提交後，自動重新整理

剛剛使用layui 來做東西，對這一切都不熟悉，使用一下form表單，但是，不能成功的使用。 問題： 提交表單，頁面自動重新整理。 出現這樣的情況呢，搜尋了一下是因為表單的提交按鈕沒有type型別。哪怕是button標籤呢，也不行。我試了一下，使用這種情況的話，主要是

spring mvc 獲取後端傳遞的值

jsp頁面怎麼獲取從後端傳遞過來的值？ JSTL 方法獲取後端傳遞的值 @RequestMapping("index1") public ModelAndView index1() { ModelAndView model = new ModelAndView("/Ind

實現SpringCloud Config 客戶端自動重新整理

一、簡介 在使用SpringCloud Config客戶端時，如果Config服務端配置檔案發現了變化，如果客戶端需要同步的話，需要手動的訪問客戶端的/refresh（POST請求）端點來重新整理客戶端配置 使用定時器的方式來解決手動重新整理 1、找到類org.

SrpingCloud ---github上面如何使用webHook實現配置檔案修改 ，客戶端自動重新整理

SrpingCloud —github上面如何使用webHook實現配置檔案修改 ，客戶端自動重新整理 一：客戶端(消費者)端新增maven依賴 <dependency> <groupId>org.springframewor

Java Spring WebSocket實現後端訊息主動推送

這篇文章將介紹如何構建一個簡單的WebSocket訊息推送Demo使用eclipse建立maven專案後引入相關的依賴jar包，如下：<?xml version="1.0" encoding="UTF-8"?><project xmlns="http://m

dataTable使用ajax後不自動重新整理表格

$(document).ready(function() {$('#summaryTable').DataTable({columnDefs : [ {orderable : false,//禁用排序targets : [ 5 ]//指定的列，以“，”號分割} ]});})

如何用Spring OAuth2.0 Client元件獲取授權access_token

使用背景 ：公司有個開放平臺，若要訪問開放平臺，必須先要獲取授權訪問令牌（也就是下面說的：access_token）。公司的授權系統是用spring oauth2.0實現的，今天就不講這個專案，網上比較多。今天主要是講下如何用spring OAuth2.0 Client 元

[技巧分享-window10]win10新建或刪除檔案後不自動重新整理

win10新建或刪除檔案後不自動重新整理 [技巧分享-window10] 問題描述： win10系統經常出現"新建或刪除檔案後不自動重新整理"，導致新建資料夾重新命名失敗或刪除檔案失敗。 解決： 控制

Spring整合Hibernate後沒有自動在資料庫中建立表結構

Hibernate配置檔案hibernate.cfg.xml中關於SessionFactory節點配置通常如下： <session-factory> <!-- Database connection settings --> <proper

Spring JSTL 獲取後端數據失敗。

.com jsp eight eat 分享 1.2 false www. 後端 顯示的jsp頁面仍是${XXX}的形式。 解決方法一： 　　這是因為我們在web.xml中使用的是jsp1.2版本的DTD，在此版本JSTL默認不打開，我們需要手動打開，打開方法： 　　在相應的

Session與JWT（實現JWT重新整理與後端限制授權）

Session與JWT（實現JWT重新整理與後端限制授權）   後端專案地址就不剝離開了，自己解讀（中介軟體那）前端專案地址（可能是空的，為還沒上傳O(∩_∩)O哈哈~） 前言 Hello World！怕是大多數程式設計師寫的第一句程式碼了吧。我就是用C語言寫的第一個程式碼

後端-框架-Spring-MyBatis-自動裝配

後端-框架-Spring-MyBatis-自動裝配 bean標籤下autowire屬性 autowire value no 手動裝配 byName

spring security oauth2 自動重新整理續簽token (refresh token)

1.引言 本篇文章適合瞭解過oauth2，有用過spring security oauth2的讀者並且瞭解過濾器鏈路的人。本篇文章的思路是首先獲取資源伺服器的某一個資源，當認證失敗返回401的時候我們通過異常處理器的嘗試通過refresh token 進行token的重新整

重拾後端之Spring Boot（四）：使用JWT和Spring Security保護REST API

通常情況下，把API直接暴露出去是風險很大的，不說別的，直接被機器攻擊就喝一壺的。那麼一般來說，對API要劃分出一定的許可權級別，然後做一個使用者的鑑權，依據鑑權結果給予使用者開放對應的API。目前，比較主流的方案有幾種: 使用者名稱和密碼鑑權，使用Session儲存使用