干掉Session？這個跨域認證解決方案真的優雅！-有解無憂

用戶登錄認證是 Web 應用中非常常見的一個業務，一般的流程是這樣的：

客戶端向服務器端發送用戶名和密碼
服務器端驗證通過后，在當前會話（session）中保存相關資料，比如說登錄時間、登錄 IP 等，
服務器端向客戶端回傳一個 session_id，客戶端將其保存在 Cookie 中，
客戶端再向服務器端發起請求時，將 session_id 傳回給服務器端，
服務器端拿到 session_id 后，對用戶的身份進行鑒定，

單機情況下，這種模式是沒有任何問題的，但對于前后端分離的 Web 應用來說，就非常痛苦了，于是就有了另外一種解決方案，服務器端不再保存 session 資料，而是將其保存在客戶端，客戶端每次發起請求時再把這個資料發送給服務器端進行驗證，JWT（JSON Web Token）就是這種方案的典型代表，

一、關于 JWT

JWT，是目前最流行的一個跨域認證解決方案：客戶端發起用戶登錄請求，服務器端接收并認證成功后，生成一個 JSON 物件（如下所示），然后將其回傳給客戶端，

{
  "sub": "wanger",
  "created": 1645700436900,
  "exp": 1646305236
}

客戶端再次與服務器端通信的時候，把這個 JSON 物件捎帶上，作為前后端互相信任的一個憑證，服務器端接收到請求后，通過 JSON 物件對用戶身份進行鑒定，這樣就不再需要保存任何 session 資料了，

假如我現在使用用戶名 wanger 和密碼 123456 進行訪問編程喵（Codingmore）的 login 介面，那么實際的 JWT 是一串看起來像是加過密的字串，

為了讓大家看的更清楚一點，我將其復制到了 jwt 的官網，

左側 Encoded 部分就是 JWT 密文，中間用「.」分割成了三部分（右側 Decoded 部分）：

Header（頭部），描述 JWT 的元資料，其中 alg 屬性表示簽名的演算法（當前為 HS512）；
Payload（負載），用來存放實際需要傳遞的資料，其中 sub 屬性表示主題（實際值為用戶名），created 屬性表示 JWT 產生的時間，exp 屬性表示過期時間
Signature（簽名），對前兩部分的簽名，防止資料篡改；這里需要服務器端指定一個密鑰（只有服務器端才知道），不能泄露給客戶端，然后使用 Header 中指定的簽名演算法，按照下面的公式產生簽名：

HMACSHA512(
  base64UrlEncode(header) + "." +
  base64UrlEncode(payload),
  your-256-bit-secret
)

算出簽名后，再把 Header、Payload、Signature 拼接成一個字串，中間用「.」分割，就可以回傳給客戶端了，

客戶端拿到 JWT 后，可以放在 localStorage，也可以放在 Cookie 里面，

const TokenKey = '1D596CD8-8A20-4CEC-98DD-CDC12282D65C' // createUuid()

export function getToken () {
  return Cookies.get(TokenKey)
}

export function setToken (token) {
  return Cookies.set(TokenKey, token)
}

以后客戶端再與服務器端通信的時候，就帶上這個 JWT，一般放在 HTTP 的請求的頭資訊 Authorization 欄位里，

Authorization: Bearer <token>

服務器端接收到請求后，再對 JWT 進行驗證，如果驗證通過就回傳相應的資源，

二、實戰 JWT

第一步，在 pom.xml 檔案中添加 JWT 的依賴，

<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.0</version>
</dependency>

第二步，在 application.yml 中添加 JWT 的配置項，

jwt:
  tokenHeader: Authorization #JWT存盤的請求頭
  secret: codingmore-admin-secret #JWT加解密使用的密鑰
  expiration: 604800 #JWT的超期限時間(60*60*24*7)
  tokenHead: 'Bearer '  #JWT負載中拿到開頭

第三步，新建 JwtTokenUtil.java 工具類，主要有三個方法：

generateToken(UserDetails userDetails)：根據登錄用戶生成 token
getUserNameFromToken(String token)：從 token 中獲取登錄用戶
validateToken(String token, UserDetails userDetails)：判斷 token 是否仍然有效

public class JwtTokenUtil {

    @Value("${jwt.secret}")
    private String secret;
    @Value("${jwt.expiration}")
    private Long expiration;
    @Value("${jwt.tokenHead}")
    private String tokenHead;

    /**
     * 根據用戶資訊生成token
     */
    public String generateToken(UserDetails userDetails) {
        Map<String, Object> claims = new HashMap<>();
        claims.put(CLAIM_KEY_USERNAME, userDetails.getUsername());
        claims.put(CLAIM_KEY_CREATED, new Date());
        return generateToken(claims);
    }

    /**
     * 根據用戶名、創建時間生成JWT的token
     */
    private String generateToken(Map<String, Object> claims) {
        return Jwts.builder()
                .setClaims(claims)
                .setExpiration(generateExpirationDate())
                .signWith(SignatureAlgorithm.HS512, secret)
                .compact();
    }

