【SpringBoot】1、SpringBoot整合JWT实现Token验证_springboot token

1.单点登录

单点登录(Single Sign On), 简称为SSO, 是目前比较流行的企业业务整合的解决方案之一.

SSO的定义:在多个应用系统中, 用户只需要登录一次就可以访问所有相互信任的应用系统, 企业间需要相互授信

1.1 单系统登录

众所皆知, HTTP是无状态的协议, 这意味着服务器无法确认用户的信息。 于是乎，W3C就提出了：给每一个用户都发一个通行证，无论谁访问的时候都需要携带通行证，这样服务器就可以从通行证上确认用户的信息。通行证就是Cookie。

如果说Cookie是检查用户身上的”通行证“来确认用户的身份，那么Session就是通过检查服务器上的”客户明细表“来确认用户的身份的。Session相当于在服务器中建立了一份“客户明细表”。

1.1.1 单系统登录流程(使用Session实现单系统登录)

一、登录
用户登录成功后, 通过request获取Session(本质是根据Cookie中携带的JSESSIONID寻找Session)

• 如果没有携带JSESSIONID或者JSESSIONID找不到Session, 说明用户未登录, 此时将用户信息保存到Session对象中(默认会以Cookie方式向客户端返回JSESSIONID, 但此JSESSIONID是会话级别的)
• 如果Session能找到, 说明当前用户已经登录

二、记住我(关闭掉浏览器后，重新打开浏览器还能保持登录状态)
因为默认返回的JSESSIONID是会话级别的, 我们可以手动为Cookie中添加JSESSIONID信息，设置Cookie的过期时间, 此时不管你的浏览器是否关闭，Cookie中都会携带JSESSION信息

//登录成功后，手动添加cookie，保存JSESSIONID信息
Cookie cookie = new Cookie("JSESSIONID", session.getId());
//300年后过期(永久有效)
cookie.setMaxAge(60 * 60 * 24 * 30 * 12 * 300); //设置cookie 和 session生命周期同步.
response.addCookie(cookie);
1
2
3
4
5

三、注销（退出登录）：从Session中删除用户的信息

 session.removeAttribute("user");
1

1.2 多系统(单点)登录

多系统、单一位置登录, 实现多系统同时登录的一种技术

1.2.1 单点登录实现方案

• Session跨域
• Spring Session共享
• Toekn机制(主要方案)
  
  

1.2.1.1 Session跨域

所谓的Session跨域就是摒弃了系统提供的Session. 而使用自定义的类似Session的机制来保存客户端数据的一种方案

如：通过设置cookie的domain来实现cookie的跨域传递。在cookie中传递一个自定义的session_id。这个session_id是客户端的唯一标记。将这个标记作为key，将客户端需要保存的数据作为value，在服务端进行保存（数据库保存或NoSQL保存）。这种机制就是Session的跨域解决。

一、什么是跨域
客户端请求的时候, 请求的服务器, 不是同一个ip、端口、域名、主机名的时候, 都称为跨域

二、什么是域
在应用模型中, 一个完整的有独立访问路径的功能集合称为一个域

三、Session跨域可以解决的两个问题

• 同一个域名下, 不同的服务实例共享Session,
• 不同的域名共享Session, 如: 百度的若干域名, 搜索引擎(www.baidu.com), 百度贴吧(tie.baidu.com), 百度知道(zhidao.baidu.com), 百度地图(map.baidu.com)等

四、Session跨域的实现流程

