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);
	}
}

package com.example.auth.web.controller;

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

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

/**
 * 认证控制器
 * <p>
 * 设计理念：Controller 只注入一个"大管家" AuthService，
 * 不需要关心底层的 TokenRedisManager 等实现细节。
 * </p>
 */
@Slf4j
@RestController
@RequestMapping("/auth")
@RequiredArgsConstructor
public class AuthController {

	// ✅ 只注入一个 Facade 服务
	private final AuthService authService;

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

	/**
	 * 刷新令牌接口
	 */
	@PostMapping("/refresh")
	public Result<AuthToken> refresh(@RequestParam String refreshToken) {
		log.info("收到刷新令牌请求");
		try {
			AuthToken authToken = authService.refresh(refreshToken);
			return Result.ok(authToken);
		} catch (Exception e) {
			log.error("刷新令牌失败", e);
			return Result.fail(401, e.getMessage());
		}
	}

	/**
	 * 验证令牌接口
	 */
	@GetMapping("/validate")
	public Result<Map<String, Object>> validate(@RequestHeader("Authorization") String authHeader) {
		log.info("收到验证令牌请求");
		String token = extractToken(authHeader);
		boolean valid = authService.isTokenValid(token);
		Map<String, Object> data = new HashMap<>();
		data.put("valid", valid);
		return Result.ok(data);
	}

	private String extractToken(String authHeader) {
		if (authHeader != null && authHeader.startsWith("Bearer ")) {
			return authHeader.substring(7);
		}
		return authHeader;
	}
}