    /**
     * 從token中獲取登錄用戶名
     */
    public String getUserNameFromToken(String token) {
        String username = null;
        Claims claims = getClaimsFromToken(token);
        if (claims != null) {
            username = claims.getSubject();
        }

        return username;
    }

    /**
     * 從token中獲取JWT中的負載
     */
    private Claims getClaimsFromToken(String token) {
        Claims claims = null;
        try {
            claims = Jwts.parser()
                    .setSigningKey(secret)
                    .parseClaimsJws(token)
                    .getBody();
        } catch (Exception e) {
            LOGGER.info("JWT格式驗證失敗:{}", token);
        }
        return claims;
    }

    /**
     * 驗證token是否還有效
     *
     * @param token       客戶端傳入的token
     * @param userDetails 從資料庫中查詢出來的用戶資訊
     */
    public boolean validateToken(String token, UserDetails userDetails) {
        String username = getUserNameFromToken(token);
        return username.equals(userDetails.getUsername()) && !isTokenExpired(token);
    }

    /**
     * 判斷token是否已經失效
     */
    private boolean isTokenExpired(String token) {
        Date expiredDate = getExpiredDateFromToken(token);
        return expiredDate.before(new Date());
    }

    /**
     * 從token中獲取過期時間
     */
    private Date getExpiredDateFromToken(String token) {
        Claims claims = getClaimsFromToken(token);
        return claims.getExpiration();
    }
}

第四步，在 UsersController.java 中新增 login 登錄介面，接收用戶名和密碼，并將 JWT 回傳給客戶端，

@Controller
@Api(tags="用戶")
@RequestMapping("/users")
public class UsersController {
    @Autowired
    private IUsersService usersService;
    @Value("${jwt.tokenHeader}")
    private String tokenHeader;
    @Value("${jwt.tokenHead}")
    private String tokenHead;

    @ApiOperation(value = "https://www.cnblogs.com/qing-gee/p/登錄以后回傳token")
    @RequestMapping(value = "https://www.cnblogs.com/login", method = RequestMethod.POST)
    @ResponseBody
    public ResultObject login(@Validated UsersLoginParam users, BindingResult result) {
        String token = usersService.login(users.getUserLogin(), users.getUserPass());

        if (token == null) {
            return ResultObject.validateFailed("用戶名或密碼錯誤");
        }

        // 將 JWT 傳遞回客戶端
        Map<String, String> tokenMap = new HashMap<>();
        tokenMap.put("token", token);
        tokenMap.put("tokenHead", tokenHead);
        return ResultObject.success(tokenMap);
    }

}

第五步，在 UsersServiceImpl.java 中新增 login 方法，根據用戶名從資料庫中查詢用戶，密碼驗證通過后生成 JWT，

@Service
public class UsersServiceImpl extends ServiceImpl<UsersMapper, Users> implements IUsersService {

    @Autowired
    private PasswordEncoder passwordEncoder;
    @Autowired
    private JwtTokenUtil jwtTokenUtil;

    public String login(String username, String password) {
        String token = null;
        //密碼需要客戶端加密后傳遞
        try {
            // 查詢用戶+用戶資源
            UserDetails userDetails = loadUserByUsername(username);

            // 驗證密碼
            if (!passwordEncoder.matches(password, userDetails.getPassword())) {
                Asserts.fail("密碼不正確");
            }

            // 回傳 JWT
            token = jwtTokenUtil.generateToken(userDetails);
        } catch (AuthenticationException e) {
            LOGGER.warn("登錄例外:{}", e.getMessage());
        }
        return token;
    }
}

第六步，新增 JwtAuthenticationTokenFilter.java，每次客戶端發起請求時對 JWT 進行驗證，

public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {
    private static final Logger LOGGER = LoggerFactory.getLogger(JwtAuthenticationTokenFilter.class);
    @Autowired
    private UserDetailsService userDetailsService;
    @Autowired
    private JwtTokenUtil jwtTokenUtil;
    @Value("${jwt.tokenHeader}")
    private String tokenHeader;
    @Value("${jwt.tokenHead}")
    private String tokenHead;

    @Override
    protected void doFilterInternal(HttpServletRequest request,
                                    HttpServletResponse response,
                                    FilterChain chain) throws ServletException, IOException {
        // 從客戶端請求中獲取 JWT
        String authHeader = request.getHeader(this.tokenHeader);
        // 該 JWT 是我們規定的格式，以 tokenHead 開頭
        if (authHeader != null && authHeader.startsWith(this.tokenHead)) {
            // The part after "Bearer "
            String authToken = authHeader.substring(this.tokenHead.length());
            // 從 JWT 中獲取用戶名
            String username = jwtTokenUtil.getUserNameFromToken(authToken);
            LOGGER.info("checking username:{}", username);

            // SecurityContextHolder 是 SpringSecurity 的一個工具類
            // 保存應用程式中當前使用人的安全背景關系
            if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
                // 根據用戶名獲取登錄用戶資訊
                UserDetails userDetails = this.userDetailsService.loadUserByUsername(username);
                // 驗證 token 是否過期
                if (jwtTokenUtil.validateToken(authToken, userDetails)) {
                    // 將登錄用戶保存到安全背景關系中
                    UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userDetails,
                            null, userDetails.getAuthorities());
                    authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                    SecurityContextHolder.getContext().setAuthentication(authentication);

                    LOGGER.info("authenticated user:{}", username);
                }
            }
        }
        chain.doFilter(request, response);
    }
}

