Spring Cache缓存击穿与穿透的双重防御方案设计 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

Spring Cache 缓存击穿与穿透的双重防御方案设计

大家好，今天我们来聊聊Spring Cache中缓存击穿和缓存穿透这两个常见问题，以及如何设计一个双重防御方案来有效解决它们。缓存是提升系统性能的重要手段，但如果使用不当，反而会成为性能瓶颈甚至安全隐患。所以，理解并掌握缓存问题的防御策略至关重要。

缓存击穿：热点Key的灾难

缓存击穿指的是一个非常热门的Key，在其缓存失效的瞬间，大量请求同时涌入数据库，导致数据库压力剧增，甚至崩溃。这种情况就像堤坝被击穿一样，后果非常严重。

问题分析：

热点Key： 高并发场景下，某些Key的访问频率远高于其他Key。
缓存失效： 无论是过期失效还是被手动删除，热点Key失效都会引发问题。
并发请求： 大量请求同时查询数据库，数据库难以承受。

解决方案：

互斥锁（Mutex Lock）：

这是最常用的方法。当缓存失效时，只允许一个线程去数据库查询数据并重建缓存，其他线程等待。

代码示例：

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

@Service
public class ProductService {

    private final Lock lock = new ReentrantLock();

    @Cacheable(value = "product", key = "#productId")
    public Product getProduct(Long productId) {
        // 尝试获取锁
        if (lock.tryLock()) {
            try {
                // 再次检查缓存，防止其他线程已经重建缓存
                Product cachedProduct = getProductFromCache(productId);
                if (cachedProduct != null) {
                    return cachedProduct;
                }

                // 从数据库加载数据
                Product product = loadProductFromDatabase(productId);

                // 将数据放入缓存
                putProductIntoCache(productId, product);

                return product;
            } finally {
                // 释放锁
                lock.unlock();
            }
        } else {
            // 获取锁失败，等待一段时间后重试，避免大量请求直接打到数据库
            try {
                Thread.sleep(50); // 短暂休眠，防止CPU空转
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return getProduct(productId); // 递归调用，重试
        }
    }

    private Product getProductFromCache(Long productId) {
        //  假设此处是从缓存中获取数据
        return null;
    }

    private Product loadProductFromDatabase(Long productId) {
        // 假设此处是从数据库加载数据
        System.out.println("Loading product from database: " + productId);
        return new Product(productId, "Product " + productId);
    }

    private void putProductIntoCache(Long productId, Product product) {
        // 假设此处是将数据放入缓存
        System.out.println("Putting product into cache: " + productId);
    }
}

class Product {
    private Long id;
    private String name;

    public Product(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }
}

优点： 简单易懂，实现方便。
缺点： 性能较低，所有请求都需要等待锁释放。

永不过期（Never Expire）+ 后台更新：

缓存永不过期，但在后台异步更新缓存。当缓存命中时，直接返回数据。同时，启动一个后台线程去数据库加载最新数据，更新缓存。

代码示例：

import org.springframework.cache.annotation.Cacheable;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import java.util.HashMap;
import java.util.Map;

@Service
public class ProductService {

    private final Map<Long, Product> productCache = new HashMap<>();

    @PostConstruct
    public void init() {
        // 初始化缓存，或者从数据库加载初始化数据
        loadAllProductsFromDatabase();
    }

    @Cacheable(value = "product", key = "#productId") // 只是为了演示Spring Cache的注解，实际缓存操作在getProduct内部
    public Product getProduct(Long productId) {
        Product product = productCache.get(productId);
        if (product == null) {
            // 理论上不应该发生，因为缓存永不过期，但为了容错，可以从数据库加载一次
            product = loadProductFromDatabase(productId);
            productCache.put(productId, product);
        }
        return product;
    }

    @Scheduled(fixedRate = 60000) // 每分钟更新一次缓存
    public void updateCache() {
        System.out.println("Updating product cache...");
        loadAllProductsFromDatabase(); // 重新加载所有产品
        System.out.println("Product cache updated.");
    }

    private void loadAllProductsFromDatabase() {
        // 模拟从数据库加载所有产品
        Map<Long, Product> allProducts = new HashMap<>();
        for (long i = 1; i <= 10; i++) {
            allProducts.put(i, new Product(i, "Product " + i));
        }
        productCache.putAll(allProducts);
    }

