前言

之前給大家許諾的給xmall 加上jwt 校驗的專案終于弄好了，最近一直加班身心俱疲，

提示：以下是本篇文章正文內容，下面案例可供參考

一、無狀態登錄是什么？

了解JWT首先要知道什么是無狀態登錄，什么是有狀態登錄，

1.有狀態登錄

有狀態登錄：有狀態服務，即服務端需要記錄每次會話的客戶端資訊，從而識別客戶端身份，根據用戶身份進行請求的處理，典型的設計如tomcat中的session，
例如登錄：用戶登錄后，我們把登錄者的資訊保存在服務端session中，并且給用戶一個cookie值，記錄對應的session，然后下次請求，用戶攜帶cookie值來，我們就能識別到對應session，從而找到用戶的資訊，
缺點是什么？

• 服務端保存大量資料，增加服務端壓力
• 服務端保存用戶狀態，無法進行水平擴展
• 客戶端請求依賴服務端，多次請求必須訪問同一臺服務器

2.無狀態登錄

微服務集群中的每個服務，對外提供的都是Rest風格的介面，而Rest風格的一個最重要的規范就是：服務的無狀態性，即：

• 服務端不保存任何客戶端請求者資訊
• 客戶端的每次請求必須具備自描述資訊，通過這些資訊識別客戶端身份

無狀態登錄的優點

• 客戶端請求不依賴服務端的資訊，任何多次請求不需要必須訪問到同一臺服務
• 服務端的集群和狀態對客戶端透明
• 服務端可以任意的遷移和伸縮
• 減小服務端存盤壓力

3.如何實作無狀態

無狀態登錄的流程：

• 當客戶端第一次請求服務時，服務端對用戶進行資訊認證（登錄）
• 認證通過，將用戶資訊進行加密形成token，回傳給客戶端，作為登錄憑證
• 以后每次請求，客戶端都攜帶認證的token
• 服務的對token進行解密，判斷是否有效，

流程圖：

整個登錄程序中，最關鍵的點是什么？
token的安全性
token是識別客戶端身份的唯一標示，如果加密不夠嚴密，被人偽造那就完蛋了，

采用何種方式加密才是安全可靠的呢？

我們將采用JWT + RSA非對稱加密

4.JWT

JWT,全稱是Json Web Token,是JSON風格輕量級的授權和身份認證規范，可實作無狀態、分布式的Web應用授權；官網：https://jwt.io

JWT資料格式
JWT包含三部分資料：

• Header：頭部，通常頭部有兩部分資訊
  宣告型別，這里是JWT
  我們會對頭部進行base64編碼，得到第一部分資料
• Payload：載荷，就是有效資料，一般包含下面資訊：
  用戶身份資訊（注意，這里因為采用base64編碼，可解碼，因此不要存放敏感資訊）
  注冊宣告：如token的簽發時間，過期時間，簽發人等
  這部分也會采用base64編碼，得到第二部分資料
• Signature：簽名，是整個資料的認證資訊，一般根據前兩步的資料，再加上服務的的密鑰（secret）（不要泄漏，最好周期性更換），通過加密演算法生成，用于驗證整個資料完整和可靠性
  生成的資料格式：token==個人證件 jwt=個人身份證
  

5.JWT互動流程

流程圖：

步驟翻譯：

• 1、用戶登錄
• 2、服務的認證，通過后根據secret生成token
• 3、將生成的token回傳給瀏覽器
• 4、用戶每次請求攜帶token
• 5、服務端利用公鑰解讀jwt簽名，判斷簽名有效后，從Payload中獲取用戶資訊
• 6、處理請求，回傳回應結果
  因為JWT簽發的token中已經包含了用戶的身份資訊，并且每次請求都會攜帶，這樣服務的就無需保存用戶資訊，甚至無需去資料庫查詢，完全符合了Rest的無狀態規范，

二、理解原有解決方案!

1.準備util類

JWTUtil

@Component
public class JwtUtil {
    @Value(value = "60000")
    private String tokenValidTime;

    /***
     * 創建token
     * @param username
     * @param currentTimeMillis
     * @return
     */
    public String createToken(String username,String currentTimeMillis){
        try{
            //加密
            Algorithm algorithm = Algorithm.HMAC256(username);
            Date tokenExpireDate = getExpireTime();
            return JWT.create().withClaim("username",username)
                    .withClaim(RedisConstant.CURRENT_TMIE_MILLIS,currentTimeMillis)
                    .withExpiresAt(tokenExpireDate).sign(algorithm);
        } catch (Exception e){
            throw new XmallException("JWTToken驗證token出現UnsupportedEncodingException例外：" + e.getMessage());
        }

    }

