解析SpringSecurity+JWT認證流程實現

阿新 • • 發佈：2020-07-08

紙上得來終覺淺，覺知此事要躬行。

楔子

本文適合：對Spring Security有一點了解或者跑過簡單demo但是對整體執行流程不明白的同學，對SpringSecurity有興趣的也可以當作你們的入門教程，示例程式碼中也有很多註釋。

本文程式碼：碼雲地址 GitHub地址

大家在做系統的時候，一般做的第一個模組就是認證與授權模組，因為這是一個系統的入口，也是一個系統最重要最基礎的一環，在認證與授權服務設計搭建好了之後，剩下的模組才得以安全訪問。

市面上一般做認證授權的框架就是shiro和Spring Security，也有大部分公司選擇自己研製。出於之前看過很多Spring Security

的入門教程，但都覺得講的不是太好，所以我這兩天在自己鼓搗Spring Security的時候萌生了分享一下的想法，希望可以幫助到有興趣的人。

Spring Security框架我們主要用它就是解決一個認證授權功能，所以我的文章主要會分為兩部分：

第一部分認證（本篇）
第二部分授權（放在下一篇）

我會為大家用一個Spring Security + JWT + 快取的一個demo來展現我要講的東西，畢竟腦子的東西要體現在具體事物上才可以更直觀的讓大家去了解去認識。

學習一件新事物的時候，我推薦使用自頂向下的學習方法，這樣可以更好的認識新事物，而不是盲人摸象。

注：只涉及到使用者認證授權不涉及oauth2之類的第三方授權。

1. :book:SpringSecurity的工作流程

想上手 Spring Security 一定要先了解它的工作流程，因為它不像工具包一樣，拿來即用，必須要對它有一定的瞭解，再根據它的用法進行自定義操作。

我們可以先來看看它的工作流程：

在Spring Security的官方文件上有這麼一句話：

Spring Security's web infrastructure is based entirely on standard servlet filters.

Spring Security 的web基礎是Filters。

這句話展示了Spring Security的設計思想：即通過一層層的Filters來對web請求做處理。

放到真實的Spring Security中，用文字表述的話可以這樣說:

一個web請求會經過一條過濾器鏈，在經過過濾器鏈的過程中會完成認證與授權，如果中間發現這條請求未認證或者未授權，會根據被保護API的許可權去丟擲異常，然後由異常處理器去處理這些異常。

用圖片表述的話可以這樣畫，這是我在百度找到的一張圖片：

解析SpringSecurity+JWT認證流程實現

如上圖，一個請求想要訪問到API就會以從左到右的形式經過藍線框框裡面的過濾器，其中綠色部分是我們本篇主要講的負責認證的過濾器，藍色部分負責異常處理，橙色部分則是負責授權。

圖中的這兩個綠色過濾器我們今天不會去說，因為這是Spring Security對form表單認證和Basic認證內建的兩個Filter，而我們的demo是JWT認證方式所以用不上。

如果你用過Spring Security就應該知道配置中有兩個叫formLogin和httpBasic的配置項，在配置中打開了它倆就對應著打開了上面的過濾器。

解析SpringSecurity+JWT認證流程實現

formLogin對應著你form表單認證方式，即UsernamePasswordAuthenticationFilter。
httpBasic對應著Basic認證方式，即BasicAuthenticationFilter。

換言之，你配置了這兩種認證方式，過濾器鏈中才會加入它們，否則它們是不會被加到過濾器鏈中去的。

因為Spring Security自帶的過濾器中是沒有針對JWT這種認證方式的，所以我們的demo中會寫一個JWT的認證過濾器，然後放在綠色的位置進行認證工作。

2. :memo:SpringSecurity的重要概念

知道了Spring Security的大致工作流程之後，我們還需要知道一些非常重要的概念也可以說是元件：

SecurityContext：上下文物件，Authentication物件會放在裡面。
SecurityContextHolder：用於拿到上下文物件的靜態工具類。
Authentication：認證介面，定義了認證物件的資料形式。
AuthenticationManager：用於校驗Authentication，返回一個認證完成後的Authentication物件。

1.SecurityContext

上下文物件，認證後的資料就放在這裡面，介面定義如下：

public interface SecurityContext extends Serializable {
 // 獲取Authentication物件
 Authentication getAuthentication();

 // 放入Authentication物件
 void setAuthentication(Authentication authentication);
}

這個接口裡面只有兩個方法，其主要作用就是get or setAuthentication。

