用戶請(qǐng)求 → Nginx網(wǎng)關(guān)（查網(wǎng)關(guān)緩存）→ 有就返回
                          ↓ 沒(méi)有
微服務(wù)實(shí)例（查本地緩存Caffeine）→ 有就返回
                          ↓ 沒(méi)有
Redis分布式緩存 → 有就返回（同時(shí)回寫(xiě)本地緩存）
                          ↓ 沒(méi)有
數(shù)據(jù)庫(kù) → 查詢結(jié)果（同時(shí)回寫(xiě)Redis和本地緩存）→ 返回

http {
    # 定義緩存區(qū)：名字叫micro_cache，內(nèi)存100M，過(guò)期時(shí)間10分鐘
    proxy_cache_path /var/nginx/cache levels=1:2 keys_zone=micro_cache:100m inactive=10m max_size=1g;
    server {
        listen 80;
        server_name api.yourecommerce.com;
        location /api/v1/category/list {
            # 啟用緩存，用上面定義的micro_cache
            proxy_cache micro_cache;
            # 緩存key：用請(qǐng)求URI+參數(shù)，避免不同請(qǐng)求混了
            proxy_cache_key $uri$is_args$args;
            # 200和304狀態(tài)碼緩存10分鐘
            proxy_cache_valid 200 304 10m;
            # 緩存命中率這些信息，加在響應(yīng)頭里，方便監(jiān)控
            add_header X-Cache-Status $upstream_cache_status;
            # 轉(zhuǎn)發(fā)到微服務(wù)集群
            proxy_pass http://micro_service_cluster;
        }
    }
}

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
    <version>3.1.8</version> <!-- 用最新版就行 -->
</dependency>

import org.springframework.cache.CacheManager;
import org.springframework.cache.caffeine.CaffeineCacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import com.github.benmanes.caffeine.cache.Caffeine;
import java.util.concurrent.TimeUnit;
@Configuration
@EnableCaching // 開(kāi)啟緩存注解支持
public class CaffeineConfig {
    // 定義緩存管理器：不同緩存用不同規(guī)則
    @Bean
    public CacheManager cacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
        
        // 1. 商品詳情緩存：最多存1000個(gè)，10分鐘過(guò)期
        Caffeine<Object, Object> productCache = Caffeine.newBuilder()
                .maximumSize(1000) // 最大緩存數(shù)量（滿了會(huì)刪最少用的）
                .expireAfterWrite(10, TimeUnit.MINUTES) // 寫(xiě)入后10分鐘過(guò)期
                .recordStats(); // 記錄緩存命中率（方便監(jiān)控）
        // 2. 熱門(mén)商品緩存：最多存500個(gè)，5分鐘過(guò)期（更新更頻繁）
        Caffeine<Object, Object> hotProductCache = Caffeine.newBuilder()
                .maximumSize(500)
                .expireAfterWrite(5, TimeUnit.MINUTES)
                .recordStats();
        // 把不同緩存規(guī)則加進(jìn)去，用名字區(qū)分
        cacheManager.setCaffeineMap(Map.of(
                "productDetailCache", productCache,
                "hotProductCache", hotProductCache
        ));
        return cacheManager;
    }
}

@Service
public class ProductService {
    @Autowired
    private ProductMapper productMapper;
    // 查商品詳情：用productDetailCache緩存
    @Cacheable(value = "productDetailCache", key = "#productId")
    public ProductVO getProductDetail(Long productId) {
        // 這里查數(shù)據(jù)庫(kù)，沒(méi)緩存時(shí)才會(huì)執(zhí)行
        ProductDO productDO = productMapper.selectById(productId);
        // 轉(zhuǎn)成VO返回
        return convertToVO(productDO);
    }
    // 查熱門(mén)商品：用hotProductCache緩存
    @Cacheable(value = "hotProductCache", key = "'hotList'") // 固定key，因?yàn)槭橇斜?    public List<ProductVO> getHotProductList() {
        return productMapper.selectHotProductList();
    }
}

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- 用Redisson，功能更多，比如分布式鎖 -->
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.23.5</version>
</dependency>

spring:
  redis:
    host: 192.168.1.100
    port: 6379
    password: your_redis_password
    lettuce:
      pool:
        max-active: 8 # 最大連接數(shù)
        max-idle: 8 # 最大空閑連接
        min-idle: 2 # 最小空閑連接
    timeout: 2000ms # 超時(shí)時(shí)間
redisson:
  singleServerConfig:
    address: redis://192.168.1.100:6379
    password: your_redis_password
    connectionMinimumIdleSize: 2
    connectionPoolSize: 8

