【實踐篇】教你玩轉JWT認證---從一個優惠券聊起

京東雲技術團隊發表於2023-05-19

引言

最近面試過程中，無意中跟候選人聊到了JWT相關的東西，也就聯想到我自己關於JWT落地過的那些專案。

關於JWT，可以說是分散式系統下的一個利器，我在我的很多專案實踐中，認證系統的第一選擇都是JWT。它的優勢會讓你欲罷不能，就像你領優惠券一樣。

大家回憶一下一個場景，如果你和你的女朋友想吃某江家的烤魚了，你會怎麼做呢？

傳統的時代，我想場景是這樣的：我們走進一家某江家餐廳，會被服務員引導一個桌子，然後我們開始點餐，服務原會記錄我們點餐資訊，然後在送到後廚去。這個過程中，那個餐桌就相當於session，而我們的點餐資訊回記錄到這個session之中，然後送到後廚。這個是一個典型的基於session的認證過程。但我們也發現了它的弊端，就是基於session的這種認證，對伺服器強依賴，而且資訊都是儲存在伺服器之上，靈活性和擴充套件性大大降低。

而網際網路時代，大眾點評、美團、餓了麼給了我們另一個選擇，我們可能第一時間會在這些平臺上搜尋江邊城外的優惠券，這個優惠券中可能會描述著兩人實惠套餐明細。這張優惠券就是我們的 JWT，我們可以在任何一家有參與優惠活動的餐廳使用這張優惠券，而不必被限制在同一家餐廳。同時這張優惠券中直接記錄了我們的點餐明細，等我們到了餐廳，只需要將優惠券二維碼告知服務員，服務員就會給我們端上我們想要的食物。

好了，以上只是一個小例子，其實只是想說明一下JWT相較於傳統的基於session的認證框架的優勢。

JWT 的優勢在於它可以跨域、跨伺服器使用，而 Session 則只能在本域名下使用。而且，JWT 不需要在服務端儲存使用者的資訊，只需要在客戶端儲存即可，這減輕了服務端的負擔。這一點在分散式架構下優勢還是很明顯的。

什麼是JWT

說了這麼多，如何定義JWT呢？

JWT（JSON Web Token）是一種用於在網路應用中進行身份驗證的開放標準（RFC7519）。它可以安全地在使用者和伺服器之間傳輸資訊，因為它使用數字簽名來驗證資料的完整性和真實性。

JWT包含三個部分：頭部、載荷和簽名。頭部包含演算法和型別資訊，載荷包含使用者的資訊，簽名用於驗證資料的完整性和真實性。

額外說一下poload，也就是負荷部分，這塊是jwt的核心模組，它內部包括一些宣告（claims）。宣告由三個型別組成：

Registered Claims：這是預定義的宣告名稱，主要包括以下幾種：

iss：Token 發行者
sub：Token 主題
aud：Token的受眾
exp：Token 過期時間
iat：Token發行時間
jti：Token唯一識別符號

Public Claims：公共宣告是自己定義的宣告名稱，以避免衝突。

Private Claims：私有宣告與公共宣告類似，不同之處在於它是用於在雙方之間共享資訊的。

當使用者登入時，伺服器將生成一個JWT，並將其作為響應返回給客戶端。客戶端將在後續的請求中傳送此JWT。伺服器將使用相同的金鑰驗證JWT的簽名，並從載荷中獲取使用者資訊。如果簽名驗證透過並且使用者資訊有效，則伺服器將允許請求繼續進行。

JWT優點

JWT優點如果我們系統的總結一下，如下：

跨語言和平臺：JWT是基於JSON標準的，因此可以在不同的程式語言和平臺之間進行交換和使用。無狀態：由於JWT包含所有必要的資訊，伺服器不需要在每個請求中儲存任何會話資料，因此可以輕鬆地進行負載均衡。
安全性：JWT使用數字簽名來驗證資料的完整性和真實性，因此可以防止資料被篡改或偽造。
可擴充套件性：JWT可以包含任何使用者資訊，因此可以輕鬆地擴充套件到其他應用程式中。
一個基於JWT認證的方案

