package com.example.auth.common.model;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Result<T> implements Serializable {
	// 响应码（200 表示成功）
	private Integer code;
	// 响应消息
	private String message;
	// 响应数据（泛型）
	private T data;

	// 成功响应（带数据）
	public static <T> Result<T> ok(T data) {
		return new Result<>(200, "操作成功", data);
	}

	// 成功响应（不带数据）
	public static <T> Result<T> ok() {
		return new Result<>(200, "操作成功", null);
	}

	// 失败响应
	public static <T> Result<T> fail(Integer code, String message) {
		return new Result<>(code, message, null);
	}

	// 失败响应（默认 500 错误码）
	public static <T> Result<T> fail(String message) {
		return new Result<>(500, message, null);
	}
}

@PostMapping("/login")
public Result<AuthToken> login() {
	AuthToken token = new AuthToken("token123", "refresh456");
	return Result.ok(token);
}

@GetMapping("/user")
public Result<User> getUser() {
	User user = new User(1001L, "admin");
	return Result.ok(user);
}

package com.example.auth.common.util;

import cn.hutool.core.lang.Snowflake;
import cn.hutool.core.util.IdUtil;

public class SnowflakeIdGenerator {

	// workerId = 1, datacenterId = 1
	private static final Snowflake SNOWFLAKE = IdUtil.getSnowflake(1, 1);

	public static Long nextId() {
		return SNOWFLAKE.nextId();
	}
}

package com.example.auth.core.util.crypto;


import org.springframework.core.io.ClassPathResource;
import org.springframework.stereotype.Component;
import org.springframework.util.FileCopyUtils;

import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
import java.security.KeyFactory;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;

@Component
public class RsaKeyManager {

	// 从 resources 目录读取文件
	public String readResourceFile(String resourcePath) throws Exception {
		ClassPathResource resource = new ClassPathResource(resourcePath);
		try (InputStreamReader reader = new InputStreamReader(
				resource.getInputStream(), StandardCharsets.UTF_8)) {
			return FileCopyUtils.copyToString(reader);
		}
	}

	// 加载私钥
	public PrivateKey loadPrivateKey(String privateKeyPem) throws Exception {
		// 清理 PEM 格式的头尾标记
		String content = privateKeyPem
				.replace("-----BEGIN PRIVATE KEY-----", "")
				.replace("-----END PRIVATE KEY-----", "")
				.replace("-----BEGIN RSA PRIVATE KEY-----", "")
				.replace("-----END RSA PRIVATE KEY-----", "")
				.replaceAll("\\s", "");

		// Base64 解码
		byte[] keyBytes = Base64.getDecoder().decode(content);

		// 使用 PKCS8 规范解析私钥
		PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance("RSA");
		return keyFactory.generatePrivate(keySpec);
	}

	// 加载公钥
	public PublicKey loadPublicKey(String publicKeyPem) throws Exception {
		String content = publicKeyPem
				.replace("-----BEGIN PUBLIC KEY-----", "")
				.replace("-----END PUBLIC KEY-----", "")
				.replaceAll("\\s", "");

		byte[] keyBytes = Base64.getDecoder().decode(content);

		// 使用 X509 规范解析公钥
		X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance("RSA");
		return keyFactory.generatePublic(keySpec);
	}
}

// ❌ 旧版本写法（存在隐患）
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;
		}
	}
}

package com.example.auth.core.service;

import com.example.auth.core.util.JwtUtil;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

@Slf4j
@Service
@RequiredArgsConstructor
public class TokenService {

	private final JwtUtil jwtUtil;

	/**
	 * 创建令牌（单令牌版本）
	 */
	public String createToken(Long userId, String username) {
		log.info("开始创建令牌: userId={}, username={}", userId, username);
		String token = jwtUtil.createToken(userId, username, null);
		log.info("令牌创建成功: userId={}", userId);
		return token;
	}

