notify-keyspace-events Ex  # E表示啟用鍵事件通知，x表示過期事件

<dependencies>
    <!-- Spring Boot Redis Starter -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    
    <!-- Lettuce連接池（默認(rèn)使用Lettuce，比Jedis更輕量） -->
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-pool2</artifactId>
    </dependency>
    
    <!-- Lombok簡化代碼 -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

spring:
  redis:
    host: localhost          # Redis服務(wù)器地址
    port: 6379               # 端口號（默認(rèn)6379）
    password: 123456         # 密碼（無密碼則忽略）
    database: 0              # 使用數(shù)據(jù)庫0（默認(rèn)）
    lettuce:                 # Lettuce連接池配置
      pool:
        max-active: 8        # 最大連接數(shù)
        max-idle: 8          # 最大空閑連接
        min-idle: 0          # 最小空閑連接
        max-wait: 10000ms    # 連接池最大等待時間
    
    # 序列化配置（默認(rèn)JDK序列化，推薦JSON）
    redis:
      serializer:
        key: org.springframework.data.redis.serializer.StringRedisSerializer
        value: org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer

@SpringBootTest
@Slf4j
public class RedisConfigTest {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Test
    public void testRedisConnection() {
        String key = "test_key";
        String value = "test_value";
        
        // 寫入Redis
        redisTemplate.opsForValue().set(key, value);
        // 讀取Redis
        String result = (String) redisTemplate.opsForValue().get(key);
        log.info("Redis測試結(jié)果：{}", result);  // 應(yīng)輸出"test_value"
    }
}

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Order {
    private Long id;                // 訂單ID
    private String userId;          // 用戶ID
    private BigDecimal amount;      // 訂單金額
    private LocalDateTime createTime; // 創(chuàng)建時間
    private LocalDateTime expireTime; // 過期時間（用于展示）
    private String status;          // 訂單狀態(tài)（待支付/已支付/已取消）
}

@Service
@Slf4j
public class OrderService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Autowired
    private OrderRepository orderRepository;  // 數(shù)據(jù)庫操作（假設(shè)使用JPA）
    
    // 訂單有效時長（30分鐘，單位：秒）
    private static final long ORDER_EXPIRE_SECONDS = 30 * 60;

    /**
     * 創(chuàng)建訂單（同步數(shù)據(jù)庫與Redis）
     */
    @Transactional
    public Order createOrder(Order order) {
        // 1. 保存訂單到數(shù)據(jù)庫
        order.setStatus("待支付");
        order.setCreateTime(LocalDateTime.now());
        order.setExpireTime(order.getCreateTime().plusMinutes(30));
        Order savedOrder = orderRepository.save(order);
        
        // 2. 存儲訂單到Redis并設(shè)置過期時間
        String redisKey = "order:" + savedOrder.getId();
        redisTemplate.opsForHash().putAll(redisKey, new HashMap<String, Object>() {{
            put("id", savedOrder.getId());
            put("userId", savedOrder.getUserId());
            put("amount", savedOrder.getAmount());
            put("status", savedOrder.getStatus());
            put("createTime", savedOrder.getCreateTime().toString());
        }});
        // 設(shè)置鍵的過期時間（30分鐘）
        redisTemplate.expire(redisKey, ORDER_EXPIRE_SECONDS, TimeUnit.SECONDS);
        
        return savedOrder;
    }

    /**
     * 支付成功后刪除Redis訂單（避免觸發(fā)過期事件）
     */
    @Transactional
    public void payOrder(Long orderId) {
        // 1. 更新數(shù)據(jù)庫訂單狀態(tài)為已支付
        Order order = orderRepository.findById(orderId)
                .orElseThrow(() -> new RuntimeException("訂單不存在"));
        order.setStatus("已支付");
        orderRepository.save(order);
        
        // 2. 從Redis刪除該訂單（避免過期事件觸發(fā)取消邏輯）
        String redisKey = "order:" + orderId;
        redisTemplate.delete(redisKey);
    }
}

@Component
@Slf4j
public class RedisOrderExpiredListener {

    @Autowired
    private OrderService orderService;  // 假設(shè)包含取消訂單和釋放庫存的方法
    
    @Autowired
    private RedisConnectionFactory redisConnectionFactory;

    @PostConstruct
    public void init() {
        // 創(chuàng)建Redis消息監(jiān)聽容器
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(redisConnectionFactory);
        
        // 訂閱過期事件（頻道格式：__keyevent@0__:expired）
        container.addMessageListener(this::handleOrderExpired, 
                new PatternTopic("__keyevent@0__:expired"));
    }

