token保活設計.md

如果我們要使用token機制用以標識用戶登錄狀態，以獲得請求相關資源接口的權限。讓你來設計一套方案，以爲怎麼設計呢？
通常有兩種思路：

1.使用refreshtoken獲取新的accesstoken

登錄成功之後，返回一個返回refreshtoken和accesstoken。accesstoken作爲請求其他接口的權限參數，它有時間期限。過期之後就無法使用。可以使用refresh_token來獲取新的accesstoken。
refresh_token也有時間期限，只不過比較長，一般可設置爲1天或3天。這種設計方案需要客戶端有“token保活機制”，比如accesstoken失效請求失敗，則獲取新的accesstoken重新請求，對時效性要求可能不是那麼高。這種機制一般常見於移動端。
典型的參數
{
“access_token”: “343bec2737979ca0ace85a80c243b1ec”,
“expires_in”: 2592000,
“refresh_token”: “de81cfe747ad7e06f2a904e73646f04c”
}

2.服務端token保活

登錄成功之後，只返回accesstoken。accesstoken作爲請求其他接口的權限參數，它也有時間期限。不同的是，我們將“token保活機制”做在服務端。在token有效內，如果使用了此token，那麼更新token的有效時長，效果相當於重新登錄之後的有效時長。web端就非常適合這樣的機制。

1.token保活機制設計

token保活機制需要滿足下面2個條件

1.登錄成功之後，返回一個token。前端所有請求都帶上token做鑑權驗證。
2.假如token的有效時長是3小時，我們期望的效果是：每用此token請求成功一次，都將token的有效時長自動延長至3小時。

最簡單的處理方法是，每成功請求一次，都對token進行put到Redis的操作，重新設置有效時長。簡單粗暴。但是我們知道，Redis是一個適合“少寫多讀”場景的緩存數據庫，這樣做顯然不合適。
而且對於第2條要求，顯然沒有次次都更新的必要，我們想要的是，在token失效之前的一小段時間，如果有帶次token的請求成功，這時我們再進行一次put到Redis的操作。而且我們希望這樣的更新操作，不會阻塞請求向前執行。

設計方案：

1.使用過濾器Filter攔截除登錄外的所有請求，驗證token是否有效，有效才放行

2.我們將token作爲key，用戶信息還有token上次的請求時間戳作爲value，存在Redis中，並設置有效時間。存redis的原因是，1是便於多個服務獲取當前用戶，2是簡單高效。

3.當Filter驗證token有效之後，異步去Redis查詢上次token使用的時間，如果token的有效時長還剩30分鐘，那麼我們才進行一次更新，將token的有效時長再次設置爲3小時。

2.編碼實現

2.1 過濾器攔截請求驗證token

public class LoginTokenFilter implements Filter {

    private Logger log = Logger.getLogger(this.getClass());

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        log.info("[+]    LoginTokenFilter init");
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain)
            throws IOException, ServletException {

        HttpServletRequest req = (HttpServletRequest) request;
        HttpServletResponse rep = (HttpServletResponse) response;

        // 設置允許跨域的配置
        // 這裏填寫你允許進行跨域的主機ip（正式上線時可以動態配置具體允許的域名和IP）
        rep.setHeader("Access-Control-Allow-Origin", "*");
        // 允許的訪問方法
        rep.setHeader("Access-Control-Allow-Methods", "POST, GET, PUT, OPTIONS, DELETE, PATCH");
        // Access-Control-Max-Age 用於 CORS 相關配置的緩存
        rep.setHeader("Access-Control-Max-Age", "3600");
        rep.setHeader("Access-Control-Allow-Headers", "token,Origin, X-Requested-With, Content-Type, Accept");

        response.setCharacterEncoding("UTF-8");
        response.setContentType("application/json; charset=utf-8");
        String loginUrl = req.getRequestURI();
        if(AdaptorConstants.LOGIN_URL.equals(loginUrl)) {//登錄放行
            filterChain.doFilter(request, response);;
            return ;
        }
        
        String token = req.getHeader("token");// header方式
        ResultObject resultInfo = new ResultObject();

        if (null == token || token.isEmpty()) {
            resultInfo.setCode(AdaptorConstants.UN_AUTHORIZED);
            resultInfo.setMessage("請求參數中無token信息");
        }

        if (TokenUtil.volidateToken(token)) {
            filterChain.doFilter(request, response);// 放行
        } else {
            resultInfo.setCode(AdaptorConstants.UN_AUTHORIZED);
            resultInfo.setMessage("請求參數token信息無效");

            PrintWriter writer = null;
            OutputStreamWriter osw = null;
            try {
                osw = new OutputStreamWriter(response.getOutputStream(), "UTF-8");
                writer = new PrintWriter(osw, true);
                String jsonStr = JacksonUtil.toJson(resultInfo);
                writer.write(jsonStr);
                writer.flush();
                writer.close();
                osw.close();
            } catch (Exception e) {
                log.error("[-] loginFiler tailed :" + e.getMessage(), e);
            } finally {
                if (null != writer) {
                    writer.close();
                }
                if (null != osw) {
                    osw.close();
                }
            }
            return;

        }

    }

    @Override
    public void destroy() {
    }
}