    /***
     * 獲取token過期時間
     * @return
     */
    private Date getExpireTime(){
        long currentTimeMillis = System.currentTimeMillis();
        return new Date(currentTimeMillis+Integer.valueOf(tokenValidTime));
    }

    /**
     * 驗證token
     *
     * @param username
     * @param token
     * @return
     */
    public boolean verifyToken(String username, String token) {
        try {
            Algorithm algorithm = Algorithm.HMAC256(username);
            JWTVerifier verifier = JWT.require(algorithm).withClaim("username", username).build();
            verifier.verify(token);
            return true;
        } catch (Exception e) {
            throw new XmallException("驗證失敗："+e.getMessage());
        }
    }

    /**
     * 根據key獲取token中攜帶key對應的資訊
     *
     * @param token token
     * @param key   關鍵詞
     * @return 該關鍵詞攜帶的值
     */
    public String getValueFromTokenByKey(String token, String key) {
        try {
            DecodedJWT decodedJWT = JWT.decode(token);
            return decodedJWT.getClaim(key).asString();
        } catch (JWTDecodeException e) {
            return null;
        }
    }

    /**
     * 獲取token中username對應的值
     *
     * @param token
     * @return
     */
    public String getUsernameFromToken(String token) {
        return getValueFromTokenByKey(token, "username");
    }

    /**
     * 獲取token中的創建的時間戳
     *
     * @param token
     * @return
     */
    public String getCurrentTmieMillisFromToken(String token) {
        return getValueFromTokenByKey(token, RedisConstant.CURRENT_TMIE_MILLIS);
    }

JedisClientPool 里添加

/**
	 * 設定key ，value 并且設定其過期時間
	 *
	 * @param key
	 * @param value
	 * @param expireTime
	 * @return
	 */
	 @Override
	public String set(String key,String value,int expireTime){
		Jedis jedis = jedisPool.getResource();
		String result = jedis.set(key, value);
		if ("OK".equals(result)) {
			jedis.expire(key, expireTime);
		}
		jedis.close();
		return result;
	}

還需要在JedisClient 介面里寫個方法

2.xmall-manager-web 重點

先理一下他原來的解決方法
首先我看找到登錄的地方

我們可以看到原來的專案里直接把 password 進行了MD5加密
再和username 組裝成token
呼叫 subject.login(token)
呼叫這個之后會到MyRealm類里執行doGetAuthenticationInfo方法

這里可以看到從token中獲取username,去資料庫里查詢，查到 就把資料放到
SimpleAuthenticationInfo類物件里回傳，這里我們注意new 實體化 傳的引數

SimpleAuthenticationInfo(Object principal, Object credentials, String realmName)

第一個是主鍵，第二個是證書，第三個隨便只要不為null

到這兒只是部分登錄的流程，還有幾個重點現在開始講完整的請求程序
先看一下shiro的配置

加入一個查詢的請求過來
首先被我們MyPermissionFilter攔截器攔截

subject.getPrincipal() 就是我們剛剛說的SimpleAuthenticationInfo 里的第一個引數
如果沒有值就是沒有登錄，如果登錄里就判斷 parms 是否被允許
subject.isPermitted(perms[0])
perms 這個值是哪里來的呢？和shiro框架里的比較，框架里是拿來的的？
第一個問題：
perms的值isAccessAllowed(ServletRequest request, ServletResponse response, Object o) 來之Object o 這個值就是來之組態檔的filterChainDefinitions
但是xmall專案把校驗的配置放到資料庫中了tb_shiro_filter
組態檔里可以看到專案自己實作了MyShiroFilterFactoryBean，這里面可以看到是讀取資料庫中的配置的，一個什么請求后面就帶了需要校驗的權限或者角色

第二個問題
還是看回我們的MyRealm
doGetAuthorizationInfo方法獲取了當前賬號所有的角色和權限路徑

三.改造專案

在controller 中

@ResponseBody
    @RequestMapping(value = "/login", method = RequestMethod.POST)
    public CommonResult login(String username, String password) {
        String token = userService.login(username, password);
        if (token != null) {
            return CommonResult.success(token);
        }
        return CommonResult.failed("傳入賬號或密碼錯誤", null);
    }

在userService中

/**
     * 用戶登錄
     *
     * @param username
     * @param password
     * @return
     */
    public String login(String username, String password) {
        User user = getUserByUsername(username);
        if (user != null && user.getPassword().equals(password)) {
            // redis存盤的時間戳
            String currentTimeMillis = String.valueOf(System.currentTimeMillis());
            // redis 設定
            redisUtil.set(username, currentTimeMillis);
            return jwtUtil.createToken(username, currentTimeMillis);
        } else {
            return null;
        }
    }

主要作業：1、把username 和password 和資料里比較如果存在
2、存到redis中設定過期時間
3、使用JWT 生成token
然后新建一個MyShiroRealm

public class MyShiroRealm extends AuthorizingRealm {
    private static final Logger log= LoggerFactory.getLogger(MyRealm.class);

