SpringBoot集成JWT实现token验证,token注销

最新推荐文章于 2024-04-14 16:15:53 发布
最新推荐文章于 2024-04-14 16:15:53 发布
阅读量2.7k 收藏 16
点赞数
分类专栏： SpringBoot Java
原文链接：https://blog.csdn.net/qq_43599835/article/details/102475940
版权
Java 同时被 2 个专栏收录
108 篇文章 9 订阅
订阅专栏
SpringBoot
101 篇文章 14 订阅
订阅专栏

JWT官网： [https://jwt.io/][https_jwt.io]
JWT(Java版)的github地址:[https://github.com/jwtk/jjwt][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 签名/签证

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的第三部分是一个签证信息

这个部分需要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，注解参考：SpringBoot 常用注解和原理！

@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容器内。拦截器看这里>：Spring Boot实战：拦截器与过滤器

@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

 

工具类例子

例子1

package com.springboot.jwt.util;


import com.springboot.jwt.entity.CheckResult;
import com.springboot.jwt.entity.SystemConstant;
import io.jsonwebtoken.*;
import sun.misc.BASE64Decoder;

import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.io.IOException;
import java.util.Date;

public class JwtUtil {
    /**
     * 签发JWT
     *
     * @param id
     * @param subject   可以是JSON数据 尽可能少
     * @param ttlMillis 有效时间
     * @return String
     */
    public static String createJWT(String id, String subject, Long ttlMillis) throws IOException {
        long nowMillis = System.currentTimeMillis();
        Date now = new Date(nowMillis);
        SecretKey secretKey = generalKey();
        JwtBuilder builder = Jwts.builder()
                .setId(id) // 是JWT的唯一标识，根据业务需要，这个可以设置为一个不重复的值，主要用来作为一次性token,从而回避重放攻击。
                .setSubject(subject)   // 代表这个JWT的主体，即它的所有人，这个是一个json格式的字符串，可以存放什么userid，roldid之类的，作为什么用户的唯一标志
                .setIssuer("user")     // 颁发者是使用 HTTP 或 HTTPS 方案的 URL（区分大小写），其中包含方案、主机及（可选的）端口号和路径部分
                .setIssuedAt(now)      // jwt的签发时间
                .signWith(SignatureAlgorithm.HS256, secretKey); // 设置签名使用的签名算法和签名使用的秘钥
        if (ttlMillis > 0) {
            long expMillis = nowMillis + ttlMillis;
            Date expDate = new Date(expMillis);
            builder.setExpiration(expDate); // 过期时间
        }
        return builder.compact();
    }

    /**
     * 验证JWT
     *
     * @param jwtStr
     * @return
     */
    public static CheckResult validateJWT(String jwtStr) {
        CheckResult checkResult = new CheckResult();
        try {
            Claims claims = parseJWT(jwtStr);
            checkResult.setSuccess(true);
            checkResult.setClaims(claims);
        } catch (ExpiredJwtException e) {
            checkResult.setErrCode(SystemConstant.JWT_ERRCODE_EXPIRE);
            checkResult.setSuccess(false);
        } catch (Exception e) {
            checkResult.setErrCode(SystemConstant.JWT_ERRCODE_FAIL);
            checkResult.setSuccess(false);
        }
        return checkResult;
    }

    private static SecretKey generalKey() throws IOException {
        BASE64Decoder decoder = new BASE64Decoder();
        byte[] encodedKey = decoder.decodeBuffer(SystemConstant.JWT_SECERT);
        return new SecretKeySpec(encodedKey, 0, encodedKey.length, "AES");
    }

    /**
     * 解析JWT字符串
     *
     * @param jwt
     * @return
     */
    public static Claims parseJWT(String jwt) throws IOException {
        SecretKey secretKey = generalKey();
        return Jwts.parser()
                .setSigningKey(secretKey)
                .parseClaimsJws(jwt)
                .getBody();
    }
}

例子2

package com.thtf.util;
import com.thtf.common.exception.CustomException;
import com.thtf.common.response.ResultCode;
import com.thtf.model.Audience;
import io.jsonwebtoken.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.crypto.spec.SecretKeySpec;
import javax.xml.bind.DatatypeConverter;
import java.security.Key;
import java.util.Date;

public class JwtTokenUtil {
    private static Logger log = LoggerFactory.getLogger(JwtTokenUtil.class);
    public static final String AUTH_HEADER_KEY = "Authorization";
    public static final String TOKEN_PREFIX = "Bearer ";
    /**
     * 解析jwt
     * @param jsonWebToken
     * @param base64Security
     * @return
     */
    public static Claims parseJWT(String jsonWebToken, String base64Security) {
        try {
            Claims claims = Jwts.parser()
                    .setSigningKey(DatatypeConverter.parseBase64Binary(base64Security))
                    .parseClaimsJws(jsonWebToken).getBody();
            return claims;
        } catch (ExpiredJwtException  eje) {
            log.error("===== Token过期 =====", eje);
            throw new CustomException(ResultCode.PERMISSION_TOKEN_EXPIRED);
        } catch (Exception e){
            log.error("===== token解析异常 =====", e);
            throw new CustomException(ResultCode.PERMISSION_TOKEN_INVALID);
        }
    }
    /**
     * 构建jwt
     * @param userId
     * @param username
     * @param role
     * @param audience
     * @return
     */
    public static String createJWT(String userId, String username, String role, Audience audience) {
        try {
            // 使用HS256加密算法
            SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
            long nowMillis = System.currentTimeMillis();
            Date now = new Date(nowMillis);
            //生成签名密钥
            byte[] apiKeySecretBytes = DatatypeConverter.parseBase64Binary(audience.getBase64Secret());
            Key signingKey = new SecretKeySpec(apiKeySecretBytes, signatureAlgorithm.getJcaName());
            //userId是重要信息，进行加密下
            String encryId = Base64Util.encode(userId);
            //添加构成JWT的参数
            JwtBuilder builder = Jwts.builder().setHeaderParam("typ", "JWT")
                    // 可以将基本不重要的对象信息放到claims
                    .claim("role", role)
                    .claim("userId", userId)
                    .setSubject(username)           // 代表这个JWT的主体，即它的所有人
                    .setIssuer(audience.getClientId())              // 代表这个JWT的签发主体；
                    .setIssuedAt(new Date())        // 是一个时间戳，代表这个JWT的签发时间；
                    .setAudience(audience.getName())          // 代表这个JWT的接收对象；
                    .signWith(signatureAlgorithm, signingKey);
            //添加Token过期时间
            int TTLMillis = audience.getExpiresSecond();
            if (TTLMillis >= 0) {
                long expMillis = nowMillis + TTLMillis;
                Date exp = new Date(expMillis);
                builder.setExpiration(exp)  // 是一个时间戳，代表这个JWT的过期时间；
                        .setNotBefore(now); // 是一个时间戳，代表这个JWT生效的开始时间，意味着在这个时间之前验证JWT是会失败的
            }
            //生成JWT
            return builder.compact();
        } catch (Exception e) {
            log.error("签名失败", e);
            throw new CustomException(ResultCode.PERMISSION_SIGNATURE_ERROR);
        }
    }
    /**
     * 从token中获取用户名
     * @param token
     * @param base64Security
     * @return
     */
    public static String getUsername(String token, String base64Security){
        return parseJWT(token, base64Security).getSubject();
    }
    /**
     * 从token中获取用户ID
     * @param token
     * @param base64Security
     * @return
     */
    public static String getUserId(String token, String base64Security){
        String userId = parseJWT(token, base64Security).get("userId", String.class);
        return Base64Util.decode(userId);
    }
    /**
     * 是否已过期
     * @param token
     * @param base64Security
     * @return
     */
    public static boolean isExpiration(String token, String base64Security) {
        return parseJWT(token, base64Security).getExpiration().before(new Date());
    }
}

例子3

 
import io.jsonwebtoken.*;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
 
import javax.crypto.spec.SecretKeySpec;
import javax.xml.bind.DatatypeConverter;
import java.security.Key;
import java.util.Base64;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Logger;
 
//jwt含有三部分：头部（header）、载荷（payload）、签证（signature）
/*
*(1)头部一般有两部分信息：声明类型、声明加密的算法（通常使用HMAC SHA256）
*(2)载荷该部分一般存放一些有效的信息。jwt的标准定义包含五个字段：
*    -iss：该JWT的签发者
    - sub: 该JWT所面向的用户
    - aud: 接收该JWT的一方
    - exp(expires): 什么时候过期，这里是一个Unix时间戳
    - iat(issued at): 在什么时候签发的
* (3)签证（signature） JWT最后一个部分。该部分是使用了HS256加密后的数据；包含三个部分：
* */
 
@Service("jwtUtil")
public class JWTUtil {
 
    private final Logger logger = Logger.getLogger(this.getClass().getName());
 
    @Value("${com.jwt.secret}")
    private  String SECRET;
 
    @Value("${com.jwt.issuer}")
    private  String JWT_ISSUER;
 
    public String creatJwtToken(){
        final SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
 
        final long nowMillis = System.currentTimeMillis();
        //设置过期时间
        final long ttlMillis = 5 * 60 * 100000;
        final long expMillis = nowMillis + ttlMillis;
 
        final Date now = new Date(nowMillis);
        final Date exp = new Date(expMillis);
 
        //Create the Signature SecretKey
        final byte[] apiKeySecretBytes = DatatypeConverter.parseBase64Binary(Base64.getEncoder().encodeToString(SECRET.getBytes()));
        final Key signingKey = new SecretKeySpec(apiKeySecretBytes, signatureAlgorithm.getJcaName());
 
        final Map<String, Object> headerMap = new HashMap<String, Object>();
        headerMap.put("alg", "HS256");
        headerMap.put("typ", "JWT");
 
        //add JWT Parameters
        final JwtBuilder builder = Jwts.builder()
                                        .setHeaderParams(headerMap)
                                        .setIssuedAt(now)
                                        .setExpiration(exp)
                                        .setIssuer(JWT_ISSUER)
                                        .signWith(signatureAlgorithm, signingKey);
 
        logger.info("JWT[" + builder.compact()+ "]");
        return builder.compact();
 
    }
 
    public Claims parseJWTToken(String token)
    {
        Claims claims = null;
        try
        {
            claims = Jwts.parser().setSigningKey(DatatypeConverter.parseBase64Binary(SECRET)).parseClaimsJws(token)
                    .getBody();
        }
        catch (ExpiredJwtException | UnsupportedJwtException | MalformedJwtException | SignatureException
                | IllegalArgumentException e)
        {
            logger.info("Parse JWT errror " + e.getMessage());
            return null;
        }
        return claims;
    }
}

例子4

import com.liuzhihang.demo.bean.UserDetailsImpl;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.stereotype.Component;

import java.time.Instant;
import java.util.Date;


@Component
public class JwtTokenUtil {

    private static final SignatureAlgorithm SIGN_TYPE = SignatureAlgorithm.HS256;

    public static final String SECRET = "jwt-secret";

    /**
     * JWT超时时间
     */
    public static final long EXPIRED_TIME = 7 * 24 * 60 * 60 * 1000L;

    /**
     * claims 为自定义的私有声明, 要放在前面
     * <p>
     * 生成token
     */
    public String generateToken(UserDetails userDetails) {

        long instantNow = Instant.now().toEpochMilli();

        Claims claims = Jwts.claims();
        claims.put(Claims.SUBJECT, userDetails.getUsername());

        return Jwts.builder().setClaims(claims).setIssuedAt(new Date(instantNow))
                .setExpiration(new Date(instantNow + EXPIRED_TIME))
                .signWith(SIGN_TYPE, SECRET).compact();
    }

    /**
     * claims 为自定义的私有声明, 要放在前面
     * <p>
     * 生成token
     */
    public String generateToken(String userName) {

        long instantNow = Instant.now().toEpochMilli();

        Claims claims = Jwts.claims();
        claims.put(Claims.SUBJECT, userName);

        return Jwts.builder().setClaims(claims).setIssuedAt(new Date(instantNow))
                .setExpiration(new Date(instantNow + EXPIRED_TIME))
                .signWith(SIGN_TYPE, SECRET).compact();
    }

    /**
     * 将token解析, 映射为 UserDetails
     *
     * @param jwtToken
     * @return
     */
    public UserDetails getUserDetailsFromToken(String jwtToken) {

        Claims claimsFromToken = getClaimsFromToken(jwtToken);

        String userName = claimsFromToken.get(Claims.SUBJECT, String.class);

        UserDetailsImpl userDetails = new UserDetailsImpl();
        userDetails.setUsername(userName);

        return userDetails;
    }

    /**
     * 验证token
     */
    public Boolean validateToken(String token, UserDetails userDetails) {
        UserDetailsImpl user = (UserDetailsImpl) userDetails;
        String username = getPhoneNoFromToken(token);

        return (username.equals(user.getUsername()) && !isTokenExpired(token));
    }

    /**
     * 刷新令牌
     *
     * @param token 原令牌
     * @return 新令牌
     */
    public String refreshToken(String token) {
        String refreshedToken;
        try {
            Claims claims = getClaimsFromToken(token);

            long instantNow = Instant.now().toEpochMilli();

            refreshedToken = Jwts.builder().setClaims(claims).setIssuedAt(new Date(instantNow))
                    .setExpiration(new Date(instantNow + EXPIRED_TIME))
                    .signWith(SIGN_TYPE, SECRET).compact();
        } catch (Exception e) {
            refreshedToken = null;
        }
        return refreshedToken;
    }

    /**
     * 获取token是否过期
     */
    public Boolean isTokenExpired(String token) {
        Date expiration = getExpirationDateFromToken(token);
        return expiration.before(new Date());
    }

    /**
     * 根据token获取username
     */
    public String getPhoneNoFromToken(String token) {
        return getClaimsFromToken(token).getSubject();
    }

    /**
     * 获取token的过期时间
     */
    public Date getExpirationDateFromToken(String token) {
        return getClaimsFromToken(token).getExpiration();
    }

    /**
     * 解析JWT
     */
    private Claims getClaimsFromToken(String token) {
        return Jwts.parser().setSigningKey(SECRET).parseClaimsJws(token).getBody();
    }

}

 

参考

https://www.jianshu.com/p/e88d3f8151db。
https://blog.csdn.net/qq_43599835/article/details/102475940

https://zhuanlan.zhihu.com/p/74345791

https://blog.csdn.net/u013363895/article/details/82496329

https://segmentfault.com/a/1190000024448199

zzhongcy
关注
  • 0
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
fastadmin token 验证错误_基于token机制鉴权架构
weixin_39620037的博客
11-22 1288
常见的鉴权方式有两种，一种是基于session，另一种是基于token方式的鉴权，我们来浅谈一下两种 鉴权方式的区别。两种鉴权方式对比session安全性：session是基于cookie进行用户识别的，cookie如果被截获，用户很容易受到跨站请求伪造的攻击。扩展性：session是有状态的，是具有IP黏贴性和有中心化特性的，在分布式环境下，虽然每台服务器业务逻辑一样，但是session是保存在...
jwt token注销_基于JWT的Token登录认证
weixin_39561004的博客
01-12 590
JWT简介 ：json Web Token(缩写JWT)是目前最流行的跨域认证解决方案session登录的认证方案是看，用户从客户端传递用户名和密码登录信息，服务端认证后将信息储存在session中，将session_id放入cookie中，以后访问其他页面，服务器都会带着cookie，服务端会自动从cookie中获取session_id,在从session中获取认证信息。JWT的解决方案是，将认...
Java令牌Token登录与退出的实现
08-19
主要介绍了Java令牌Token登录与退出的实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Spring Cloud Alibaba微服务实战三十五 - 退出登录注销 jwt token
最新发布
smart_an的专栏
04-14 659
作者简介：大家好，我是哥，前中兴通讯、美团架构师，现某互联网公司联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬学习必须往深处挖，挖的越深，基础越扎实！前几天有一个看我SpringCloud alibaba系列文章的粉丝私下问我：如何处理jwt失效的问题？修改密码或退出登录后需要将之前的jwt token失效掉，不允许使用旧token登录系统。我说：很简单呀，咱们直接 无为而治，用户退出或修改密码的时候前端直接删除这个token不就完了吗？
基于JWT的Token删除案例使用拦截器方式实现token鉴权
L__MY的博客
07-18 5069
删除用户功能 需求：删除用户，必须拥有管理员权限，否则不能删除。 前后端约定：前端请求微服务时需要添加头信息Authorization ,内容为Bearer+空格 +token jwtutil工具类 package util; import io.jsonwebtoken.Claims; import io.jsonwebtoken.JwtBuilder; import io.jsonwebto...
springboot拦截器的使用以及JWT忽略token
taiguolaotu的博客
09-14 4742
上代码 public class JWTInterceptor implements HandlerInterceptor { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { Map<Object, Object> map = new HashMap&lt
jwt token注销_JWT生成token及过期处理方案
weixin_34118593的博客
01-27 4388
## 业务场景在前后分离场景下，越来越多的项目使用token作为接口的安全机制，APP端或者WEB端(使用VUE、REACTJS等构建)使用token与后端接口交互，以达到安全的目的。本文结合stackoverflow以及本身项目实践，试图总结出一个通用的，可落地的方案。## 基本思路- 单个token1. token(A)过期设置为15分钟2. 前端发起请求，后端验证token(A)是否过期；如...
springboot整和jwt、shiro、redis实现token自动刷新
08-19
接着，我们需要创建一个JWTToken Realm，实现Shiro的AuthenticationInfo接口，处理JWT的验证。在Realm中，我们可以解析JWT，获取用户信息，并与数据库进行比对，完成身份验证。 对于Redis的使用，我们需要配置一个...
springboot整合Sa-Token 实现前后端分离登录注销功能，刚学习Sa-Token，用来练手，适合初学者。仅作学习使用
05-22
springboot整合Sa-Token 实现前后端分离登录注销功能，刚学习Sa-Token，用来练手，适合初学者。仅作学习使用 前端使用html jquery ajax异步请求 后端springboot框架，Sa-Token框架。 jdk使用1.8 mysql 8.0
jwt_token_test.zip
05-21
Java Web Token（JWT）是一种轻量级的身份验证和授权机制，广泛应用于移动应用与服务器之间的交互。JWT允许在用户身份验证后将权限信息安全地编码为一个字符串，并在客户端和服务端之间传递，无需存储session信息在...
springboot+jwt+spring-security.rar
05-20
Spring Boot集成JWT的过程主要包括创建Token、验证Token和处理Token过期。在创建Token时，我们需要定义一个密钥，使用这个密钥和JWT的Payload生成Signature。验证Token时，服务器会检查Signature是否匹配，确保Token...
基于springboot+springSecurity+jwt实现的基于token的权限管理+源代码+文档
04-11
在Spring Security与JWT的集成中，通常会有一个TokenProvider组件负责生成和验证JWT。这个组件会使用一个密钥（secret key）对JWT进行签名，确保token没有被篡改。同时，JWT还可以设置过期时间，以增加安全性。 在...
SpringCloud Alibaba 实战 - 如何让 jwt token 主动失效？
wdjnb的博客
01-19 3723
前言 有一个看我SpringCloud alibaba系列文章的粉丝私下问我：如何处理jwt失效的问题？修改密码或退出登录后需要将之前的jwt token失效掉，不允许使用旧token登录系统。 我说：很简单呀，咱们直接 无为而治，用户退出或修改密码的时候前端直接删除这个token不就完了吗？后端啥都不用管，啥也不用做。 他说：别闹，你的每篇文章我都给你一键三连。 我当时就被感动了，既然是这样的好读者，我果断答应专门给他写篇文章来分享一下我这个不太成熟的做法，改造一下这个SpringCloud al
jwt token注销_关于JWT用户主动注销、强制登出、忘记密码、修改密码的一些思考...
weixin_33937306的博客
01-27 1393
JWT(JSON WEB TOKEN)的特点是无状态，通常用来作为验证登录以及鉴权,在这一方面，JWT体现出了他的优点。然而，如果使用JWT实现，用户主动注销、强制登出(禁止登陆)、忘记密码、修改密码，JWT续签等方面的需求,就会让人头疼。按照网上的一些讨论，我概括如下：1、将每一个签发的JWT保存在REDIS上，当出现上述的需求时，就更新对应的JWT，如果客户端与REDIS中的不同，那么登录失败...
SpringSecurity（六）注销登录
陈橙橙
03-11 1634
注销登录 SpringScurity中提供了默认的注销页面，当然我们也可以根据自己的需求对注销登录进行定制。 @Configuration public class SecurityConfig extends WebSecurityConfigurerAdapter { @Override protected void configure(HttpSecurity http) throws Exception { http.authorizeRequests()
SpringBoot如何优雅的处理免登录接口
morecccc的博客
12-31 2079
SpringBoot下采用自定义注解的方式处理免登录校验
Java实现登录与注销--JWT（2）
java_ying的博客
12-15 2021
上文介绍了JWT的创建 与 拦截器的配置 这篇基于上篇文档jwt生成token后的在登录中的具体使用 （ps：因为我也是探索使用 所以陆续更新。有好的建议也欢迎指出） 首先拦截器和 JwtTokenUtil我重新放一个。可能会有些许区别 此篇文章加入了会话管理token的存储。当然你可以自己切换为redis管理。 因为隐私问题 不方便透漏包名。请自行添加 若少什么不会的东西 可以留言 我会提供 /** * @author chunying * @Date 2020.12.06 * @Descript
jwt token注销_如何在注销时销毁JWT令牌？
热门推荐
weixin_30119251的博客
12-29 1万+
6 个答案:答案 0 :(得分：42)JWT存储在浏览器上，因此删除在客户端删除cookie的令牌如果您还需要在服务器端到期之前使令牌无效，例如帐户已删除/阻止/暂停，密码已更改，权限已更改，用户已由管理员注销，请查看Invalidating JSON Web Tokens一些公共技术，如创建黑名单或旋转令牌答案 1 :(得分：7)创建令牌后，无法手动使令牌失效。因此，实际上无法像在会话中那样在服...
SpringCloud Alibaba微服务实战三十五 - 实现退出登录后注销 jwt token(1)
m0_61549353的博客
04-04 1179
1、看视频进行系统学习这几年的Crud经历，让我明白自己真的算是菜鸡中的战斗机，也正因为Crud，导致自己技术比较零散，也不够深入不够系统，所以重新进行学习是很有必要的。我差的是系统知识，差的结构框架和思路，所以通过视频来学习，效果更好，也更全面。关于视频学习，个人可以推荐去B站进行学习，B站上有很多学习视频，唯一的缺点就是免费的容易过时。2、读源码，看实战笔记，学习大神思路“编程语言是程序员的表达的方式，而架构是程序员对世界的认知”。所以，程序员要想快速认知并学习架构，读源码是必不可少的。
jwt实现token销毁
07-27
JWT实现token销毁的方式有几种方法。一种常见的方法是将token存储在服务器端的黑名单中。当用户注销或需要销毁token时，将该token添加到黑名单中。在每次请求时，服务器会检查token是否在黑名单中，如果是，则拒绝该请求。这种方法需要服务器维护一个黑名单列表，并增加一些额外的逻辑来检查token的有效性。\[2\] 另一种方法是使用token的过期时间来实现销毁。在生成token时，可以设置一个过期时间，一旦token过期，它将自动失效。这样，即使token被保留在客户端，一旦过期，它也无法再被使用。这种方法不需要服务器维护黑名单列表，但需要在生成token时设置合适的过期时间。\[3\] 需要注意的是，JWT本身是无状态的，它不提供直接的注销功能。因此，实现token销毁需要额外的逻辑和控制。具体的实现方式可以根据具体的需求和系统架构来选择。 #### 引用[.reference_title] - *1* [SpringBoot集成JWT实现token验证,token注销](https://blog.csdn.net/yangyangye/article/details/117445245)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insert_down1,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* *3* [如何使用jwt 完成注销(退出登录)功能](https://blog.csdn.net/weixin_39813433/article/details/122287823)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insert_down1,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值