手把手教你,使用JWT实现单点登录

开发 前端
JSON Web Token(JWT)是目前最流行的跨域身份验证解决方案之一,今天我们一起来揭开它神秘的面纱!

[[326154]]

JSON Web Token(JWT)是目前最流行的跨域身份验证解决方案之一,今天我们一起来揭开它神秘的面纱!

一、故事起源

说起 JWT,我们先来谈一谈基于传统session认证的方案以及瓶颈。

传统session交互流程,如下图:

当浏览器向服务器发送登录请求时,验证通过之后,会将用户信息存入seesion中,然后服务器会生成一个sessionId放入cookie中,随后返回给浏览器。

当浏览器再次发送请求时,会在请求头部的cookie中放入sessionId,将请求数据一并发送给服务器。

服务器就可以再次从seesion获取用户信息,整个流程完毕!

通常在服务端会设置seesion的时长,例如 30 分钟没有活动,会将已经存放的用户信息从seesion中移除。

  1. session.setMaxInactiveInterval(30 * 60);//30分钟没活动,自动移除 

同时,在服务端也可以通过seesion来判断当前用户是否已经登录,如果为空表示没有登录,直接跳转到登录页面;如果不为空,可以从session中获取用户信息即可进行后续操作。

在单体应用中,这样的交互方式,是没啥问题的。

但是,假如应用服务器的请求量变得很大,而单台服务器能支撑的请求量是有限的,这个时候就容易出现请求变慢或者OOM。

解决的办法,要么给单台服务器增加配置,要么增加新的服务器,通过负载均衡来满足业务的需求。

如果是给单台服务器增加配置,请求量继续变大,依然无法支撑业务处理。

显而易见,增加新的服务器,可以实现无限的水平扩展。

但是增加新的服务器之后,不同的服务器之间的sessionId是不一样的,可能在A服务器上已经登录成功了,能从服务器的session中获取用户信息,但是在B服务器上却查不到session信息,此时肯定无比的尴尬,只好退出来继续登录,结果A服务器中的session因为超时失效,登录之后又被强制退出来要求重新登录,想想都挺尴尬~~

面对这种情况,几位大佬于是合起来商议,想出了一个token方案。

将各个应用程序与内存数据库redis相连,对登录成功的用户信息进行一定的算法加密,生成的ID被称为token,将token还有用户的信息存入redis;等用户再次发起请求的时候,将token还有请求数据一并发送给服务器,服务端验证token是否存在redis中,如果存在,表示验证通过,如果不存在,告诉浏览器跳转到登录页面,流程结束。

token方案保证了服务的无状态,所有的信息都是存在分布式缓存中。基于分布式存储,这样可以水平扩展来支持高并发。

当然,现在springboot还提供了session共享方案,类似token方案将session存入到redis中,在集群环境下实现一次登录之后,每个服务器都可以获取到用户信息。

二、JWT是什么

上文中,我们谈到的session还有token的方案,在集群环境下,他们都是靠第三方缓存数据库redis来实现数据的共享。

那有没有一种方案,不用缓存数据库redis来实现用户信息的共享,以达到一次登录,处处可见的效果呢?

答案肯定是有的,就是我们今天要介绍的JWT!

JWT全称JSON Web Token,实现过程简单的说就是用户登录成功之后,将用户的信息进行加密,然后生成一个token返回给客户端,与传统的session交互没太大区别。

交互流程如下:

唯一的不同点就是:token存放了用户的基本信息,更直观一点就是将原本放入redis中的用户数据,放入到token中去了!

这样一来,客户端、服务端都可以从token中获取用户的基本信息,既然客户端可以获取,肯定是不能存放敏感信息的,因为浏览器可以直接从token获取用户信息。

JWT具体长什么样呢?

JWT是由三段信息构成的,将这三段信息文本用.链接一起就构成了JWT字符串。就像这样:

  1. eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9.TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ 
  • 第一部分:我们称它为头部(header),用于存放token类型和加密协议,一般都是固定的;
  • 第二部分:我们称其为载荷(payload),用户数据就存放在里面;
  • 第三部分:是签证(signature),主要用于服务端的验证;

1、header

JWT的头部承载两部分信息:

  • 声明类型,这里是JWT;
  • 声明加密的算法,通常直接使用 HMAC SHA256;

完整的头部就像下面这样的JSON:

  1.   'typ''JWT'
  2.   'alg''HS256' 

使用base64加密,构成了第一部分。

  1. eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9 

2、playload

载荷就是存放有效信息的地方,这些有效信息包含三个部分:

  • 标准中注册的声明;
  • 公共的声明;
  • 私有的声明;