@Configuration
public class WebBeanConfig {    
    /**
     * 鑑權攔截器
     * @return
     */
    @Bean
    public FilterRegistrationBean webAuthFilterRegistration() {
        FilterRegistrationBean registration = new FilterRegistrationBean();
        registration.setFilter(loginTokenFilter());
        registration.setName("loginTokenFilter");
        registration.addUrlPatterns("/api/*");
        registration.addInitParameter("excludeUrls", "/api/login);
        registration.setOrder(0);
        return registration;
    }

    @Bean
    public Filter loginTokenFilter() {
        return new LoginTokenFilter();
    }

}

2.2 檢查token及更新

public class TokenUtil {
    
    public static final String TOKEN_PREFIX = "gw.token.";
    private static CacheService cacheService;
    private static long TOKEN_EXPIRETIME = 3*60*60;//3小時
    private static long BUFFER_EXPIRETIME = 30*60;//30分鐘
    
    private static ExecutorService executor =  createThreadPool();
    
    
    private static ExecutorService createThreadPool() {
        int corePoolSize = 10;
        int maximumPoolSize = 60;
        BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>(300);
        ExecutorService executor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, 5, TimeUnit.MINUTES, workQueue);
        return executor;
    }
    
    public static class TokenChecker implements Runnable{
        String token;
        public TokenChecker(String token) {
            this.token = token;
        }
        @Override
        public void run() {
            TokenUserDTO tokenUser = (TokenUserDTO) getCacheService().get(TOKEN_PREFIX+token);
            if(null != tokenUser) {
                long currentTime = System.currentTimeMillis()/1000;
                if( (tokenUser.getAccessTime()+TOKEN_EXPIRETIME) < (currentTime + BUFFER_EXPIRETIME) ) {
                    //token有效時長小於30分鐘則更新
                    tokenUser.setAccessTime(currentTime);
                    putToken(tokenUser);
                }
            }
        }
    }
    
    public static boolean volidateToken(String token) {
        if(token==null) {
            return false;
        }
        String key = TOKEN_PREFIX+token;
        Object obj = getCacheService().get(key);
        if(obj == null) {
            return false;
        }
        /**
         * token有效，異步檢測更新有效時長
         */
        executor.execute(new TokenChecker(token));
        return true;
    }
    public static void putToken(String token, EnterpriseAccessAccount accessAccount) {
        long currentTime = System.currentTimeMillis()/1000;
        putToken(new TokenUserDTO(token,currentTime,accessAccount));
    }
    public static void putToken(TokenUserDTO tokenUser) {
        getCacheService().set(TOKEN_PREFIX +tokenUser.getToken(), tokenUser, TOKEN_EXPIRETIME);
    }    
    
    private static CacheService getCacheService() {
        if(cacheService == null) {
            cacheService = (CacheService) SpringContextUtil.getBean("cacheService");
        }
        return cacheService;
    }

    public static String genToken() {
        return DigestUtil.md5(UUID.randomUUID().toString());
    }

在TokenUtil的volidateToken方法中，如果驗證token是有效的，則執行executor.execute(new TokenChecker(token));即我們異步查詢判斷token的有效時長，把判斷和更新的操作的線程交給線程池處理。不會阻塞請求的執行。而且大部分都是redis的查詢操作，對性能基本沒有影響。