我將舉一個我實際業務落地的一個例子。

我的業務場景中一般都會有一個業務閘道器，該閘道器的核心功能就是鑑權和上線文轉換。使用者請求會將JWT字串存與header之中，然後到閘道器後進行JWT解析，解析後的上下文資訊，會轉變成明文K-V的方式在此存於header之中，供系統內部各個微服務之間互相呼叫時提供明文上下文資訊。具體時序圖如下：

基於Spring security的JWT實踐

JWT原理很簡單，當然，你可以完全自己實現JWT的全流程，但是，實際中，我們一般不需要這麼幹，因為有很多成熟和好用的輪子提供給我們，而且封裝性和安全性也遠比自己匆忙的封裝一個簡單的JWT來的高。

如果是基於學習JWT，我是建議大家自己手寫一個demo的，但是如果重實踐的角度觸發，我們完全可以使用Spring Security提供的JWT元件，來高效快速的實現一個穩定性和安全性都非常高的JWT認證框架。

以下是我基於我的業務實際情況，根據保密性要求，簡化了的JWT實踐程式碼。也算是拋磚引玉，希望可以給大家在業務場景中運用JWT做一個參考。

maven依賴

首先，我們需要新增以下依賴到pom.xml檔案中：

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt</artifactId>
<version>0.9.1</version>
</dependency>

JWT工具類封裝

然後，我們可以建立一個JwtTokenUtil類來生成和驗證JWT令牌：

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.stereotype.Component;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Function;

@Component
public class JwtTokenUtil {
    private static final long JWT_TOKEN_VALIDITY = 5 * 60 * 60;
    @Value("${jwt.secret}")
    private String secret;

    public String generateToken(UserDetails userDetails) {
        Map<String, Object> claims = newHashMap <>();
        return createToken(claims, userDetails.getUsername());
    }
    private String createToken(Map<String, Object> claims, String subject) {
        Date now = new Date();
        Date expiration = new Date(now.getTime() + JWT_TOKEN_VALIDITY * 1000);
        return Jwts.builder()
                .setClaims(claims)
                .setSubject(subject)
                .setIssuedAt(now)
                .setExpiration(expiration)
                .signWith(SignatureAlgorithm.HS256, secret)
                .compact();
    }
    public boolean validateToken(String token, UserDetails userDetails) {
        final String username = extractUsername(token);
        return (username.equals(userDetails.getUsername()) && !isTokenExpired(token));
    }
    private boolean isTokenExpired(String token) {
        return extractExpiration(token).before(new Date());
    }
    public String extractUsername(String token) {
        return extractClaim(token, Claims::getSubject);
    }
    public Date extractExpiration(String token) {
        return extractClaim(token, Claims::getExpiration);
    }
    private <T> T extractClaim(String token, Function<Claims, T> claimsResolver) {
        final Claims claims = extractAllClaims(token);
        return claimsResolver.apply(claims);
    }
    private Claims extractAllClaims(String token) {
        return Jwts.parser().setSigningKey(secret).parseClaimsJws(token).getBody();
    }
}

在這個實現中，我們使用了jjwt庫來建立和解析JWT令牌。我們定義了以下方法：

generateToken：生成JWT令牌。
createToken：建立JWT令牌。
validateToken：驗證JWT令牌是否有效。
isTokenExpired：檢查JWT令牌是否過期。
extractUsername：從JWT令牌中提取使用者名稱。
extractExpiration：從JWT令牌中提取過期時間。
extractClaim：從JWT令牌中提取指定的宣告。
extractAllClaims：從JWT令牌中提取所有宣告。

UserDetailsService類定義

接下來，我們可以建立一個自定義的UserDetailsService，用於驗證使用者登入資訊：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;

@Service
public class JwtUserDetailsService implements UserDetailsService {
    @Autowired
    private UserRepository userRepository;
    @Override
    public UserDetails loadUserByUsername(String username)
            throws UsernameNotFoundException {
        UserEntity user = userRepository.findByUsername(username);
        if (user == null) {
            throw new UsernameNotFoundException("User not found with username: " + username);
        }
        return new User(user.getUsername(), user.getPassword(),
                new ArrayList<>());
    }
}