	/**
	 * 验证令牌是否有效
	 */
	public boolean validateToken(String token) {
		return jwtUtil.validateToken(token);
	}
}

package com.example.auth.web.controller;

import com.example.auth.common.model.Result;
import com.example.auth.core.service.TokenService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;
import java.util.Map;

@Slf4j
@RestController
@RequestMapping("/auth")
@RequiredArgsConstructor
public class AuthController {

	private final TokenService tokenService;

	/**
	 * 单令牌登录接口
	 */
	@PostMapping("/login")
	public Result<Map<String, Object>> login(@RequestParam Long userId,
	                                         @RequestParam String username) {
		log.info("收到登录请求: userId={}, username={}", userId, username);

		String token = tokenService.createToken(userId, username);

		Map<String, Object> data = new HashMap<>();
		data.put("token", token);
		data.put("tokenType", "Bearer");

		return Result.ok(data);
	}

	/**
	 * 验证令牌接口
	 */
	@GetMapping("/validate")
	public Result<Map<String, Object>> validate(@RequestHeader("Authorization") String token) {
		log.info("收到验证令牌请求");

		if (token.startsWith("Bearer ")) {
			token = token.substring(7);
		}

		boolean valid = tokenService.validateToken(token);

		Map<String, Object> data = new HashMap<>();
		data.put("valid", valid);

		return Result.ok(data);
	}
}

package com.example.auth.web;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication(scanBasePackages = "com.example.auth")
public class AuthApplication {

	public static void main(String[] args) {
		SpringApplication.run(AuthApplication.class, args);
	}
}

// 存储 Refresh Token（7 天过期）
redisTemplate.opsForValue().

set(
    "auth:token:refresh:abc123",  // Key
		    "1001",                        // Value（用户 ID）
		    7,                             // 过期时间
    TimeUnit.DAYS                  // 时间单位
);

// 获取 Refresh Token 对应的用户 ID
String userId = redisTemplate.opsForValue().get("auth:token:refresh:abc123");

// 检查 Token 是否在黑名单中
Boolean isBlacklisted = redisTemplate.hasKey("auth:token:black:jti123");

// 记录登录失败次数
Long failCount = redisTemplate.opsForValue().increment("auth:login:fail:admin");
if(failCount ==1){
		// 第一次失败，设置 15 分钟过期
		redisTemplate.

expire("auth:login:fail:admin",15,TimeUnit.MINUTES);
}

// 记录用户的在线设备
redisTemplate.opsForSet().

add("auth:user:tokens:1001","jti123");

// 获取用户的所有在线设备
Set<String> devices = redisTemplate.opsForSet().members("auth:user:tokens:1001");

// 检查某个设备是否在线
Boolean isOnline = redisTemplate.opsForSet().isMember("auth:user:tokens:1001", "jti123");

// 用户注销，移除设备
redisTemplate.

opsForSet().

remove("auth:user:tokens:1001","jti123");

// 获取在线设备数量
Long deviceCount = redisTemplate.opsForSet().size("auth:user:tokens:1001");

// 第 1 次网络请求
redisTemplate.opsForValue().

set("auth:token:refresh:abc123","1001",7,TimeUnit.DAYS);

// 第 2 次网络请求
redisTemplate.

opsForSet().

add("auth:user:tokens:1001","jti123");

// 第 3 次网络请求
redisTemplate.

expire("auth:user:tokens:1001",7,TimeUnit.DAYS);

redisTemplate.executePipelined((RedisCallback<Object>) connection ->{

		// 操作 1：存储 Refresh Token
		connection.

stringCommands().

setEx(
        "auth:token:refresh:abc123".getBytes(),
        7*86400,  // 7 天（秒）
		        "1001".

getBytes()
    );

		    // 操作 2：记录在线设备
		    connection.

setCommands().

sAdd(
        "auth:user:tokens:1001".getBytes(),
        "jti123".

getBytes()
    );

		    // 操作 3：设置过期时间
		    connection.

keyCommands().

expire(
        "auth:user:tokens:1001".getBytes(),
        7*86400  // 7 天（秒）
		        );

		        return null;
		        });