import org.redisson.api.RBloomFilter;
import org.redisson.api.RedissonClient;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.List;
@Component
public class BloomFilterInit implements CommandLineRunner {
    @Resource
    private RedissonClient redissonClient;
    @Resource
    private ProductMapper productMapper;
    // 布隆過(guò)濾器名字
    private static final String PRODUCT_BLOOM_FILTER = "productBloomFilter";
    // 預(yù)計(jì)數(shù)據(jù)量（比如100萬(wàn)商品）
    private static final long EXPECTED_INSERTIONS = 1000000;
    // 誤判率（越小越費(fèi)內(nèi)存，一般設(shè)0.01就行）
    private static final double FALSE_POSITIVE_RATE = 0.01;
    @Override
    public void run(String... args) throws Exception {
        // 獲取布隆過(guò)濾器
        RBloomFilter<Long> bloomFilter = redissonClient.getBloomFilter(PRODUCT_BLOOM_FILTER);
        // 初始化：如果沒(méi)初始化過(guò)才執(zhí)行
        if (!bloomFilter.isExists()) {
            bloomFilter.tryInit(EXPECTED_INSERTIONS, FALSE_POSITIVE_RATE);
            // 把數(shù)據(jù)庫(kù)里所有商品ID加載到布隆過(guò)濾器
            List<Long> allProductIds = productMapper.selectAllProductIds();
            allProductIds.forEach(bloomFilter::add);
        }
    }
}

@Service
publicclass ProductService {

    @Resource
    private RedissonClient redissonClient;

    @Resource
    private ProductMapper productMapper;

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    // 查商品詳情（防穿透版）
    public ProductVO getProductDetail(Long productId) {
        String cacheKey = "product:detail:" + productId;
        RBloomFilter<Long> bloomFilter = redissonClient.getBloomFilter("productBloomFilter");

        // 1. 先過(guò)布隆過(guò)濾器：不在就直接返回
        if (!bloomFilter.contains(productId)) {
            returnnull; // 或者返回“商品不存在”
        }

        // 2. 查Redis緩存
        String cacheValue = stringRedisTemplate.opsForValue().get(cacheKey);
        if (cacheValue != null) {
            // 緩存有值：如果是空值，返回null；否則轉(zhuǎn)VO
            return"null".equals(cacheValue) ? null : JSON.parseObject(cacheValue, ProductVO.class);
        }

        // 3. 查數(shù)據(jù)庫(kù)
        ProductDO productDO = productMapper.selectById(productId);
        if (productDO == null) {
            // 數(shù)據(jù)庫(kù)沒(méi)找到，緩存空值，1分鐘過(guò)期
            stringRedisTemplate.opsForValue().set(cacheKey, "null", 1, TimeUnit.MINUTES);
            returnnull;
        }

        // 4. 數(shù)據(jù)庫(kù)找到，緩存真實(shí)數(shù)據(jù)，30分鐘過(guò)期
        ProductVO productVO = convertToVO(productDO);
        stringRedisTemplate.opsForValue().set(cacheKey, JSON.toJSONString(productVO), 30, TimeUnit.MINUTES);

        return productVO;
    }
}

public ProductVO getHotProductDetail(Long productId) {
    String cacheKey = "product:hot:detail:" + productId;
    String lockKey = "lock:product:hot:" + productId;

    // 1. 先查本地緩存（Caffeine）：熱點(diǎn)數(shù)據(jù)優(yōu)先讀本地
    ProductVO localCache = caffeineCache.getIfPresent(cacheKey);
    if (localCache != null) {
        return localCache;
    }

    // 2. 查Redis緩存
    String redisValue = stringRedisTemplate.opsForValue().get(cacheKey);
    if (redisValue != null && !"null".equals(redisValue)) {
        ProductVO productVO = JSON.parseObject(redisValue, ProductVO.class);
        // 回寫(xiě)本地緩存
        caffeineCache.put(cacheKey, productVO);
        return productVO;
    }

    // 3. 加分布式鎖：只有一個(gè)線程能查數(shù)據(jù)庫(kù)
    RLock lock = redissonClient.getLock(lockKey);
    try {
        // 加鎖：30秒自動(dòng)釋放（避免死鎖），最多等5秒
        boolean locked = lock.tryLock(5, 30, TimeUnit.SECONDS);
        if (locked) {
            // 4. 加鎖成功，查數(shù)據(jù)庫(kù)
            ProductDO productDO = productMapper.selectById(productId);
            if (productDO == null) {
                stringRedisTemplate.opsForValue().set(cacheKey, "null", 1, TimeUnit.MINUTES);
                returnnull;
            }

            // 5. 數(shù)據(jù)庫(kù)有數(shù)據(jù)，更新Redis和本地緩存
            ProductVO productVO = convertToVO(productDO);
            // Redis不設(shè)過(guò)期時(shí)間（永不過(guò)期），靠定時(shí)任務(wù)更新
            stringRedisTemplate.opsForValue().set(cacheKey, JSON.toJSONString(productVO));
            // 本地緩存設(shè)5分鐘過(guò)期
            caffeineCache.put(cacheKey, productVO, 5, TimeUnit.MINUTES);

            return productVO;
        } else {
            // 加鎖失敗，等100ms再重試（遞歸或循環(huán)都行）
            Thread.sleep(100);
            return getHotProductDetail(productId);
        }
    } catch (InterruptedException e) {
        log.error("獲取鎖異常", e);
        returnnull;
    } finally {
        // 釋放鎖：只有持有鎖的線程才能釋放
        if (lock.isHeldByCurrentThread()) {
            lock.unlock();
        }
    }
}