2. SecurityContextHolder

public class SecurityContextHolder {

 public static void clearContext() {
 strategy.clearContext();
 }

 public static SecurityContext getContext() {
 return strategy.getContext();
 }
  
  public static void setContext(SecurityContext context) {
 strategy.setContext(context);
 }

}

可以說是SecurityContext的工具類，用於get or set or clearSecurityContext，預設會把資料都儲存到當前執行緒中。

3. Authentication

public interface Authentication extends Principal,Serializable {
 
 Collection<? extends GrantedAuthority> getAuthorities();
 Object getCredentials();
 Object getDetails();
 Object getPrincipal();
 boolean isAuthenticated();
 void setAuthenticated(boolean isAuthenticated) throws IllegalArgumentException;
}

這幾個方法效果如下：

getAuthorities: 獲取使用者許可權，一般情況下獲取到的是使用者的角色資訊。
getCredentials: 獲取證明使用者認證的資訊，通常情況下獲取到的是密碼等資訊。
getDetails: 獲取使用者的額外資訊，（這部分資訊可以是我們的使用者表中的資訊）。
getPrincipal: 獲取使用者身份資訊，在未認證的情況下獲取到的是使用者名稱，在已認證的情況下獲取到的是 UserDetails。
isAuthenticated: 獲取當前Authentication是否已認證。setAuthenticated: 設定當前Authentication是否已認證（true or false）。

Authentication只是定義了一種在SpringSecurity進行認證過的資料的資料形式應該是怎麼樣的，要有許可權，要有密碼，要有身份資訊，要有額外資訊。

4. AuthenticationManager

public interface AuthenticationManager {
 // 認證方法
 Authentication authenticate(Authentication authentication)
  throws AuthenticationException;
}

AuthenticationManager定義了一個認證方法，它將一個未認證的Authentication傳入，返回一個已認證的Authentication，預設使用的實現類為：ProviderManager。

接下來大家可以構思一下如何將這四個部分，串聯起來，構成Spring Security進行認證的流程：

1. :point_right:先是一個請求帶著身份資訊進來

2. :point_right:經過AuthenticationManager的認證，

3. :point_right:再通過SecurityContextHolder獲取SecurityContext，

4. :point_right:最後將認證後的資訊放入到SecurityContext。

3. :page_with_curl:程式碼前的準備工作

真正開始講訴我們的認證程式碼之前，我們首先需要匯入必要的依賴，資料庫相關的依賴可以自行選擇什麼JDBC框架，我這裡用的是國人二次開發的myabtis-plus。

  <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-security</artifactId>
    </dependency>

    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-validation</artifactId>
    </dependency>
    
    <dependency>
      <groupId>io.jsonwebtoken</groupId>
      <artifactId>jjwt</artifactId>
      <version>0.9.0</version>
    </dependency>
    
    <dependency>
      <groupId>com.baomidou</groupId>
      <artifactId>mybatis-plus-boot-starter</artifactId>
      <version>3.3.0</version>
    </dependency>
    
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.47</version>
    </dependency>

接著，我們需要定義幾個必須的元件。

由於我用的Spring-Boot是2.X所以必須要我們自己定義一個加密器：

1. 定義加密器Bean

 @Bean
  public PasswordEncoder passwordEncoder() {
    return new BCryptPasswordEncoder();
  }

這個Bean是不必可少的，Spring Security在認證操作時會使用我們定義的這個加密器，如果沒有則會出現異常。

2. 定義AuthenticationManager

@Bean
  public AuthenticationManager authenticationManager() throws Exception {
    return super.authenticationManager();
  }

這裡將Spring Security自帶的authenticationManager宣告成Bean，宣告它的作用是用它幫我們進行認證操作，呼叫這個Bean的authenticate方法會由Spring Security自動幫我們做認證。

3. 實現UserDetailsService

public class CustomUserDetailsService implements UserDetailsService {
  @Autowired
  private UserService userService;
  @Autowired
  private RoleInfoService roleInfoService;
  @Override
  public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException {
    log.debug("開始登陸驗證，使用者名稱為: {}",s);

    // 根據使用者名稱驗證使用者
    QueryWrapper<UserInfo> queryWrapper = new QueryWrapper<>();
    queryWrapper.lambda().eq(UserInfo::getLoginAccount,s);
    UserInfo userInfo = userService.getOne(queryWrapper);
    if (userInfo == null) {
      throw new UsernameNotFoundException("使用者名稱不存在，登陸失敗。");
    }

    // 構建UserDetail物件
    UserDetail userDetail = new UserDetail();
    userDetail.setUserInfo(userInfo);
    List<RoleInfo> roleInfoList = roleInfoService.listRoleByUserId(userInfo.getUserId());
    userDetail.setRoleInfoList(roleInfoList);
    return userDetail;
  }
}