在這個實現中，我們使用了UserRepository來檢索使用者資訊。我們實現了UserDetailsService介面，並覆蓋了loadUserByUsername方法，以便驗證使用者登入資訊。

JwtAuthenticationFilter定義

接下來，我們可以建立一個JwtAuthenticationFilter類，用於攔截登入請求並生成JWT令牌：

import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Collections;
import java.util.Date;

public class JwtAuthenticationFilter extends UsernamePasswordAuthenticationFilter {
    private final AuthenticationManager authenticationManager;
    private final JwtTokenUtil jwtTokenUtil;

    public JwtAuthenticationFilter(AuthenticationManager authenticationManager, JwtTokenUtil jwtTokenUtil) {
        this.authenticationManager = authenticationManager;
        this.jwtTokenUtil = jwtTokenUtil;
    }

    @Override
    public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {
        try {
            LoginRequest loginRequest = new ObjectMapper().readValue(request.getInputStr eam(), LoginRequest.class);
            return authenticationManager.authenticate(
                    new UsernamePasswordAuthenticationToken(loginRequest.getUsername(), loginRequest.getPassword(), Collections.emptyList())
            );
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain, Authentication authResult)throwsIOException,ServletException {
        UserDetails userDetails = (UserDetails) authResult.getPrincipal();
        String token = jwtTokenUtil.generateToken(userDetails);
        response.addHeader("Authorization", "Bearer " + token);
    }

    private static class LoginRequest {
        private String username;
        private String password;

        public String getUsername() {
            return username;
        }

        public void setUsername(String username) {
            this.username = username;
        }

        public String getPassword() {
            return password;
        }

        public void setPassword(String password) {
            this.password = password;
        }
    }
}

在這個實現中，我們繼承了
UsernamePasswordAuthenticationFilter類，並覆蓋了attemptAuthentication和successfulAuthentication方法，以便在登入成功時生成JWT令牌並將其新增到HTTP響應頭中。

Spring Security配置類

最後，我們可以建立一個Spring Security配置類，以便配置驗證和授權規則：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    private JwtUserDetailsService jwtUserDetailsService;
    @Autowired
    private JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint;
    @Autowired
    private JwtTokenUtil jwtTokenUtil;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
                .authorizeRequests().antMatchers("/authenticate").permitAll()
                .anyRequest().authenticated().and()
                .exceptionHandling().authenticationEntryPoint(jwtAuthenticationEntryPoint).and()
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);
        http.addFilterBefore(newJwtAuthenticationFilter(authenticationManager(), jwtTokenUtil), UsernamePasswordAuthenticationFilter.class);
    }
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(jwtUserDetailsService).passwordEncoder(passwordEncoder());
    }
    @Override
    @Bean
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

在這個實現中，我們使用JwtUserDetailsService來驗證使用者登入資訊，並使用
JwtAuthenticationEntryPoint來處理驗證錯誤。

我們還配置了JwtAuthenticationFilter來生成JWT令牌，並將其新增到HTTP響應頭中。我們還定義了一個PasswordEncoderbean，用於加密使用者密碼。

除錯介面驗證

現在，我們可以向/authenticate端點傳送POST請求，以驗證使用者登入資訊並生成JWT令牌。例如：

bash
curl -X POST \
  http://localhost:8080/authenticate \
  -H 'Content-Type: application/json'\
  -d '{
    "username": "user",
    "password": "password"
}'

如果登入資訊驗證成功，將返回一個帶有JWT令牌的HTTP響應頭。我們可以使用這個令牌來訪問需要授權的端點。例如：

bash
curl -X GET \
  http://localhost:8080/hello \
  -H 'Authorization: Bearer eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJ1c2VyIiwiaWF0IjoxNjI0MDM2NzA4LCJleHAiOjE2MjQwMzc1MDh9.9fZS7jPp0NzB0JyOo4y4jO4x3s3KjV7yW1nLzV7cO_c'