// 定時(shí)任務(wù)更新熱點(diǎn)商品緩存（每5分鐘執(zhí)行一次）
@Scheduled(fixedRate = 5 * 60 * 1000)
public void refreshHotProductCache() {
    List<Long> hotProductIds = productMapper.selectHotProductIds(); // 查熱門(mén)商品ID列表
    for (Long productId : hotProductIds) {
        String cacheKey = "product:hot:detail:" + productId;
        ProductDO productDO = productMapper.selectById(productId);
        if (productDO != null) {
            ProductVO productVO = convertToVO(productDO);
            // 更新Redis緩存
            stringRedisTemplate.opsForValue().set(cacheKey, JSON.toJSONString(productVO));
            // 更新本地緩存
            caffeineCache.put(cacheKey, productVO, 5, TimeUnit.MINUTES);
        }
    }
}

// 給緩存加隨機(jī)過(guò)期時(shí)間：30分鐘±5分鐘（25-35分鐘）
int baseExpire = 30; // 基礎(chǔ)過(guò)期時(shí)間（分鐘）
int randomExpire = new Random().nextInt(10); // 0-10分鐘隨機(jī)值
int totalExpire = baseExpire - 5 + randomExpire; // 25-35分鐘

// 存Redis時(shí)用這個(gè)總過(guò)期時(shí)間
stringRedisTemplate.opsForValue().set(cacheKey, JSON.toJSONString(productVO), totalExpire, TimeUnit.MINUTES);

<dependency>
    <groupId>io.github.resilience4j</groupId>
    <artifactId>resilience4j-spring-boot2</artifactId>
    <version>2.1.0</version>
</dependency>

resilience4j:
  circuitbreaker:
    instances:
      productDbCircuit: # 熔斷器名字
        slidingWindowSize: 100 # 滑動(dòng)窗口大小
        failureRateThreshold: 50 # 失敗率閾值：50%失敗就熔斷
        waitDurationInOpenState: 60000 # 熔斷后60秒嘗試恢復(fù)
        permittedNumberOfCallsInHalfOpenState: 10 # 半開(kāi)狀態(tài)允許10個(gè)請(qǐng)求測(cè)試
  fallback:
    instances:
      productDbCircuit:
        fallback-exception: # 哪些異常觸發(fā)降級(jí)
          - java.sql.SQLException
          - org.springframework.dao.DataAccessException

// 查數(shù)據(jù)庫(kù)時(shí)加熔斷降級(jí)：失敗了就返回緩存的舊數(shù)據(jù)（如果有的話）
@CircuitBreaker(name = "productDbCircuit", fallbackMethod = "getProductDetailFallback")
private ProductDO getProductFromDb(Long productId) {
    return productMapper.selectById(productId);
}

// 降級(jí)方法：參數(shù)和返回值要和原方法一致
private ProductDO getProductDetailFallback(Long productId, Exception e) {
    log.error("查數(shù)據(jù)庫(kù)失敗，觸發(fā)降級(jí)", e);
    // 嘗試從Redis拿舊數(shù)據(jù)（就算過(guò)期了也拿）
    String cacheKey = "product:detail:" + productId;
    String redisValue = stringRedisTemplate.opsForValue().get(cacheKey);
    if (redisValue != null && !"null".equals(redisValue)) {
        ProductVO productVO = JSON.parseObject(redisValue, ProductVO.class);
        return convertToDO(productVO); // 轉(zhuǎn)成DO返回
    }
    // 沒(méi)舊數(shù)據(jù)就拋異常（或者返回默認(rèn)值）
    thrownew RuntimeException("服務(wù)繁忙，請(qǐng)稍后再試");
}

@Service
publicclass ProductUpdateService {

    @Resource
    private ProductMapper productMapper;

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Resource
    private RabbitTemplate rabbitTemplate;

    @Transactional// 加事務(wù)，確保數(shù)據(jù)庫(kù)更新成功才刪緩存
    public void updateProductPrice(Long productId, BigDecimal newPrice) {
        // 1. 更新數(shù)據(jù)庫(kù)
        ProductDO productDO = new ProductDO();
        productDO.setId(productId);
        productDO.setPrice(newPrice);
        productMapper.updateById(productDO);

        // 2. 刪除Redis緩存
        String redisKey = "product:detail:" + productId;
        stringRedisTemplate.delete(redisKey);

        // 3. 發(fā)送消息，通知所有實(shí)例刪除本地緩存
        rabbitTemplate.convertAndSend("cache-invalidate-exchange", "product.detail", productId);
    }
}

@Component
publicclass CacheInvalidateConsumer {

    @Resource
    private CacheManager cacheManager;

    @RabbitListener(queues = "product-detail-cache-queue")
    public void handleCacheInvalidate(Long productId) {
        // 獲取本地緩存，刪除對(duì)應(yīng)的key
        Cache productCache = cacheManager.getCache("productDetailCache");
        if (productCache != null) {
            productCache.evict(productId);
        }
        log.info("刪除本地緩存：productDetailCache:{}", productId);
    }
}