其中,标准中注册的声明 (建议但不强制使用)包括如下几个部分 :

  • iss: jwt签发者;
  • sub: jwt所面向的用户;
  • aud: 接收jwt的一方;
  • exp: jwt的过期时间,这个过期时间必须要大于签发时间;
  • nbf: 定义在什么时间之前,该jwt都是不可用的;
  • iat: jwt的签发时间;
  • jwt的唯一身份标识,主要用来作为一次性token,从而回避重放攻击;

公共的声明部分:公共的声明可以添加任何的信息,一般添加用户的相关信息或其他业务需要的必要信息,但不建议添加敏感信息,因为该部分在客户端可解密。

私有的声明部分:私有声明是提供者和消费者所共同定义的声明,一般不建议存放敏感信息,因为base64是对称解密的,意味着该部分信息可以归类为明文信息。

定义一个payload:

  1.   "sub""1234567890"
  2.   "name""John Doe"
  3.   "admin"true 

然后将其进行base64加密,得到Jwt的第二部分:

  1. eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9 

3、signature

jwt的第三部分是一个签证信息,这个签证信息由三部分组成:

  • header (base64后的);
  • payload (base64后的);
  • secret (密钥);

这个部分需要base64加密后的header和base64加密后的payload使用.连接组成的字符串,然后通过header中声明的加密方式进行加盐secret组合加密,然后就构成了jwt的第三部分。

  1. //javascript 
  2. var encodedString = base64UrlEncode(header) + '.' + base64UrlEncode(payload); 
  3.  
  4. var signature = HMACSHA256(encodedString, '密钥'); 

加密之后,得到signature签名信息。

  1. TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ 

将这三部分用.连接成一个完整的字符串,就构成了最终的jwt:

  1. //jwt最终格式 
  2. eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9.TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ 

这个只是通过javascript实现的一个演示,JWT的签发和密钥的保存都是在服务端来完成。

secret用来进行jwt的签发和jwt的验证,所以,在任何场景都不应该流露出去。

三、实战

