从 0 到精通：三级缓存系统化教程

客户端请求 → Nginx负载均衡 → Gateway网关 → 【Java业务服务（JVM进程）】
→ 1. 查Caffeine一级缓存 → 命中：直接返回结果，链路结束
→ 未命中 → 2. 查Redis二级缓存 → 命中：回写Caffeine + 返回结果，链路结束
→ 未命中 → 3. 查MySQL数据库 → 查到数据：写Redis + 写Caffeine + 返回结果
→ 未查到：返回空/报错

客户端更新请求 → Nginx → Gateway → 【Java业务服务】
→ 1. 先更新MySQL数据库（唯一权威源，必须先改这里）
→ 2. 同步删除Redis二级缓存
→ 3. 异步延迟执行「第二次删除Redis」（延迟双删兜底）
→ 4. 发布广播消息，通知所有服务实例删除本地Caffeine对应缓存

<!-- SpringBoot核心 -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.7.18</version>
    <relativePath/>
</parent>

<dependencies>
    <!-- Web基础 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- Caffeine本地缓存 -->
    <dependency>
        <groupId>com.github.ben-manes.caffeine</groupId>
        <artifactId>caffeine</artifactId>
        <version>2.9.3</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-cache</artifactId>
    </dependency>

    <!-- Redis分布式缓存 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>

    <!-- 数据库操作（MyBatis-Plus极简版） -->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.5.3.1</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.33</version>
    </dependency>

    <!-- 工具类 -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

server:
  port: 8080

# 数据库配置
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai
    username: root
    password: 你的数据库密码

  # Redis配置
  redis:
    host: localhost
    port: 6379
    password: 你的Redis密码（没有就空着）
    database: 0

  # 缓存配置
  cache:
    type: caffeine # 一级缓存默认用Caffeine
    caffeine:
      spec: maximumSize=10000,expireAfterWrite=60s # 最大缓存1万条，写入后60秒过期

# 开启SQL日志打印
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.scheduling.annotation.EnableAsync;

@SpringBootApplication
@EnableCaching // 开启缓存注解
@EnableAsync // 开启异步（用于延迟双删）
@MapperScan("com.example.demo.mapper") // 扫描Mapper接口
public class CacheDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(CacheDemoApplication.class, args);
    }
}

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;

@Configuration
public class RedisConfig {
    // Redis消息监听容器，用于接收缓存失效广播
    @Bean
    public RedisMessageListenerContainer redisMessageListenerContainer(RedisConnectionFactory connectionFactory) {
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(connectionFactory);
        return container;
    }
}

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import java.io.Serializable;

@Data
@TableName("t_product")
public class Product implements Serializable {
    private static final long serialVersionUID = 1L;

    @TableId(type = IdType.AUTO)
    private Long id; // 商品ID
    private String name; // 商品名称
    private Integer stock; // 商品库存
    private String detail; // 商品详情
}

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.demo.entity.Product;
import org.springframework.stereotype.Repository;

@Repository
public interface ProductMapper extends BaseMapper<Product> {
}

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.example.demo.entity.Product;
import com.example.demo.mapper.ProductMapper;
import lombok.RequiredArgsConstructor;
import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import java.util.concurrent.TimeUnit;

@Service
@RequiredArgsConstructor
public class ProductService {
    private final ProductMapper productMapper;
    private final RedisTemplate<String, Object> redisTemplate;
    private final CacheManager cacheManager; // Caffeine缓存管理器

    // Redis缓存前缀
    private static final String REDIS_CACHE_PREFIX = "product:cache:";
    // 缓存失效广播主题
    public static final String CACHE_INVALID_TOPIC = "product:cache:invalid";
    // 延迟双删等待时间（500ms，根据业务压测调整）
    private static final long DELAY_TIME = 500;

    /**
     * 读请求：三级缓存完整链路
     * @Cacheable 自动查Caffeine一级缓存，未命中才执行方法体
     */
    @Cacheable(value = "product-caffeine", key = "#id", unless = "#result == null")
    public Product getProductById(Long id) {
        // 1. Caffeine未命中，先查Redis二级缓存
        String redisKey = REDIS_CACHE_PREFIX + id;
        Product product = (Product) redisTemplate.opsForValue().get(redisKey);
        if (product != null) {
            return product; // Redis命中，直接返回，Spring自动回写Caffeine
        }

        // 2. Redis未命中，查MySQL三级存储
        product = productMapper.selectById(id);
        if (product != null) {
            // 查到数据，回写Redis（设置10分钟过期，兜底）
            redisTemplate.opsForValue().set(redisKey, product, 10, TimeUnit.MINUTES);
        }
        return product; // Spring自动回写Caffeine
    }

    /**
     * 写请求：更新数据+缓存一致性处理
     */
    public void updateProduct(Product product) {
        // 1. 先更新MySQL（唯一权威源）
        productMapper.updateById(product);
        Long id = product.getId();
        String redisKey = REDIS_CACHE_PREFIX + id;

        // 2. 第一次删除Redis缓存
        redisTemplate.delete(redisKey);

        // 3. 异步延迟双删（兜底）
        asyncDeleteCache(redisKey, id);

        // 4. 发布广播，通知所有服务实例删除本地Caffeine缓存
        redisTemplate.convertAndSend(CACHE_INVALID_TOPIC, id);
    }

    /**
     * 异步延迟双删：不阻塞主线程
     */
    @Async
    public void asyncDeleteCache(String redisKey, Long productId) {
        try {
            // 延迟等待，保证并发读请求的脏数据已经回写Redis
            Thread.sleep(DELAY_TIME);
            // 第二次删除Redis缓存
            redisTemplate.delete(redisKey);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    /**
     * 本地Caffeine缓存删除方法（供广播监听器调用）
     */
    public void removeLocalCache(Long productId) {
        Cache caffeineCache = cacheManager.getCache("product-caffeine");
        if (caffeineCache != null) {
            caffeineCache.evict(productId);
        }
    }
}

import com.example.demo.service.ProductService;
import lombok.RequiredArgsConstructor;
import org.springframework.data.redis.connection.Message;
import org.springframework.data.redis.connection.MessageListener;
import org.springframework.data.redis.listener.PatternTopic;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;

@Component
@RequiredArgsConstructor
public class CacheInvalidListener implements MessageListener {
    private final RedisMessageListenerContainer container;
    private final ProductService productService;

    // 项目启动后，订阅缓存失效主题
    @PostConstruct
    public void subscribe() {
        container.addMessageListener(this, new PatternTopic(ProductService.CACHE_INVALID_TOPIC));
    }

    // 收到广播消息，删除本地Caffeine缓存
    @Override
    public void onMessage(Message message, byte[] pattern) {
        Long productId = Long.valueOf(new String(message.getBody()));
        productService.removeLocalCache(productId);
    }
}

import com.example.demo.entity.Product;
import com.example.demo.service.ProductService;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/product")
@RequiredArgsConstructor
public class ProductController {
    private final ProductService productService;

    // 查商品接口（三级缓存链路）
    @GetMapping("/{id}")
    public Product getProduct(@PathVariable Long id) {
        return productService.getProductById(id);
    }

    // 更新商品接口（缓存一致性处理）
    @PutMapping
    public String updateProduct(@RequestBody Product product) {
        productService.updateProduct(product);
        return "更新成功";
    }
}