    @Autowired
    private UserService userService;

    @Autowired
    JwtUtil jwtUtil;

    @Autowired
    JedisClient redisUtil;

    /**
     * 回傳權限資訊
     * @param principal
     * @return
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principal) {
        // 從token中獲取username
        String username = jwtUtil.getUsernameFromToken(principal.toString());
        TbUser tbUser = userService.getUserByUsername(username);
        SimpleAuthorizationInfo authorizationInfo=new SimpleAuthorizationInfo();
        //獲得授權角色
        authorizationInfo.setRoles(userService.getRoles(username));
        //獲得授權權限
        authorizationInfo.setStringPermissions(userService.getPermissions(username));
        return authorizationInfo;
    }

    /**
     * 先執行登錄驗證
     * @param auth
     * @return
     * @throws AuthenticationException
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken auth) throws AuthenticationException {
        // 在shiro中獲得用戶（token）
        String token = (String) auth.getCredentials();
        // 驗證token 首先查看token是否包含username，其次查看其中的username是否在資料庫里，最后，校驗token的正確性
        String username = jwtUtil.getUsernameFromToken(token);
        if (username == null) {
            throw new AuthenticationException("無效token");
        }
        // 驗證用戶是否存在
        TbUser tbUser = userService.getUserByUsername(username);
        if(tbUser == null){
            throw new AuthenticationException("無效token");
        }

        String redisUsername = String.format("%s%s", RedisConstant.REDIS_USERNAME_PREFIX, username);
        //資料庫里取的username 和token和redis里的比較是否一致
        if(jwtUtil.verifyToken(username,token) && redisUtil.exists(redisUsername)){
            // redis中存盤的token
            String currentTimeMillisRedis = redisUtil.get(redisUsername); //根據key可以獲取存盤的時間戳
            //從引數token中獲取時間戳 和redis里存的比較是否一致
            if(jwtUtil.getCurrentTmieMillisFromToken(token).equals(currentTimeMillisRedis)){
                //得到用戶賬號(token)和密碼(token)存放到authenticationInfo中用于Controller層的權限判斷 第三個引數隨意不能為null
                return new SimpleAuthenticationInfo(token,token,"MyShiroRealm");
            }
        }
        throw new AuthenticationException("無效token");
    }
}

這里主要變化就是doGetAuthenticationInfo登錄的方法
主要是JWT 解碼token 獲得引數 去資料庫查找比較，在和redis 里比較是否一致
一致就把subject.login(token) 傳過來的JWT加密過的token 放到
SimpleAuthenticationInfo(token,token,“MyShiroRealm”) 實體化物件里回傳

我們接著看自定義的MyLoginFilter

public class MyLoginFilter extends BasicHttpAuthenticationFilter {
    private static final Logger log= LoggerFactory.getLogger(MyPermissionFilter.class);

    @Value(value="60000")
    private String tokenValidTime;

    @Value(value="80000")
    private String inValidTokenLiveSaveTime;

    @Autowired
    JwtUtil jwtUtil;

    @Autowired
    JedisClient redisUtil;

    /**
     * 判斷請求頭中是否含有token
     *
     * @param request
     * @param response
     * @return
     */
    @Override
    protected boolean isLoginAttempt(ServletRequest request, ServletResponse response) {
        return !StringUtils.isEmpty(this.getAuthzHeader(request));
    }