package com.example.auth.core.constant;

public class RedisKeyConstants {

	/**
	 * 刷新令牌映射 Key 前缀
	 */
	public static final String TOKEN_REFRESH_PREFIX = "auth:token:refresh:";

	/**
	 * 用户在线设备索引 Key 前缀
	 */
	public static final String USER_ONLINE_TOKENS_PREFIX = "auth:user:tokens:";

	/**
	 * 构建刷新令牌 Key
	 */
	public static String buildRefreshTokenKey(String refreshToken) {
		return TOKEN_REFRESH_PREFIX + refreshToken;
	}

	/**
	 * 构建用户在线设备 Key
	 */
	public static String buildUserOnlineKey(Long userId) {
		return USER_ONLINE_TOKENS_PREFIX + userId;
	}
}

package com.example.auth.core.model;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class AuthToken implements Serializable {

	/**
	 * 访问令牌（短效，JWT）
	 */
	private String accessToken;

	/**
	 * 刷新令牌（长效，随机串）
	 */
	private String refreshToken;

	/**
	 * Access Token 剩余有效期（秒）
	 */
	private Long expiresIn;

	/**
	 * 令牌类型
	 */
	@Builder.Default
	private String tokenType = "Bearer";
}

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 {

	// ...之前的内容

	/**
	 * Refresh Token 有效期（天）
	 */
	private Integer refreshTokenExpireDays = 7;
}

package com.example.auth.core.manager;

import com.example.auth.core.constant.RedisKeyConstants;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import java.util.Set;

/**
 * Token Redis 管理器（基础设施层）
 * <p>
 * 职责：只负责 Token 在 Redis 中的 CRUD 操作，不包含业务逻辑判断。
 * 这是一个"底层苦力"，只有存取方法，没有复杂的 if-else。
 * </p>
 */
@Slf4j
@Component
@RequiredArgsConstructor
public class TokenRedisManager {

	private final StringRedisTemplate redisTemplate;

	/**
	 * 存储 Refresh Token（使用 Pipeline 批量操作）
	 */
	public void saveRefreshToken(Long userId, String refreshToken,
	                             String jti, long expireSeconds) {
		redisTemplate.executePipelined((RedisCallback<Object>) connection -> {

			// 1. 存储 Refresh Token (K = refreshToken, V = userId)
			String refreshKey = RedisKeyConstants.buildRefreshTokenKey(refreshToken);
			connection.stringCommands().setEx(
					refreshKey.getBytes(),
					expireSeconds,
					userId.toString().getBytes()
			);

			// 2. 记录用户的在线设备
			String userKey = RedisKeyConstants.buildUserOnlineKey(userId);
			connection.setCommands().sAdd(
					userKey.getBytes(),
					jti.getBytes()
			);

			// 3. 给设备记录也设置过期时间
			connection.keyCommands().expire(
					userKey.getBytes(),
					expireSeconds
			);

			return null;
		});

		log.debug("存储 Refresh Token 成功: userId={}, jti={}, 有效期={}秒",
				userId, jti, expireSeconds);
	}

	/**
	 * 根据 Refresh Token 获取用户 ID
	 */
	public Long getUserIdByRefreshToken(String refreshToken) {
		String key = RedisKeyConstants.buildRefreshTokenKey(refreshToken);
		String userId = redisTemplate.opsForValue().get(key);
		return userId == null ? null : Long.parseLong(userId);
	}

	/**
	 * 删除 Refresh Token
	 */
	public void deleteRefreshToken(String refreshToken) {
		String key = RedisKeyConstants.buildRefreshTokenKey(refreshToken);
		redisTemplate.delete(key);
		log.debug("删除 Refresh Token: {}", refreshToken);
	}

