SpringBoot集成JWT实现Token登录验证
Posted 深情不及里子
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了SpringBoot集成JWT实现Token登录验证相关的知识,希望对你有一定的参考价值。
目录
1.1 JWT是什么?
在JWT官网中可以明确看到关于它的定义
JSON Web令牌(JWT)是一种开放的标准(RFC 7519),它定义了一种紧凑而独立的方式在各方之间安全地传输信息为JSON对象。该信息可以被验证和信任,因为它是数字签名的。JWT可以使用秘密(使用HMAC算法)或使用RSA或ECDSA的公开/私有密钥类型签名。 虽然JWT可以被加密以提供各方之间的保密,但我们将重点关注签名的令牌。被签名的令牌可以验证包含在其中的声明的完整性,而加密的令牌对其他各方隐藏这些声明。当使用公钥/私钥对签名时,签名还证明只有持有私钥的一方才是签名方。
1.2 JWT主要使用场景
-
授权(Authorization):这是使用JWT最常见的场景。一旦用户登录,每个后续请求都将包括JWT,允许用户访问该令牌允许的路由、服务和资源。
-
单点登录(Single Sign On ):单点登录是当今广泛使用的JWT特性,因为它的小规模和易于跨不同领域使用的能力。
-
信息交换(lnformation Exchange):信息交换在通信的双方之间使用JWT对数据进行编码是一种非常安全的方式,由于它的信息是经过签名的,可以确保发送者发送的信息是没有经过伪造的。
-
传输信息(transmitting information):在各方之间传输信息。由于JWT可以签名--例如,使用公共/私钥对--您可以确保发件人是他们所说的发送者。此外,由于签名是使用头和有效载荷计算的,您还可以验证内容没有被篡改。
1.3 JWT请求流程
- 用户使用账号和密码发出post请求;
- 服务器使用私钥创建一个jwt;
- 服务器返回这个jwt给浏览器;
- 浏览器将该jwt串在请求头中像服务器发送请求;
- 服务器验证该jwt;
- 返回响应的资源给浏览器。
1.4 JWT结构
JWT是由三段信息构成的,将这三段信息文本用.连接一起就构成了JWT字符串。
就像这样:
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c
JWT包含了三部分:
-
Header 头部(标题包含了令牌的元数据,并且包含签名和/或加密算法的类型)
-
Payload 负载 (类似于飞机上承载的物品)
-
Signature 签名/签证
Header
JWT的头部承载两部分信息:token类型和采用的加密算法。
"alg": "HS256",
"typ": "JWT"
声明类型:这里是jwt
声明加密的算法:通常直接使用 HMAC SHA256
加密算法是单向函数散列算法,常见的有MD5、SHA、HAMC。
MD5(message-digest algorithm 5) (信息-摘要算法)缩写,广泛用于加密和解密技术,常用于文件校验。校验?不管文件多大,经过MD5后都能生成唯一的MD5值
SHA (Secure Hash Algorithm,安全散列算法),数字签名等密码学应用中重要的工具,安全性高于MD5
HMAC (Hash Message Authentication Code),散列消息鉴别码,基于密钥的Hash算法的认证协议。用公开函数和密钥产生一个固定长度的值作为认证标识,用这个标识鉴别消息的完整性。常用于接口签名验证
Payload
载荷就是存放有效信息的地方。
有效信息包含三个部分:
-
标准中注册的声明
-
公共的声明
-
私有的声明
标准中注册的声明 (建议但不强制使用) :
-
iss: jwt签发者
-
sub: 面向的用户(jwt所面向的用户)
-
aud: 接收jwt的一方
-
exp: 过期时间戳(jwt的过期时间,这个过期时间必须要大于签发时间)
-
nbf: 定义在什么时间之前,该jwt都是不可用的.
-
iat: jwt的签发时间
-
jti: jwt的唯一身份标识,主要用来作为一次性token,从而回避重放攻击。
公共的声明:
公共的声明可以添加任何的信息,一般添加用户的相关信息或其他业务需要的必要信息.但不建议添加敏感信息,因为该部分在客户端可解密.
私有的声明:
私有声明是提供者和消费者所共同定义的声明,一般不建议存放敏感信息,因为base64是对称解密的,意味着该部分信息可以归类为明文信息。
Signature
jwt的第三部分是一个签证信息
这个部分需要base64加密后的header和base64加密后的payload使用.连接组成的字符串,然后通过header中声明的加密方式进行加盐secret组合加密,然后就构成了jwt的第三部分。最主要的目的:服务器应用在接受到JWT后,会首先对头部和载荷的内容用同一算法再次签名,如果服务器应用对头部和载荷再次以同样方法签名之后发现,自己计算出来的签名和接受到的签名不一样,那么就说明这个Token的内容被别人动过的,我们应该拒绝这个Token,返回一个HTTP 401 Unauthorized响应。
密钥secret是保存在服务端的,服务端会根据这个密钥进行生成token和进行验证,所以需要保护好。
这些信息在官网上也有相关信息的说明:
二,SpringBoot集成JWT具体实现过程
这里由于只涉及对验证功能的实现,因此其他数据库,业务类编写一概省略,只对相关步骤做说明。
2.1添加相关依赖
既然要使用JWT我们肯定需要引入其依赖
<dependency>
<groupId>com.auth0</groupId>
<artifactId>java-jwt</artifactId>
<version>3.10.3</version>
</dependency>
2.2自定义跳出拦截器的注解
方便我们后续不用对在配置拦截器时排除每一个接口,只用自定义注解去标记即可。
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* @author young
* @date 2022/11/24 14:53
* @description: 自定义通过token注解,如果不加该注解直接拦截
*/
@Target(ElementType.METHOD,ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface PassToken
boolean required() default true;
@Retention注解说明
-
RetentionPolicy.SOURCE:这种类型的Annotations只在源代码级别保留,编译时就会被忽略,在class字节码文件中不包含。
-
RetentionPolicy.CLASS:这种类型的Annotations编译时被保留,默认的保留策略,在class文件中存在,但JVM将会忽略,运行时无法获得。
-
RetentionPolicy.RUNTIME:这种类型的Annotations将被JVM保留,所以他们能在运行时被JVM或其他使用反射机制的代码所读取和使用。
-
@Document:说明该注解将被包含在javadoc中
-
@Inherited:说明子类可以继承父类中的该注解
2.3自定义全局统一返回值方法,异常类及相关枚举
定义全局枚举类
package com.yy.enums;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.Getter;
import java.util.UUID;
/**
* @author young
* @date 2022/8/19 21:36
* @description: 响应结果枚举
*/
@AllArgsConstructor
@Getter
public enum ResponseEnum
/**响应成功**/
SUCCESS(200, "操作成功"),
/**操作失败*/
FAIL(201,"获取数据失败"),
NO_TOKEN(400,"无token,请重新登录"),
TOKEN_EX(401,"token验证失败,请重新登录"),
USER_EX(402,"用户不存在,请重新登录"),
/**错误请求**/
ERROR(400,"错误请求");
/**响应码**/
private final Integer code;
/** 结果 **/
private final String resultMessage;
public static ResponseEnum getResultCode(Integer code)
for (ResponseEnum value : ResponseEnum.values())
if (code.equals(value.getCode()))
return value;
return ResponseEnum.ERROR;
/*
简单测试一下
*/
public static void main(String[] args)
ResponseEnum resultCode = ResponseEnum.getResultCode(100);
System.out.println(resultCode);
定义全局异常类
package com.yy.util;
import com.yy.Enums.ResultEnum;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
/**
* @author young
* @date 2022/9/25 19:15
* @description: 自定义运行时异常
*/
@Data
@ApiModel(value = "自定义全局异常类")
public class MyException extends RuntimeException
@ApiModelProperty(value = "异常状态码")
private final Integer code;
/**
* 通过状态码和异常信息创建异常对象
* @param code
* @param message
*/
public MyException(Integer code,String message)
super(message);
this.code = code;
/**
* 接受枚举类型对象
* @param resultEnum
*/
public MyException(ResponseEnum responseEnum)
super(responseEnum.getMessage());
this.code = responseEnum.getCode();
package com.yy.Config;
import com.yy.utils.MyException;
import com.yy.utils.R;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
/**
* @author young
* @date 2022/9/12 15:43
* @description: 自定义异常配置
*/
@RestControllerAdvice
public class GlobalExceptionConfig
@ExceptionHandler(MyException.class)
public R<MyException> handle(MyException e)
e.printStackTrace();
return R.exception(e.getCode(),e.getMessage());
定义统一返回结果类
package com.yy.utils;
import com.yy.enums.ResponseEnum;
import lombok.Data;
import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;
/**
* @author young
* @date 2022/8/19 21:52
* @description: 统一返回结果的类
*/
@Data
public class R<T> implements Serializable
private static final long serialVersionUID = 56665257248936049L;
/**响应码**/
private Integer code;
/**返回消息**/
private String message;
/**返回数据**/
private T data;
private R()
/**
* 操作成功ok方法
*/
public static <T> R<T> ok(T data)
R<T> response = new R<>();
response.setCode(ResponseEnum.SUCCESS.getCode()); response.setMessage(ResponseEnum.SUCCESS.getResultMessage());
response.setData(data);
return response;
/**
* 编译失败方法
*/
public static <T> R<T> buildFailure(Integer errCode, String errMessage)
R<T> response = new R<>();
response.setCode(errCode);
response.setMessage(errMessage);
return response;
public static <T> R<T> exception(Integer errCode, String errMessage)
R<T> response = new R<>();
response.setCode(errCode);
response.setMessage(errMessage);
return response;
2.4编写JWT工具类,用于生成Token令牌
package com.yy.utils;
import cn.hutool.core.date.DateUtil;
import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import java.util.Date;
/**
* @author young
* @date 2022/9/12 14:46
* @description: 整合JWT生成token
*/
public class JwtTokenUtils
private JwtTokenUtils()
throw new IllegalStateException("Utility class");
/**
* 生成token
* @param userId
* @param sign
* @return
*/
public static String getToken(String userId,String sign)
return JWT.create()
//签收者
.withAudience(userId)
//主题
.withSubject("token")
//2小时候token过期
.withExpiresAt(DateUtil.offsetHour(new Date(),2))
//以password作为token的密钥
.sign(Algorithm.HMAC256(sign));
Algorithm.HMAC256():使用HS256生成token,密钥则是用户的密码,唯一密钥的话可以保存在服务端。
withAudience():存入需要保存在token的信息,这里我们把用户ID存入token中
2.5编写拦截器并注入容器
package com.yy.Config.inteceptor;
import cn.hutool.core.text.CharSequenceUtil;
import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.exceptions.JWTDecodeException;
import com.auth0.jwt.exceptions.JWTVerificationException;
import com.yy.enums.ResponseEnum;
import com.yy.admin.pojo.Admin;
import com.yy.admin.service.Impl.AdminServiceImpl;
import com.yy.utils.MyException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.lang.reflect.Method;
/**
* @author young
* @date 2022/9/12 15:37
* @description: 获取token并验证
*/
@Component
public class MyJwtInterceptor implements HandlerInterceptor
@Autowired
private AdminServiceImpl adminService;
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception
String token = request.getHeader("token");
if (!(handler instanceof HandlerMethod))
return true;
HandlerMethod handlerMethod = (HandlerMethod) handler;
Method method = handlerMethod.getMethod();
//检查是否通过有PassToken注解
if (method.isAnnotationPresent(PassToken.class))
//如果有则跳过认证检查
PassToken passToken = method.getAnnotation(PassToken.class);
if (passToken.required())
return true;
//否则进行token检查
if (CharSequenceUtil.isBlank(token))
throw new MyException(ResponseEnum.TOKEN_EX.getCode(), ResponseEnum.TOKEN_EX.getResultMessage());
//获取token中的用户id
String userId;
try
userId = JWT.decode(token).getAudience().get(0);
catch (JWTDecodeException j)
throw new MyException(ResponseEnum.TOKEN_EX.getCode(), ResponseEnum.TOKEN_EX.getResultMessage());
//根据token中的userId查询数据库
Admin user = adminService.getById(userId);
if (user == null)
throw new MyException(ResponseEnum.USER_EX.getCode(), ResponseEnum.USER_EX.getResultMessage());
//验证token
JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256(user.getPwd())).build();
try
jwtVerifier.verify(token);
catch (JWTVerificationException e)
throw new MyException(406, "权限验证失败!");
return true;
这里需要说明一下实现拦截器的方法,我们只需要实现HandlerInterceptor接口即可,它主要定义了三个方法:
boolean preHandle ():
预处理回调方法,实现处理器的预处理,第三个参数为响应的处理器,自定义Controller,返回值为true表示继续流程(如调用下一个拦截器或处理器)或者接着执行postHandle()和afterCompletion();false表示流程中断,不会继续调用其他的拦截器或处理器,中断执行。
void postHandle():
后处理回调方法,实现处理器的后处理(DispatcherServlet进行视图返回渲染之前进行调用),此时我们可以通过modelAndView(模型和视图对象)对模型数据进行处理或对视图进行处理,modelAndView也可能为null。
void afterCompletion():
整个请求处理完毕回调方法,该方法也是需要当前对应的Interceptor的preHandle()的返回值为true时才会执行,也就是在DispatcherServlet渲染了对应的视图之后执行。用于进行资源清理。
整个请求处理完毕回调方法。如性能监控中我们可以在此记录结束时间并输出消耗时间,还可以进行一些资源清理,类似于try-catch-finally中的finally,但仅调用处理器执行链中。
这里我们主要需要调用预处理回调方法即可,如果有其他业务需求,也可自行更改。
主要流程:
-
从 http 请求头中取出 token,
-
判断是否映射到方法
-
检查是否有passtoken注释,有则跳过认证
-
检查有没有需要用户登录的注解,有则需要取出并验证
-
认证通过则可以访问,不通过会报相关错误信息
然后通过配置类将我们自定义的拦截类注入到spring容器中,并进行拦截配置。
package com.yy.Config.inteceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
/**
* @author young
* @date 2022/9/12 15:36
* @description: JWT拦截配置
*/
@Configuration
public class InterceptorConfig implements WebMvcConfigurer
@Override
public void addInterceptors(InterceptorRegistry registry)
registry.addInterceptor(jwtInterceptor())
//拦截所有请求,通过判断token来决定是否需要登陆
.addPathPatterns("/**");
@Bean
public MyJwtInterceptor jwtInterceptor()
return new MyJwtInterceptor();
至此,我们对于JWT在SpringBoot中的基本配置就算完成了。我们只需在controller层在自己想要放行的api接口上添加我们自定义的放行注解,即可实现对api接口的放行,其他接口均要进行Token令牌的验证判断。如果没有Token则返回自定义的异常信息。
三,测试
3.1放行一般类接口
这里我们先只对一个业务接口进行放行。
/**
* 查找指定id信息
*
* @param id
* @return
*/
@GetMapping("/getOne/id")
@CostTime
@PassToken
public R<TestUser> selectOne(@PathVariable Integer id)
TestUser user = testUserService.getById(id);
return R.ok(user);
进行接口测试后发现,该接口获取数据正常。
其他没有加@PassToken的接口由于没有token进行验证,均会被拦截器拦截,并返回我们预期的异常信息"token验证失败,请重新登录"
因此,同理我们只需要在登陆注册或其他不需要token验证的接口上添加自定义注解即可实现拦截。
为了达到业务需求,我们需要在用户登录成功后获取到token,然后将token信息存放在每次的接口请求头(headers)上,这样就能实现对用户接口信息基本保护了。
3.2放行登录接口
编写用户登录的业务接口并放行Token
@PostMapping("/login")
@PassToken
public Object loginStatus(@RequestParam("username") String username, @RequestParam("password") String password)
JSONObject object = new JSONObject();
Admin admin = adminService.getMsg(username, password);
if (admin!=null)
object.put("code",1);
object.put("msg","登陆成功");
object.put("success",true);
object.put("type","success");
object.put("userMsg",admin);
else
object.put("code",0);
object.put("success",false);
object.put("msg","用户名或密码错误");
object.put("type","error");
return object;
进行接口测试
这样就可以看到生成的Token信息了,然后我们将token信息设置在请求头上对其他接口进行测试。
此时就能看到,接口请求成功。
注意:这里的参数名token对应拦截器配置String token=request.getHeader("token")中的getHeader中设置的的参数名。
SpringBoot集成JWT实现token验证
原文:https://www.jianshu.com/p/e88d3f8151db
JWT官网: https://jwt.io/
JWT(Java版)的github地址:https://github.com/jwtk/jjwt
什么是JWT
Json web token (JWT), 是为了在网络应用环境间传递声明而执行的一种基于JSON
的开放标准((RFC 7519).定义了一种简洁的,自包含的方法用于通信双方之间以JSON
对象的形式安全的传递信息。因为数字签名的存在,这些信息是可信的,JWT可以使用HMAC
算法或者是RSA
的公私秘钥对进行签名。
JWT请求流程
1. 用户使用账号和面发出post请求;
2. 服务器使用私钥创建一个jwt;
3. 服务器返回这个jwt给浏览器;
4. 浏览器将该jwt串在请求头中像服务器发送请求;
5. 服务器验证该jwt;
6. 返回响应的资源给浏览器。
JWT的主要应用场景
身份认证在这种场景下,一旦用户完成了登陆,在接下来的每个请求中包含JWT,可以用来验证用户身份以及对路由,服务和资源的访问权限进行验证。由于它的开销非常小,可以轻松的在不同域名的系统中传递,所有目前在单点登录(SSO)中比较广泛的使用了该技术。 信息交换在通信的双方之间使用JWT对数据进行编码是一种非常安全的方式,由于它的信息是经过签名的,可以确保发送者发送的信息是没有经过伪造的。
优点
1.简洁(Compact): 可以通过URL
,POST
参数或者在HTTP header
发送,因为数据量小,传输速度也很快
2.自包含(Self-contained):负载中包含了所有用户所需要的信息,避免了多次查询数据库
3.因为Token
是以JSON
加密的形式保存在客户端的,所以JWT
是跨语言的,原则上任何web形式都支持。
4.不需要在服务端保存会话信息,特别适用于分布式微服务。
`
JWT的结构
JWT是由三段信息构成的,将这三段信息文本用.链接一起就构成了JWT字符串。
就像这样:
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9.TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ
JWT包含了三部分:
Header 头部(标题包含了令牌的元数据,并且包含签名和/或加密算法的类型)
Payload 负载 (类似于飞机上承载的物品)
Signature 签名/签证
Header
JWT的头部承载两部分信息:token类型和采用的加密算法。
{
"alg": "HS256",
"typ": "JWT"
}
声明类型:这里是jwt
声明加密的算法:通常直接使用 HMAC SHA256
加密算法是单向函数散列算法,常见的有MD5、SHA、HAMC。
MD5(message-digest algorithm 5) (信息-摘要算法)缩写,广泛用于加密和解密技术,常用于文件校验。校验?不管文件多大,经过MD5后都能生成唯一的MD5值
SHA (Secure Hash Algorithm,安全散列算法),数字签名等密码学应用中重要的工具,安全性高于MD5
HMAC (Hash Message Authentication Code),散列消息鉴别码,基于密钥的Hash算法的认证协议。用公开函数和密钥产生一个固定长度的值作为认证标识,用这个标识鉴别消息的完整性。常用于接口签名验证
Payload
载荷就是存放有效信息的地方。
有效信息包含三个部分
1.标准中注册的声明
2.公共的声明
3.私有的声明
标准中注册的声明 (建议但不强制使用) :
iss
: jwt签发者
sub
: 面向的用户(jwt所面向的用户)
aud
: 接收jwt的一方
exp
: 过期时间戳(jwt的过期时间,这个过期时间必须要大于签发时间)
nbf
: 定义在什么时间之前,该jwt都是不可用的.
iat
: jwt的签发时间
jti
: jwt的唯一身份标识,主要用来作为一次性token
,从而回避重放攻击。
公共的声明 :
公共的声明可以添加任何的信息,一般添加用户的相关信息或其他业务需要的必要信息.但不建议添加敏感信息,因为该部分在客户端可解密.
私有的声明 :
私有声明是提供者和消费者所共同定义的声明,一般不建议存放敏感信息,因为base64
是对称解密的,意味着该部分信息可以归类为明文信息。
Signature
jwt的第三部分是一个签证信息,这个签证信息由三部分组成:
header (base64后的)
payload (base64后的)
secret
这个部分需要base64
加密后的header
和base64
加密后的payload
使用.
连接组成的字符串,然后通过header
中声明的加密方式进行加盐secret
组合加密,然后就构成了jwt
的第三部分。
密钥secret
是保存在服务端的,服务端会根据这个密钥进行生成token
和进行验证,所以需要保护好。
下面来进行SpringBoot和JWT的集成
引入JWT
依赖,由于是基于Java
,所以需要的是java-jwt
<dependency>
<groupId>com.auth0</groupId>
<artifactId>java-jwt</artifactId>
<version>3.4.0</version>
</dependency>
需要自定义两个注解
用来跳过验证的PassToken
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface PassToken {
boolean required() default true;
}
需要登录才能进行操作的注解UserLoginToken
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface UserLoginToken {
boolean required() default true;
}
@Target
:注解的作用目标
@Target(ElementType.TYPE)
——接口、类、枚举、注解
@Target(ElementType.FIELD)
——字段、枚举的常量
@Target(ElementType.METHOD)
——方法
@Target(ElementType.PARAMETER)
——方法参数
@Target(ElementType.CONSTRUCTOR)
——构造函数
@Target(ElementType.LOCAL_VARIABLE)
——局部变量
@Target(ElementType.ANNOTATION_TYPE)
——注解
@Target(ElementType.PACKAGE)
——包
@Retention
:注解的保留位置
RetentionPolicy.SOURCE
:这种类型的Annotations
只在源代码级别保留,编译时就会被忽略,在class
字节码文件中不包含。
RetentionPolicy.CLASS
:这种类型的Annotations
编译时被保留,默认的保留策略,在class
文件中存在,但JVM
将会忽略,运行时无法获得。
RetentionPolicy.RUNTIME
:这种类型的Annotations
将被JVM
保留,所以他们能在运行时被JVM
或其他使用反射机制的代码所读取和使用。
@Document
:说明该注解将被包含在javadoc
中
@Inherited
:说明子类可以继承父类中的该注解
简单自定义一个实体类User
,使用lombok
简化实体类的编写
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
String Id;
String username;
String password;
}
需要写token
的生成方法
public String getToken(User user) {
String token="";
token= JWT.create().withAudience(user.getId())
.sign(Algorithm.HMAC256(user.getPassword()));
return token;
}
Algorithm.HMAC256()
:使用HS256
生成token
,密钥则是用户的密码,唯一密钥的话可以保存在服务端。
withAudience()
存入需要保存在token
的信息,这里我把用户ID
存入token
中
接下来需要写一个拦截器去获取token
并验证token
public class AuthenticationInterceptor implements HandlerInterceptor {
@Autowired
UserService userService;
@Override
public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object object) throws Exception {
String token = httpServletRequest.getHeader("token");// 从 http 请求头中取出 token
// 如果不是映射到方法直接通过
if(!(object instanceof HandlerMethod)){
return true;
}
HandlerMethod handlerMethod=(HandlerMethod)object;
Method method=handlerMethod.getMethod();
//检查是否有passtoken注释,有则跳过认证
if (method.isAnnotationPresent(PassToken.class)) {
PassToken passToken = method.getAnnotation(PassToken.class);
if (passToken.required()) {
return true;
}
}
//检查有没有需要用户权限的注解
if (method.isAnnotationPresent(UserLoginToken.class)) {
UserLoginToken userLoginToken = method.getAnnotation(UserLoginToken.class);
if (userLoginToken.required()) {
// 执行认证
if (token == null) {
throw new RuntimeException("无token,请重新登录");
}
// 获取 token 中的 user id
String userId;
try {
userId = JWT.decode(token).getAudience().get(0);
} catch (JWTDecodeException j) {
throw new RuntimeException("401");
}
User user = userService.findUserById(userId);
if (user == null) {
throw new RuntimeException("用户不存在,请重新登录");
}
// 验证 token
JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256(user.getPassword())).build();
try {
jwtVerifier.verify(token);
} catch (JWTVerificationException e) {
throw new RuntimeException("401");
}
return true;
}
}
return true;
}
@Override
public void postHandle(HttpServletRequest httpServletRequest,
HttpServletResponse httpServletResponse,
Object o, ModelAndView modelAndView) throws Exception {
}
@Override
public void afterCompletion(HttpServletRequest httpServletRequest,
HttpServletResponse httpServletResponse,
Object o, Exception e) throws Exception {
}
实现一个拦截器就需要实现HandlerInterceptor
接口
HandlerInterceptor
接口主要定义了三个方法
1.boolean preHandle ()
:
预处理回调方法,实现处理器的预处理,第三个参数为响应的处理器,自定义Controller
,返回值为true
表示继续流程(如调用下一个拦截器或处理器)或者接着执行postHandle()
和afterCompletion()
;false
表示流程中断,不会继续调用其他的拦截器或处理器,中断执行。
2.void postHandle()
:
后处理回调方法,实现处理器的后处理(DispatcherServlet
进行视图返回渲染之前进行调用),此时我们可以通过modelAndView
(模型和视图对象)对模型数据进行处理或对视图进行处理,modelAndView
也可能为null
。
3.void afterCompletion()
:
整个请求处理完毕回调方法,该方法也是需要当前对应的Interceptor
的preHandle()
的返回值为true时才会执行,也就是在DispatcherServlet
渲染了对应的视图之后执行。用于进行资源清理。整个请求处理完毕回调方法。如性能监控中我们可以在此记录结束时间并输出消耗时间,还可以进行一些资源清理,类似于try-catch-finally
中的finally
,但仅调用处理器执行链中
主要流程:
1.从 http
请求头中取出 token
,
2.判断是否映射到方法
3.检查是否有passtoken
注释,有则跳过认证
4.检查有没有需要用户登录的注解,有则需要取出并验证
5.认证通过则可以访问,不通过会报相关错误信息
配置拦截器
在配置类上添加了注解@Configuration
,标明了该类是一个配置类并且会将该类作为一个SpringBean
添加到IOC
容器内
@Configuration
public class InterceptorConfig extends WebMvcConfigurerAdapter {
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(authenticationInterceptor())
.addPathPatterns("/**"); // 拦截所有请求,通过判断是否有 @LoginRequired 注解 决定是否需要登录
}
@Bean
public AuthenticationInterceptor authenticationInterceptor() {
return new AuthenticationInterceptor();
}
}
WebMvcConfigurerAdapter
该抽象类其实里面没有任何的方法实现,只是空实现了接口
WebMvcConfigurer
内的全部方法,并没有给出任何的业务逻辑处理,这一点设计恰到好处的让我们不必去实现那些我们不用的方法,都交由WebMvcConfigurerAdapter
抽象类空实现,如果我们需要针对具体的某一个方法做出逻辑处理,仅仅需要在WebMvcConfigurerAdapter
子类中@Override
对应方法就可以了。
注:
在SpringBoot2.0
及Spring 5.0
中WebMvcConfigurerAdapter
已被废弃
网上有说改为继承WebMvcConfigurationSupport()
,不过试了下,还是过期的
解决方法:
直接实现WebMvcConfigurer
(官方推荐)
@Configuration
public class InterceptorConfig implements WebMvcConfigurer {
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(authenticationInterceptor())
.addPathPatterns("/**");
}
@Bean
public AuthenticationInterceptor authenticationInterceptor() {
return new AuthenticationInterceptor();
}
}
InterceptorRegistry
内的addInterceptor
需要一个实现HandlerInterceptor
接口的拦截器实例,addPathPatterns
方法用于设置拦截器的过滤路径规则。
这里我拦截所有请求,通过判断是否有@LoginRequired
注解 决定是否需要登录
在数据访问接口中加入登录操作注解
@RestController
@RequestMapping("api")
public class UserApi {
@Autowired
UserService userService;
@Autowired
TokenService tokenService;
//登录
@PostMapping("/login")
public Object login(@RequestBody User user){
JSONObject jsonObject=new JSONObject();
User userForBase=userService.findByUsername(user);
if(userForBase==null){
jsonObject.put("message","登录失败,用户不存在");
return jsonObject;
}else {
if (!userForBase.getPassword().equals(user.getPassword())){
jsonObject.put("message","登录失败,密码错误");
return jsonObject;
}else {
String token = tokenService.getToken(userForBase);
jsonObject.put("token", token);
jsonObject.put("user", userForBase);
return jsonObject;
}
}
}
@UserLoginToken
@GetMapping("/getMessage")
public String getMessage(){
return "你已通过验证";
}
}
不加注解的话默认不验证,登录接口一般是不验证的。在getMessage()
中我加上了登录注解,说明该接口必须登录获取token
后,在请求头中加上token
并通过验证才可以访问
下面进行测试,启动项目,使用postman测试接口
在没token
的情况下访问api/getMessage
接口
我这里使用了统一异常处理,所以只看到错误
message
下面进行登录,从而获取token
登录操作我没加验证注解,所以可以直接访问
把token
加在请求头中,再次访问api/getMessage
接口
注意:这里的
key
一定不能错,因为在拦截器中是取关键字token
的值String token = httpServletRequest.getHeader("token");
加上
token
之后就可以顺利通过验证和进行接口访问了
github项目源码地址:https://github.com/JinBinPeng/springboot-jwt
作者:意识流丶
链接:https://www.jianshu.com/p/e88d3f8151db
來源:简书
简书著作权归作者所有,任何形式的转载都请联系作者获得授权并注明出处。
以上是关于SpringBoot集成JWT实现Token登录验证的主要内容,如果未能解决你的问题,请参考以下文章
SpringBoot从入门到精通(三十四)如何集成JWT实现Token验证