#无状态设计模式

// 有状态：会话存储在服务器内存
public class UserController {
    private Map<String, UserSession> sessions = new ConcurrentHashMap<>();

    @PostMapping("/login")
    public User login(String username, String password) {
        User user = authenticate(username, password);
        String sessionId = UUID.randomUUID().toString();
        sessions.put(sessionId, new UserSession(user));  // 存储在内存
        return user;
    }
}

// 无状态：会话存储在 Redis
public class UserController {

    @Autowired
    private StringRedisTemplate redisTemplate;

    @PostMapping("/login")
    public LoginResponse login(String username, String password) {
        User user = authenticate(username, password);
        String token = generateToken(user);

        // 会话存储在 Redis
        String key = "session:" + token;
        redisTemplate.opsForHash().putAll(key, Map.of(
            "userId", user.getId().toString(),
            "username", user.getUsername()
        ));
        redisTemplate.expire(key, Duration.ofHours(24));

        return new LoginResponse(token, user);
    }

    @GetMapping("/userinfo")
    public User getUserInfo(@RequestHeader("Authorization") String token) {
        // 任意服务器都可以从 Redis 获取会话
        String key = "session:" + token;
        Map<Object, Object> session = redisTemplate.opsForHash().entries(key);
        if (session.isEmpty()) {
            throw new UnauthorizedException("会话已过期");
        }
        return userService.findById(Long.parseLong((String) session.get("userId")));
    }
}

// 有状态：计算中间结果存储在内存
public class ReportService {
    // 存储多步计算的中间结果
    private Map<String, ReportProgress> progressMap = new ConcurrentHashMap<>();

    public String startReport(String reportId) {
        progressMap.put(reportId, new ReportProgress());
        return reportId;
    }

    public ReportProgress continueReport(String reportId) {
        ReportProgress progress = progressMap.get(reportId);
        // 计算中间步骤
        progress.addStep(processStep(progress.getCurrentStep()));
        return progress;
    }
}

// 无状态：计算上下文存储在外部
public class ReportService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    public String startReport(String reportId) {
        // 初始化计算上下文
        String key = "report:context:" + reportId;
        redisTemplate.opsForHash().putAll(key, Map.of(
            "step", "0",
            "status", "PROCESSING"
        ));
        redisTemplate.expire(key, Duration.ofHours(1));
        return reportId;
    }

    public ReportProgress continueReport(String reportId) {
        String key = "report:context:" + reportId;
        Map<Object, Object> context = redisTemplate.opsForHash().entries(key);
        if (context.isEmpty()) {
            throw new ReportNotFoundException(reportId);
        }

        int currentStep = Integer.parseInt((String) context.get("step"));
        ReportProgress progress = new ReportProgress();
        progress.addStep(processStep(currentStep));

        // 更新计算上下文
        redisTemplate.opsForHash().put(key, "step", String.valueOf(currentStep + 1));

        return progress;
    }
}

// 有状态：文件存储在服务器本地
@PostMapping("/upload")
public String upload(MultipartFile file) {
    String path = "/data/uploads/" + file.getOriginalFilename();
    file.transferTo(new File(path));  // 存储在本地磁盘
    return path;
}

// 无状态：文件存储在对象存储
@Service
public class FileService {

    @Autowired
    private OSSClient ossClient;

    @Autowired
    private StringRedisTemplate redisTemplate;

    public String upload(MultipartFile file) {
        String objectKey = "uploads/" + UUID.randomUUID() + "/" + file.getOriginalFilename();

        // 上传到对象存储
        ossClient.putObject("bucket", objectKey, file.getInputStream());

        // 元数据存储到 Redis
        String metaKey = "file:meta:" + objectKey;
        redisTemplate.opsForHash().putAll(metaKey, Map.of(
            "filename", file.getOriginalFilename(),
            "size", String.valueOf(file.getSize()),
            "contentType", file.getContentType()
        ));
        redisTemplate.expire(metaKey, Duration.ofDays(365));

        return objectKey;
    }
}

@Configuration
@EnableRedisHttpSession(maxInactiveIntervalInSeconds = 3600)
public class SessionConfig {
    // 通过 @EnableRedisHttpSession 注解自动配置
    // 会话数据自动存储到 Redis
}