	/**
	 * 获取用户的所有在线设备（JTI 列表）
	 */
	public Set<String> getUserOnlineDevices(Long userId) {
		String key = RedisKeyConstants.buildUserOnlineKey(userId);
		return redisTemplate.opsForSet().members(key);
	}

	/**
	 * 从用户在线设备列表中移除指定设备
	 */
	public void removeUserDevice(Long userId, String jti) {
		String key = RedisKeyConstants.buildUserOnlineKey(userId);
		redisTemplate.opsForSet().remove(key, jti);
		log.debug("移除用户设备: userId={}, jti={}", userId, jti);
	}

	/**
	 * 清空用户的所有在线设备
	 */
	public void clearUserDevices(Long userId) {
		String key = RedisKeyConstants.buildUserOnlineKey(userId);
		redisTemplate.delete(key);
		log.debug("清空用户所有设备: userId={}", userId);
	}
}

package com.example.auth.core.service;

import cn.hutool.core.util.IdUtil;
import com.example.auth.core.config.properties.JwtProperties;
import com.example.auth.core.manager.TokenRedisManager;
import com.example.auth.core.model.AuthToken;
import com.example.auth.core.util.JwtUtil;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

/**
 * 认证服务（Facade 层 / 应用服务层）
 * <p>
 * 职责：作为"大管家"，负责编排所有认证相关的业务流程。
 * Controller 只需要注入这一个 Service，不需要关心底层的实现细节。
 * </p>
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class AuthService {

	private final JwtUtil jwtUtil;
	private final JwtProperties jwtProperties;
	private final TokenRedisManager tokenRedisManager;

	/**
	 * 登录：创建双令牌
	 */
	public AuthToken login(Long userId, String username) {
		log.info("用户登录: userId={}, username={}", userId, username);

		// 1. 生成 Access Token (JWT) - 纯内存操作
		String accessToken = jwtUtil.createToken(userId, username, null);

		// 2. 从 Access Token 中提取 JTI
		String jti = jwtUtil.getJtiFromToken(accessToken);

		// 3. 生成 Refresh Token（随机字符串）
		String refreshToken = IdUtil.fastSimpleUUID();

		// 4. 计算 Refresh Token 的过期时间（秒）
		long expireSeconds = jwtProperties.getRefreshTokenExpireDays() * 86400L;

		// 5. 将 Refresh Token 存入 Redis - IO 操作
		tokenRedisManager.saveRefreshToken(userId, refreshToken, jti, expireSeconds);

		log.info("用户登录成功: userId={}, jti={}", userId, jti);

		// 6. 打包返回
		return AuthToken.builder()
				.accessToken(accessToken)
				.refreshToken(refreshToken)
				.expiresIn((long) jwtProperties.getAccessTokenExpireMinutes() * 60)
				.build();
	}

	/**
	 * 刷新令牌：使用 Refresh Token 换取新的令牌对
	 */
	public AuthToken refresh(String oldRefreshToken) {
		log.info("刷新令牌请求");

		// 1. 验证 Refresh Token 并获取用户 ID
		Long userId = tokenRedisManager.getUserIdByRefreshToken(oldRefreshToken);

		if (userId == null) {
			log.warn("Refresh Token 无效或已过期");
			throw new RuntimeException("刷新令牌无效或已过期，请重新登录");
		}

		// 2. 查询用户信息（实际业务中应该从数据库查询）
		String username = "User-" + userId;

		// 3. 令牌轮换 - 生成一对全新的令牌
		AuthToken newTokenPair = login(userId, username);

		// 4. 立即销毁旧的 Refresh Token（防止重放攻击）
		tokenRedisManager.deleteRefreshToken(oldRefreshToken);

		log.info("令牌刷新成功: userId={}", userId);
		return newTokenPair;
	}

	/**
	 * 快速验证令牌
	 */
	public boolean isTokenValid(String token) {
		return jwtUtil.validateToken(token);
	}
}