實現UserDetailsService的抽象方法並返回一個UserDetails物件，認證過程中SpringSecurity會呼叫這個方法訪問資料庫進行對使用者的搜尋，邏輯什麼都可以自定義，無論是從資料庫中還是從快取中，但是我們需要將我們查詢出來的使用者資訊和許可權資訊組裝成一個UserDetails返回。

UserDetails也是一個定義了資料形式的介面，用於儲存我們從資料庫中查出來的資料，其功能主要是驗證賬號狀態和獲取許可權，具體實現可以查閱我倉庫的程式碼。

4. TokenUtil

由於我們是JWT的認證模式，所以我們也需要一個幫我們操作Token的工具類，一般來說它具有以下三個方法就夠了：

建立token
驗證token
反解析token中的資訊

在下文我的程式碼裡面，JwtProvider充當了Token工具類的角色，具體實現可以查閱我倉庫的程式碼。

4. ✍程式碼中的具體實現

有了前面的講解之後，大家應該都知道用SpringSecurity做JWT認證需要我們自己寫一個過濾器來做JWT的校驗，然後將這個過濾器放到綠色部分。

在我們編寫這個過濾器之前，我們還需要進行一個認證操作，因為我們要先訪問認證介面拿到token，才能把token放到請求頭上，進行接下來請求。

如果你不太明白，不要緊，先接著往下看我會在這節結束再次梳理一下。

1. 認證方法

訪問一個系統，一般最先訪問的是認證方法，這裡我寫了最簡略的認證需要的幾個步驟，因為實際系統中我們還要寫登入記錄啊，前臺密碼解密啊這些操作。

@Override
  public ApiResult login(String loginAccount,String password) {
    // 1 建立UsernamePasswordAuthenticationToken
    UsernamePasswordAuthenticationToken usernameAuthentication = new UsernamePasswordAuthenticationToken(loginAccount,password);
    // 2 認證
    Authentication authentication = this.authenticationManager.authenticate(usernameAuthentication);
    // 3 儲存認證資訊
    SecurityContextHolder.getContext().setAuthentication(authentication);
    // 4 生成自定義token
    UserDetail userDetail = (UserDetail) authentication.getPrincipal();
    AccessToken accessToken = jwtProvider.createToken((UserDetails) authentication.getPrincipal());

    // 5 放入快取
    caffeineCache.put(CacheName.USER,userDetail.getUsername(),userDetail);
    return ApiResult.ok(accessToken);
  }

這裡一共五個步驟，大概只有前四步是比較陌生的：

傳入使用者名稱和密碼建立了一個UsernamePasswordAuthenticationToken物件，這是我們前面說過的Authentication的實現類，傳入使用者名稱和密碼做構造引數，這個物件就是我們創建出來的未認證的Authentication物件。
使用我們先前已經宣告過的Bean-authenticationManager呼叫它的authenticate方法進行認證，返回一個認證完成的Authentication物件。
認證完成沒有出現異常，就會走到第三步，使用SecurityContextHolder獲取SecurityContext之後，將認證完成之後的Authentication物件，放入上下文物件。
從Authentication物件中拿到我們的UserDetails物件，之前我們說過，認證後的Authentication物件呼叫它的getPrincipal()方法就可以拿到我們先前資料庫查詢後組裝出來的UserDetails物件，然後建立token。
把UserDetails物件放入快取中，方便後面過濾器使用。

這樣的話就算完成了，感覺上很簡單，因為主要認證操作都會由authenticationManager.authenticate()幫我們完成。

接下來我們可以看看原始碼，從中窺得Spring Security是如何幫我們做這個認證的（省略了一部分）：

// AbstractUserDetailsAuthenticationProvider