1. 用户登录成功后, 判断是否携带CookieName, 此处的CookieName作用等同于系统提供的JSESSIONID,我们可以将CookieName自定义为任何值,它在所有的Cookie中起唯一标识的作用(标识这个key-value是用来实现SSO的), 然后用过CookieName获取value
2. 我们可以将这个value理解为sessionId, 之前系统默认根据这个sessionId寻找session, 如果session不存在, 则代表没有登录过, 如果存在则代表已经登录. 我们现在拿这个value去持久化库(mysql或nosql)中匹配
   • 如果通过value找到数据, 则代表已登录, 刷新redis中这条数据的生命, 重新设置Cookie
   • 如果通过value找不到数据, 则代表首次登录
     • 1.首先将value和用户信息以hash的形式存储到redis中, 并设置生命(30分钟)
     • 2.重新设置Cookie(名称和value不变, 主要设置domain这个值, 将domain设置为.baidu.com, 这样就能保证这个cookie会发送到www.baidu.com、tie.baidu.com等等

代码实现:

• 登录部分

@Controller
@RequestMapping("sso")
public class UserController {

    @Autowired
    private RedisTemplate redisTemplate;

    private static final String COOKIE_NAME = "sso_session_id";

    @GetMapping("login")
    @ResponseBody
    public String login(@RequestParam("un") String userName, @RequestParam("pw") String password,
                        HttpServletRequest request, HttpServletResponse response) {
        String token = getToken(userName, password);

        if (StringUtils.isNotEmpty(token)) {
            // 登录成功, 将token存入Cookie
            setCookie(request, response, COOKIE_NAME, token);
            return "success";
        }
        // 没有token, 代表用户名或密码错误
        return "error";
    }

    // 获取token(类似于JSESSIONID)
    private String getToken(String userName, String password) {
        if (userName.equals("wxf") && password.equals("123456")) {
            // 登录成功

            // 步骤一:生成token(此处的token的作用类似于JSESSIONID)
            String token = UUID.randomUUID().toString();

            // 步骤二:将用户信息保存到redis中
            User user = new User(userName, password);
            redisTemplate.opsForValue().set(token, JSON.toJSONString(user), 1800);
            return token;
        }
        // 登录失败
        return null;

    }
	
	/**
	* 设置cookie
	*/
    private void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName, String cookieValue) {
        // 创建cookie
        Cookie cookie = new Cookie(cookieName, cookieValue);

        if (null != request) {
            // 分析解析域名
            String domainName = getDomainName(request);

            // 设置域名的cookie
            cookie.setDomain(domainName);

        }
        // 从根路径下的后面任意路径地址,cookie都有效
        cookie.setPath("/");
        // response响应写入到客户端即可
        response.addCookie(cookie);
    }
	
	/**
	* 根据url来设置domain
	*/
    private static final String getDomainName(HttpServletRequest request) {
        // 定义一个变量domainName
        String domainName = null;

        // 获取完整的请求URL地址。请求url，转换为字符串类型
        String serverName = request.getRequestURL().toString();
        // 判断如果请求url地址为空或者为null
        if (serverName == null || serverName.equals("")) {
            domainName = "";
        } else {
            // 不为空或者不为null，将域名转换为小写。域名不敏感的。大小写一样
            serverName = serverName.toLowerCase();
            // 判断开始如果以http://开头的
            if (serverName.startsWith("http://")) {
                // 截取前七位字符
                serverName = serverName.substring(7);
            } else if (serverName.startsWith("https://")) {
                // 否则如果开始以https://开始的。//截取前八位字符
                serverName = serverName.substring(8);
            }
            // 找到/开始的位置，可以判断end的值是否为-1，如果为-1的话说明没有这个值
            // 如果存在这个值，找到这个值的位置，否则返回值为-1
            final int end = serverName.indexOf("/");
            // .test.com www.test.com.cn/sso.test.com.cn/.test.com.cn spring.io/xxxx/xxx
            // 然后截取到0开始到/的位置
            if (end != -1) {
                // end等于-1。说明没有/。否则end不等于-1说明有这个值
                serverName = serverName.substring(0, end);
                // 这是将\\.是转义为.。然后进行分割操作。
                final String[] domains = serverName.split("\\.");
                // 获取到长度
                int len = domains.length;
                // 注意，如果是两截域名，一般没有二级域名。比如spring.io/xxx/xxx，都是在spring.io后面/拼接的
                // 如果是三截域名，都是以第一截为核心分割的。
                // 如果是两截的就保留。三截以及多截的就
                // 多截进行匹配域名规则，第一个相当于写*，然后加.拼接后面的域名地址
                if (len > 3) {
                    // 如果是大于等于3截的，去掉第一个点之前的。留下剩下的域名
                    domainName = "." + domains[len - 3] + "." + domains[len - 2] + "." + domains[len - 1];
                } else if (len <= 3 && len > 1) {
                    // 如果是2截和3截保留
                    domainName = "." + domains[len - 2] + "." + domains[len - 1];
                } else {
                    domainName = serverName;
                }
            }
        }
        // 如果域名不为空并且有这个:
        if (domainName != null && domainName.indexOf(":") > 0) {
            // 将:转义。去掉端口port号，cookie（cookie的domainName）和端口无关。只看域名的。
            String[] ary = domainName.split("\\:");
            domainName = ary[0];
        }
        // 返回域名
        System.out.println("==============================================" + domainName);
        return domainName;
    }

}
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

• 校验登录
  我们在拦截器中, 根据请求携带的Cookie校验用户是否登录

1.2.1.2 Spring Session共享

Spring-Session技术是Spring提供的用于处理集群会话共享的解决方案. Spring-Session技术是将用户Session数据保存到第三方存储容器中, 例如Mysql、redis等

Spring-Session技术是解决同域名下多服务器集群session共享问题的, 不能解决跨域名Session共享问题

利用spring session解决共享Session问题
SpringBoot+SpringSession

---

1.3 Token机制

1.3.1 传统身份认证

HTTP是一种没有状态的协议，也就是它并不知道是谁在访问应用，这里我们把用户看成是客户端，客户端使用用户名还有密码通过了身份验证，不过下回这个客户端再发送请求时，还得再校验一次。这明显是不合适的，如果客户每次访问应用都需要登录验证、登录验证…客户体验会非常差

