<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>4.1.0</version>
</parent>
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-cache</artifactId>
    </dependency>
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-pool2</artifactId>
    </dependency>
</dependencies>

spring:
  data:
    redis:
      host: 127.0.0.1
      port: 6379
      password: 
      lettuce:
        pool:
          max-active: 16
          max-idle: 8
          min-idle: 2
          max-wait: 3000ms
  cache:
    type: redis
    redis:
      time-to-live: 30m
      cache-null-values: false

@Configuration
@EnableCaching
public class RedisConfig {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new GenericJacksonJsonRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(new GenericJacksonJsonRedisSerializer());
        template.afterPropertiesSet();
        return template;
    }
}

@Configuration
@EnableRedisListeners
public class RedisListenerConfig {
    @Bean
    public RedisMessageListenerContainer redisMessageListenerContainer(
            RedisConnectionFactory connectionFactory) {
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(connectionFactory);
        return container;
    }
}

@Service
public class OrderNotifyService {
    private final RedisMessageSendingTemplate<String, String> sendingTemplate;
    public OrderNotifyService(RedisMessageSendingTemplate<String, String> sendingTemplate) {
        this.sendingTemplate = sendingTemplate;
    }
    public void notifyOrderPaid(Long orderId) {
        String payload = "{\"orderId\":" + orderId + ",\"status\":\"PAID\"}";
        sendingTemplate.convertAndSend("order-notify", payload);
    }
}

@Component
public class OrderNotifyListener {
    private static final Logger log = LoggerFactory.getLogger(OrderNotifyListener.class);
    @RedisListener(topic = "order-notify")
    public void onOrderPaid(String message) {
        log.info("收到訂單通知: {}", message);
        // 這里寫你的業(yè)務(wù)邏輯，比如更新本地狀態(tài)、發(fā)站內(nèi)信等
    }
}

@Service
public class CouponService {
    private final StringRedisTemplate stringRedisTemplate;
    public CouponService(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }
    /**
     * 只有券狀態(tài)為 AVAILABLE 時(shí)，才改成 CLAIMED
     */
    public boolean claimCoupon(String couponId, String userId) {
        String key = "coupon:" + couponId;
        Boolean success = stringRedisTemplate.opsForValue()
                .setIfPresent(key, "CLAIMED:" + userId,
                        Duration.ofHours(24));
        return Boolean.TRUE.equals(success);
    }
    /**
     * 只有值匹配時(shí)才刪除（用于 token 失效場(chǎng)景）
     */
    public boolean invalidateToken(String token) {
        String key = "token:" + token;
        return Boolean.TRUE.equals(
                stringRedisTemplate.delete(key, token));
    }
}

@Service
public class FileDigestService {
    private final RedisTemplate<String, String> redisTemplate;
    public FileDigestService(RedisTemplate<String, String> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }
    public String computeDigest(String content) {
        // 調(diào)用 Redis 8 DIGEST 命令，服務(wù)端計(jì)算 XXH3 哈希
        return redisTemplate.execute((RedisCallback<String>) connection ->
                connection.digest(content.getBytes(StandardCharsets.UTF_8)));
    }
    public boolean isDuplicate(String content) {
        String digest = computeDigest(content);
        String key = "file:digest:" + digest;
        Boolean isNew = redisTemplate.opsForValue()
                .setIfAbsent(key, "1", Duration.ofDays(7));
        return !Boolean.TRUE.equals(isNew); // true 表示重復(fù)文件
    }
}

// 舊寫法（已標(biāo)記過(guò)時(shí)）
// redisTemplate.expire("user:1001", 30, TimeUnit.MINUTES);
// 新寫法（推薦）
redisTemplate.expire("user:1001", Duration.ofMinutes(30));
// 帶過(guò)期條件的 SET
redisTemplate.opsForValue().set("session:abc", userInfo,
        Expiration.from(Duration.ofHours(2)));

@RestController
@RequestMapping("/admin/cache")
public class CacheAdminController {
    private final CacheManager cacheManager;
    public CacheAdminController(CacheManager cacheManager) {
        this.cacheManager = cacheManager;
    }
    @PostMapping("/reset")
    public String resetAllCaches() {
        if (cacheManager instanceof RedisCacheManager redisCacheManager) {
            redisCacheManager.resetCaches();
            return "緩存已重置";
        }
        return "當(dāng)前 CacheManager 不支持 resetCaches";
    }
}

@Service
public class ProductService {
    @Cacheable(value = "product", key = "#id")
    public Product getById(Long id) {
        return productMapper.selectById(id);
    }
    @CacheEvict(value = "product", key = "#product.id")
    public void update(Product product) {
        productMapper.updateById(product);
    }
}

spring:
  data:
    redis:
      timeout: 3s
      connect-timeout: 3s
      lettuce:
        pool:
          max-active: 32
          max-idle: 16
          min-idle: 4
        shutdown-timeout: 200ms