Springboot系列之九：Json Web Token介绍与基本使用

最新推荐文章于 2024-06-19 10:23:57 发布

xk_一步一步来

最新推荐文章于 2024-06-19 10:23:57 发布

阅读量1.7k

点赞数 2

分类专栏： SpringBoot 文章标签： Json Web Token介绍与基本使用

SpringBoot 专栏收录该内容

67 篇文章 8 订阅

订阅专栏

阅读：JWT全面解读、使用步骤
https://blog.csdn.net/qq_32534441/article/details/89920384

转自：https://blog.csdn.net/yuanlaijike/article/details/80174327

一、Session与JWT

1.1 传统Cookie+Session

Cookie+Session的存在主要是为了解决HTTP这一无状态协议下服务器如何识别用户的问题。

其原理就是在用户登录通过验证后，服务端将数据加密后存储在服务器Session中，同时服务器将Session的标识即SessionId存放在客户端Cookie中。

用户之后发起的请求都会携带Cookie信息，服务器根据SessionId寻回对应的Session，从而完成验证，确认这是之前登陆过的用户。其工作原理如下图所示：

1.2 JWT技术

JWT，即JSON Web Token，当用户使用它的认证信息登陆系统之后，会返回给用户一个JWT，用户只需要本地保存即可。

当用户希望访问一个受保护的路由或者资源的时候，在请求头部添加该JWT。后台获取请求头部的JWT并进行验证，如果合法，则允许用户的行为。

二、JWT的组成

一个JWT实际上就是一个字符串，它由三部分组成：头部、载荷(Payload)与签名。

2.1 头部

头部用于描述关于该JWT的最基本的信息，例如其类型以及签名所用的算法等。这也可以被表示成一个JSON对象。

{
	"typ": "JWT",
	"alg": "HS256"
}

 
 
 
 1
2
3
4

注：指明了这是一个JWT，并且我们所用的签名算法（后面会提到）是HS256算法。

对JSON串进行Base64编码，得到了JWT的Header（头部）。

2.2 载荷

JWT主体内容主要包含以下三种类型：

Reserved（保留声明），它的含义就像是编程语言的保留字一样，属于JWT规范中规定好的，这类声明不是必须的，但是是建议使用的。有以下几种：

iss: JWT的签发者
sub: 该JWT所面向的用户
aud:JWT的接收方
exp(expires): 过期时间，这里是一个Unix时间戳
iat(issued at): 签发时间，这里是一个Unix时间戳

Public （公共声明）：这类声明需要在 IANA JSON Web Token Registry 中定义或者提供一个URI，因为要避免重名等冲突。
Private（私有声明）：根据业务需要自己定义的数据了

例如下面这个JSON串，最后一项user_id就是我自定义的数据：

{
	"iss": "Jitwxs",
	"iat": 1441593502,
	"exp": 1441594722,
	"aud": "www.example.com",
	"sub": "wxs@example.com",
	"user_id":"10001"
}

 
 
 
 1
2
3
4
5
6
7
8

对上面的JSON串进行Base64编码，得到了JWT的载荷

2.3 签名

将上面的两个编码后的字符串都用句号 .连接在一起（头部在前），形如：

eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJmcm9tX3VzZXIiOiJCIiwidGFyZ2V0X3VzZXIiOiJBIn0

 
 
 
 1

最后，我们将上面拼接完的字符串用HS256算法进行加密。

在加密的时候，我们还需要提供一个密钥（secret）。如果我们用 mySecret作为密钥的话，那么得到结构如下：

rSWamyAYwuHCo7IFAgd1oRpSP7nzL7BF5t7ItqpKViM

 
 
 
 1

这就是签名。

最后将这一部分签名也拼接在被签名的字符串后面，我们就得到了完整的JWT，形如：

我们就可以将这个传递给客户端了。

三、JWT在客户端的存储

3.1 HTML5 Web Storage

Web存储就是使用localStorage或sessionStorage进行存储，许多人使用这种方式存储，是因为能够防止CSRF(跨站请求伪造)。但是使用Web存储，反而会增加XSS(跨站脚本攻击)的风险。

XSS，简而言之是一种漏洞，攻击者可以注入在页面上运行的JavaScript。为了防止XSS，常见的反应是转义和编码所有不可信的数据。但是只要有一个漏洞存在，那么整个防护体系就完全失效。如果你使用的第三方脚本被攻击，你的Web存储仍然会收受到威胁。

3.2 Cookies

3.2.1 CSRF