解决方式：当客户请求登录的时候，如果没有问题，我们在服务端生成一条记录，这个记录里可以说明一下登录的用户是谁，然后把这条记录的ID编号发给客户端，客户端收到以后将ID编号存储在Cookie中，下次这个用户再向服务端发送请求的时候，可以携带这个Cookie，这样服务端就会验证这个Cookie里的信息，看看能不能在服务端这里找到对应的记录，如果可以，说明用户已经通过了身份验证，就把用户请求的数据返回给客户端。

上面说的就是HTTP Session，我们需要在服务端存储为登录的用户生成的Session，这些Session可能会存储在内存、磁盘、或者数据库里。我们可能需要在服务端定期的去清理过期的Session

这种认证出现的问题是：

• 内存开销问题：每次认证用户发起请求时，服务器需要去创建一个记录来存储信息。当越来越多的用户发请求时，内存的开销也会不断增加。
• 可扩展性：在服务器的内存中使用Session存储用户信息，伴随而来的是可扩展性问题。

1.3.2 基于Token的身份认证

使用基于Token的身份认证方式, 在服务端不需要存储用户的登录记录, 大概的流程是这样的:

1. 客户端使用用户名、密码请求登录
2. 服务端收到请求, 验证用户名、密码
3. 验证成功后, 服务端会签发一个Token, 再把这个Token发送给客户端
4. 客户端收到Token以后可以把它存储起来, 比如放在Cookie里或者Local Storage里
5. 客户端每次向服务端请求资源时携带服务端签发的Token
6. 服务器收到请求, 然后去验证客户端请求里面带着的Token, 如果验证成功, 就向客户端返回请求的数据

使用Token的优势:

• 无状态、可扩展
  在客户端存储的Tokens是无状态的, 并且能够被扩展. 基于这种无状态和不存储Session信息, 负载均衡器能够将用户信息从一个服务器传到其他服务器上
• 安全性
  请求中发送Token而不再是发送Cookie能够防止CSRF(跨站请求伪造). 即使在客户端使用Cokkie存储Token, Cookie也仅仅是一个存储机制而不是用于认证, 不将信息存储在Session中, 让我们少了对Session的操作

---

1.4 JWT机制

JWT(JSON Web Token)

JWT是一种紧凑、自包含的, 用于在多方传递JSON对象的技术. 传递的数据可以使用数字签名增加其安全性. 可以使用HMAC加密算法或RSA公钥/私钥加密方式

• 紧凑:数据小, 可以通过URL, POST参数, 请求头发送. 且数据小代表传输速度快
• 自包含:使用payload数据块记录用户必要且不隐私的数据, 可以有效的减少数据库访问次数, 提高代码能力

JWT是一般用于处理用户身份验证、数据信息交换

• 用户身份验证:一旦用户登录, 每个后续请求都将包含JWT, 允许用户访问该令牌允许的路由、服务和资源. 单点登录是当今广泛使用JWT的一项功能, 因为它的开销很小, 能够轻松的跨域使用
• 数据信息交换:JWT是一种非常方便的多方传递数据的载体, 因为其可以使用数据签名来保证数据的有效性和安全性

1.4.1 JWT数据结构

JWT的数据结构是:A.B.C
由字符点"."来分隔三部分数据

• A:header 头信息
• B:payload 有效荷载
• C:Signature 签名

1.4.1.1 header

数据结构:

{"alg":"加密算法名称", "typ": "JWT"}
1

• alg是加密算法定义内容, 例如HMAC、SHA256、RSA
• typ是token类型, 这里固定为JWT

1.4.1.2 payload

在payload数据块中一般用于记录实体(通常为用户信息)或其他数据的, 主要分为三个部分. 分别是

• 已注册信息(registered claims).
• 公开数据(public claims)
• 私有数据(private claims)

已注册信息(最重要的数据), 包括: iss(发行者), exp(到期时间), sub(主题), aud(受众)等…
公开数据部分一般都会在JWT注册表中增加定义, 避免和已注册信息冲突
公开数据和私有数据可以由程序员任意定义

1.4.1.3 signature

签名信息, 这是一个由开发者提供的信息, 是服务器验证的传递的数据是否有效安全的标准, 在生成JWT最终数据之前, 先使用header中定义的加密算法, 将header和payload进行加密, 并使用点进行连接, 如:加密后的head.加密后的payload, 再使用相同的加密算法, 对加密后的数据和签名信息进行加密, 得到最终结果

1.4.2 JWT执行流程

1.客户端(browser)发起post请求, 请求的路径为/users/login,需要提供用户名和密码
2.服务端(server)对用户名和密码校验, 校验通过后, 会生成一个JWT的加密字符串(secret), 这个字符串就是token
3.把JWT返回给客户端浏览器(browser), 浏览器将JWT存储起来
4.后期, 客户端(browser)再发起请求, 需要在请求头里加上JWT(建议是将JWT放header中)
5.服务端(server)校验JWT, 判断是否登录

1.4.3 JWT代码案例