在這個示例中，我們向/hello端點傳送GET請求，並在HTTP頭中新增JWT令牌。如果令牌有效並且使用者有權訪問該端點，則返回一個成功的HTTP響應。

總結

JWT是一種簡單、安全和可擴充套件的身份驗證機制，適用於各種應用程式和場景。它可以減少伺服器的負擔，提高應用程式的安全性，並且可以輕鬆地擴充套件到其他應用程式中。

但是JWT也有一定的缺點，比如他的payload模組並沒有明確說明一定要加密傳輸，所以當你沒有額外做一些安全性措施的情況下，jwt一旦被別人截獲，很容易洩漏使用者資訊。所以，如果要增加JWT的在實際專案中的安全性，安全加固措施必不可少，包括加密方式，秘鑰的儲存，JWT的過期策略等等。

當然實際中的認證鑑權框架不止有JWT，JWT只是解決了使用者上下文傳輸的問題。實際專案中經常是JWT結合其他認證系統一同使用，比如OAuth2.0。這裡篇幅有限，就不展開。以後有機會再單獨寫一篇關於OAuth2.0認證架構的文章。

作者：京東物流趙勇萍

內容來源：京東雲開發者社群

Dotnet core使用JWT認證授權最佳實踐(一)
2020-05-15
JWT
jwt 如何實現一個服務認證了另一個服務也可以認證
2023-03-10
JWT
DRF JWT認證（一）
2022-04-09
JWT
Express + JWT使用者認證最輕實踐
2018-05-28
ExpressJWT
koa 實現 jwt 認證
2019-02-16
JWT
Dotnet core使用JWT認證授權最佳實踐(二)
2020-05-19
JWT
基於 JWT + Refresh Token 的使用者認證實踐
2018-12-13
JWT
理解JWT（JSON Web Token）認證及python實踐
2017-07-23
JWTJSONWebPython
JWT 多表認證
2020-07-28
JWT
DRF之JWT認證
2021-07-14
JWT
瞭解JWT認證
2020-11-04
JWT
drf的JWT認證
2022-04-07
JWT
DRF JWT認證（二）
2022-04-10
JWT
JWT實現登入認證例項
2021-02-14
JWT
ASP.NET Core - JWT認證實現
2021-01-17
ASP.NETJWT
實戰模擬│JWT 登入認證
2022-07-04
JWT
從一個shell指令碼執行出錯聊起
2014-01-13
指令碼
Django（65）jwt認證原理
2021-06-20
DjangoJWT
OAuth2.0實戰！使用JWT令牌認證！
2021-12-07
OAuthJWT
使用JWT實現Spring Boot令牌認證
2017-02-21
JWTSpring Boot
express實現JWT使用者認證系統
2018-12-31
ExpressJWT
ASP.NET Core 基於JWT的認證(一)
2019-02-24
ASP.NETJWT
一文搞懂Session和JWT登入認證
2023-04-15
SessionJWT
基於JWT規範實現的認證微服務
2019-03-05
JWT微服務
基於 go-zero 輕鬆實現 JWT 認證
2020-09-22
GoJWT
前端架構之node jwt認證
2018-08-18
前端架構JWT
drf JWT認證模組與自定製
2020-11-05
JWT
Lumen 8.0 使用 Jwt 認證的 Api
2020-09-18
JWTAPI
使用 JWT 認證使用者身份
2021-11-09
JWT
laravel 介面使用JWT(dingo)認證
2020-10-10
LaravelJWTGo
JWT登入認證-專案BotBattle
2024-03-19
JWTBAT
JWT refreshtoken 實踐
2019-04-29
JWT
四個微服務授權認證的最佳實踐 - thenewstack
2022-05-13
微服務
Node.js的Koa實現JWT使用者認證
2019-02-16
Node.jsJWT
玩轉spring boot——簡單登入認證
2017-01-23
Spring Boot
go-kit微服務：JWT身份認證
2019-03-11
Go微服務JWT
PHP 使用 jwt 使用者身份認證
2019-01-04
PHPJWT
.net core中使用jwt進行認證
2020-09-06
JWT