CSRF(跨站请求伪造)是一种典型的利用cookie-session漏洞的攻击。

假设你经常使用bank.example.com进行网上转账，在你提交转账请求时bank.example.com的前端代码会提交一个HTTP请求:

POST /transfer HTTP/1.1
Host: bank.example.com
cookie: JsessionID=randomid; Domain=bank.example.com; Secure; HttpOnly
Content-Type: application/x-www-form-urlencoded
amount=100.00&routingNumber=1234&account=9876

 
 
 
 1
2
3
4
5
6

你图方便没有登出bank.example.com，随后又访问了一个恶意网站，该网站的HTML页面包含了这样一个表单：

<form action="https://bank.example.com/transfer" method="post">
    <input type="hidden" name="amount" value="100.00"/>
    <input type="hidden" name="routingNumber" value="evilsRoutingNumber"/>
    <input type="hidden" name="account" value="evilsAccountNumber"/>
    <input type="submit" value="点击就送!"/>
</form>

 
 
 
 1
2
3
4
5
6

你被“点击就送”吸引了，当你点了提交按钮时你已经向攻击者的账号转了100元。

现实中的攻击可能更隐蔽，恶意网站的页面可能使用Javascript自动完成提交。尽管恶意网站没有办法盗取你的session cookie（从而假冒你的身份），但恶意网站向bank.example.com发起请求时，你的cookie会被自动发送过去。

很多人用JWT+Web存储的本心是为了防护CRSF。这样做的原因是——因为Cookie的发送是完全由浏览器控制的，不受网页本身的控制。所以最简单直接的办法，就是不用Cookie，不让自动发送认证信息成为可能。问题在于，这么干是有XSS风险的。那么怎么在使用Cookie的同时，还能防范CSRF呢？

3.2.1 CSRF的防护

3.2.1.1 传统页面网站

在传统页面Web网站中，一般会使用CSRF Token。这是个非常流行的做法。像Tomcat这类的容器都会自带CSRF Token的产生和检查Filter。

CSRF Token是这样工作的。客户端要首先向服务器请求一个带有提交表单的页面，服务器返回的页面中会嵌入一个CSRF Token。当用户提交表单时，CSRF Token会被一起携带发给服务器做验证。所以当服务器看到CSRF Token，就可以放心大胆的确认用户的的确确是看看到了提交前的表单界面，从而避免了用户稀里糊涂提交一个被伪造的表单的可能性。

3.2.1.2 SPA应用

在SPA中，客户端与服务器之间的交互主要是通过接口完成的，没有页面的概念。此时，你的确可以照猫画虎的做一个接口让用户拿到CSRF Token，但这样什么也确认不了。因为攻击者可以调用同样的接口，拿到合法的CSRF Token。

这时有几种办法：

给所有接口都添加一个请求secret，来标记其来自于合法的客户端。这个secrect可以是固定的随机字符串，也可以通过某些动态算法产生。对于CSRF，浏览器只会做自动传Cookie而已，并不能帮助传入secret。这样一来，就可以确定消除CSRF的风险。但注意，这个机制仅能防范CSRF，而不能防范人为的攻击。黑客只要拿得到客户端，就一定能找到生成secret的办法。
用Same-Site Cookie。当用户看到了B站点伪造的表单，点击了提交，向站点A发出请求时，被标记了Same-Site=strict的Cookie是不会被携带的，因为当时的主站点域名B和提交的站点域名A不一样。这是Same-Site=strict标记是个相对较新的标准。目前大部分浏览器都已经支持了。
总是用JSON格式提交。CSRF可能发生的一个前提条件是必须用传统表单提交。这是因为传统表单提交可以跨域——你在站点B，可以提交表单给站点A。而Ajax的请求除非开启CORS，是不允许跨域的，所以天然的屏蔽掉了这个问题。传统表单的提交的格式必然是application/x-www-form-urlencoded。因此只要保证服务器能够拒绝处理所有这种格式的POST请求，就能确保SPA不受CSRF的影响。

四、 JWT的优缺点与适用场景

4.1 优点

无状态。Token机制在服务端不需要存储session信息，因为Token 自身包含了所有登录用户的信息，只需要在客户端的cookie或本地介质存储状态信息.
去耦。不需要绑定到一个特定的身份验证方案。Token可以在任何地方生成，只要在你的API被调用的时候，你可以进行Token生成调用即可.
更适用于移动应用。当你的客户端是一个原生平台时，Cookie是不被支持的（你需要通过Cookie容器进行处理），这时采用Token认证机制就会简单得多。
CSRF。因为不再依赖于Cookie，所以你就不需要考虑对CSRF的防范，但需要防范XSS。