    private Product loadProductFromDatabase(Long productId) {
        // 模拟从数据库加载单个产品
        System.out.println("Loading product from database: " + productId);
        Product product = new Product(productId, "Product " + productId);
        productCache.put(productId, product);
        return product;
    }
}

class Product {
    private Long id;
    private String name;

    public Product(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }
}

优点： 高性能，所有请求都直接从缓存获取数据。
缺点： 数据一致性不高，可能存在短暂的数据不一致。

提前刷新（Pre-Refresh）：

在缓存即将过期之前，提前刷新缓存。可以通过设置一个较短的过期时间，并启动一个定时任务，定期检查缓存是否即将过期，如果即将过期，则提前刷新缓存。

代码示例：

import org.springframework.cache.annotation.Cacheable;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

import java.util.HashMap;
import java.util.Map;
import java.util.Random;
import java.util.concurrent.TimeUnit;

@Service
public class ProductService {

    private final Map<Long, Product> productCache = new HashMap<>();
    private final Random random = new Random();

    // 缓存的过期时间，单位：秒
    private final long cacheExpiration = 60;
    // 提前刷新缓存的时间，单位：秒
    private final long preRefreshTime = 10;

    @Cacheable(value = "product", key = "#productId") // 只是为了演示Spring Cache的注解，实际缓存操作在getProduct内部
    public Product getProduct(Long productId) {
        Product product = productCache.get(productId);
        if (product == null) {
            product = loadProductFromDatabase(productId);
            productCache.put(productId, product);
        }
        return product;
    }

    @Scheduled(fixedRate = 5000) // 每5秒检查一次缓存是否需要刷新
    public void checkAndRefreshCache() {
        System.out.println("Checking cache for refresh...");
        for (Long productId : productCache.keySet()) {
            // 模拟计算缓存的剩余时间（实际应该从缓存系统中获取）
            long remainingTime = getRandomRemainingTime(); // 模拟的剩余时间

            if (remainingTime <= preRefreshTime) {
                System.out.println("Refreshing cache for product: " + productId);
                refreshProductCache(productId);
            }
        }
    }

    private void refreshProductCache(Long productId) {
        // 在后台异步刷新缓存
        new Thread(() -> {
            Product product = loadProductFromDatabase(productId);
            productCache.put(productId, product);
            System.out.println("Cache refreshed for product: " + productId);
        }).start();
    }

    private Product loadProductFromDatabase(Long productId) {
        // 模拟从数据库加载产品
        System.out.println("Loading product from database: " + productId);
        try {
            TimeUnit.MILLISECONDS.sleep(50); // 模拟数据库查询耗时
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return new Product(productId, "Product " + productId + " (Refreshed)");
    }

    // 模拟获取缓存剩余时间
    private long getRandomRemainingTime() {
        // 模拟剩余时间在0到cacheExpiration之间
        return random.nextInt((int) cacheExpiration);
    }
}

class Product {
    private Long id;
    private String name;

    public Product(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }
}

优点： 减少了缓存击穿的概率。
缺点： 实现较为复杂，需要精确控制过期时间和刷新时间。

选择策略：

策略	优点	缺点	适用场景
互斥锁	简单易懂，数据一致性高	性能较低	对数据一致性要求高，并发量不高的场景
永不过期+后台更新	高性能	数据一致性不高	对数据一致性要求不高，并发量高的场景
提前刷新	减少缓存击穿概率	实现较为复杂，需要精确控制过期时间和刷新时间	对数据一致性有一定要求，需要平衡性能和一致性

缓存穿透：无中生有的攻击

缓存穿透指的是查询一个根本不存在的数据，缓存和数据库都查不到数据，导致每次请求都直接打到数据库。如果大量请求查询不存在的数据，数据库的压力会急剧增加。

问题分析：

不存在的数据： 请求的Key在数据库中不存在。
缓存未命中： 因为数据不存在，所以缓存中也不会有。
大量请求： 大量请求查询不存在的数据，数据库压力剧增。

解决方案：

缓存空对象（Cache Null Value）：

如果数据库查询结果为空，则将空对象（例如null或者一个特殊的空对象）放入缓存，设置一个较短的过期时间。这样，后续请求可以直接从缓存获取空对象，避免访问数据库。

代码示例：

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import java.util.concurrent.TimeUnit;

@Service
public class ProductService {

