jwt token 附加用户信息_基于JWT的Token认证机制实现

最新推荐文章于 2022-11-07 13:26:49 发布

weixin_39993454

最新推荐文章于 2022-11-07 13:26:49 发布

阅读量249

点赞数

文章标签： jwt token 附加用户信息

本文链接：https://blog.csdn.net/weixin_39993454/article/details/113005202

版权

1、JWT简介

1.1什么是JWT

JSON Web Token(JWT)是一个非常轻巧的规范。这个规范允许我们使用JWT在用

户和服务器之间传递安全可靠的信息。

1.2 JWT组成

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

头部(Header)

头部用于描述关于该JWT的最基本的信息，例如其类型以及签名所用的算法等。这也可以

被表示成一个JSON对象。

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

在头部指明了签名算法是HS256算法。将上面的json字符串进行BASE64编码

载荷(playload)

载荷就是存放有效信息的地方。这个名字像是特指飞机上承载的货品，这些有效信息包含三个部分

(1)标准中注册的声明(建议但不强制使用)

iss: jwt签发者

sub: jwt所面向的用户

aud: 接收jwt的一方

exp: jwt的过期时间，这个过期时间必须要大于签发时间

nbf: 定义在什么时间之前，该jwt都是不可用的.

iat: jwt的签发时间

jti: jwt的唯一身份标识，主要用来作为一次性token,从而回避重放攻击。

(2)公共的声明

公共的声明可以添加任何的信息，一般添加用户的相关信息或其他业务需要的必要信息.

但不建议添加敏感信息，因为该部分在客户端可解密.

(3)私有的声明

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

这个指的就是自定义的claim。比如前面那个结构举例中的admin和name都属于自定的claim。这些claim跟JWT标准规定的claim区别在于：JWT规定的claim，JWT的接收方在拿到JWT之后，都知道怎么对这些标准的claim进行验证(还不知道是否能够验证)；而private claims不会验证，除非明确告诉接收方要对这些claim进行验证以及规则才行。

定义一个payload:

{"sub":"1234567890","name":"John Doe","admin":true}

然后将其进行base64编码，得到Jwt的第二部分。

eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9

签证(signature)

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

header (base64后的)

payload (base64后的)

secret

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

TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ

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

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6I kpvaG4gRG9lIiwiYWRtaW4iOnRydWV9.TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7Hg Q

注意：secret是保存在服务器端的，jwt的签发生成也是在服务器端的，secret就是用来进行jwt的签发和jwt的验证，所以，它就是你服务端的私钥，在任何场景都不应该流露出去。一旦客户端得知这个secret,那就意味着客户端是可以自我签发jwt了。

2、java的JJWT实现JWT测试

(1)导入依赖

io.jsonwebtoken

jjwt

0.6.0

(2)创建测试类，用于生成token

@Test

public void testCreat(){

Date loginTime = new Date();//登录时间Date limitTime = new Date(loginTime.getTime() + 60000);//设置过期时间为1分钟

JwtBuilder jwtBuilder = Jwts.builder()

.setId("111") //用户id.setSubject("小周") //用户名.setIssuedAt(loginTime)//登录时间.signWith(SignatureAlgorithm.HS256,"zhouran") //指定头和盐.setExpiration(limitTime);//设置过期时间 .claim("roles","admin")//添加自定义属性.claim("hobby","code") ;//添加自定义属性

System.out.println(jwtBuilder.compact());//将jwtBuilder变成字符串

//结果：//eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiIxMTEiLCJzdWIiOiLlsI_lkagiLCJpYXQiOjE1ODQyNTczMzcsImV4cCI6MTU4NDI1NzM5N30.bctrsV-FId6vspTsGu144gJR_swrE_ZiVD8wrGUI9k4

}}

(2)创建测试类，用于解析token

@Test

public void testParse(){

String token = "eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiIxMTEiLCJzdWIiOiLlsI_lkagiLCJpYXQiOjE1ODQyNTczMzcsImV4cCI6MTU4NDI1NzM5N30.bctrsV-FId6vspTsGu144gJR_swrE_ZiVD8wrGUI9k4";

Claims claims = Jwts.parser()

.setSigningKey("zhouran") //盐.parseClaimsJws(token)//需要解析的token.getBody(); //返回一个Claims对象，里面是键值对

System.out.println("用户id:"+claims.getId());

System.out.println("用户昵称:"+claims.getSubject());

System.out.println("用户登录时间:"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(claims.getIssuedAt()));

System.out.println("过期时间:"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(claims.getExpiration()));

System.out.println("角色:"+claims.get("roles"));

System.out.println("爱好:"+claims.get("hobby"));

}

结果：

用户id:111

用户昵称:小周

用户登录时间:2020-03-15 15:34:07

过期时间:2020-03-15 15:35:07

角色:admin

爱好:code