    /**
     * 正常情況下回傳true，如果遇到Token過期的話，這里呼叫重繪token，遇到其他的例外，這里回傳401，
     *
     * @param request
     * @param response
     * @param mappedValue
     * @return
     */
    @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
        String token = this.getAuthzHeader(request);
        if (isLoginAttempt(request, response) == true) {
            try {
                this.executeLogin(request, response);
            } catch (Exception e) {
                Throwable throwable = e.getCause();
                if (throwable instanceof TokenExpiredException) {
                    // 執行重繪token
                    String newToken = this.refreshToken(token);
                    if (!StringUtils.isEmpty(newToken)) {
                        // 將重繪之后的token放在回應的頭上 前端下次取出很本地的比較，如果不一樣的話做token的替換，
                        ((HttpServletResponse) response).setHeader(AUTHORIZATION_HEADER, newToken);
                        ((HttpServletResponse) response).setHeader("Access-Control-Expose-Headers", AUTHORIZATION_HEADER);
                        return true;
                    }
                }
            }
            this.response401(response);
            return false;
        }
        return true;

    }


    @Override
    protected boolean executeLogin(ServletRequest request, ServletResponse response) throws Exception {
        String token = this.getAuthzHeader(request);
        JwtToken jwtToken = new JwtToken(token);
        Subject subject = getSubject(request, response);
        subject.login(jwtToken);
        return true;
    }


    /**
     * 重繪過期的token
     *
     * @param needRefreshToken
     * @return
     */
    private String refreshToken(String needRefreshToken) {
        // 過期token的username
        String needRefreshTokenUsername = jwtUtil.getUsernameFromToken(needRefreshToken);

        if (redisUtil.exists(needRefreshTokenUsername)) {
            // 如果redis中存在過期token的key 則獲取存盤的時間戳
            String redisTokenTimeMillis = redisUtil.get(needRefreshTokenUsername);
            // 需要被重繪的token中獲取時間戳
            String needRefreshTokenTimeMillis = jwtUtil.getCurrentTmieMillisFromToken(needRefreshToken);

            // 相等執行重繪token的步驟
            if (redisTokenTimeMillis.equals(needRefreshTokenTimeMillis)) {
                String currentTimeMillis = String.valueOf(System.currentTimeMillis());
                redisUtil.set(RedisConstant.REDIS_USERNAME_PREFIX + needRefreshTokenUsername, currentTimeMillis);

                String newToken = jwtUtil.createToken(needRefreshTokenUsername, currentTimeMillis);

                // 這里的目的是為了防止 前端同時多請求 所帶來重繪token多次的問題（當第二個請求帶著老得token來的時候，在myRealm中增加此判斷 這樣的請求不會認為其過期）
                // 而這里的過期時間是按照前端設定了請求8秒沒有回傳則默認為請求超時， 這里給老得token16秒的存在時間，
                redisUtil.set(RedisConstant.REDIS_EXPIRE_TOKEN_PREFIX + needRefreshTokenUsername, needRefreshToken, Integer.valueOf(inValidTokenLiveSaveTime));
                return newToken;
            }
        }
        return "";
    }


    /**
     * 將非法請求跳轉到 /401
     */
    private void response401(ServletResponse resp) {
        try {
            HttpServletResponse httpServletResponse = (HttpServletResponse) resp;
            httpServletResponse.sendRedirect("/401");
        } catch (IOException e) {
            log.error(e.getMessage());
        }
    }
}

這邊我們看到了subject.login()，這里就是請求中是不是帶token,如果有就是登錄
還有一個是重繪redis里過期時間，
我就說一些重繪的思路
首先如果MyShiroRealm 中登錄失敗
我們拿著這個token 去redis中找是否存在，再看它的時間戳是否和redis中的一致
生成新的token設定到redis中并設定過期時間
這邊說一下redis中存的資料
redis里存兩種資料
一個是 “XXX”+username,時間戳
一個是 “XXX”+username,token，并設定過期時間

總結

由于篇幅的問題我就不在說了，基本上到這邊就介紹了，
思考一下使用JWT 登錄的時候真的登錄了么？
其實沒有，shiro沒有登錄，因為login 請求過來的時候url里沒有token，只是生成了token回傳，下次發送請求的時候shiro才會登錄，
還有一個shiro組態檔沒貼出來，應該不難把，自己配一下檢驗一下自己，如果真有需要，就在下方留言，