JWT令牌的创建以及解析

最新推荐文章于 2024-07-26 12:00:00 发布

yuban10403

最新推荐文章于 2024-07-26 12:00:00 发布

阅读量1.6k

点赞数 27

文章标签： java

本文链接：https://blog.csdn.net/yuban10403/article/details/138257725

版权

要使用jwt令牌首先得引入相关依赖

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

为了方便后面使用，我们直接创建一个JwtUtil

完整的JtwUtil工具类

package com.sky.utils;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import java.nio.charset.StandardCharsets;
import java.util.Date;
import java.util.Map;

public class JwtUtil {
    /**
     * 生成jwt
     * 使用Hs256算法, 私匙使用固定秘钥
     *
     * @param secretKey jwt秘钥
     * @param ttlMillis jwt过期时间(毫秒)
     * @param claims    设置的信息
     * @return
     */
    public static String createJWT(String secretKey, long ttlMillis, Map<String, Object> claims) {
        // 指定签名的时候使用的签名算法，也就是header那部分
        SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;

        // 生成JWT的时间
        long expMillis = System.currentTimeMillis() + ttlMillis;
        Date exp = new Date(expMillis);

        // 设置jwt的body
        JwtBuilder builder = Jwts.builder()
                // 如果有私有声明，一定要先设置这个自己创建的私有的声明，这个是给builder的claim赋值，一旦写在标准的声明赋值之后，就是覆盖了那些标准的声明的
                .setClaims(claims)
                // 设置签名使用的签名算法和签名使用的秘钥
                .signWith(signatureAlgorithm, secretKey.getBytes(StandardCharsets.UTF_8))
                // 设置过期时间
                .setExpiration(exp);
//      builder.compact()的返回值是String类型
        return builder.compact();
    }

    /**
     * Token解密
     *
     * @param secretKey jwt秘钥 此秘钥一定要保留好在服务端, 不能暴露出去, 否则sign就可以被伪造, 如果对接多个客户端建议改造成多个
     * @param token     加密后的token
     * @return
     */
    public static Claims parseJWT(String secretKey, String token) {
        // 得到DefaultJwtParser
        Claims claims = Jwts.parser()
                // 设置签名的秘钥
                .setSigningKey(secretKey.getBytes(StandardCharsets.UTF_8))
                // 设置需要解析的jwt
                .parseClaimsJws(token).getBody();
        return claims;
    }

}

生成jwt令牌的方法

再生成jwt令牌时需要用到4个参数，一个参数是claims，通常使用 Map<String, Object> 来表示。通过设置自定义声明，你可以将自定义数据嵌入到 JWT 中，用于传递关于用户或业务上下文的额外信息。

  .setClaims(claims)

第二个参数是使用的签名算法，这个代码比较固定

 // 指定签名的时候使用的签名算法，也就是header那部分
 SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;

这里用的是HS256,除了这个，还有其他很多可供选择

第三个参数是签名使用的秘钥,这个是自定义的字符串,后面解析jwt令牌的时候也要需要用到

// 设置签名使用的签名算法和签名使用的秘钥
.signWith(signatureAlgorithm, secretKey.getBytes(StandardCharsets.UTF_8))

第四个参数是过期时间

.setExpiration(exp);

生成jwt的方法是Jwts.builder()，设置好对应参数后，进行.compact（）完成创建并返回String类型的jwt令牌

解析jwt令牌的方法

 public static Claims parseJWT(String secretKey, String token) {
        // 得到DefaultJwtParser
        Claims claims = Jwts.parser()
                // 设置签名的秘钥
                .setSigningKey(secretKey.getBytes(StandardCharsets.UTF_8))
                // 设置需要解析的jwt
                .parseClaimsJws(token).getBody();
        return claims;
    }

解析jwt令牌使用的是Jwts.parser(),用到的参数包括之前提供的秘钥第二个是需要解析的jwt令牌，也就是这里的token

重点说一下.parseClaimsJws(token)

