Redis 核心知識

implementation 'org.springframework.boot:spring-boot-starter-data-redis'
implementation 'org.apache.commons:commons-pool2'   // 連線池（必要）
// 若使用分散式鎖
implementation 'org.redisson:redisson-spring-boot-starter:3.25.0'

spring:
  data:
    redis:
      host: localhost
      port: 6379
      password: your-password   # 如有設定
      timeout: 2000             # 連線超時 2s
      lettuce:
        pool:
          max-active: 20        # 最大連線數
          max-idle: 10
          min-idle: 2

@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
    RedisTemplate<String, Object> template = new RedisTemplate<>();
    template.setConnectionFactory(factory);
    // Key 用字串序列化
    template.setKeySerializer(new StringRedisSerializer());
    template.setHashKeySerializer(new StringRedisSerializer());
    // Value 用 JSON 序列化（人類可讀）
    Jackson2JsonRedisSerializer<Object> json = new Jackson2JsonRedisSerializer<>(Object.class);
    template.setValueSerializer(json);
    template.setHashValueSerializer(json);
    return template;
}

@Service
@RequiredArgsConstructor
public class ProductCacheService {

    private final RedisTemplate<String, Object> redis;

    // String 操作
    public void cacheProduct(Long id, Product p) {
        redis.opsForValue().set("product:" + id, p, Duration.ofHours(1));
    }
    public Product getProduct(Long id) {
        return (Product) redis.opsForValue().get("product:" + id);
    }

    // Hash 操作
    public void updateUserField(Long uid, String field, Object val) {
        redis.opsForHash().put("user:" + uid, field, val);
    }

    // ZSet 排行榜
    public void addScore(String uid, double score) {
        redis.opsForZSet().incrementScore("leaderboard", uid, score);
    }
    public Set<ZSetOperations.TypedTuple<Object>> getTopN(int n) {
        return redis.opsForZSet().reverseRangeWithScores("leaderboard", 0, n - 1);
    }

    // 刪除快取
    public void evict(Long id) {
        redis.delete("product:" + id);
    }
}

@Service
public class ProductService {

    // 首次呼叫查 DB 並存入快取；之後直接回傳快取，不執行方法體
    // key = "product::1001"，TTL 由 CacheManager 統一設定
    @Cacheable(value = "product", key = "#id", unless = "#result == null")
    public Product findById(Long id) {
        return productRepo.findById(id).orElse(null);  // 只有 Cache Miss 才執行
    }

    // 更新資料後，刪除快取（讓下次讀取重建）
    @CacheEvict(value = "product", key = "#product.id")
    public Product update(Product product) {
        return productRepo.save(product);
    }

    // 更新後主動更新快取（而非刪除）
    @CachePut(value = "product", key = "#result.id")
    public Product save(Product product) {
        return productRepo.save(product);
    }
}

// 在 application.yml 設定各快取的 TTL
// spring.cache.redis.time-to-live=3600000   # 全域 1 小時
// 或用 RedisCacheConfiguration 精細控制每個 cacheName 的 TTL

// 1. 定義 Domain Event
public record OrderCreatedEvent(Long orderId, String userId, BigDecimal amount) {}

// 2. 發布事件（在 Service 或 Aggregate 中）
@Service
public class OrderService {
    private final ApplicationEventPublisher events;

    public Order createOrder(CreateOrderCmd cmd) {
        Order order = orderRepo.save(new Order(cmd));
        events.publishEvent(new OrderCreatedEvent(order.getId(), cmd.userId(), order.total()));
        return order;
    }
}

// 3. Projection：監聽事件，主動更新 Redis Read Model
@Component
@RequiredArgsConstructor
public class OrderSummaryProjection {

    private final RedisTemplate<String, Object> redis;

    @EventListener  // 同步；用 @TransactionalEventListener 可等 DB commit 後再執行
    public void on(OrderCreatedEvent event) {
        OrderSummary summary = OrderSummary.builder()
            .orderId(event.orderId())
            .status("CREATED")
            .amount(event.amount())
            .build();

        // 主動更新 Redis，下次讀取直接命中，不需要去查 DB
        redis.opsForValue().set(
            "order:summary:" + event.orderId(),
            summary,
            Duration.ofHours(24)
        );
    }
}

@Service
@RequiredArgsConstructor
public class InventoryService {

    private final RedissonClient redisson;
    private final InventoryRepo repo;

    public boolean deductStock(Long productId, int qty) {
        RLock lock = redisson.getLock("lock:inventory:" + productId);
        try {
            // 等待最多 3 秒拿鎖；拿到鎖後 10 秒自動釋放（防止死鎖）
            boolean acquired = lock.tryLock(3, 10, TimeUnit.SECONDS);
            if (!acquired) return false;  // 拿不到鎖，直接回傳失敗

            Inventory inv = repo.findById(productId).orElseThrow();
            if (inv.getStock() < qty) return false;
            inv.setStock(inv.getStock() - qty);
            repo.save(inv);
            return true;
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return false;
        } finally {
            if (lock.isHeldByCurrentThread()) lock.unlock();  // 一定要在 finally 釋放
        }
    }
}