public Authentication authenticate(Authentication authentication){

 // 校驗未認證的Authentication物件裡面有沒有使用者名稱
 String username = (authentication.getPrincipal() == null) ? "NONE_PROVIDED"
  : authentication.getName(); 
  
   boolean cacheWasUsed = true;
   // 從快取中去查使用者名稱為XXX的物件
 UserDetails user = this.userCache.getUserFromCache(username);

   // 如果沒有就進入到這個方法
 if (user == null) {
  cacheWasUsed = false;

  try {
        // 呼叫我們重寫UserDetailsService的loadUserByUsername方法
        // 拿到我們自己組裝好的UserDetails物件
  user = retrieveUser(username,(UsernamePasswordAuthenticationToken) authentication);
  }
  catch (UsernameNotFoundException notFound) {
  logger.debug("User '" + username + "' not found");

  if (hideUserNotFoundExceptions) {
   throw new BadCredentialsException(messages.getMessage(
    "AbstractUserDetailsAuthenticationProvider.badCredentials","Bad credentials"));
  }
  else {
   throw notFound;
  }
  }

  Assert.notNull(user,"retrieveUser returned null - a violation of the interface contract");
 }
  
  try {
     // 校驗賬號是否禁用
  preAuthenticationChecks.check(user);
     // 校驗資料庫查出來的密碼，和我們傳入的密碼是否一致
  additionalAuthenticationChecks(user,(UsernamePasswordAuthenticationToken) authentication);
 }


}

看了原始碼之後你會發現和我們平常寫的一樣，其主要邏輯也是查資料庫然後對比密碼。

登入之後效果如下：

解析SpringSecurity+JWT認證流程實現

我們返回token之後，下次請求其他API的時候就要在請求頭中帶上這個token，都按照JWT的標準來做就可以。

2. JWT過濾器

有了token之後，我們要把過濾器放在過濾器鏈中，用於解析token，因為我們沒有session，所以我們每次去辨別這是哪個使用者的請求的時候，都是根據請求中的token來解析出來當前是哪個使用者。

所以我們需要一個過濾器去攔截所有請求，前文我們也說過，這個過濾器我們會放在綠色部分用來替代UsernamePasswordAuthenticationFilter，所以我們新建一個JwtAuthenticationTokenFilter，然後將它註冊為Bean，並在編寫配置檔案的時候需要加上這個：

@Bean
  public JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter() {
    return new JwtAuthenticationTokenFilter();
  }

@Override
  protected void configure(HttpSecurity http) throws Exception {
    http.addFilterBefore(jwtAuthenticationTokenFilter(),UsernamePasswordAuthenticationFilter.class);
  }

addFilterBefore的語義是新增一個Filter到XXXFilter之前，放在這裡就是把JwtAuthenticationTokenFilter放在UsernamePasswordAuthenticationFilter之前，因為filter的執行也是有順序的，我們必須要把我們的filter放在過濾器鏈中綠色的部分才會起到自動認證的效果。

接下來我們可以看看JwtAuthenticationTokenFilter的具體實現了：

@Override
  protected void doFilterInternal(@NotNull HttpServletRequest request,@NotNull HttpServletResponse response,@NotNull FilterChain chain) throws ServletException,IOException {
    log.info("JWT過濾器通過校驗請求頭token進行自動登入...");

    // 拿到Authorization請求頭內的資訊
    String authToken = jwtProvider.getToken(request);

    // 判斷一下內容是否為空且是否為(Bearer )開頭
    if (StrUtil.isNotEmpty(authToken) && authToken.startsWith(jwtProperties.getTokenPrefix())) {
      // 去掉token字首(Bearer )，拿到真實token
      authToken = authToken.substring(jwtProperties.getTokenPrefix().length());

      // 拿到token裡面的登入賬號
      String loginAccount = jwtProvider.getSubjectFromToken(authToken);

      if (StrUtil.isNotEmpty(loginAccount) && SecurityContextHolder.getContext().getAuthentication() == null) {
        // 快取裡查詢使用者，不存在需要重新登陸。
        UserDetail userDetails = caffeineCache.get(CacheName.USER,loginAccount,UserDetail.class);

        // 拿到使用者資訊後驗證使用者資訊與token
        if (userDetails != null && jwtProvider.validateToken(authToken,userDetails)) {

          // 組裝authentication物件，構造引數是Principal Credentials 與 Authorities
          // 後面的攔截器裡面會用到 grantedAuthorities 方法
          UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userDetails,userDetails.getPassword(),userDetails.getAuthorities());

          // 將authentication資訊放入到上下文物件中
          SecurityContextHolder.getContext().setAuthentication(authentication);

          log.info("JWT過濾器通過校驗請求頭token自動登入成功,user : {}",userDetails.getUsername());
        }
      }
    }

    chain.doFilter(request,response);
  }