JwtAuthenticationTokenFilter 繼承了 OncePerRequestFilter，該過濾器能確保一次請求只通過一次 filter，而不需要重復執行，也就是說，客戶端每發起一次請求，該過濾器就會執行一次，

這個過濾器非常關鍵啊，基本上每行代碼我都添加了注釋，當然了，為了確保大家都能搞清楚這個類到底做了什么，我再來畫一幅流程圖，這樣就一清二楚了，

SpringSecurity 是一個安全管理框架，可以和 Spring Boot 應用無縫銜接，SecurityContextHolder 是其中非常關鍵的一個工具類，持有安全背景關系資訊，里面保存有當前操作的用戶是誰，用戶是否已經被認證，用戶擁有的權限等關鍵資訊，

SecurityContextHolder 默認使用了 ThreadLocal 策略來存盤認證資訊，ThreadLocal 的特點是存在它里邊的資料，哪個執行緒存的，哪個執行緒才能訪問到，這就意味著不同的請求進入到服務器端后，會由不同的 Thread 去處理，例如執行緒 A 將請求 1 的用戶資訊存入了 ThreadLocal，執行緒 B 在處理請求 2 的時候是無法獲取到用戶資訊的，

所以說 JwtAuthenticationTokenFilter 過濾器會在每次請求過來的時候進行一遍 JWT 的驗證，確保客戶端過來的請求是安全的，然后 SpringSecurity 才會對接下來的請求介面放行，這也是 JWT 和 Session 的根本區別：

JWT 需要每次請求的時候驗證一次，并且只要 JWT 沒有過期，哪怕服務器端重啟了，認證仍然有效，
Session 在沒有過期的情況下是不需要重新對用戶資訊進行驗證的，當服務器端重啟后，用戶需要重新登錄獲取新的 Session，

也就是說，在 JWT 的方案下，服務器端保存的密鑰（secret）一定不能泄露，否則客戶端就可以根據簽名演算法偽造用戶的認證資訊了，

三、Swagger 中添加 JWT 驗證

對于后端開發人員來說，如何在 Swagger（整合了 Knife4j 進行美化）中添加 JWT 驗證呢？

第一步，訪問 login 介面，輸入用戶名和密碼進行登錄，獲取服務器端回傳的 JWT，

第二步，收集服務器端回傳的 tokenHead 和 token，將其填入 Authorize（注意 tokenHead 和 token 之間有一個空格）完成登錄認證，

第三步，再次請求其他介面時，Swagger 會自動將 Authorization 作為請求頭資訊發送到服務器端，

第四步，服務器端接收到該請求后，會通過 JwtAuthenticationTokenFilter 過濾器對 JWT 進行校驗，

到此為止，整個流程全部打通了，完美！

四、總結

綜上來看，用 JWT 來解決前后端分離專案中的跨域認證還是非常絲滑的，這主要得益于 JSON 的通用性，可以跨語言，JavaScript 和 Java 都支持；另外，JWT 的組成非常簡單，非常便于傳輸；還有 JWT 不需要在服務器端保存會話資訊（Session），非常易于擴展，

當然了，為了保證 JWT 的安全性，不要在 JWT 中保存敏感資訊，因為一旦私鑰泄露，JWT 是很容易在客戶端被解密的；如果可以，請使用 HTTPS 協議，

參考鏈接：

阮一峰：https://www.ruanyifeng.com/blog/2018/07/json_web_token-tutorial.html

春夏秋冬過：https://segmentfault.com/a/1190000012557493

江南一點雨：https://cloud.tencent.com/developer/article/1612175

Dearmadman：https://www.jianshu.com/p/576dbf44b2ae

mcarozheng：http://www.macrozheng.com/

原始碼路徑：

https://github.com/itwanger/coding-more

本篇已收錄至 GitHub 上星標 1.6k+ star 的開源專欄《Java 程式員進階之路》，據說每一個優秀的 Java 程式員都喜歡她，風趣幽默、通俗易懂，內容包括 Java 基礎、Java 并發編程、Java 虛擬機、Java 企業級開發、Java 面試等核心知識點，學 Java，就認準 Java 程式員進階之路??，

https://github.com/itwanger/toBeBetterJavaer

star 了這個倉庫就等于你擁有了成為了一名優秀 Java 工程師的潛力，也可以戳下面的鏈接跳轉到《Java 程式員進階之路》的官網網址，開始愉快的學習之旅吧，

https://tobebetterjavaer.com/

沒有什么使我停留——除了目的，縱然岸旁有玫瑰、有綠蔭、有寧靜的港灣，我是不系之舟，

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/435330.html

標籤：Java

上一篇：為什么 Redis 集群要使用反向代理? 看這篇就明白了

下一篇：八大排序演算法之直接插入排序（InsertionSort）