    @Cacheable(value = "product", key = "#productId")
    public Product getProduct(Long productId) {
        Product product = loadProductFromDatabase(productId);
        if (product == null) {
            // 将空对象放入缓存，设置较短的过期时间，防止恶意攻击
            // 在实际应用中，应该使用专门的缓存客户端API来设置过期时间
            System.out.println("Caching null value for product: " + productId);
            // 假设此处是将null放入缓存，并设置过期时间
            cacheNullValue(productId); // 使用具体缓存客户端的操作
            return null;
        }
        return product;
    }

    private Product loadProductFromDatabase(Long productId) {
        // 模拟从数据库加载产品
        System.out.println("Loading product from database: " + productId);
        // 模拟数据库中不存在该产品
        return null;
    }

    private void cacheNullValue(Long productId) {
        // 模拟将null值放入缓存，并设置过期时间
        System.out.println("Caching null for product: " + productId);
        try {
            TimeUnit.MILLISECONDS.sleep(50); // 模拟缓存操作耗时
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

    }
}

class Product {
    private Long id;
    private String name;

    public Product(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }
}

优点： 简单有效，可以有效防止缓存穿透。
缺点： 缓存中存在空对象，占用一定的存储空间。需要设置合理的过期时间。

布隆过滤器（Bloom Filter）：

在缓存之前维护一个布隆过滤器，将所有存在的Key预先加载到布隆过滤器中。当请求到达时，先判断Key是否存在于布隆过滤器中，如果不存在，则直接返回，避免访问缓存和数据库。

代码示例：

import com.google.common.hash.BloomFilter;
import com.google.common.hash.Funnels;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;

@Service
public class ProductService {

    private BloomFilter<String> bloomFilter;

    @PostConstruct
    public void init() {
        // 初始化布隆过滤器，将所有存在的Key加载到布隆过滤器中
        bloomFilter = BloomFilter.create(Funnels.stringFunnel(Charset.defaultCharset()), 100000, 0.01);
        loadAllProductIdsToBloomFilter();
    }

    private void loadAllProductIdsToBloomFilter() {
        // 模拟从数据库加载所有存在的Product ID
        List<Long> productIds = getAllProductIdsFromDatabase();
        for (Long productId : productIds) {
            bloomFilter.put(String.valueOf(productId));
        }
        System.out.println("Bloom filter initialized with " + productIds.size() + " product IDs.");
    }

    private List<Long> getAllProductIdsFromDatabase() {
        // 模拟从数据库获取所有Product ID
        List<Long> productIds = new ArrayList<>();
        for (long i = 1; i <= 100; i++) {
            productIds.add(i);
        }
        return productIds;
    }

    @Cacheable(value = "product", key = "#productId") // 只是为了演示Spring Cache的注解，实际缓存控制在方法内部
    public Product getProduct(Long productId) {
        String productIdStr = String.valueOf(productId);
        if (!bloomFilter.mightContain(productIdStr)) {
            // 如果布隆过滤器中不存在该Key，则直接返回null，避免访问缓存和数据库
            System.out.println("Product ID " + productId + " not found in Bloom filter.");
            return null;
        }

        // 如果布隆过滤器中存在该Key，则继续访问缓存和数据库
        Product product = loadProductFromDatabase(productId);
        if (product == null) {
            return null;
        }
        return product;
    }

    private Product loadProductFromDatabase(Long productId) {
        // 模拟从数据库加载产品
        System.out.println("Loading product from database: " + productId);
        // 模拟数据库查询
        if (productId > 100) {
            return null; // 模拟ID大于100的产品不存在
        }
        return new Product(productId, "Product " + productId);
    }
}

class Product {
    private Long id;
    private String name;

    public Product(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }
}

优点： 性能较高，可以有效过滤掉不存在的Key。
缺点： 存在一定的误判率，可能会将存在的Key误判为不存在。需要定期更新布隆过滤器。

参数校验：

在接口层面进行参数校验，过滤掉不合法的参数，避免无效请求到达缓存和数据库。

代码示例：

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

@Service
public class ProductService {