4.2 缺点

占用太多空间。上面提到 JWT存储在Web存储中会导致XSS攻击，那就只能存储在 Cookie 里了。但是，Cookie 的存储容量是有限制的（通常为 4 KB）。而JWT 占用的空间又不是那么小，尤其是在使用无状态 JWT 时，所有的数据都被放到 JWT 里，数据大小很快就会超过 Cookie 的容量限制。
**无法完全掌控JWT。**使用了JWT，无法实现在服务器端对用户请求进行管理——管理员没法统计多少个人登录了，一个人登录了多少次，登陆了什么设备；同时，也无法强行“踢”掉一个用户的登录——JWT一旦生成，在失效之前，总是有效的。如果实现了一个token黑名单之类的功能，就等价于实现了Session机制，无状态带来的好处就无从谈起。这个限制对于任何一个要认真做用户风险控制的网站来说都是不可能接受的。
数据实效性差。 JWT 一旦被生成，就不会再和服务端有任何瓜葛，一旦服务端中的相关数据更新，JWT 中存储的数据由于得不到更新，就变成了过期的数据。

以上这些缺点都只针对无状态 JWT。如果使用有状态 JWT（JWT 中存储认证授权信息的 ID，具体数据存储在服务端），就可以规避这些缺点。不过，有状态 JWT 基本上等同于 Session / Cookie，没有存在价值。

4.3 适用场景

JWT 的最佳用途是「一次性授权 Token」，这种场景下的 Token 的特性如下：

有效期短
只希望被使用一次

例如使用邮箱注册时，需要发一封注册邮件进行验证，只需验证一次，并且超过一定时间后失效。

五、提高安全性

5.1 使用https

http是明文传输的。在http下，用户输入的任何信息，从他的电脑到服务器之间的每个链路节点都是明文的。在这里个链路中的任何地方，都可以截取到完整的数据，包含你的密码，认证token……

这就是为什么https是必须的。https主要提供三个保证：

端端加密。通过https交互的原始数据，只有用户的浏览器和最终的服务器可以看到。其他中间节点无法获）。
客户端可以认定要访问的服务器就是那个服务器。这是被证书体系所支撑的。一旦浏览器的地址栏出现了网址的证书信息，并且是绿色的提示，那么用户的心里就可以稳了。（当然国内其实也不完全是这样，讲多了查水表，懂者自懂）。
服务器可以认定访问的客户端就是合法的客户端。这种模式被称为“2-Way SSL”或者“Mutal SSL”。这种模式是可选的，需要多配置一个客户端证书，一般场景用不到，多见于企业Web服务。

使用了https后，为了进一步保证安全，将Cookie设置为Secure。这样，浏览器就可以只在访问https网址时才会携带Cookie。如果不做这样的设置，通过https站点设置的Cookie，仍然会向http站点发送。当这个站点的域名解析被劫持，就可能造成向一个伪造的服务器发出你的认证信息。

5.2 认证信息不应该永久有效

很多人为了“用户体验”，选择让一个登录永久有效。这样做是非常危险的。因为一旦用户的认证信息被别人获取了，就永久性的失去了防御的机会。

因此，总是要保证认证信息的有效期是有限的。一般根据业务场景的安全级别不同，可以设为若干分钟～若干天。就算是社交娱乐类的应用，有效期最好也不要超过两周。

5.3 设计安全的secret

JWT唯一存储在服务端的只有一个 secret，个人认为这个 secret 应该设计成和用户相关的，而不是一个所有用户公用的统一值。这样可以有效的提高安全性。

例如用户修改密码时，需要重新生成jwt，密码就需要和secret存在一定的联系。

六、总结

注意：这里的总结是在Web开发中

可以使用Session也可以使用Token做认证，但是总是要保证服务器端可以管理Session，通过Session是否存在来最终确定认证的有效性
将认证信息存放在标记为HttpOnly，Secure，Same-Site=strict的Cookie中，从而避免XSS和CSRF
如果是传统的页面网站，请使用CSRF Token机制
总是使用https，只要你的网络链路经过了公网
保证token/session 必须有一个有效期
不要用 JWT 来做 Web 应用的会话管理，请用 Session / Cookie

七、示例程序

源码地址：https://github.com/jitwxs/blog_sample

7.1 HelloWorld

光说不练假把式，下面只用三步来实现一个JWT的HelloWorld程序（注意我是在SpringBoot的环境下）。