注意，如果时间超了，执行此方法会报错，所以要try-catch一下

3、springboot继集成JWT

3.1编写JWT工具类

@ConfigurationProperties("jwt.config")

public class JwtUtil {

private String salt ;//盐

private long limitTime ; //过期时间毫秒

public String getSalt() {

return salt;

}

public void setSalt(String salt) {

this.salt = salt;

}

public long getLimitTime() {

return limitTime;

}

public void setLimitTime(long limitTime) {

this.limitTime = limitTime;

}

/*** 生成JWT** @param id* @param subject* @return*/

public String createJWT(String id, String subject, String roles) {

long nowMillis = System.currentTimeMillis();

Date now = new Date(nowMillis);

JwtBuilder builder = Jwts.builder().setId(id)

.setSubject(subject)

.setIssuedAt(now)

.signWith(SignatureAlgorithm.HS256, salt)

.claim("roles", roles);

if (limitTime > 0) {

builder.setExpiration( new Date( nowMillis + limitTime));

}

return builder.compact();

}

/*** 解析JWT* @param jwtStr* @return*/

public Claims parseJWT(String jwtStr){

return Jwts.parser()

.setSigningKey(salt)

.parseClaimsJws(jwtStr)

.getBody();

}

3.2、在需要用到jwt的工程下

编写配置文件

jwt:

config:

salt: selfSalt

limitTime: 3600000 #1个小时

将工具类导入环境中

@Bean

public JwtUtil jwtUtil(){

return new JwtUtil();

}

3.3、使用

@Autowired

private JwtUtil jwtUtil;

/*** 登录* @return*/

@PostMapping("/login")

public Result login(@RequestBody Admin admin){

admin = adminService.login(admin);

if(admin==null){

return new Result(false,StatusCode.LOGINERROR,"登录失败");

}

//使前后端可以通话的操作，使用jwt实现//生成令牌String roles = "admin";

String token = jwtUtil.createJWT(admin.getId(), admin.getLoginname(), roles);

//将令牌和角色一起传给前端Map map = new HashMap<>();

map.put("token",token);

map.put("roles",roles);

return new Result(true,StatusCode.OK,"登录成功",map);

}

4、测试权限功能

需求：删除用户，必须拥有管理员权限，否则不能删除。

前后端约定：前端请求微服务时需要添加头信息Authorization ,内容为Bearer+空格 +token

(1)修改UserController的findAll方法，判断请求中的头信息，提取token并验证权

限。

/*** 删除** 必须有管理员权限才可以删除用户** 前后端约定：前端请求微服务时需要添加头信息Authorization ,内容为Bearer+空格 +token** @param id*/

@RequestMapping(value="/{id}",method= RequestMethod.DELETE)

public Result delete(@PathVariable String id, HttpServletRequest request){

String authorization = request.getHeader("Authorization");

//约定为空 if(authorization == null || "".equals(authorization)){

return new Result(false,StatusCode.ACCESSERROR,"权限不足1——约定为空");

}

// 判断Bearer+空格 if(!authorization.startsWith("Bearer ")){

return new Result(false,StatusCode.ACCESSERROR,"权限不足2——约定有误");

}

//得到token 从第七位往后都是token String token = authorization.substring(7);

try {

Claims claims = jwtUtil.parseJWT(token);

if(claims==null){

return new Result(false,StatusCode.ACCESSERROR,"权限不足5——令牌为空");

}

String roles = (String) claims.get("roles");

if (!roles.contains("admin")) {

return new Result(false,StatusCode.ACCESSERROR,"权限不足3——没有管理员权限");

}

} catch (Exception e) {

return new Result(false,StatusCode.ACCESSERROR,"权限不足4——时间过期");

}

userService.deleteById(id);

return new Result(true,StatusCode.OK,"删除成功");

}

问题：每次验证用户权限时，都要写这么长的代码，很多都是重复的

解决：将该功能放到拦截器中

Spring为我们提供了

org.springframework.web.servlet.handler.HandlerInterceptorAdapter这个适配器，

继承此类，可以非常方便的实现自己的拦截器。他有三个方法：

分别实现预处理、后处理(调用了Service并返回ModelAndView，但未进行页面渲

染)、返回处理(已经渲染了页面)

在preHandle中，可以进行编码、安全控制等处理；

在postHandle中，有机会修改ModelAndView；

在afterCompletion中，可以根据ex是否为null判断是否发生了异常，进行日志记录。

问题：

springboot没有配置文件，该如何将拦截器放入容器中？

注册拦截器：

/*** @author: zhouR* @date: Create in 2020/3/15 - 17:18* @function: 注册拦截器*/

@Configuration