.parseClaimsJws(token) 方法是用于解析 JWT 的方法，它会将给定的 JWT 字符串解析成一个 JwsJws对象代表了一个已签名的 JWT。一旦通过.parseClaimsJws(token)方法解析了 JWT，我们可以通过调用.getBody()方法获取到 JWT 的主体部分，即Claims` 对象。

Claims 对象包含了 JWT 的所有声明信息，比如用户ID、过期时间等。通过 .getBody() 方法获取到 Claims 对象后，你就可以进一步操作和使用其中的声明信息了。

jwt令牌的具体使用

jwt令牌的生成一般在登录操作之后,后端会生成一个jwt令牌，

客户端收到这个令牌后，通常会将其存储起来，之后，客户端每次向服务器发送请求时，都会将这个令牌作为请求头的一部分发送给服务器，服务器收到请求后，可以从请求头中提取出这个令牌，并进行验证，以确定请求是否合法以及请求的身份信息。我们会设置一个拦截器，一般用于拦截除登录外的其他方法，在调用这些方法是进行令牌的验证和解析

jwt令牌校验的拦截器

定义jwt令牌拦截器

package com.sky.interceptor;

import com.sky.constant.JwtClaimsConstant;
import com.sky.context.BaseContext;
import com.sky.properties.JwtProperties;
import com.sky.utils.JwtUtil;
import io.jsonwebtoken.Claims;
import lombok.extern.slf4j.Slf4j;
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;

/**
 * jwt令牌校验的拦截器
 */
@Component
@Slf4j
public class JwtTokenAdminInterceptor implements HandlerInterceptor {

    @Autowired
    private JwtProperties jwtProperties;

    /**
     * 校验jwt
     *
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //判断当前拦截到的是Controller的方法还是其他资源
        if (!(handler instanceof HandlerMethod)) {
            //当前拦截到的不是动态方法，直接放行
            return true;
        }

        //1、从请求头中获取令牌
        String token = request.getHeader(jwtProperties.getAdminTokenName());

        //2、校验令牌
        try {
            log.info("jwt校验:{}", token);
            Claims claims = JwtUtil.parseJWT(jwtProperties.getAdminSecretKey(), token);
            Long empId = Long.valueOf(claims.get(JwtClaimsConstant.EMP_ID).toString());
            log.info("当前员工id：", empId);
            //3、通过，放行
            //将当前员工的id存储到该线程的存储空间中（客户端的一次请求对应一个线程）
//            这一步操作可以让后端自己获取empId
            BaseContext.setCurrentId(empId);
            return true;
        } catch (Exception ex) {
            //4、不通过，响应401状态码
            response.setStatus(401);
            return false;
        }
    }
}

jwt拦截器注册

package com.sky.config;

import com.sky.interceptor.JwtTokenAdminInterceptor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;




/**
 * 配置类，注册web层相关组件
 */
@Configuration
@Slf4j
public class WebMvcConfiguration extends WebMvcConfigurationSupport {

    @Autowired
    private JwtTokenAdminInterceptor jwtTokenAdminInterceptor;

    /**
     * 注册自定义拦截器
     *
     * @param registry
     */
    protected void addInterceptors(InterceptorRegistry registry) {
        log.info("开始注册自定义拦截器...");
        registry.addInterceptor(jwtTokenAdminInterceptor)
                .addPathPatterns("/admin/**")
                .excludePathPatterns("/admin/employee/login");
    }
}

这里就指定了要拦截的相关路径的方法以及其中不需要拦截的例外。

在jwt拦截器中我们先从请求头中获取令牌

之后调用我们写好的工具类中的方法进行jwt令牌的解析

 Claims claims = JwtUtil.parseJWT(jwtProperties.getAdminSecretKey(), token);

在这里进行jwt的校验并获取其中的claims，在之前创建jwt令牌时，我们在claims设置了一个empId的信息，现在，我们可以将其解析并取出以便使用

参数分别是前面使用的秘钥以及需要解析的jwt，这里如果秘钥和对应的token没有错误，且token没有过期，那么该请求就会通过，否则将被拦截。

该拦截器中还有一个方法

BaseContext.setCurrentId(empId);

这个方法是将当前员工的id存储到该线程的存储空间中（客户端的一次请求对应一个线程）,这一步操作可以让后端自己获取empId

BaseContext

package com.sky.context;

public class BaseContext {

    public static ThreadLocal<Long> threadLocal = new ThreadLocal<>();

    public static void setCurrentId(Long id) {
        threadLocal.set(id);
    }

    public static Long getCurrentId() {
        return threadLocal.get();
    }

    public static void removeCurrentId() {
        threadLocal.remove();
    }

}

这段代码定义了一个名为 BaseContext 的类，用于管理当前线程的上下文信息。具体来说，它包含以下几个元素：

threadLocal：这是一个静态的 ThreadLocal 对象，用于存储当前线程的上下文信息。在多线程环境下，ThreadLocal 可以让每个线程都拥有自己的数据副本，从而实现线程封闭的效果，避免线程间数据共享带来的并发问题。
setCurrentId(Long id)：这是一个静态方法，用于设置当前线程的上下文信息，即当前线程的ID。它接受一个 Long 类型的参数 id，将其设置到当前线程的 threadLocal 中。
getCurrentId()：这是一个静态方法，用于获取当前线程的上下文信息，即当前线程的ID。它从当前线程的 threadLocal 中获取值并返回。
removeCurrentId()：这是一个静态方法，用于移除当前线程的上下文信息。它会清除当前线程的 threadLocal 中存储的值。

通过这些方法，您可以在应用程序中方便地设置和获取当前线程的上下文信息，例如用户ID、会话ID等。