程式碼裡步驟雖然說的很詳細了，但是可能因為程式碼過長不利於閱讀，我還是簡單說說，也可以直接去倉庫檢視原始碼：

拿到Authorization請求頭對應的token資訊
去掉token的頭部(Bearer)
解析token，拿到我們放在裡面的登陸賬號
因為我們之前登陸過，所以我們直接從快取裡面拿我們的UserDetail資訊即可
檢視是否UserDetail為null，以及檢視token是否過期，UserDetail使用者名稱與token中的是否一直。
組裝一個authentication物件，把它放在上下文物件中，這樣後面的過濾器看到我們上下文物件中有authentication物件，就相當於我們已經認證過了。

這樣的話，每一個帶有正確token的請求進來之後，都會找到它的賬號資訊，並放在上下文物件中，我們可以使用SecurityContextHolder很方便的拿到上下文物件中的Authentication物件。

完成之後，啟動我們的demo，可以看到過濾器鏈中有以下過濾器，其中我們自定義的是第5個：

解析SpringSecurity+JWT認證流程實現

:cat:‍ 就醬，我們登入完了之後獲取到的賬號資訊與角色資訊我們都會放到快取中，當帶著token的請求來到時，我們就把它從快取中拿出來，再次放到上下文物件中去。

結合認證方法，我們的邏輯鏈就變成了：

登入:point_right:拿到token:point_right:請求帶上token:point_right:JWT過濾器攔截:point_right:校驗token:point_right:將從快取中查出來的物件放到上下文中

這樣之後，我們認證的邏輯就算完成了。

4. 程式碼優化

認證和JWT過濾器完成後，這個JWT的專案其實就可以跑起來了，可以實現我們想要的效果，如果想讓程式更健壯，我們還需要再加一些輔助功能，讓程式碼更友好。

1. 認證失敗處理器

解析SpringSecurity+JWT認證流程實現

當用戶未登入或者token解析失敗時會觸發這個處理器，返回一個非法訪問的結果。

解析SpringSecurity+JWT認證流程實現

2. 許可權不足處理器

解析SpringSecurity+JWT認證流程實現

當用戶本身許可權不滿足所訪問API需要的許可權時，觸發這個處理器，返回一個許可權不足的結果。

解析SpringSecurity+JWT認證流程實現

3. 退出方法

解析SpringSecurity+JWT認證流程實現

使用者退出一般就是清除掉上下文物件和快取就行了，你也可以做一下附加操作，這兩步是必須的。

4. token重新整理

解析SpringSecurity+JWT認證流程實現

JWT的專案token重新整理也是必不可少的，這裡重新整理token的主要方法放在了token工具類裡面，重新整理完了把快取過載一遍就行了，因為快取是有有效期的，重新put可以重置失效時間。

後記

這篇文我從上週日就開始構思了，為了能講的老嫗能解，修修改改了幾遍才發出來。

Spring Security的上手的確有點難度，在我第一次去了解它的時候看的是尚矽谷的教程，那個視訊的講師拿它和Thymeleaf結合，這就導致網上也有很多部落格去講Spring Security的時候也是這種方式，而沒有去關注前後端分離。

也有教程做過濾器的時候是直接繼承UsernamePasswordAuthenticationFilter，這樣的方法也是可行的，不過我們瞭解了整體的執行流程之後你就知道沒必要這樣做，不需要去繼承XXX，只要寫個過濾器然後放在那個位置就可以了。

本文程式碼：碼雲地址 GitHub地址

到此這篇關於解析SpringSecurity+JWT認證流程實現的文章就介紹到這了,更多相關SpringSecurity+JWT認證內容請搜尋我們以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援我們！

解析SpringSecurity+JWT認證流程實現

楔子

1. :book:SpringSecurity的工作流程

2. :memo:SpringSecurity的重要概念

1.SecurityContext

2. SecurityContextHolder

3. Authentication

4. AuthenticationManager

3. :page_with_curl:程式碼前的準備工作

1. 定義加密器Bean

2. 定義AuthenticationManager

3. 實現UserDetailsService

4. TokenUtil

4. ✍程式碼中的具體實現

1. 認證方法

2. JWT過濾器

4. 程式碼優化

1. 認證失敗處理器

2. 許可權不足處理器

3. 退出方法

4. token重新整理

後記

相關推薦