public class InterceptorConfig extends WebMvcConfigurationSupport {

@Autowired

private JwtInterceptor jwtInterceptor;

/*** 注册拦截器* 声明拦截器对象 + 要拦截的请求** @param registry*/

public void addInterceptors(InterceptorRegistry registry) {

registry.addInterceptor(jwtInterceptor)

.addPathPatterns("/**") //拦截所有请求.excludePathPatterns("/**/login");//登录请求不拦截}

}

完善过滤器：这里不是拦截请求，而是根据请求头来解析角色，如果是admin角色，就在request请求中放入claims_admin为key的token值，如果是user，就放入claims_user，这样在controller方法中，如果某个方法需要admin角色，只要获取requeset中的claims_admin进行判断即可

@Component

public class JwtInterceptor implements HandlerInterceptor {

@Autowired

private JwtUtil jwtUtil;

public boolean preHandle(HttpServletRequest request,

HttpServletResponse response, Object handler) throws Exception {

System.out.println("经过了拦截器");

String authorization = request.getHeader("Authorization");

//如果有authorization头信息，就解析，如果没有就放行if(authorization!=null && !"".equals(authorization)){

//约定正确if(authorization.startsWith("Bearer ")){

//获取令牌String token = authorization.substring(7);

//对令牌进行验证try {

Claims claims = jwtUtil.parseJWT(token);

if(claims==null){

String roles = (String) claims.get("roles");

//如果是admin角色，往request域中放入令牌if (roles!=null && roles.contains("admin")) {

request.setAttribute("claims_admin",token);

}

//如果是user角色，往request域中放入令牌if (roles!=null && roles.contains("user")) {

request.setAttribute("claims_user",token);

}

} catch (Exception e) {

throw new RuntimeException("令牌有误");

}

return true;

}

改造controller：该方法需要admin权限，只要获取requeset中的claims_admin进行判断即可，如果有值就删除，如果没有值就提示权限不足

/*** 删除** 必须有管理员权限才可以删除用户** 前后端约定：前端请求微服务时需要添加头信息Authorization ,内容为Bearer+空格 +token** @param id*/

@RequestMapping(value="/{id}",method= RequestMethod.DELETE)

public Result delete(@PathVariable String id, HttpServletRequest request){

String token = (String) request.getAttribute("claims_admin");

if(token==null||"".equals(token)){

throw new RuntimeException("权限不足");

}

userService.deleteById(id);

return new Result(true,StatusCode.OK,"删除成功");

}

我自己的改造：将以上权限判断代码以注解的形式完成

(1)自定义注解

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.METHOD)

public @interface AuthName {

/*** 权限：* admin - 管理员* user - 用户** 支持多个角色，以逗号分隔*/

String value() default "";

}

(2)改造代码

/*** @author: zhouR* @date: Create in 2020/3/15 - 17:05* @function: 用户拦截器*/

@Component

public class JwtInterceptor implements HandlerInterceptor {

@Autowired

private JwtUtil jwtUtil;

public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

System.out.println("经过了拦截器");

//静态资源放行if (!(handler instanceof HandlerMethod)) return true;

//将请求的方法强转成子类，这个子类可以通过反射得到方法上面的注解HandlerMethod hm = (HandlerMethod) handler;

// 判断被拦截的请求的访问的方法的注解(是否时需要拦截的)AuthName authNameAnnotation = hm.getMethodAnnotation(AuthName.class);

//如果没有标注注解，就不用拦截，直接放行if (authNameAnnotation == null) return true;

//获取注解上的值String authName = authNameAnnotation.value();

//支持多个角色，以逗号分隔String[] authNames = authName.split(",");

String authorization = request.getHeader("Authorization");

//如果有authorization头信息，就解析，如果没有就放行if(authorization!=null && !"".equals(authorization)){

//约定正确if(authorization.startsWith("Bearer ")){

//获取令牌String token = authorization.substring(7);

//对令牌进行验证try {

Claims claims = jwtUtil.parseJWT(token);

if(claims!=null){

String roles = (String) claims.get("roles");

if(roles!=null && !"".equals(roles)){

//遍历注解上的角色，挨个比对当前用户的角色for (String name : authNames) {

//如果用户的角色不包含注解上的角色，抛出异常if(!roles.contains(name)){

throw new RuntimeException("权限不足");

}

request.setAttribute("token",token);

}

} catch (Exception e) {

throw new RuntimeException("权限不足");

}

return true;

}

(3)使用时，只需要在需要权限的方法上，加上注解，写上角色名称即可

@AuthName("admin")，如果需要多个注解，以逗号分隔@AuthName("admin,user")

@AuthName("admin")

@RequestMapping(value="/{id}",method= RequestMethod.DELETE)

public Result delete(@PathVariable String id){

/*String token = (String) request.getAttribute("claims_admin");if(token==null||"".equals(token)){throw new RuntimeException("权限不足");}*/

userService.deleteById(id);

return new Result(true,StatusCode.OK,"删除成功");

}