    /**
     * 處理訂單過期事件
     */
    private void handleOrderExpired(Message message, byte[] pattern) {
        // 1. 解析過期的鍵名（格式：order:10001）
        String expiredKey = new String(message.getBody(), StandardCharsets.UTF_8);
        if (!expiredKey.startsWith("order:")) {
            log.warn("非訂單鍵過期，跳過處理：{}", expiredKey);
            return;
        }
        
        // 2. 提取訂單ID（去除前綴"order:"）
        String orderIdStr = expiredKey.substring("order:".length());
        Long orderId;
        try {
            orderId = Long.parseLong(orderIdStr);
        } catch (NumberFormatException e) {
            log.error("訂單ID格式錯誤，鍵：{}", expiredKey, e);
            return;
        }
        
        // 3. 查詢數(shù)據(jù)庫確認(rèn)訂單狀態(tài)（避免Redis數(shù)據(jù)與數(shù)據(jù)庫不一致）
        Order order = orderService.getOrderById(orderId);
        if (order == null || !"待支付".equals(order.getStatus())) {
            log.info("訂單已處理或不存在，無需取消：{}", orderId);
            return;
        }
        
        // 4. 執(zhí)行訂單取消邏輯（冪等性設(shè)計，避免重復(fù)處理）
        try {
            orderService.cancelOrder(orderId);
            log.info("訂單超時自動取消成功，orderId={}", orderId);
        } catch (Exception e) {
            log.error("訂單取消失敗，orderId={}", orderId, e);
            // 可重試或人工介入
        }
    }
}

@Service
@Slf4j
public class OrderService {

    // ...（其他方法）

    /**
     * 取消訂單（釋放庫存、更新狀態(tài)）
     */
    @Transactional
    public void cancelOrder(Long orderId) {
        Order order = orderRepository.findById(orderId)
                .orElseThrow(() -> new RuntimeException("訂單不存在"));
        
        // 冪等性校驗（避免重復(fù)取消）
        if (!"待支付".equals(order.getStatus())) {
            log.info("訂單已取消或已支付，無需重復(fù)操作：{}", orderId);
            return;
        }
        
        // 1. 更新訂單狀態(tài)為已取消
        order.setStatus("已取消");
        orderRepository.save(order);
        
        // 2. 釋放庫存（調(diào)用庫存服務(wù)）
        stockService.releaseStock(order.getUserId(), order.getAmount());
    }
}

@Service
@Slf4j
public class StockService {

    /**
     * 釋放庫存（示例方法）
     */
    public void releaseStock(String userId, BigDecimal amount) {
        log.info("釋放用戶{}的庫存，金額：{}", userId, amount);
        // 實際邏輯：調(diào)用庫存微服務(wù)API或操作庫存數(shù)據(jù)庫
    }
}

/**
 * 查詢訂單（同時校驗是否超時）
 */
public Order getOrderById(Long orderId) {
    Order order = orderRepository.findById(orderId).orElse(null);
    if (order != null && "待支付".equals(order.getStatus())) {
        // 校驗是否超時（數(shù)據(jù)庫時間與當(dāng)前時間比較）
        LocalDateTime now = LocalDateTime.now();
        if (now.isAfter(order.getExpireTime())) {
            // 觸發(fā)取消邏輯（避免Redis未及時刪除）
            cancelOrder(orderId);
            return null;  // 返回null表示訂單已取消
        }
    }
    return order;
}

@Bean
public RedisMessageListenerContainer redisMessageListenerContainer(RedisConnectionFactory connectionFactory) {
    RedisMessageListenerContainer container = new RedisMessageListenerContainer();
    container.setConnectionFactory(connectionFactory);
    // 配置線程池（核心線程數(shù)、最大線程數(shù)）
    container.setTaskExecutor(Executors.newFixedThreadPool(10));
    return container;
}

@Service
@Slf4j
public class OrderService {

    @Autowired
    private StockService stockService;

    @Async("asyncTaskExecutor")  // 使用自定義線程池
    public void releaseStock(Long userId, BigDecimal amount) {
        stockService.releaseStock(userId, amount);
    }
}

@Configuration
@EnableAsync
public class AsyncConfig {

    @Bean("asyncTaskExecutor")
    public Executor asyncTaskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);      // 核心線程數(shù)
        executor.setMaxPoolSize(20);      // 最大線程數(shù)
        executor.setQueueCapacity(100);   // 隊列容量
        executor.setKeepAliveSeconds(30); // 空閑線程存活時間
        executor.setThreadNamePrefix("order-async-");
        executor.initialize();
        return executor;
    }
}

// Redisson配置
@Bean
public RedissonClient redissonClient() {
    Config config = new Config();
    config.useSingleServer().setAddress("redis://localhost:6379");
    return Redisson.create(config);
}

// 使用延遲隊列
@Service
@Slf4j
public class RedissonDelayedQueueService {

    @Autowired
    private RedissonClient redissonClient;

    private RDelayedQueue<Order> delayedQueue;
    private RBlockingQueue<Order> blockingQueue;

    @PostConstruct
    public void init() {
        blockingQueue = redissonClient.getBlockingQueue("orderDelayedQueue");
        delayedQueue = redissonClient.getDelayedQueue(blockingQueue);
    }

    /**
     * 添加延遲訂單（30分鐘后觸發(fā)）
     */
    public void addDelayedOrder(Order order) {
        delayedQueue.offer(order, 30, TimeUnit.MINUTES);
    }

    /**
     * 處理延遲訂單（阻塞獲?。?
     */
    public void processDelayedOrders() {
        while (true) {
            try {
                Order order = blockingQueue.take();  // 阻塞直到有訂單到期
                log.info("處理延遲訂單：{}", order.getId());
                // 執(zhí)行取消邏輯...
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                break;
            }
        }
    }
}