JWT(JJWT)结合注解实现Token验证

最新推荐文章于 2024-04-15 23:32:56 发布

LuckyLay

最新推荐文章于 2024-04-15 23:32:56 发布

阅读量663

点赞数 1

文章标签： java spring 开发语言

本文链接：https://blog.csdn.net/LuckyLay/article/details/126707998

版权

使用JJWT工具，实现Token验证

依赖

在SpringBoot的依赖文件中，首先导入JJWT的依赖

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

JwtTokenUtils

创建一个工具类，实现Jwt的主要功能

1、创建Token

在jwt中有三部分结构，表头、声明、加密算法

在JwtBuilder提供了在JWT规范中定义的标准注册权利要求名方便setter方法。他们是：

setIssuer：设置iss（发行方）索赔
setSubject：设置sub（主题）声明
setAudience：设置aud（受众群体）声明
setExpiration：设置exp（到期时间）声明
setNotBefore：设置nbf（不早于）声明
setIssuedAt：设置iat（签发）声明
setId：设置jti（JWT ID）声明

public String createJWTToken(Map<String,String> infoMap, long efftice_min_time) {
          String jwtKey = "dsgsgcxvcx54s31gd3s2x3zvdsdev";

        //The JWT signature algorithm we will be using to sign the token
        SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;

        //We will sign our JWT with our ApiKey secret
        byte[] apiKeySecretBytes = DatatypeConverter.parseBase64Binary(jwtKey);
        Key signingKey = new SecretKeySpec(apiKeySecretBytes, signatureAlgorithm.getJcaName());
      
        Map<String, Object> claims = new HashMap<>(infoMap);
        UUID uuid = UUID.randomUUID();
        claims.put(Claims.ID,uuid);
        //Let's set the JWT Claims
        JwtBuilder builder = Jwts.builder()
                .setClaims(claims)
                .setExpiration(tokenExpiration)
                .signWith(signatureAlgorithm, signingKey);

        // if(null != tokenExpiration) {
        //     builder.setExpiration(tokenExpiration);
        // }

        //Builds the JWT and serializes it to a compact, URL-safe string
        return builder.compact();
    }

1、验证Token

 public static void verify(String token) {
        Jwts.parser()
                    .setSigningKey(DatatypeConverter.parseBase64Binary(jwtKey))
                    .setAllowedClockSkewSeconds(10)
                    .parseClaimsJws(token)
                    .getBody();
    }

根据代码中出现的异常，判断token状态。可能出现的异常：

SignatureVerificationException
TokenExpiredException
AlgorithmMismatchException
Exception

编写注释

用来标记不用验证token的方法

@Target({ElementType.METHOD, ElementType.TYPE})
public @interface PassToken {
    boolean required() default true;
}

用来标记需要验证token的方法

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface UserLoginToken {


    boolean required() default true;
}

编写拦截器

用来拦截收到的请求，判断是否需要对token进行验证。

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();

        //检查是否有 pass token 注释，如果有则跳过认真
        if (method.isAnnotationPresent(PassToken.class)) {
            PassToken passTokenAnnotation = method.getAnnotation(PassToken.class);
            if (passTokenAnnotation.required()) {
                System.out.println("pass token");
                return true;
            }
        }

        // 检查是否有需要 用户权限 的注解
        if (method.isAnnotationPresent(UserLoginToken.class)) {
            UserLoginToken userLoginTokenAnnotation = method.getAnnotation(UserLoginToken.class);
            if (userLoginTokenAnnotation.required()) {

                if (token == null) {
                    throw new RuntimeException("no token info.");
                }
                // 只是简单打印结果，未做其他处理。## 
                String resToken = tokenUtils.verifyTokenDate(token);
                System.out.println("user login token :\n");
                System.out.println(resToken);

                return true;
            }
            return true;
        }

        return true;
    }

配置拦截器

    @Bean
    public AuthenticationInterceptor authenticationInterceptor() {
        return new AuthenticationInterceptor();
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(authenticationInterceptor())
                .addPathPatterns("/**");
    }

测试

    @PassToken
    @GetMapping("/login")
    public String login() {
        TokenUtils tokenUtils = new TokenUtils();
        Map<String, String> paramMap = new HashMap<>();
        paramMap.put("id", "11111111");

        Date date = new Date();
        Date afterDate = new Date(date.getTime() + 20000);

        String jwtToken = tokenUtils.createJWTToken(paramMap, afterDate);

        return jwtToken;

    }

    @GetMapping("/test")
    @UserLoginToken
    public void testToken(@PathParam("token") String token) {
        tokenUtils.verifyTokenDate(token);
    }