    @Cacheable(value = "product", key = "#productId")
    public Product getProduct(Long productId) {
        // 参数校验，例如校验productId是否合法
        if (productId == null || productId <= 0) {
            System.out.println("Invalid product ID: " + productId);
            return null;
        }

        Product product = loadProductFromDatabase(productId);
        return product;
    }

    private Product loadProductFromDatabase(Long productId) {
        // 模拟从数据库加载产品
        System.out.println("Loading product from database: " + productId);
        // 模拟数据库查询
        if (productId > 100) {
            return null; // 模拟ID大于100的产品不存在
        }
        return new Product(productId, "Product " + productId);
    }
}

class Product {
    private Long id;
    private String name;

    public Product(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }
}

优点： 简单有效，可以避免无效请求。
缺点： 只能过滤掉不合法的参数，无法解决所有缓存穿透问题。

选择策略：

策略	优点	缺点	适用场景
缓存空对象	简单有效	占用存储空间，需要设置合理的过期时间	大部分场景
布隆过滤器	性能较高，可以有效过滤掉不存在的Key	存在误判率，需要定期更新布隆过滤器	数据量大，需要高性能过滤的场景
参数校验	简单有效，可以避免无效请求	只能过滤掉不合法的参数，无法解决所有缓存穿透问题	接口层面，需要进行参数校验的场景

双重防御方案设计：组合拳出击

为了更有效地防御缓存击穿和缓存穿透，我们可以将多种策略组合起来，形成一个双重防御方案。

方案设计：

参数校验： 首先在接口层面进行参数校验，过滤掉不合法的参数。
布隆过滤器： 使用布隆过滤器过滤掉不存在的Key。
互斥锁 + 永不过期 + 后台更新： 对于缓存击穿，使用互斥锁 + 永不过期 + 后台更新策略。互斥锁保证只有一个线程可以重建缓存，永不过期保证缓存可用性，后台更新保证数据一致性。
缓存空对象： 如果数据库查询结果为空，则将空对象放入缓存，设置一个较短的过期时间。

代码示例：

import com.google.common.hash.BloomFilter;
import com.google.common.hash.Funnels;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import javax.annotation.PostConstruct;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

@Service
public class ProductService {

    private final Map<Long, Product> productCache = new HashMap<>();
    private final Lock lock = new ReentrantLock();
    private BloomFilter<String> bloomFilter;

    @PostConstruct
    public void init() {
        // 初始化布隆过滤器
        bloomFilter = BloomFilter.create(Funnels.stringFunnel(Charset.defaultCharset()), 100000, 0.01);
        loadAllProductIdsToBloomFilter();

        // 初始化缓存
        loadAllProductsFromDatabase();
    }

    private void loadAllProductIdsToBloomFilter() {
        // 模拟从数据库加载所有存在的Product ID
        List<Long> productIds = getAllProductIdsFromDatabase();
        for (Long productId : productIds) {
            bloomFilter.put(String.valueOf(productId));
        }
        System.out.println("Bloom filter initialized with " + productIds.size() + " product IDs.");
    }

    private List<Long> getAllProductIdsFromDatabase() {
        // 模拟从数据库获取所有Product ID
        List<Long> productIds = new ArrayList<>();
        for (long i = 1; i <= 100; i++) {
            productIds.add(i);
        }
        return productIds;
    }

    @Cacheable(value = "product", key = "#productId") // 只是为了演示Spring Cache的注解，实际缓存控制在方法内部
    public Product getProduct(Long productId) {
        // 1. 参数校验
        if (productId == null || productId <= 0) {
            System.out.println("Invalid product ID: " + productId);
            return null;
        }

        // 2. 布隆过滤器
        String productIdStr = String.valueOf(productId);
        if (!bloomFilter.mightContain(productIdStr)) {
            System.out.println("Product ID " + productId + " not found in Bloom filter.");
            return null;
        }

        // 3. 互斥锁 + 永不过期 + 后台更新
        Product product = productCache.get(productId);
        if (product == null) {
            if (lock.tryLock()) {
                try {
                    // 再次检查缓存
                    product = productCache.get(productId);
                    if (product != null) {
                        return product;
                    }

                    // 从数据库加载
                    product = loadProductFromDatabase(productId);

                    // 4. 缓存空对象
                    if (product == null) {
                        System.out.println("Caching null value for product: " + productId);
                        // 模拟将null放入缓存，并设置过期时间
                        cacheNullValue(productId);
                        return null;
                    }

                    productCache.put(productId, product);
                    return product;
                } finally {
                    lock.unlock();
                }
            } else {
                // 获取锁失败，等待一段时间后重试
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                return getProduct(productId); // 递归调用，重试
            }
        }

        return product;
    }

