public class GenSecretKeyTest {

    @Test
    public void genSecretKey() throws Exception{
        //自定义 随机密码,  请修改这里
        String password = "dawnstar";

        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        SecureRandom secureRandom = new SecureRandom(password.getBytes());
        keyPairGenerator.initialize(1024, secureRandom);
        KeyPair keyPair = keyPairGenerator.genKeyPair();
        // 获取公钥和私钥的字节数组
        byte[] publicKeyBytes = keyPair.getPublic().getEncoded();
        byte[] privateKeyBytes = keyPair.getPrivate().getEncoded();

        // 将字节数组编码为Base64字符串
        String publicKeyBase64 = Base64.getEncoder().encodeToString(publicKeyBytes);
        String privateKeyBase64 = Base64.getEncoder().encodeToString(privateKeyBytes);

        // 构建PEM格式字符串
        String publicKeyPem = "-----BEGIN PUBLIC KEY-----\n" +
                insertLineBreaks(publicKeyBase64, 64) +
                "\n-----END PUBLIC KEY-----\n";

        String privateKeyPem = "-----BEGIN PRIVATE KEY-----\n" +
                insertLineBreaks(privateKeyBase64, 64) +
                "\n-----END PRIVATE KEY-----\n";

        // 定义文件路径
        Path publicKeyPath = Paths.get("d:\\test\\pub.pem");
        Path privateKeyPath = Paths.get("d:\\test\\pri.pem");

        // 将PEM格式的密钥写入文件
        Files.write(publicKeyPath, publicKeyPem.getBytes());
        Files.write(privateKeyPath, privateKeyPem.getBytes());

        System.out.println("PEM格式的密钥生成并保存成功！");
    }
    /**
     * 将长字符串每隔指定长度插入换行符，提高PEM文件的可读性
     *
     * @param input  输入字符串
     * @param length 每行长度
     * @return 带有换行符的字符串
     */
    private String insertLineBreaks(String input, int length) {
        StringBuilder sb = new StringBuilder();
        int index = 0;
        while (index < input.length()) {
            sb.append(input, index, Math.min(index + length, input.length()));
            sb.append("\n");
            index += length;
        }
        return sb.toString().trim();
    }
}

public class JwtUtil {

    private static final String KEY = "dawnstar";

    //接收业务数据,生成token并返回
    public static String genToken(Map<String, Object> claims) {
        return JWT.create()
                .withClaim("claims", claims)
                .withExpiresAt(new Date(System.currentTimeMillis() + 1000 * 60 * 60 * 24)) // 24小时过期
//                .withExpiresAt(new Date(System.currentTimeMillis() + 1000 * 60)) // 1分钟过期，用于测试
                .sign(Algorithm.HMAC256(KEY));
    }

    //接收token,验证token,并返回业务数据
    public static Map<String, Object> parseToken(String token) {
        return JWT.require(Algorithm.HMAC256(KEY))
                .build()
                .verify(token)
                .getClaim("claims")
                .asMap();
    }

}

@Service
public class JwtService implements InitializingBean {

    private static final Logger logger = LoggerFactory.getLogger(JwtService.class);
	// 私钥
    private PrivateKey privateKey;
	// JWT解析器
    private JwtParser jwtParser;
	// 创建JWT,使用私钥对 JWT 进行签名
    // expiredAt：应确保传入的过期时间合理，以防 JWT 过早失效或长时间有效，增加安全风险。
	// jwtPayload：负载部分可以包含用户信息、权限等，但应避免存储敏感信息，因为虽然签名保证了完整性，但负载部分是可解码的。
    public String createJwt(Object jwtPayload, long expiredAt) {
        // 添加构成JWT的参数
        // 构建JWT头部，alg签名算法，typ固定JWT
        Map<String, Object> headMap = new HashMap<>();
        headMap.put("alg", SignatureAlgorithm.RS256.getValue());//使用RS256签名算法
        headMap.put("typ", "JWT");
        // 构建JWT负载，body
        Map body = JSONUtil.parse(JSONUtil.stringify(jwtPayload), HashMap.class);
        // 构建JWT
        String jwt = Jwts.builder()
                .setHeader(headMap)
                .setClaims(body)
                .setExpiration(new Date(expiredAt))
                .signWith(privateKey)
                .compact();
        // 返回生成的 JWT 字符串
        return jwt;
    }
	// 私钥的 Base64 编码字符串
    @Value("${login.jwt.private-key}")
    private String privateKeyBase64;
    //获取私钥，用于生成Jwt
    private PrivateKey getPrivateKey() {
        try {
            // 利用JDK自带的工具生成私钥
            KeyFactory kf = KeyFactory.getInstance("RSA");
            // 解码Base64私钥为字节数组，构建 PKCS8EncodedKeySpec
            PKCS8EncodedKeySpec ks = new PKCS8EncodedKeySpec(Decoders.BASE64.decode(privateKeyBase64));
            // 返回生成的 PrivateKey 对象，用于 JWT 的签名操作
            return kf.generatePrivate(ks);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            throw new BusinessException( "获取Jwt私钥失败");
        }
    }
	// 公钥的 Base64 编码字符串
    @Value("${login.jwt.public-key}")
    private String publicKeyBase64;
    // 获取 JwtParser，公钥用于验证签名，确保JWT没有被纂改
    private JwtParser getJwtParser() {
        try {
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(Decoders.BASE64.decode(publicKeyBase64));
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            PublicKey pk = keyFactory.generatePublic(keySpec);
            return Jwts.parserBuilder().setSigningKey(pk).build();
        } catch (Exception e) {
            // 获取公钥失败
            throw new BusinessException("获取Jwt公钥失败");
        }
    }
	// 初始化方法
    @Override
    public void afterPropertiesSet() throws Exception {
        // 调用 getPrivateKey 方法将 Base64 编码的私钥字符串转换为 PrivateKey 对象。
        // 私钥生成数字签名
        privateKey = getPrivateKey();
        // 调用 getJwtParser 方法将 Base64 编码的公钥字符串转换为 JwtParser 对象，用于后续的 JWT 验证。
        // 公钥验证数字签名
        jwtParser = getJwtParser();
    }
	// 验证JWT
    public <T> T verifyJwt(String jwt, Class<T> jwtPayloadClass) {
        // 为空，返回null，表示无效的JWT
        if (jwt == null || jwt.isEmpty()) {
            return null;
        }
        // 签名验证，过期时间验证
        Jws<Claims> jws = this.jwtParser.parseClaimsJws(jwt); 
        // 获取JWT负载
        Claims jwtPayload = jws.getBody();
        if (jwtPayload == null) {
            return null;
        }
        // 负载转换
        return JSONUtil.convert(jwtPayload, jwtPayloadClass);
    }
	// 提取 JWT 负载
    public static <T> T getPayload(String jwt, Class<T> jwtPayloadClass) {
        if (jwt == null || jwt.isEmpty()) {
            return null;
        }
        try {
            // jwt字符串由3部分组成，用英文的点分割：herder.payload.sign
            // 可以直接取中间一段，进行Base64解码
            byte[] decodedBytes = Base64.getDecoder().decode(jwt.split("\\.")[1]);
            return JSONUtil.parse(new String(decodedBytes), jwtPayloadClass);
        } catch (Exception e) {
            return null;
        }
    }
}