连每个方法里面的四行判断代码都不需要了，上面代码已经注掉

注意：这个过滤器写在common工程中，给其他所有工程共用，但是在springboot中，启动类只能扫描自己所在的包下的注解，所以需要在启动类上添加指定扫描的包

比如当前项目启动类在com.tensquare.user包下，而过滤器在common包中的com.tensquare包下，有两种解决办法

1、将com.tensquare.user包下的启动类，拖拽到上一级目录com.tensquare.，就可以使用了

2、启动类上添加组件扫描器@ComponentScan("com.tensquare")

@SpringBootApplication

@ComponentScan("com.tensquare")

public class UserApplication {

public static void main(String[] args) {

SpringApplication.run(UserApplication.class, args);

}

@Bean

public IdWorker idWorkker(){

return new IdWorker(1, 1);

}

//spring-security 密码加密@Bean

public BCryptPasswordEncoder encoder(){

return new BCryptPasswordEncoder();

}

//jwt生成token@Bean

public JwtUtil jwtUtil(){

return new JwtUtil();

}

------------------------------------------------------------------

上面的自定义注解方法有点问题，无法将所有问题都捕获到，并且无法返回指定响应，修改如下：

package com.tensquare;

import entity.Result;

import entity.StatusCode;

import io.jsonwebtoken.Claims;

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 com.alibaba.fastjson.JSON;

import util.JwtUtil;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import java.io.IOException;

import java.io.PrintWriter;

/*** @author: zhouR* @date: Create in 2020/3/15 - 17:05* @function: 用户拦截器*/

@Component

public class JwtInterceptor implements HandlerInterceptor {

@Autowired

private JwtUtil jwtUtil;

public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

System.out.println("经过了拦截器");

//静态资源放行if (!(handler instanceof HandlerMethod)) return true;

//将请求的方法强转成子类，这个子类可以通过反射得到方法上面的注解HandlerMethod hm = (HandlerMethod) handler;

// 判断被拦截的请求的访问的方法的注解(是否时需要拦截的)AuthName authNameAnnotation = hm.getMethodAnnotation(AuthName.class);

//如果没有标注注解，就不用拦截，直接放行if (authNameAnnotation == null) return true;

//获取注解上的值String authName = authNameAnnotation.value();

//支持多个角色，以逗号分隔String[] authNames = authName.split(",");

//获取请求头中的令牌String authorization = request.getHeader("Authorization");

//需要认证的方法里，却没有Authorization请求头if (authorization == null || "".equals(authorization)) {

write(response, StatusCode.ACCESSERROR, "请求头有误，请重新登录");

return false;

}

//authorization头信息中的约定不正确if (!authorization.startsWith("Bearer ")) {

write(response, StatusCode.ACCESSERROR, "约定有误，请重新登录");

return false;

}

//获取令牌String token = authorization.substring(7);

//对令牌进行验证Claims claims;

try {

claims = jwtUtil.parseJWT(token);

} catch (Exception e) {

write(response, StatusCode.ACCESSERROR, "令牌失效1，登录时间过期，请重新登录");

return false;

}

if (claims == null) {

write(response, StatusCode.ACCESSERROR, "令牌失效2，请重新登录");

return false;

}

String roles = (String) claims.get("roles");

if (roles == null || "".equals(roles)) {

write(response, StatusCode.ACCESSERROR, "角色获取失败，请重新登录");

return false;

}

//遍历注解上的角色，挨个比对当前用户的角色for (String name : authNames) {

//如果用户的角色不包含注解上的角色，拦截返回错误信息if (!roles.contains(name)) {

if (name.equals("admin")) {

write(response, StatusCode.ACCESSERROR, "权限不足");

return false;

} else if (name.equals("user")) {

write(response, StatusCode.ERROR, "请先登录");

return false;

}

request.setAttribute("token", token);

return true;

}

private void write(HttpServletResponse response, int errCode, String message) throws IOException {

//重置responseresponse.reset();

//设置编码格式response.setCharacterEncoding("UTF-8");

response.setContentType("application/json;charset=UTF-8");

PrintWriter pw = response.getWriter();

Result result = new Result(false, errCode, message);

String jsonString = JSON.toJSONString(result);

pw.write(jsonString);

pw.flush();

pw.close();

}

weixin_39993454

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
jwt token 附加用户信息_基于JWT的Token认证机制实现

1、JWT简介1.1什么是JWTJSON Web Token(JWT)是一个非常轻巧的规范。这个规范允许我们使用JWT在用户和服务器之间传递安全可靠的信息。1.2 JWT组成一个JWT实际上就是一个字符串，它由三部分组成，头部、载荷与签名。头部(Header)头部用于描述关于该JWT的最基本的信息，例如其类型以及签名所用的算法等。这也可以被表示成一个JSON对象。{"typ":"JWT","alg...
复制链接

扫一扫