<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

spring:
  redis:
    host: localhost
    port: 6379
    password:       # 可選
    database: 0     # 默認(rèn)數(shù)據(jù)庫索引
    timeout: 3000ms
    lettuce:
      pool:
        max-active: 8   # 連接池最大連接數(shù)
        max-idle: 8     # 最大空閑連接
        min-idle: 0     # 最小空閑連接

@Autowired
private StringRedisTemplate redisTemplate;

// 字符串操作
public void setValue(String key, String value) {
    redisTemplate.opsForValue().set(key, value);
}

public String getValue(String key) {
    return redisTemplate.opsForValue().get(key);
}

// 計數(shù)器
public Long increment(String key) {
    return redisTemplate.opsForValue().increment(key);
}

// Hash 操作
public void setHash(String key, String field, String value) {
    redisTemplate.opsForHash().put(key, field, value);
}

public Map<Object, Object> getHash(String key) {
    return redisTemplate.opsForHash().entries(key);
}

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.24.2</version>
</dependency>

@Configuration
public class RedissonConfig {

    @Bean
    public RedissonClient redissonClient() {
        Config config = new Config();
        config.useSingleServer()
              .setAddress("redis://127.0.0.1:6379")
              .setConnectionPoolSize(10)
              .setConnectionMinimumIdleSize(5)
              .setConnectTimeout(3000)
              .setTimeout(3000);
        return Redisson.create(config);
    }
}

@Service
public class ProductService {

    @Autowired
    private StringRedisTemplate redisTemplate;

    @Autowired
    private ProductMapper productMapper;  // MyBatis 數(shù)據(jù)庫操作

    private static final String CACHE_KEY_PREFIX = "product:";

    /**
     * 根據(jù)商品ID獲取商品詳情（先查緩存，再查數(shù)據(jù)庫）
     */
    public Product getProductById(Long id) {
        String key = CACHE_KEY_PREFIX + id;

        // 1. 嘗試從緩存獲取
        Map<Object, Object> cachedMap = redisTemplate.opsForHash().entries(key);
        if (!cachedMap.isEmpty()) {
            // 將 Map 轉(zhuǎn)換為 Product 對象
            return convertMapToProduct(cachedMap);
        }

        // 2. 緩存未命中，查詢數(shù)據(jù)庫
        Product product = productMapper.selectById(id);
        if (product != null) {
            // 3. 寫入緩存（使用 Hash 結(jié)構(gòu)存儲對象字段）
            Map<String, Object> productMap = convertProductToMap(product);
            redisTemplate.opsForHash().putAll(key, productMap);
            // 設(shè)置緩存過期時間（例如 1 小時）
            redisTemplate.expire(key, 1, TimeUnit.HOURS);
        }
        return product;
    }

    /**
     * 更新商品信息（更新數(shù)據(jù)庫同時更新緩存）
     */
    @Transactional
    public void updateProduct(Product product) {
        // 1. 更新數(shù)據(jù)庫
        productMapper.updateById(product);

        // 2. 更新緩存
        String key = CACHE_KEY_PREFIX + product.getId();
        Map<String, Object> productMap = convertProductToMap(product);
        redisTemplate.opsForHash().putAll(key, productMap);
    }
}

@Service
public class InventoryService {

    @Autowired
    private RedissonClient redissonClient;

    /**
     * 扣減庫存
     * @param productId 商品ID
     * @param quantity  扣減數(shù)量
     * @return 是否成功
     */
    public boolean decreaseStock(Long productId, Integer quantity) {
        String lockKey = "lock:product:" + productId;
        RLock lock = redissonClient.getLock(lockKey);

        try {
            // 嘗試加鎖，最多等待 5 秒，鎖自動釋放時間 10 秒
            boolean isLocked = lock.tryLock(5, 10, TimeUnit.SECONDS);
            if (!isLocked) {
                return false;  // 獲取鎖失敗
            }

            // 執(zhí)行業(yè)務(wù)邏輯：查詢庫存并扣減（需配合數(shù)據(jù)庫操作）
            Integer stock = getStockFromDB(productId);
            if (stock >= quantity) {
                updateStockInDB(productId, stock - quantity);
                return true;
            }
            return false;

        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return false;
        } finally {
            // 確保鎖釋放
            if (lock.isLocked() && lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }

    // 模擬數(shù)據(jù)庫操作
    private Integer getStockFromDB(Long productId) { return 100; }
    private void updateStockInDB(Long productId, int newStock) {}
}

@Service
public class RateLimitService {

    @Autowired
    private RedissonClient redissonClient;

    /**
     * 判斷請求是否允許通過
     * @param userId 用戶ID
     * @return true 允許，false 拒絕
     */
    public boolean tryAcquire(String userId) {
        // 每個用戶獨立的限流器
        String key = "rate:limiter:user:" + userId;
        RRateLimiter limiter = redissonClient.getRateLimiter(key);

        // 初始化：每秒 5 個請求，共享配額（只需初始化一次）
        limiter.trySetRate(RateType.OVERALL, 5, 1, TimeUnit.SECONDS);

        // 設(shè)置限流器自動過期（避免 Redis 內(nèi)存泄漏）
        limiter.expire(30, TimeUnit.MINUTES);

        // 嘗試獲取一個令牌
        return limiter.tryAcquire();
    }
}

// 在 Controller 中使用
@RestController
public class ApiController {

    @Autowired
    private RateLimitService rateLimitService;

    @GetMapping("/api/data")
    public String getData(@RequestParam String userId) {
        if (!rateLimitService.tryAcquire(userId)) {
            throw new RuntimeException("請求過于頻繁，請稍后再試");
        }
        return "請求成功，數(shù)據(jù)返回";
    }
}

Config config = new Config();
config.useClusterServers()
      .addNodeAddress("redis://192.168.1.1:7000", "redis://192.168.1.2:7001")
      .setMasterConnectionPoolSize(20)
      .setSlaveConnectionPoolSize(10);