介绍了这么多,怎么实现呢?废话不多说,下面我们直接开撸!

  • 创建一个springboot项目,添加JWT依赖库
  1. <!-- jwt支持 --> 
  2. <dependency> 
  3.     <groupId>com.auth0</groupId> 
  4.     <artifactId>java-jwt</artifactId> 
  5.     <version>3.4.0</version> 
  6. </dependency> 

 

  • 然后,创建一个用户信息类,将会通过加密存放在token中
  1. @Data 
  2. @EqualsAndHashCode(callSuper = false
  3. @Accessors(chain = true
  4. public class UserToken implements Serializable { 
  5.  
  6.     private static final long serialVersionUID = 1L; 
  7.  
  8.     /** 
  9.      * 用户ID 
  10.      */ 
  11.     private String userId; 
  12.  
  13.     /** 
  14.      * 用户登录账户 
  15.      */ 
  16.     private String userNo; 
  17.  
  18.     /** 
  19.      * 用户中文名 
  20.      */ 
  21.     private String userName; 
  • 接着,创建一个JwtTokenUtil工具类,用于创建token、验证token
  1. public class JwtTokenUtil { 
  2.  
  3.     //定义token返回头部 
  4.     public static final String AUTH_HEADER_KEY = "Authorization"
  5.  
  6.     //token前缀 
  7.     public static final String TOKEN_PREFIX = "Bearer "
  8.  
  9.     //签名密钥 
  10.     public static final String KEY = "q3t6w9z$C&F)J@NcQfTjWnZr4u7x"
  11.      
  12.     //有效期默认为 2hour 
  13.     public static final Long EXPIRATION_TIME = 1000L*60*60*2; 
  14.  
  15.  
  16.     /** 
  17.      * 创建TOKEN 
  18.      * @param content 
  19.      * @return 
  20.      */ 
  21.     public static String createToken(String content){ 
  22.         return TOKEN_PREFIX + JWT.create() 
  23.                 .withSubject(content) 
  24.                 .withExpiresAt(new Date(System.currentTimeMillis() + EXPIRATION_TIME)) 
  25.                 .sign(Algorithm.HMAC512(KEY)); 
  26.     } 
  27.  
  28.     /** 
  29.      * 验证token 
  30.      * @param token 
  31.      */ 
  32.     public static String verifyToken(String token) throws Exception { 
  33.         try { 
  34.             return JWT.require(Algorithm.HMAC512(KEY)) 
  35.                     .build() 
  36.                     .verify(token.replace(TOKEN_PREFIX, "")) 
  37.                     .getSubject(); 
  38.         } catch (TokenExpiredException e){ 
  39.             throw new Exception("token已失效,请重新登录",e); 
  40.         } catch (JWTVerificationException e) { 
  41.             throw new Exception("token验证失败!",e); 
  42.         } 
  43.     } 
  • 编写配置类,允许跨域,并且创建一个权限拦截器
  1. @Slf4j 
  2. @Configuration 
  3. public class GlobalWebMvcConfig implements WebMvcConfigurer { 
  4.        /** 
  5.      * 重写父类提供的跨域请求处理的接口 
  6.      * @param registry 
  7.      */ 
  8.     @Override 
  9.     public void addCorsMappings(CorsRegistry registry) { 
  10.         // 添加映射路径 
  11.         registry.addMapping("/**"
  12.                 // 放行哪些原始域 
  13.                 .allowedOrigins("*"
  14.                 // 是否发送Cookie信息 
  15.                 .allowCredentials(true
  16.                 // 放行哪些原始域(请求方式) 
  17.                 .allowedMethods("GET""POST""DELETE""PUT""OPTIONS""HEAD"
  18.                 // 放行哪些原始域(头部信息) 
  19.                 .allowedHeaders("*"
  20.                 // 暴露哪些头部信息(因为跨域访问默认不能获取全部头部信息) 
  21.                 .exposedHeaders("Server","Content-Length""Authorization""Access-Token""Access-Control-Allow-Origin","Access-Control-Allow-Credentials"); 
  22.     } 
  23.  
  24.     /** 
  25.      * 添加拦截器 
  26.      * @param registry 
  27.      */ 
  28.     @Override 
  29.     public void addInterceptors(InterceptorRegistry registry) { 
  30.         //添加权限拦截器 
  31.         registry.addInterceptor(new AuthenticationInterceptor()).addPathPatterns("/**").excludePathPatterns("/static/**"); 
  32.     } 
  • 使用AuthenticationInterceptor拦截器对接口参数进行验证
  1. @Slf4j 
  2. public class AuthenticationInterceptor implements HandlerInterceptor { 
  3.  
  4.     @Override 
  5.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { 
  6.         // 从http请求头中取出token 
  7.         final String token = request.getHeader(JwtTokenUtil.AUTH_HEADER_KEY); 
  8.         //如果不是映射到方法,直接通过 
  9.         if(!(handler instanceof HandlerMethod)){ 
  10.             return true
  11.         } 
  12.         //如果是方法探测,直接通过 
  13.         if (HttpMethod.OPTIONS.equals(request.getMethod())) { 
  14.             response.setStatus(HttpServletResponse.SC_OK); 
  15.             return true
  16.         } 
  17.         //如果方法有JwtIgnore注解,直接通过 
  18.         HandlerMethod handlerMethod = (HandlerMethod) handler; 
  19.         Method method=handlerMethod.getMethod(); 
  20.         if (method.isAnnotationPresent(JwtIgnore.class)) { 
  21.             JwtIgnore jwtIgnore = method.getAnnotation(JwtIgnore.class); 
  22.             if(jwtIgnore.value()){ 
  23.                 return true
  24.             } 
  25.         } 
  26.         LocalAssert.isStringEmpty(token, "token为空,鉴权失败!"); 
  27.         //验证,并获取token内部信息 
  28.         String userToken = JwtTokenUtil.verifyToken(token); 
  29.          
  30.         //将token放入本地缓存 
  31.         WebContextUtil.setUserToken(userToken); 
  32.         return true
  33.     } 
  34.  
  35.     @Override 
  36.     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception { 
  37.         //方法结束后,移除缓存的token 
  38.         WebContextUtil.removeUserToken(); 
  39.     } 
  • 最后,在controller层用户登录之后,创建一个token,存放在头部即可
  1. /** 
  2.  * 登录 
  3.  * @param userDto 
  4.  * @return 
  5.  */ 
  6. @JwtIgnore 
  7. @RequestMapping(value = "/login", method = RequestMethod.POST, produces = {"application/json;charset=UTF-8"}) 
  8. public UserVo login(@RequestBody UserDto userDto, HttpServletResponse response){ 
  9.     //...参数合法性验证 
  10.  
  11.     //从数据库获取用户信息 
  12.     User dbUser = userService.selectByUserNo(userDto.getUserNo); 
  13.  
  14.     //....用户、密码验证 
  15.  
  16.     //创建token,并将token放在响应头 
  17.     UserToken userToken = new UserToken(); 
  18.     BeanUtils.copyProperties(dbUser,userToken); 
  19.  
  20.     String token = JwtTokenUtil.createToken(JSONObject.toJSONString(userToken)); 
  21.     response.setHeader(JwtTokenUtil.AUTH_HEADER_KEY, token); 
  22.  
  23.  
  24.     //定义返回结果 
  25.     UserVo result = new UserVo(); 
  26.     BeanUtils.copyProperties(dbUser,result); 
  27.     return result; 

到这里基本就完成了!

其中AuthenticationInterceptor中用到的JwtIgnore是一个注解,用于不需要验证token的方法上,例如验证码的获取等等。

  1. @Target({ElementType.METHOD, ElementType.TYPE}) 
  2. @Retention(RetentionPolicy.RUNTIME) 
  3. public @interface JwtIgnore { 
  4.  
  5.     boolean value() default true

而WebContextUtil是一个线程缓存工具类,其他接口通过这个方法即可从token中获取用户信息。

  1. public class WebContextUtil { 
  2.  
  3.     //本地线程缓存token 
  4.     private static ThreadLocal<String> local = new ThreadLocal<>(); 
  5.  
  6.     /** 
  7.      * 设置token信息 
  8.      * @param content 
  9.      */ 
  10.     public static void setUserToken(String content){ 
  11.         removeUserToken(); 
  12.         local.set(content); 
  13.     } 
  14.  
  15.     /** 
  16.      * 获取token信息 
  17.      * @return 
  18.      */ 
  19.     public static UserToken getUserToken(){ 
  20.         if(local.get() != null){ 
  21.             UserToken userToken = JSONObject.parseObject(local.get() , UserToken.class); 
  22.             return userToken; 
  23.         } 
  24.         return null
  25.     } 
  26.  
  27.     /** 
  28.      * 移除token信息 
  29.      * @return 
  30.      */ 
  31.     public static void removeUserToken(){ 
  32.         if(local.get() != null){ 
  33.             local.remove(); 
  34.         } 
  35.     } 

最后,启动项目,我们来用postman测试一下,看看头部返回结果。

我们把返回的信息提取处理,使用浏览器的base64对前两个部分进行解密。

  • 第一部分,也就是header,结果如下:
  • 第二部分,也就是playload,结果如下:

可以很清晰的看到,头部、载荷的信息都可以通过base64解密出来。

所以,一定别在token中存放敏感信息!

当我们需要请求其它服务接口时,只需要在请求头部headers中加入Authorization参数即可。

当权限拦截器验证通过之后,在接口方法中只需要通过WebContextUtil工具类就可以获取用户信息。

  1. //获取用户token信息 
  2. UserToken userToken = WebContextUtil.getUserToken(); 

四、总结

JWT相比session方案,因为json的通用性,所以JWT是可以进行跨语言支持的,像JAVA、JavaScript、PHP等很多语言都可以使用,而session方案只针对JAVA。

因为有了payload部分,所以JWT可以存储一些其他业务逻辑所必要的非敏感信息。

同时,保护好服务端secret私钥非常重要,因为私钥可以对数据进行验证、解密!

如果可以,请使用https协议!

五、参考

1、简书 - 什么是 JWT -- JSON WEB TOKEN

 

2、博客园 - 基于session和token的身份认证方案

 

责任编辑:武晓燕 来源: Java极客技术
相关推荐

2021-06-29 12:27:19

Spring BootCAS 登录

2021-03-12 10:01:24

JavaScript 前端表单验证

2021-07-14 09:00:00

JavaFX开发应用

2011-01-06 10:39:25

.NET程序打包

2009-11-09 14:57:37

WCF上传文件

2011-05-03 15:59:00

黑盒打印机

2011-01-10 14:41:26

2023-04-26 12:46:43

DockerSpringKubernetes

2022-12-07 08:42:35

2021-12-15 08:49:21

gpio 子系统pinctrl 子系统API

2022-07-22 12:45:39

GNU

2022-10-30 10:31:42

i2ccpuftrace

2011-02-22 13:46:27

微软SQL.NET

2021-02-26 11:54:38

MyBatis 插件接口

2021-12-28 08:38:26

Linux 中断唤醒系统Linux 系统

2021-08-02 07:35:19

Nacos配置中心namespace

2011-10-06 14:32:43

2021-04-02 10:01:00

JavaScript前端Web项目

2020-12-08 10:32:15

Python邮件tcp

2022-04-12 08:46:12

i2c-tools开源工具
点赞
收藏

51CTO技术栈公众号