@RestController
@RequestMapping("/api")
public class UserController {

    @GetMapping("/userinfo")
    public User getUserInfo(HttpSession session) {
        // HttpSession 底层是 Redis，自动同步
        Long userId = (Long) session.getAttribute("userId");
        if (userId == null) {
            throw new UnauthorizedException("未登录");
        }
        return userService.findById(userId);
    }

    @PostMapping("/login")
    public LoginResponse login(String username, String password, HttpSession session) {
        User user = authenticate(username, password);
        // 存储到 Session（自动同步到 Redis）
        session.setAttribute("userId", user.getId());
        session.setAttribute("username", user.getUsername());
        return new LoginResponse(user);
    }

    @PostMapping("/logout")
    public void logout(HttpSession session) {
        session.invalidate();  // 从 Redis 删除
    }
}

@Service
public class ResilientOrderService {

    @Autowired
    private OrderService orderService;

    @Autowired
    private RetryTemplate retryTemplate;

    /**
     * 带重试的业务调用
     */
    public Order createOrderWithRetry(OrderRequest request, String idempotencyKey) {
        return retryTemplate.execute(context -> {
            int attempt = context.getRetryCount() + 1;
            log.info("创建订单，第 {} 次尝试: orderNo={}", attempt, request.getOrderNo());

            try {
                return orderService.createOrder(idempotencyKey, request);
            } catch (DuplicateOrderException e) {
                // 幂等异常：订单已创建，返回现有订单
                log.info("订单已存在，返回现有订单: orderNo={}", request.getOrderNo());
                return orderService.getByOrderNo(request.getOrderNo());
            } catch (Exception e) {
                // 其他异常，触发重试
                log.warn("创建订单失败，将重试: orderNo={}, attempt={}",
                    request.getOrderNo(), attempt);
                throw e;
            }
        });
    }
}

@Configuration
public class RetryConfig {

    @Bean
    public RetryTemplate retryTemplate() {
        RetryTemplate retryTemplate = new RetryTemplate();

        // 指数退避策略
        ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy();
        backOffPolicy.setInitialInterval(1000);    // 初始等待 1 秒
        backOffPolicy.setMultiplier(2.0);          // 每次翻倍
        backOffPolicy.setMaxInterval(30000);      // 最大等待 30 秒
        retryTemplate.setBackOffPolicy(backOffPolicy);

        // 重试策略
        Map<Class<? extends Throwable>, Boolean> retryableExceptions = new HashMap<>();
        retryableExceptions.put(TimeoutException.class, true);
        retryableExceptions.put(ConnectionException.class, true);
        retryableExceptions.put(DuplicateOrderException.class, false);  // 幂等异常不重试

        SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy(3, retryableExceptions);
        retryTemplate.setRetryPolicy(retryPolicy);

        return retryTemplate;
    }
}

@Service
public class CachedSessionService {

    @Autowired
    private StringRedisTemplate redisTemplate;

    // 本地缓存：Guava Cache 或 Caffeine
    private Cache<String, Map<String, Object>> localCache;

    public Map<String, Object> getSession(String sessionId) {
        String cacheKey = "session:" + sessionId;

        // 1. 先查本地缓存
        Map<String, Object> session = localCache.getIfPresent(cacheKey);
        if (session != null) {
            return session;
        }

        // 2. 本地缓存未命中，查 Redis
        session = redisTemplate.opsForHash().entries(cacheKey);
        if (session != null && !session.isEmpty()) {
            // 写入本地缓存
            localCache.put(cacheKey, session);
            return session;
        }

        return null;  // 会话不存在
    }

    public void updateSession(String sessionId, Map<String, Object> session) {
        String cacheKey = "session:" + sessionId;

        // 1. 更新 Redis（权威数据源）
        redisTemplate.opsForHash().putAll(cacheKey, session);
        redisTemplate.expire(cacheKey, Duration.ofHours(24));

        // 2. 更新本地缓存
        localCache.put(cacheKey, session);
    }

    public void invalidateSession(String sessionId) {
        String cacheKey = "session:" + sessionId;

        // 1. 删除 Redis
        redisTemplate.delete(cacheKey);

        // 2. 删除本地缓存
        localCache.invalidate(cacheKey);
    }
}