2. 程式人生 > >用JWT技術為SpringBoot的API增加授權保護（轉），需要自己實現userdetailservice接口

用JWT技術為SpringBoot的API增加授權保護（轉），需要自己實現userdetailservice接口

阿新 • • 發佈：2018-06-14
success RM -s bind 利用 proc ger start.s 自己

轉自：https://blog.csdn.net/haiyan_qi/article/details/77373900

概述

示例 https://github.com/qihaiyan/jwt-boot-auth

用spring-boot開發RESTful API非常的方便，在生產環境中，對發布的API增加授權保護是非常必要的。現在我們來看如何利用JWT技術為API增加授權保護，保證只有獲得授權的用戶才能夠訪問API。

開發一個簡單的API

spring提供了一個網頁可以便捷的生成springboot程序。

如圖：在Search for dependencies中選擇H2、Web、Security、JPA，這幾個依賴在我們的示例工程中會用到。

技術分享圖片

點擊Generate Project按鈕後，下載文件到本地。

在JwtauthApplication.java中增加一個方法：

@RequestMapping("/hello")
@ResponseBody
public String hello(){
  return "hello";
}
  • 1
  • 2
  • 3
  • 4
  • 5

這樣一個簡單的RESTful API就開發好了。

現在我們運行一下程序看看效果，打開命令行工具，執行：

cd jwtauth
gradle bootRun
  • 1
  • 2

等待程序啟動完成後，可以簡單的通過curl工具進行API的調用：

curl http://localhost:8080/tasks
  • 1

至此，我們的接口就開發完成了。但是這個接口沒有任何授權防護，任何人都可以訪問，這樣是不安全的，下面我們開始加入授權機制。

增加用戶註冊功能

首先增加一個實體類MyUser：

