// ❌ 旧版本写法（存在隐患）
Jwts.builder()
    .

signWith(SignatureAlgorithm.HS256, rsaPrivateKey) // 运行时才会报错！
    .

compact();

// ✅ 新版本写法（类型安全）
Jwts.builder()
    .

signWith(rsaPrivateKey, Jwts.SIG.RS256) // 编译期检查
    .

compact();

package com.example.auth.core.config.properties;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

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

	/**
	 * 签发者标识 (Issuer)
	 */
	private String issuer = "auth-service";

	/**
	 * Access Token 有效期（分钟）
	 */
	private Integer accessTokenExpireMinutes = 15;

	/**
	 * 时钟偏差容忍度（秒）
	 */
	private Long clockSkewSeconds = 30L;

	/**
	 * 公钥资源路径
	 */
	private String publicKeyResource = "certs/public_key.pem";

	/**
	 * 私钥资源路径
	 */
	private String privateKeyResource = "certs/private_key.pem";
}

package com.example.auth.core.util;

import cn.hutool.core.util.IdUtil;
import com.example.auth.common.util.crypto.RsaKeyManager;
import com.example.auth.core.config.properties.JwtProperties;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.JwtException;
import io.jsonwebtoken.Jwts;
import jakarta.annotation.PostConstruct;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import java.security.PrivateKey;
import java.security.PublicKey;
import java.util.Date;
import java.util.Map;

@Slf4j
@Component
@RequiredArgsConstructor
public class JwtUtil {

	private final JwtProperties jwtProperties;
	private final RsaKeyManager rsaKeyManager;

	// 缓存解析后的密钥对象，避免每次请求重复解析
	private PrivateKey privateKey;
	private PublicKey publicKey;


	/**
	 * 初始化阶段：加载密钥
	 */
	@PostConstruct
	public void init() throws Exception {
		// 读取加载公钥和私钥内容
		String privateKeyContent = rsaKeyManager.readResourceFile(jwtProperties.getPrivateKeyResource());
		this.privateKey = rsaKeyManager.loadPrivateKey(privateKeyContent);
		String publicKeyContent = rsaKeyManager.readResourceFile(jwtProperties.getPublicKeyResource());
		this.publicKey = rsaKeyManager.loadPublicKey(publicKeyContent);
		log.info("JWT 密钥加载完成。");
	}

	/**
	 * 创建 Token
	 * @param userId 用户 ID
	 * @param username 用户名
	 * @param extraClaims 额外的自定义声明
	 * @return 生成的 JWT 字符串
	 */
	public String createToken(Long userId, String username, Map<String, Object> extraClaims) {
		long nowMillis = System.currentTimeMillis();
		Date now = new Date(nowMillis);

		// 计算过期时间
		Date expiration = new Date(nowMillis + jwtProperties.getAccessTokenExpireMinutes() * 60 * 1000L);
		// 生成 JTI（用于后续的黑名单功能）
		String jti = IdUtil.fastSimpleUUID();
		JwtBuilder builder = Jwts.builder()
				.header().type("JWT").and() // 设置头部
				.issuer(jwtProperties.getIssuer()) // 签发者
				.subject(userId.toString()) // 主题（用户 ID）
				.issuedAt(now) // 签发时间
				.expiration(expiration) // 过期时间
				.id(jti) // JWT ID
				.claim("username", username) // 自定义声明：用户名
				.claim("userId", userId); // 自定义声明：用户 ID
		// 添加额外的载荷
		if (extraClaims != null && !extraClaims.isEmpty()) {
			builder.claims().add(extraClaims);
		}
		// 使用 RSA 私钥 + RS256 算法签名
		return builder.signWith(privateKey, Jwts.SIG.RS256).compact();
	}

	/**
	 * 解析并验证 Token
	 * @param token JWT 字符串
	 * @return 解析后的 Claims 对象
	 */
	public Claims parseToken(String token) {
		return Jwts.parser()
				.verifyWith(publicKey)
				.clockSkewSeconds(jwtProperties.getClockSkewSeconds())
				.build()
				.parseSignedClaims(token)
				.getPayload();
	}

	/**
	 * 快速验证方法
	 * @param token JWT 字符串
	 * @return boolean 验证结果
	 */
	public boolean validateToken(String token) {
		try {
			parseToken(token);
			return true;
		} catch (JwtException | IllegalArgumentException e) {
			log.debug("Token验证失败: {}", e.getMessage());
			return false;
		}
	}

	/**
	 * 从 Token 中提取用户 ID
	 * @param token JWT 字符串
	 * @return 用户 ID
	 */
	public Long getUserIdFromToken(String token) {
		try {
			Claims claims = parseToken(token);
			return Long.parseLong(claims.getSubject());
		} catch (Exception e) {
			log.warn("从Token中提取用户ID失败: {}", e.getMessage());
			return null;
		}
	}

	/**
	 * 从 Token 中提取用户名
	 * @param token JWT 字符串
	 * @return 用户名
	 */
	public String getUsernameFromToken(String token) {
		try {
			Claims claims = parseToken(token);
			return claims.get("username", String.class);
		} catch (Exception e) {
			log.warn("从Token中提取用户名失败: {}", e.getMessage());
			return null;
		}
	}

	/**
	 * 从 Token 中提取 JTI
	 * @param token JWT 字符串
	 * @return JTI
	 */
	public String getJtiFromToken(String token) {
		try {
			Claims claims = parseToken(token);
			return claims.getId();
		} catch (Exception e) {
			log.warn("从Token中提取JTI失败: {}", e.getMessage());
			return null;
		}
	}
}