导入JJWT包简化操作：

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

 
 
 
 1
2
3
4
5

第一步：JWT工具类，直接使用即可

import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
/**
 * JWT工具类
 * @author jitwxs
 * @since 2018/5/2 18:49
 */
public class JwtUtils {
    // 签名密钥（高度保密）
    private static final String SECRET = "qYYjXt7s1C*nEC%9RCwQGFA$YwPr$Jrj";
    // 签名算法
    private static final SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS512;
    // token前缀
    private static final String TOKEN_PREFIX = "Bearer ";
    /**
     * 生成JWT token
     * @param map 传入数据
     * @param maxAge 有效期（单位：ms）
     * @author jitwxs
     * @since 2018/5/3 23:19
     */
    public static String sign(Map<String,Object> map, long maxAge) {
        return sign(map, null, null, maxAge);
    }
    /**
     * 生成JWT token
     * @param map 传入数据
     * @param issuer 签发者
     * @param subject 面向用户
     * @param maxAge 有效期（单位：ms）
     * @author jitwxs
     * @since 2018/5/3 23:19
     */
    public static String sign(Map<String,Object> map, String issuer, String subject, long maxAge) {
        Date now  = new Date(System.currentTimeMillis());
        String jwt = Jwts.builder()
                .setClaims(map) // 设置自定义数据
                .setIssuedAt(now) // 设置签发时间
                .setExpiration(new Date(now.getTime() + maxAge)) // 设置过期时间
                .setIssuer(issuer) // 设置签发者
                .setSubject(subject) // 设置面向用户
                .signWith(signatureAlgorithm, SECRET)
                .compact();
        return TOKEN_PREFIX + jwt;
    }
    /**
     * 验证JWT token并返回数据。当验证失败时，抛出异常
     * @author jitwxs
     * @since 2018/5/3 23:20
     */
    public static Map unSign(String token) {
        try {
            return Jwts.parser()
                    .setSigningKey(SECRET)
                    .parseClaimsJws(token.replace(TOKEN_PREFIX,""))
                    .getBody();
        }catch (Exception e){
            throw new IllegalStateException("Token验证失败："+e.getMessage());}}
    public static void main(String[] args) {
        Map<String,Object> map = new HashMap<>(); map.put("userName","admin");
        map.put("userId","001");
        String token = JwtUtils.sign(map, 3600_000);
//        String token = JwtUtils.sign(map, "jitwxs","普通用户",3600_000);
        System.out.println(JwtUtils.unSign(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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

第二步：Controller类

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestAttribute;
import org.springframework.web.bind.annotation.RestController;
import java.util.HashMap;
import java.util.Map;
/**
 * @author jitwxs
 * @date 2018/5/2 21:03
 */
@RestController
public class SystemController {
    private final String USER_NAME_KEY = "USER_NAME";
    private final Long EXP_IMT = 3600_000L;
    @GetMapping("/api/test")
    public Object hellWorld(@RequestAttribute(value = USER_NAME_KEY)  String username) {
        return "Welcome! Your USER_NAME : " + username;
    }
    @PostMapping("/login")
    public Object login(String name, String password) {
        if(isValidPassword(name,password)) {
            // 将用户名传入并生成jwt
            Map<String,Object> map = new HashMap<>();
            map.put(USER_NAME_KEY, name);
            String jwt = JwtUtils.sign(map, EXP_IMT);
            // 将jwt返回给客户端
            return new HashMap<String,String>(){{
                put("token", jwt);
            }};
        }else {
            return new ResponseEntity(HttpStatus.UNAUTHORIZED);
        }
    }
    /**
     * 验证密码是否正确，模拟
     */
    private boolean isValidPassword(String name, String password) {
        return "admin".equals(name) && "admin".equals(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
36
37
38
39
40
41
42
43
44
45
46
47
48

主要就两个方法，一个用于登陆，一个用于测试JWT。

第三步：Filter类并在启动类中注册

import org.springframework.stereotype.Component;
import org.springframework.util.AntPathMatcher;
import org.springframework.util.PathMatcher;
import org.springframework.web.filter.OncePerRequestFilter;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Map;
/**
 * JWT过滤器
 * @author jitwxs
 * @date 2018/5/2 20:43
 */
public class JwtAuthenticationFilter extends OncePerRequestFilter {
    private final String USER_NAME_KEY = "USER_NAME";
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        try {
            // 从用户请求头中取token，key一般为Authorization
            String token = request.getHeader("Authorization");
            Map map = JwtUtils.unSign(token);
            // 将用户名存入request属性
            request.setAttribute(USER_NAME_KEY, map.get(USER_NAME_KEY));
        } catch (Exception e) {
            response.sendError(HttpServletResponse.SC_UNAUTHORIZED, e.getMessage());
            return;
        }
        filterChain.doFilter(request, response);
    }
}

 
 
 
 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

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
    @Bean
    public FilterRegistrationBean jwtAuthenticationFilterRegister() {
        FilterRegistrationBean registration = new FilterRegistrationBean();
        //注入过滤器
        registration.setFilter(new JwtAuthenticationFilter());
        //拦截规则
        registration.addUrlPatterns("/api/*");
        //过滤器名称
        registration.setName("jwtAuthenticationFilter");
        return registration;
    }
}

 
 
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

到此结束！也许你有点迷糊，我来解释下：

在Controller的login方法中，如果用户登陆成功，将会返回一个jwt token给用户，在这个token中，存放了用户的名称。
用户访问api/test，该url会被过滤器所拦截，在过滤器中，会取出jwt token并验证，如果验证失败（不存在或错误），抛出异常；如果验证成功，取出用户的名称并放入request的attribute中。
如果通过了过滤器，在api/test中，取出request attribute中的用户名称并输出。

是不是很简单，让我们运行下程序：

（1）当我们未携带或携带错误的jwt token访问/api/test时，抛出异常：
未携带JWT

（2）当我们成功登录后，返回jwt token：
登陆成功

（3）重新访问jwt token，并在请求头中携带jwt token：
携带JWT

7.2 与Spring Security结合

本节将带你体验下JWT 和 Spring Security 结合的实际应用。如果你还不了解Spring Security，可以参考我的《SpringBoot集成Spring Security》系列文章，从SpringBoot集成Spring Security（1）——入门程序看起。

首先我们先整理下思路，我们的程序对外提供一些api服务，使用这些服务用户需要验证身份，且根据用户的身份，只允许用户访问部分资源，使用到的技术为Spring Security + JWT。

有了思路，我们来想一下流程，Spring Security本身可以帮助我们鉴别用户身份和权限，那么流程大概如下：

用户登录，如果登录失败，返回错误信息；如果登录成功，返回一个JWT token给用户。
如果用户登录成功，用户携带着JWT token访问api服务，如果用户身份允许，则返回api结果；否则不允许获取。

为了实现这个流程，我们需要自定义两个过滤器，作用如下：

过滤器1：当用户登录成功后，将JWT token 返回给用户
过滤器2：当用户访问api服务验证时，验证携带的token

思路理的差不多了，下面开始实践吧！

7.2.1 准备数据库

数据库为Spring Security常规的三张表，即用户表、权限表、用户权限表。

CREATE TABLE `sys_role`  (
  `id` int(11) NOT NULL,
  `name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
INSERT INTO `sys_role` VALUES (1, 'ROLE_ADMIN');
INSERT INTO `sys_role` VALUES (2, 'ROLE_USER');
CREATE TABLE `sys_user`  (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `password` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
INSERT INTO `sys_user` VALUES (1, 'admin', '123');
INSERT INTO `sys_user` VALUES (2, 'jitwxs', '123');
DROP TABLE IF EXISTS `sys_user_role`;
CREATE TABLE `sys_user_role`  (
  `user_id` int(11) NOT NULL,
  `role_id` int(11) NOT NULL,
  PRIMARY KEY (`user_id`, `role_id`) USING BTREE,
  INDEX `fk_role_id`(`role_id`) USING BTREE,
  CONSTRAINT `fk_role_id` FOREIGN KEY (`role_id`) REFERENCES `sys_role` (`id`) ON DELETE CASCADE ON UPDATE CASCADE,
  CONSTRAINT `fk_user_id` FOREIGN KEY (`user_id`) REFERENCES `sys_user` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
INSERT INTO `sys_user_role` VALUES (1, 1);
INSERT INTO `sys_user_role` VALUES (2, 2);

 
 
 
 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

在配置文件中添加数据库信息：

spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/test1?useUnicode=true&characterEncoding=utf-8&useSSL=true
spring.datasource.username=root
spring.datasource.password=root
mybatis.configuration.map-underscore-to-camel-case=true

 
 
 
 1
2
3
4
5
6

7.2.2 导入依赖、准备实体、Mapper、Service

使用到的依赖包如下，主要就是spring security、mybatis和jjwt：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
    </dependency>
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>1.3.1</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-lang3</artifactId>
        <version>3.7</version>
    </dependency>
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt</artifactId>
        <version>0.9.0</version>
    </dependency>
</dependencies>

 
 
 
 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

（1）实体

public class SysUser implements Serializable{
    static final long serialVersionUID = 1L;
    private Integer id;
    private String username;
    private String password;
   // 省略getter/setter
}

 
 
 
 1
2
3
4
5
6
7
8
9
10
11

public class SysRole implements Serializable {
    static final long serialVersionUID = 1L;
    private Integer id;
    private String name;
    // 省略getter/setter
}

 
 
 
 1
2
3
4
5
6
7
8
9

public class SysUserRole implements Serializable {
    static final long serialVersionUID = 1L;
    private Integer userId;
    private Integer roleId;
    // 省略getter/setter
}

 
 
 
 1
2
3
4
5
6
7
8
9

（2）Mapper

@Mapper
public interface SysUserMapper {
    @Select("SELECT * FROM sys_user WHERE id = #{id}")
    SysUser selectById(Integer id);
    @Select("SELECT * FROM sys_user WHERE username = #{username}")
    SysUser selectByUsername(String username);
}

 
 
 
 1
2
3
4
5
6
7
8

@Mapper
public interface SysRoleMapper {
    @Select("SELECT * FROM sys_role WHERE id = #{id}")
    SysRole selectById(Integer id);
}

 
 
 
 1
2
3
4
5

@Mapper
public interface SysUserRoleMapper {
    @Select("SELECT * FROM sys_user_role WHERE user_id = #{userId}")
    List<SysUserRole> listByUserId(Integer userId);
}

 
 
 
 1
2
3
4
5

（3）Service

@Service
public class SysUserService {
    @Autowired
    private SysUserMapper userMapper;
    public SysUser selectById(Integer id) {
        return userMapper.selectById(id);
    }
    public SysUser selectByUsername(String username) {
        return userMapper.selectByUsername(username);
    }
}

 
 
 
 1
2
3
4
5
6
7
8
9
10
11
12
13

@Service
public class SysRoleService {
    @Autowired
    private SysRoleMapper roleMapper;
    public SysRole selectById(Integer id){
        return roleMapper.selectById(id);
    }
}

 
 
 
 1
2
3
4
5
6
7
8
9

@Service
public class SysUserRoleService {
    @Autowired
    private SysUserRoleMapper userRoleMapper;
    public List<SysUserRole> listByUserId(Integer userId) {
        return userRoleMapper.listByUserId(userId);
    }
}

 
 
 
 1
2
3
4
5
6
7
8
9

7.2.3 编写Controller

Controller中，一个是登录失败的处理，剩下两个模拟api资源，一个需要ROLE_ADMIN身份，一个需要ROLE_USER身份。其中USER_ID_KEY 为从request中取出的值。

@Controller
public class LoginController {
    private final String USER_ID_KEY = "USER_ID";
    @RequestMapping("/login/error")
    @ResponseBody
    public String loginError(HttpServletRequest request, HttpServletResponse response) {
        AuthenticationException exception =
                (AuthenticationException)request.getSession().getAttribute("SPRING_SECURITY_LAST_EXCEPTION");
        return exception.toString();
    }
    @GetMapping("/api/admin")
    @ResponseBody
    @PreAuthorize("hasRole('ROLE_ADMIN')")
    public Object helloAdmin(@RequestAttribute(value = USER_ID_KEY)  Integer userId) {
        return "Welcome Admin! Your USER_ID : " + userId;
    }
    @GetMapping("/api/user")
    @ResponseBody
    @PreAuthorize("hasRole('ROLE_USER')")
    public Object helloUser(@RequestAttribute(value = USER_ID_KEY)  Integer userId) {
        return "Welcome User! Your USER_ID : " + userId;
    }
}

 
 
 
 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

7.2.4 准备工具类

工具类除了上面使用的JwtUtils以外，还要加上一个用于获取Bean的工具类，因为我们要在过滤器中查询用户权限。

/**
 * @author jitwxs
 * @date 2018/3/20 14:22
 */
@Component
public class SpringBeanFactoryUtils implements ApplicationContextAware {
    private static ApplicationContext context = null;
    public static <T> T getBean(Class<T> type) {
        return context.getBean(type);
    }
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        if (SpringBeanFactoryUtils.context == null) {
            SpringBeanFactoryUtils.context = applicationContext;
        }
    }
}

 
 
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

7.2.5 编写登录的过滤器

前面说了那么多无关紧要的，下面开始重点了，现在编写第一个过滤器，用于登录成功后生成JWT token并返回给用户。

import jit.wxs.jwt.entity.SysUser;
import jit.wxs.jwt.service.SysUserService;
import jit.wxs.jwt.utils.JwtUtils;
import jit.wxs.jwt.utils.SpringBeanFactoryUtils;
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.Collections;
import java.util.HashMap;
import java.util.Map;
/**
 * 该filter继承自UsernamePasswordAuthenticationFilter
 * 在验证用户名密码正确后，生成一个token，并将token返回给客户端
 * @author jitwxs
 * @since 2018/5/4 10:34
 */
public class JwtLoginFilter extends UsernamePasswordAuthenticationFilter {
    static final String USER_ID_KEY = "USER_ID";
    private AuthenticationManager authenticationManager;
    public JwtLoginFilter(AuthenticationManager authenticationManager) {
        this.authenticationManager = authenticationManager;
    }
    /**
     * 该方法在Spring Security验证前调用
     * 将用户信息从request中取出，并放入authenticationManager中
     * @author jitwxs
     * @since 2018/5/4 10:35
     */
    @Override
    public Authentication attemptAuthentication(HttpServletRequest req, HttpServletResponse res) throws AuthenticationException {
        try {
            String username = req.getParameter("username");
            String password = req.getParameter("password");
            // 将用户信息放入authenticationManager
            return authenticationManager.authenticate(
                    new UsernamePasswordAuthenticationToken(
                            username,
                            password,
                            Collections.emptyList())
            );
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    /**
     * 该方法在Spring Security验证成功后调用
     * 在这个方法里生成JWT token，并返回给用户
     * @author jitwxs
     * @since 2018/5/4 10:37
     */
    @Override
    protected void successfulAuthentication(HttpServletRequest req, HttpServletResponse res, FilterChain chain, Authentication auth) throws IOException, ServletException {
        String username = ((User)auth.getPrincipal()).getUsername();
	    // 从数据库中取出用户信息
        SysUserService userService = SpringBeanFactoryUtils.getBean(SysUserService.class);
        SysUser user = userService.selectByUsername(username);;
        // 将用户id放入JWT token
        Map<String,Object> map = new HashMap<>();
        map.put(USER_ID_KEY, user.getId());
        String token = JwtUtils.sign(map, 3600_000);
	// 将token放入响应头中
        res.addHeader("Authorization", 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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

7.2.6 编写验证token的过滤器

在isProtectedUrl()方法中规定了只拦截/api下的所有请求
在getAuthentication()方法中验证token，验证失败，返回null；验证成功，返回的对象中包含用户的角色
在doFilterInternal()中，如果上面返回值为null，则抛出异常；否则将返回对象，也就是用户信息注入到框架中，并放行

import jit.wxs.jwt.entity.SysRole;
import jit.wxs.jwt.entity.SysUserRole;
import jit.wxs.jwt.service.SysRoleService;
import jit.wxs.jwt.service.SysUserRoleService;
import jit.wxs.jwt.utils.JwtUtils;
import jit.wxs.jwt.utils.SpringBeanFactoryUtils;
import org.springframework.security.authentication.AuthenticationCredentialsNotFoundException;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.authentication.www.BasicAuthenticationFilter;
import org.springframework.util.AntPathMatcher;
import org.springframework.util.PathMatcher;
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.Collection;
import java.util.List;
import java.util.Map;
/**
 * JWT过滤器
 * 在访问受限URL前，验证JWT token
 * @author jitwxs
 * @since 2018/5/2 20:43
 */
public class JwtAuthenticationFilter extends BasicAuthenticationFilter {
    private static final PathMatcher pathMatcher = new AntPathMatcher();
    static final String USER_ID_KEY = "USER_ID";
    public JwtAuthenticationFilter(AuthenticationManager authenticationManager) {
        super(authenticationManager);
    }
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        if (isProtectedUrl(request)) {
            UsernamePasswordAuthenticationToken authentication = getAuthentication(request);
            // 如果验证失败，设置异常；否则将UsernamePasswordAuthenticationToken注入到框架中
            if (authentication == null) {
                //手动设置异常
                request.getSession().setAttribute("SPRING_SECURITY_LAST_EXCEPTION", new AuthenticationCredentialsNotFoundException("权限认证失败"));
                // 转发到错误Url
                request.getRequestDispatcher("/login/error").forward(request, response);
            } else {
                SecurityContextHolder.getContext().setAuthentication(authentication);
                filterChain.doFilter(request, response);
            }
        }
    }
    /**
     * 验证token
     * @return 成功返回包含角色的UsernamePasswordAuthenticationToken；失败返回null
     */
    private UsernamePasswordAuthenticationToken getAuthentication(HttpServletRequest request) {
        Collection<GrantedAuthority> authorities = new ArrayList<>();
        String token = request.getHeader("Authorization");
        if (token != null) {
            Map map = JwtUtils.unSign(token);
            Integer userId = (Integer) map.get(USER_ID_KEY);
            if (userId != null) {
                // 将用户id放入request中
                request.setAttribute(USER_ID_KEY, userId);
                // 从数据库中获取用户角色
                SysUserRoleService userRoleService = SpringBeanFactoryUtils.getBean(SysUserRoleService.class);
                SysRoleService roleService = SpringBeanFactoryUtils.getBean(SysRoleService.class);
                List<SysUserRole> userRoles = userRoleService.listByUserId(userId);
                for (SysUserRole userRole : userRoles) {
                    SysRole role = roleService.selectById(userRole.getRoleId());
                    authorities.add(new SimpleGrantedAuthority(role.getName()));
                }
                // 这里直接注入角色，因为JWT已经验证了用户合法性，所以principal和credentials直接为null即可
                return new UsernamePasswordAuthenticationToken(null, null, authorities);
            }
            return null;
        }
        return null;
    }
    //只对/api/*下请求拦截
    private boolean isProtectedUrl(HttpServletRequest request) {
        return pathMatcher.match("/api/**", request.getServletPath());
    }
}

 
 
 
 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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

7.2.7 注入过滤器

完成了最关键的过滤器，下面只要将这两个过滤器注入到Spring Security中即可。

首先给出CustomUserDetailsService ，这是Spring Security的知识，不再赘述。

@Service("userDetailsService")
public class CustomUserDetailsService implements UserDetailsService {
    @Autowired
    private SysUserService userService;
    @Autowired
    private SysRoleService roleService;
    @Autowired
    private SysUserRoleService userRoleService;
    @Override
    public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException {
        Collection<GrantedAuthority> authorities = new ArrayList<>();
        SysUser user = userService.selectByUsername(s);
        // 判断用户是否存在
        if(user == null) {
            throw new UsernameNotFoundException("用户名不存在");
        }
        // 添加权限
        List<SysUserRole> userRoles = userRoleService.listByUserId(user.getId());
        for (SysUserRole userRole : userRoles) {
            SysRole role = roleService.selectById(userRole.getRoleId());
            authorities.add(new SimpleGrantedAuthority(role.getName()));
        }
        // 返回UserDetails实现类
        return new User(user.getUsername(), user.getPassword(), authorities);
    }
}

 
 
 
 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

在WebSecurityConfig中注入我们的过滤器，也就是addFilter()方法：

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    private CustomUserDetailsService userDetailsService;
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService).passwordEncoder(new PasswordEncoder() {
            @Override
            public String encode(CharSequence charSequence) {
                return charSequence.toString();
            }
            @Override
            public boolean matches(CharSequence charSequence, String s) {
                return s.equals(charSequence.toString());
            }
        });
    }
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                .anyRequest().authenticated()
                .and()
                // 设置登陆页
                .formLogin().loginPage("/login")
                // 设置登陆失败页
                .failureUrl("/login/error")
                // 设置登陆成功页
                .defaultSuccessUrl("/").permitAll()
                .and()
                .addFilter(new JwtLoginFilter(authenticationManager()))
                .addFilter(new JwtAuthenticationFilter(authenticationManager()))
                .logout().permitAll();
        http.csrf().disable();
    }
    @Override
    public void configure(WebSecurity web) throws Exception {
        // 设置拦截忽略文件夹，可以对静态资源放行
        web.ignoring().antMatchers("/css/**", "/js/**");
    }
}

 
 
 
 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

7.2.8 运行程序

下面来验证下，运行程序。

在未登录情况下，是无法访问api资源的：

未登录

我们使用一个角色为ROLE_USER的用户登录，登录成功后会返回一个token，在响应头：

下面带着这个token再次访问api资源：
携带JWT

携带JWT

xk_一步一步来

关注

2
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
Springboot系列之九：Json Web Token介绍与基本使用

阅读：JWT全面解读、使用步骤https://blog.csdn.net/qq_32534441/article/details/89920384转自：https://blog.csdn.net/yuanlaijike/article/details/80174327一、Session与JWT1.1 传统Cookie+SessionCookie+Session的存在主要是为了解决HTTP...
复制链接

扫一扫

专栏目录