package com.example.jwtauth;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class MyUser {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private long id;
    private String username;
    private String password;

    public long getId() {
        return id;
    }

    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;
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35

然後增加一個Repository類MyUserRepository，可以讀取和保存用戶信息：

package com.example.jwtauth;

import org.springframework.data.jpa.repository.JpaRepository;

public interface MyUserRepository extends JpaRepository<MyUser, Long> {
    MyUser findByUsername(String username);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

得益於SpringDataJpa，只需要定義一個interface，就讓我們擁有了數據的CRUD功能。由於我們在build.gradle中引入了H2，所以我們擁有了一個本地數據庫，不需要做任何配置，springboot就會使用這個數據庫，不得不說springboot確實極大的減輕了開發工作量。

下面增加一個類UserController，實現用戶註冊的接口：

package com.example.jwtauth;

import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/users")
public class UserController {

    private MyUserRepository applicationUserRepository;
    private BCryptPasswordEncoder bCryptPasswordEncoder;

    public UserController(MyUserRepository myUserRepository,
                          BCryptPasswordEncoder bCryptPasswordEncoder) {
        this.applicationUserRepository = myUserRepository;
        this.bCryptPasswordEncoder = bCryptPasswordEncoder;
    }

    @PostMapping("/signup")
    public void signUp(@RequestBody MyUser user) {
        user.setPassword(bCryptPasswordEncoder.encode(user.getPassword()));
        applicationUserRepository.save(user);
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

其中的

@PostMapping("/signup")
  • 1

這個方法定義了用戶註冊接口，並且指定了url地址是/users/signup。由於類上加了註解 @RequestMapping(“/users”)，類中的所有方法的url地址都會有/users前綴，所以在方法上只需指定/signup子路徑即可。

密碼采用了BCryptPasswordEncoder進行加密，我們在Application中增加BCryptPasswordEncoder實例的定義。

@SpringBootApplication
@RestController
public class JwtauthApplication {
    @Bean
    public BCryptPasswordEncoder bCryptPasswordEncoder() {
        return new BCryptPasswordEncoder();
    }
  // ...
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

增加JWT認證功能

用戶填入用戶名密碼後，與數據庫裏存儲的用戶信息進行比對，如果通過，則認證成功。傳統的方法是在認證通過後，創建sesstion，並給客戶端返回cookie。現在我們采用JWT來處理用戶名密碼的認證。區別在於，認證通過後，服務器生成一個token，將token返回給客戶端，客戶端以後的所有請求都需要在http頭中指定該token。服務器接收的請求後，會對token的合法性進行驗證。驗證的內容包括：

  1. 內容是一個正確的JWT格式

  2. 檢查簽名

  3. 檢查claims

  4. 檢查權限

處理登錄

創建一個類JWTLoginFilter，核心功能是在驗證用戶名密碼正確後，生成一個token，並將token返回給客戶端：

package com.example.jwtauth;

import com.fasterxml.jackson.databind.ObjectMapper;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
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.core.userdetails.User;
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.ArrayList;
import java.util.Date;

public class JWTLoginFilter extends UsernamePasswordAuthenticationFilter {
    private AuthenticationManager authenticationManager;

    public JWTLoginFilter(AuthenticationManager authenticationManager) {
        this.authenticationManager = authenticationManager;
    }

    @Override
    public Authentication attemptAuthentication(HttpServletRequest req,
                                                HttpServletResponse res) throws AuthenticationException {
        try {
            MyUser user = new ObjectMapper()
                    .readValue(req.getInputStream(), MyUser.class);

            return authenticationManager.authenticate(
                    new UsernamePasswordAuthenticationToken(
                            user.getUsername(),
                            user.getPassword(),
                            new ArrayList<>())
            );
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    protected void successfulAuthentication(HttpServletRequest req,
                                            HttpServletResponse res,
                                            FilterChain chain,
                                            Authentication auth) throws IOException, ServletException {

        String token = Jwts.builder()
                .setSubject(((User) auth.getPrincipal()).getUsername())
                .setExpiration(new Date(System.currentTimeMillis() + 60 * 60 * 24 * 1000))
                .signWith(SignatureAlgorithm.HS512, "MyJwtSecret")
                .compact();
        res.addHeader("Authorization", "Bearer " + token);
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59

該類繼承自UsernamePasswordAuthenticationFilter，重寫了其中的2個方法：

attemptAuthentication ：接收並解析用戶憑證。

successfulAuthentication ：用戶成功登錄後，這個方法會被調用，我們在這個方法裏生成token。

授權驗證

用戶一旦登錄成功後，會拿到token，後續的請求都會帶著這個token，服務端會驗證token的合法性。

創建JwtAuthenticationFilter類，我們在這個類中實現token的校驗功能。

package com.example.jwtauth;

import io.jsonwebtoken.Jwts;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.authentication.www.BasicAuthenticationFilter;

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.ArrayList;

public class JwtAuthenticationFilter extends BasicAuthenticationFilter {
    public JwtAuthenticationFilter(AuthenticationManager authManager) {
        super(authManager);
    }

    @Override
    protected void doFilterInternal(HttpServletRequest req,
                                    HttpServletResponse res,
                                    FilterChain chain) throws IOException, ServletException {
        String header = req.getHeader("Authorization");

        if (header == null || !header.startsWith("Bearer ")) {
            chain.doFilter(req, res);
            return;
        }

        UsernamePasswordAuthenticationToken authentication = getAuthentication(req);

        SecurityContextHolder.getContext().setAuthentication(authentication);
        chain.doFilter(req, res);
    }

    private UsernamePasswordAuthenticationToken getAuthentication(HttpServletRequest request) {
        String token = request.getHeader("Authorization");
        if (token != null) {
            // parse the token.
            String user = Jwts.parser()
                    .setSigningKey("MyJwtSecret")
                    .parseClaimsJws(token.replace("Bearer ", ""))
                    .getBody()
                    .getSubject();

            if (user != null) {
                return new UsernamePasswordAuthenticationToken(user, null, new ArrayList<>());
            }
            return null;
        }
        return null;
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55

該類繼承自BasicAuthenticationFilter，在doFilterInternal方法中，從http頭的Authorization 項讀取token數據，然後用Jwts包提供的方法校驗token的合法性。如果校驗通過，就認為這是一個取得授權的合法請求。

SpringSecurity配置

通過SpringSecurity的配置，將上面的方法組合在一起。

package com.example.jwtauth;

import org.springframework.boot.autoconfigure.security.SecurityProperties;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.annotation.Order;
import org.springframework.http.HttpMethod;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
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.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

@Configuration
@Order(SecurityProperties.ACCESS_OVERRIDE_ORDER)
public class MyWebSecurityConfig extends WebSecurityConfigurerAdapter {
    private UserDetailsService userDetailsService;
    private BCryptPasswordEncoder bCryptPasswordEncoder;

    public MyWebSecurityConfig(UserDetailsService userDetailsService, BCryptPasswordEncoder bCryptPasswordEncoder) {
        this.userDetailsService = userDetailsService;
        this.bCryptPasswordEncoder = bCryptPasswordEncoder;
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.cors().and().csrf().disable().authorizeRequests()
                .antMatchers(HttpMethod.POST, "/users/signup").permitAll()
                .anyRequest().authenticated()
                .and()
                .addFilter(new JWTLoginFilter(authenticationManager()))
                .addFilter(new JwtAuthenticationFilter(authenticationManager()));
    }

    @Override
    public void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService).passwordEncoder(bCryptPasswordEncoder);
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39

這是標準的SpringSecurity配置內容，就不在詳細說明。註意其中的


.addFilter(new JWTLoginFilter(authenticationManager()))
.addFilter(new JwtAuthenticationFilter(authenticationManager()))

這兩行，將我們定義的JWT方法加入SpringSecurity的處理流程中。

下面對我們的程序進行簡單的驗證：

# 請求hello接口，會收到403錯誤
curl http://localhost:8080/hello

# 註冊一個新用戶
curl -H "Content-Type: application/json" -X POST -d ‘{
    "username": "admin",
    "password": "password"
}‘ http://localhost:8080/users/signup

# 登錄，會返回token，在http header中，Authorization: Bearer 後面的部分就是token
curl -i -H "Content-Type: application/json" -X POST -d ‘{
    "username": "admin",
    "password": "password"
}‘ http://localhost:8080/login

# 用登錄成功後拿到的token再次請求hello接口
# 將請求中的XXXXXX替換成拿到的token
# 這次可以成功調用接口了
curl -H "Content-Type: application/json" -H "Authorization: Bearer XXXXXX" "http://localhost:8080/hello"
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

總結

至此，給SpringBoot的接口加上JWT認證的功能就實現了，過程並不復雜，主要是開發兩個SpringSecurity的filter，來生成和校驗JWT token。

JWT作為一個無狀態的授權校驗技術，非常適合於分布式系統架構，因為服務端不需要保存用戶狀態，因此就無需采用redis等技術，在各個服務節點之間共享session數據。

用JWT技術為SpringBoot的API增加授權保護（轉），需要自己實現userdetailservice接口

相關推薦

用JWT技術為SpringBoot的API增加授權保護（轉），需要自己實現userdetailservice接口

success RM -s bind 利用 proc ger start.s 自己 轉自：https://blog.csdn.net/haiyan_qi/article/details/77373900 概述 示例 https://github.com/qihaiyan

FCN用卷積層代替FC層原因（轉）

alex spa 內容 pool 計算 lex 級別 conv2 本質 分類任務 CNN對於常見的分類任務，基本是一個魯棒且有效的方法。例如，做物體分類的話，入門級別的做法就是利用caffe提供的alexnet的模型，然後把輸出的全連接層稍稍修改稱為自己想要的類別數，然後再

C++繼承：公有，私有，保護（轉）

情況 pre mes 派生類 它的 保持 ++ col ble 公有繼承(public)、私有繼承(private)、保護繼承(protected)是常用的三種繼承方式。 1. 公有繼承(public) 公有繼承的特點是基類的公有成員和保護成員作為派生類的成員時，它們都保持

（轉）開放window是服務器端口——以8080為例

win 做了 tcp and setting 範圍 -- .com 右上角 本文記錄兩個內容: 1.win7下打開端口 2.服務器(2003或者其他老版的系統以2003為例) 測試端口時 可用telnet 命令 偵聽端口：C:\Documents and Setti

用 LVS 搭建一個負載均衡集群（轉）

always iptable sina watch 通過 main test 集群服務器 負載 http://blog.jobbole.com/87503/ 第一篇：《如何生成每秒百萬級別的 HTTP 請求？》 第二篇：《為最佳性能調優 Nginx》 第三篇：《用 L

Java技術——Java泛型詳解（轉）

cal 5.1 try 既然 參數 top 兩種 泛型編程 編譯器 1．為什麽需要泛型轉載請註明出處：http://blog.csdn.net/seu_calvin/article/details/52230032泛型在Java中有很重要的地位，網上很多文章羅列各種理論，不

無線網絡中，使用MDK3把指定的用戶或者熱點踢到掉線（轉）

欺騙 超過 bsp 信息 code www 參數 參考 wifi熱點 閱讀目錄 　　準備 　　驗證洪水攻擊 / Authentication Flood Attack 　　取消身份驗證攻擊 / Deauth攻擊 　　參考 回到頂部 　　準備 　　1：系統環境為ubu

SQL SERVER 2005 資料庫狀態為“可疑”的解決方法（轉）

在被設定為“可疑”後很納悶，之前沒有遇到此類情況，問了幾個前輩依然未找到問題所在。最後還是解決了，現在給大家分享我的解決辦法： 　　首先，不能使得資料庫離線、分離等操作，在這種情況下，資料庫不能驚醒備份的。如果你真的使得資料庫離線，就再也沒有辦法解決了。我也幹過這件傻事，千萬不能重蹈覆轍哦。(切記！切記！

簡單好用的sshfs -- 通過ssh對映遠端路徑（轉）

最近習慣性訪問N個Linux機器,在不同機器間跳來跳去,很是麻煩,最終,找到了sshfs,可以把遠端目錄直接對映到本地,無需修改遠端機器的設定,僅要求有ssh連線的許可權(ssh都沒有的話,還能幹啥?!~!) 安裝: #如果是ubuntu apt-get install sshfs #如果是Fed

用版本控制工具將資料庫版本化（轉）

原文地址：http://blog.csdn.net/tywo45/article/details/2480078 1、概述 　　版本化資料庫的起點——建立一個數據庫Schema基線，這個基線是一些資料庫指令碼（包括create table，alter table，drop table，insert data，

用CMake建立動態庫和靜態庫（轉）

五，靜態庫與動態庫構建 讀者雲，太能羅唆了，一個Hello World就折騰了兩個大節。OK，從本節開始，我們不再折騰Hello World了，我們來折騰Hello World的共享庫。 本節的任務：１，建立一個靜態庫和動態庫，提供HelloFunc函式供其他程式程式設計使用

管理方法論-學習技術管理實戰36講有感（1）-為什麼需要學管理

1.自我傾聽-why 理順內心的糾結與彷徨，而後心無旁騖地開始用心學習技術管理 2.角色認知-what 搞清楚技術管理涉及的管理範圍 3.管理方法-how 管理三部曲：管理規劃、團隊建設、任務管理，即“看方向、帶人、做事“ 4.管理溝通 向上、向下、橫向 5.

shelve -- 用來持久化任意的Python對象（轉）

src 缺省 alt 開始 log 因此 每一個 gpo plain 這幾天接觸了Python中的shelve這個module，感覺比pickle用起來更簡單一些，它也是一個用來持久化（序列化）Python對象的簡單工具。當我們寫程序的時候如果不想用關系數據庫那麽重量級的東

ON_WM_TIMER() void (__cdecl xx::* )(UINT)”轉換為“void (__cdecl CWnd::* )(UINT_PTR)（轉）

開發十年，就只剩下這套架構體系了！ >>>   

（轉）log4j（一）——為什麽要用log4j？

控制 clas 姓名 private 開發環境 負責人 getname 麻煩 方法名 1 試驗環境 OS：win7 JDK：jdk7 Log4j：1.2.17（好尷尬，原本是想試驗下log4j2的，結果陰差陽錯用了這個版本，不過幸好，試驗也不白試驗，試驗的作用是一樣的

用sharding技術來擴充套件你的資料庫（hash分佈擴充套件，一致性雜湊）

EMC中國研究院大資料組研究員 郭小燕 摘要： 本部分首先簡單介紹sharding系統的基本架構，然後重點介紹sharding機制中常用的三種表資料劃分方法。 一.  資料劃分演算法 1. Sharding 系統的基本結構 上節我們說到Sharding可以簡單定義為將大資料庫分佈到多個物理節點上的

MySQL核心技術之“增加新檔案（boost）”

本篇內容和資料庫技術本身無關。只是針對特定的MySQL code base進行開發時涉及到的一些細節問題。不關心的朋友可自行略過。 在MySQL的code base中新增檔案需要做如下事情： 1. 如果是cc檔案，需要在對應的CMakefileList.txt中新增檔名

奔三技術男：聊聊從華為裸辭後的一點感悟（轉）

關於離開 知乎上“你為什麼從騰訊離職”、“你為什麼從百度離職”這類話題長盛不衰，華為的話題下，也有這樣的討論。不同公司、不同部門乃至不同的人，從某種程度上來說，無論是來是去都有相似的緣由，參與的人多了，免不了抱怨、吐槽，於事無補，於人無益。 我的離開，有長期出差幾

centos7 用yum安裝mysql（轉）

unity 文件 設置密碼 highlight yum oca 網上 get r文件 CentOS 7的yum源中貌似沒有正常安裝mysql時的mysql-sever文件，需要去官網上下載 # wget http://dev.mysql.com/get/mysql-

華為軟件開發雲（DevCloud）：免費可商用的項目管理工具

簡單 rails 分享 關註 質量 覆蓋 全生命周期管理 部署過程 快速 在軟件開發技術和理念層出不窮的今天，如何更快的適應變化的環境，更好的滿足客戶的需求，已經成為決定從小到大各種規模企業能否活下去的關鍵。 天下武功唯快不破，在當今大環境中更是如此，微服務，敏捷開發，新的