    @Scheduled(fixedRate = 60000) // 每分钟更新一次缓存
    public void updateCache() {
        System.out.println("Updating product cache...");
        loadAllProductsFromDatabase();
        System.out.println("Product cache updated.");
    }

    private void loadAllProductsFromDatabase() {
        // 模拟从数据库加载所有产品
        Map<Long, Product> allProducts = new HashMap<>();
        for (long i = 1; i <= 100; i++) {
            allProducts.put(i, new Product(i, "Product " + i));
        }
        productCache.putAll(allProducts);
    }

    private Product loadProductFromDatabase(Long productId) {
        // 模拟从数据库加载产品
        System.out.println("Loading product from database: " + productId);
        // 模拟数据库查询
        if (productId > 200) {
            return null; // 模拟ID大于200的产品不存在
        }
        try {
            TimeUnit.MILLISECONDS.sleep(50); // 模拟数据库查询耗时
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return new Product(productId, "Product " + productId);
    }

    private void cacheNullValue(Long productId) {
        // 模拟将null值放入缓存，并设置过期时间
        System.out.println("Caching null for product: " + productId);
        try {
            TimeUnit.MILLISECONDS.sleep(50); // 模拟缓存操作耗时
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

class Product {
    private Long id;
    private String name;

    public Product(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }
}

总结

这个双重防御方案结合了多种策略，既能有效防御缓存击穿，又能有效防御缓存穿透，提高了系统的可用性和性能。在实际应用中，需要根据具体场景选择合适的策略，并进行合理的配置和调优。例如，布隆过滤器的大小和误判率需要根据数据量进行调整，缓存的过期时间需要根据业务需求进行设置。此外，还需要监控缓存的命中率和数据库的压力，及时发现和解决问题。

深入理解策略选择

在实际应用中，选择哪种策略或策略组合，需要根据具体的业务场景和需求进行权衡。以下是一些更细致的考虑因素：

数据一致性要求： 如果对数据一致性要求非常高，那么互斥锁可能是更好的选择，尽管它性能较低。如果允许短暂的数据不一致，那么永不过期+后台更新或者提前刷新可能更适合。
并发量： 如果并发量非常高，互斥锁可能会成为性能瓶颈。此时，永不过期+后台更新或者提前刷新可能更合适。
数据量： 如果数据量非常大，布隆过滤器可以有效地过滤掉不存在的Key，减少对缓存和数据库的访问。但是，需要考虑布隆过滤器的内存占用和误判率。
业务特点： 如果业务中存在大量的无效请求，那么参数校验可以有效地避免这些请求到达缓存和数据库。如果业务中存在大量的热点Key，那么需要特别关注缓存击穿问题。
缓存系统： 不同的缓存系统提供的功能和特性不同。例如，某些缓存系统支持原子操作，可以更方便地实现互斥锁。某些缓存系统支持过期回调，可以在缓存过期时自动刷新缓存。

监控与调优

缓存策略的有效性需要通过监控和调优来保证。以下是一些常用的监控指标：

缓存命中率： 缓存命中率越高，说明缓存的效果越好。
数据库压力： 数据库压力越低，说明缓存起到了保护数据库的作用。
响应时间： 响应时间越短，说明系统的性能越好。
错误率： 错误率越低，说明系统的可用性越高。

通过监控这些指标，可以及时发现和解决缓存问题。例如，如果缓存命中率较低，可能需要调整缓存的过期时间或者增加缓存的容量。如果数据库压力较高，可能需要优化数据库查询或者增加缓存的层级。

应对各种情况的方案，提升系统可靠性

缓存击穿和穿透是缓存使用中常见的问题，但通过合理的策略选择和组合，可以有效地防御这些问题，提高系统的可用性和性能。在实际应用中，需要根据具体的业务场景和需求进行权衡，并进行持续的监控和调优。希望今天的分享能够帮助大家更好地理解和应用缓存技术。