引言

最近面試程序中，無意中跟候選人聊到了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認證架構的文章，

作者：京東物流趙勇萍

內容來源：京東云開發者社區

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

標籤：架構設計

上一篇：ET介紹——強大的MongoBson庫

下一篇：返回列表

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

引言