@Slf4j
public class JWTUtils {

    /**
     * Generates an encryption key from a string. The key is not hard-coded in this code and can be flexibly configured.
     *
     * @return
     */
    public static SecretKey generalKey(String stringKey) {
        byte[] encodedKey = Base64.decodeBase64(stringKey);
        SecretKey key = new SecretKeySpec(encodedKey, 0, encodedKey.length, "AES");
        return key;
    }

    /**
     * createJWT: Creates a JWT.
     *
     * @param id        Unique id, such as UUID.
     * @param subject   JSON-format or plain text string to store user non-sensitive information, such as user tid, to compare with the parsed token to prevent abuse.
     * @param ttlMillis Expiration time.
     * @param stringKey
     * @return JWT token.
     * @throws Exception
     */
    public static String createJWT(String id, String subject, long ttlMillis, String stringKey) throws Exception {
        SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
        long nowMillis = System.currentTimeMillis();
        Date now = new Date(nowMillis);
        SecretKey key = generalKey(stringKey);
        JwtBuilder builder = Jwts.builder().setIssuer("").setId(id).setIssuedAt(now).setSubject(subject)
                .signWith(signatureAlgorithm, key);
        if (ttlMillis >= 0) {
            long expMillis = nowMillis + ttlMillis;
            Date exp = new Date(expMillis);
            builder.setExpiration(exp);
        }
        return builder.compact();
    }

    /**
     * parseJWT: Decrypts a JWT.
     *
     * @param jwt
     * @param stringKey
     * @return
     * @throws ExpiredJwtException
     * @throws UnsupportedJwtException
     * @throws MalformedJwtException
     * @throws SignatureException
     * @throws IllegalArgumentException
     */
    public static Claims parseJWT(String jwt, String stringKey) throws ExpiredJwtException, UnsupportedJwtException,
            MalformedJwtException, SignatureException, IllegalArgumentException {
        SecretKey key = generalKey(stringKey);
        Claims claims = Jwts.parser().setSigningKey(key).parseClaimsJws(jwt).getBody();
        return claims;
    }

    public static boolean isTokenExpire(String jwt, String stringKey) {
        Claims aClaims = parseJWT(jwt, stringKey);
        // Compare the current time with the token expiration time
        if (LocalDateTime.now().isAfter(LocalDateTime.now()
                .with(aClaims.getExpiration().toInstant().atOffset(ZoneOffset.ofHours(8)).toLocalDateTime()))) {
            log.info("Token is valid");
            return true;
        } else {
            return false;
        }
    }

    public static void main(String[] args) {
        try {
            String key = "eyJqdGkiOiI1NGEzNmQ5MjhjYzE0MTY2YTk0MmQ5NTg4NGM2Y2JjMSIsImlhdCI6MTU3OTE2MDkwMiwic3ViIjoiMTIxMiIsImV4cCI6MTU3OTE2MDkyMn0";
            String token = createJWT(UUID.randomUUID().toString().replace("-", ""), "1212", 2000, key);
            System.out.println(token);
            parseJWT(token, key);
//          Thread.sleep(2500);
            Claims aClaims = parseJWT(token, key);
            System.out.println(aClaims.getExpiration());
            if (isTokenExpire(token, key)) {
                System.out.println("Expired");
            } else {
                System.out.println("Normal");
            }
            System.out.println(aClaims.getSubject().substring(0, 2));

} catch (ExpiredJwtException e) {
    System.out.println("Token has expired again");
} catch (Exception e) {
    e.printStackTrace();
}

}
}

#### **Token Validation**

To validate the availability of the token, we need to create a filter that works with Spring Cloud Gateway as the gateway filter:

```java
@Component
@Slf4j
public class JWTFilter implements GlobalFilter, Ordered {

    @Autowired
    JWTData jwtData;

    private ObjectMapper objectMapper = new ObjectMapper();

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {

        String url = exchange.getRequest().getURI().getPath();

        // Skip validation for specific paths
        if (null != jwtData.getSkipUrls() && Arrays.asList(jwtData.getSkipUrls()).contains(url)) {
            return chain.filter(exchange);
        }

        // Get token
        String token = exchange.getRequest().getHeaders().getFirst("token");
        ServerHttpResponse resp = exchange.getResponse();
        if (StringUtils.isEmpty(token)) {
            // No token
            return authError(resp, "Please log in first!");
        } else {
            // Has token
            try {
                JWTUtils.parseJWT(token, jwtData.getTokenKey());
                log.info("Validation passed");
                return chain.filter(exchange);
            } catch (ExpiredJwtException e) {
                log.error(e.getMessage(), e);
                return authError(resp, "Token expired");
            } catch (Exception e) {
                log.error(e.getMessage(), e);
                return authError(resp, "Authentication failed");
            }
        }
    }

    /**
     * Output authentication error
     * 
     * @param resp    response object
     * @param message error message
     * @return
     */
    private Mono<Void> authError(ServerHttpResponse resp, String message) {
        resp.setStatusCode(HttpStatus.UNAUTHORIZED);
        resp.getHeaders().add("Content-Type", "application/json;charset=UTF-8");
        CommonResult<String> returnData = new CommonResult<>(org.apache.http.HttpStatus.SC_UNAUTHORIZED + "");
        returnData.setRespMsg(message);
        String returnStr = "";
        try {
            returnStr = objectMapper.writeValueAsString(returnData.getRespMsg());
        } catch (JsonProcessingException e) {
            log.error(e.getMessage(), e);
        }
        DataBuffer buffer = resp.bufferFactory().wrap(returnStr.getBytes(StandardCharsets.UTF_8));
        return resp.writeWith(Flux.just(buffer));
    }

    @Override
    public int getOrder() {
        return -200;
    }

}

jwt:
  token-key: eyJqdGkiOiI1NGEzNmQ5MjhjYzE0MTY2YTk0MmQ5NTg4NGM2Y2JjMSIsImlhdCI6MTU3OTE2MDkwMiwic3ViIjoiMTIxMiIsImV4cCI6MTU3OTE2MDkyMn0
  skip-urls: 
  - /member-service/member/bindMobile
  - /member-service/member/logout

@Component
@Data
@ConfigurationProperties(prefix = "jwt")
public class JWTData {

    public String tokenKey;

    private String[] skipUrls;
}