Spring Boot REST接口并发导致缓存雪崩的解决与分布式防御方案 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

Spring Boot REST接口并发与缓存雪崩：分布式防御方案讲座

大家好，今天我们来探讨一个在构建高并发Spring Boot REST接口时经常遇到的问题：缓存雪崩，以及如何利用分布式系统来构建有效的防御机制。

一、缓存雪崩：问题的根源

缓存雪崩是指在缓存系统中，大量的缓存数据在同一时刻失效或者过期，导致大量的请求直接落到数据库上，使得数据库压力剧增，甚至崩溃。想象一下，如果你的电商网站正在进行秒杀活动，大量的商品缓存同时过期，用户请求全部涌向数据库，服务器很可能瞬间宕机。

导致缓存雪崩的原因有很多，常见的包括：

缓存集中过期： 为所有缓存设置相同的过期时间，导致在同一时刻大量缓存失效。
缓存服务器宕机： 如果缓存服务器发生故障，所有缓存数据都无法访问，请求直接访问数据库。
热点数据过期： 某个热点数据缓存过期，大量请求同时访问数据库获取该数据。

二、Spring Boot REST接口中的缓存雪崩

在Spring Boot REST接口中，我们通常使用缓存来提高接口的响应速度和降低数据库压力。例如，使用Spring Cache或Redis缓存查询结果。如果缓存使用不当，就很容易引发缓存雪崩。

假设我们有一个查询用户信息的REST接口：

@RestController
@RequestMapping("/users")
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/{id}")
    public User getUser(@PathVariable Long id) {
        return userService.getUser(id);
    }
}

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    @Cacheable(value = "users", key = "#id")
    public User getUser(Long id) {
        System.out.println("从数据库查询用户：" + id);
        return userRepository.findById(id).orElse(null);
    }
}

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
}

@Entity
@Data
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String email;
}

在这个例子中，我们使用@Cacheable注解将getUser方法的返回结果缓存起来。如果大量用户同时请求不同的用户ID，并且这些用户ID对应的缓存数据都过期了，那么所有的请求都会直接访问数据库，造成缓存雪崩。

三、防御方案：从单机到分布式

要解决缓存雪崩问题，我们需要采取多种策略，从单机到分布式，层层设防。

1. 本地预防措施：避免集中过期

随机过期时间： 在设置缓存过期时间时，使用一个随机数，避免所有缓存同时过期。

@Cacheable(value = "users", key = "#id")
public User getUser(Long id) {
    // 在过期时间基础上增加一个随机数
    long expireTime = 60 * 60 + new Random().nextInt(30 * 60); // 60-90分钟
    System.out.println("从数据库查询用户：" + id + ", expire time: " + expireTime);
    return userRepository.findById(id).orElse(null);
}

但是Spring Cache并不能直接设置缓存过期时间，需要结合缓存管理器来实现。比如，使用RedisCacheManager：

@Configuration
@EnableCaching
public class CacheConfig {

    @Bean
    public RedisCacheConfiguration redisCacheConfiguration() {
        return RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofSeconds(60 * 60)) // 默认过期时间
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));
    }

    @Bean
    public RedisCacheManager redisCacheManager(RedisConnectionFactory redisConnectionFactory) {
        Map<String, RedisCacheConfiguration> cacheConfigurations = new HashMap<>();
        cacheConfigurations.put("users", RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofSeconds(new Random().nextInt(30 * 60) + 60 * 60)) // 针对users缓存自定义过期时间，增加随机值
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer())));

        RedisCacheManager redisCacheManager = RedisCacheManager.builder(redisConnectionFactory)
                .cacheDefaults(redisCacheConfiguration())
                .withInitialCacheConfigurations(cacheConfigurations)
                .build();
        return redisCacheManager;
    }
}

互斥锁（Mutex）： 当缓存失效时，只允许一个线程去数据库查询数据并更新缓存，其他线程等待。

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    private static final String MUTEX_KEY_PREFIX = "mutex:user:";

    public User getUser(Long id) {
        String cacheKey = "user:" + id;
        User user = getUserFromCache(cacheKey);
        if (user != null) {
            return user;
        }

        // 尝试获取互斥锁
        String mutexKey = MUTEX_KEY_PREFIX + id;
        Boolean locked = stringRedisTemplate.opsForValue().setIfAbsent(mutexKey, "locked", Duration.ofSeconds(10));
        if (Boolean.TRUE.equals(locked)) {
            try {
                // 从数据库查询数据
                System.out.println("从数据库查询用户：" + id);
                user = userRepository.findById(id).orElse(null);

                // 更新缓存
                if (user != null) {
                    setUserToCache(cacheKey, user);
                }
            } finally {
                // 释放互斥锁
                stringRedisTemplate.delete(mutexKey);
            }
        } else {
            // 获取锁失败，等待一段时间后重试
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return getUser(id); // 递归调用，直到获取到数据
        }

        return user;
    }

    private User getUserFromCache(String key) {
        String userJson = stringRedisTemplate.opsForValue().get(key);
        if (userJson != null) {
            return new Gson().fromJson(userJson, User.class);
        }
        return null;
    }

    private void setUserToCache(String key, User user) {
        stringRedisTemplate.opsForValue().set(key, new Gson().toJson(user), Duration.ofSeconds(60 * 60 + new Random().nextInt(30 * 60)));
    }
}

这个例子使用Redis的setIfAbsent命令来实现互斥锁。当缓存失效时，只有一个线程可以成功获取锁，其他线程需要等待。这种方法可以有效防止大量请求同时访问数据库。

2. 分布式系统防御：多层保护

单机的预防措施只能缓解部分问题，在高并发场景下，仍然可能出现缓存雪崩。因此，我们需要构建分布式系统来提供更强的保护。

多级缓存： 使用多层缓存架构，例如：本地缓存（Guava Cache） + 分布式缓存（Redis）。先访问本地缓存，如果本地缓存没有命中，再访问分布式缓存。如果分布式缓存也没有命中，才访问数据库。

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    private LoadingCache<Long, User> localCache = CacheBuilder.newBuilder()
            .maximumSize(1000)
            .expireAfterWrite(10, TimeUnit.MINUTES)
            .build(new CacheLoader<Long, User>() {
                @Override
                public User load(Long id) throws Exception {
                    // 从Redis加载数据
                    String userJson = stringRedisTemplate.opsForValue().get("user:" + id);
                    if (userJson != null) {
                        return new Gson().fromJson(userJson, User.class);
                    }
                    return null;
                }
            });

    public User getUser(Long id) {
        try {
            // 先从本地缓存获取
            User user = localCache.get(id);
            if (user != null) {
                return user;
            }
        } catch (ExecutionException e) {
            // 本地缓存加载失败，忽略
        }

        // 本地缓存未命中，从Redis获取
        String userJson = stringRedisTemplate.opsForValue().get("user:" + id);
        if (userJson != null) {
            User user = new Gson().fromJson(userJson, User.class);
            localCache.put(id, user); // 更新本地缓存
            return user;
        }

        // Redis未命中，从数据库获取
        System.out.println("从数据库查询用户：" + id);
        User user = userRepository.findById(id).orElse(null);

        if (user != null) {
            stringRedisTemplate.opsForValue().set("user:" + id, new Gson().toJson(user), Duration.ofSeconds(60 * 60 + new Random().nextInt(30 * 60))); // 更新Redis
            localCache.put(id, user); // 更新本地缓存
        }

        return user;
    }
}

这个例子使用Guava Cache作为本地缓存。当请求到达时，首先尝试从本地缓存获取数据。如果本地缓存没有命中，则从Redis获取数据。如果Redis也没有命中，则从数据库获取数据，并将数据更新到Redis和本地缓存。

服务降级： 当缓存系统出现故障时，可以采取服务降级策略，例如：返回默认值、返回错误页面、限制访问频率等。

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    private boolean isCacheAvailable = true; // 缓存是否可用

    public User getUser(Long id) {
        if (!isCacheAvailable) {
            // 缓存不可用，直接从数据库获取，并返回默认值或错误信息
            System.out.println("缓存不可用，直接从数据库查询用户：" + id);
            User user = userRepository.findById(id).orElse(null);
            if (user == null) {
                // 返回默认值或错误信息
                return getDefaultUser();
            }
            return user;
        }

        try {
            String userJson = stringRedisTemplate.opsForValue().get("user:" + id);
            if (userJson != null) {
                return new Gson().fromJson(userJson, User.class);
            }
        } catch (Exception e) {
            // Redis连接异常，标记缓存不可用
            isCacheAvailable = false;
            return getUser(id); // 递归调用，从数据库获取
        }

        // Redis未命中，从数据库获取
        System.out.println("从数据库查询用户：" + id);
        User user = userRepository.findById(id).orElse(null);

        if (user != null) {
            try {
                stringRedisTemplate.opsForValue().set("user:" + id, new Gson().toJson(user), Duration.ofSeconds(60 * 60 + new Random().nextInt(30 * 60)));
            } catch (Exception e) {
                // Redis连接异常，标记缓存不可用
                isCacheAvailable = false;
            }
        }

        return user;
    }

    private User getDefaultUser() {
        User defaultUser = new User();
        defaultUser.setId(-1L);
        defaultUser.setName("Default User");
        defaultUser.setEmail("[email protected]");
        return defaultUser;
    }
}

这个例子中，我们使用一个isCacheAvailable标志来表示缓存是否可用。当Redis连接出现异常时，我们将isCacheAvailable设置为false，后续的请求将直接从数据库获取数据，并返回默认值。

熔断机制： 使用熔断器（Circuit Breaker）来防止服务雪崩。当数据库压力过大时，熔断器会切断对数据库的访问，避免数据库被压垮。可以使用Hystrix或Resilience4j等框架来实现熔断机制。

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @CircuitBreaker(name = "userCircuitBreaker", fallbackMethod = "getUserFallback")
    public User getUser(Long id) {
        // 先从缓存获取
        try {
            String userJson = stringRedisTemplate.opsForValue().get("user:" + id);
            if (userJson != null) {
                return new Gson().fromJson(userJson, User.class);
            }
        } catch (Exception e) {
            // 缓存异常，继续尝试从数据库获取
            System.err.println("缓存异常：" + e.getMessage());
        }

        // 从数据库获取
        System.out.println("从数据库查询用户：" + id);
        User user = userRepository.findById(id).orElse(null);

        if (user != null) {
            try {
                stringRedisTemplate.opsForValue().set("user:" + id, new Gson().toJson(user), Duration.ofSeconds(60 * 60 + new Random().nextInt(30 * 60)));
            } catch (Exception e) {
                System.err.println("缓存异常：" + e.getMessage());
            }
        }

        // 模拟数据库异常
        if (id % 2 == 0) {
            throw new RuntimeException("模拟数据库异常");
        }

        return user;
    }

    public User getUserFallback(Long id, Throwable t) {
        System.err.println("熔断降级，返回默认用户，错误信息：" + t.getMessage());
        User defaultUser = new User();
        defaultUser.setId(-1L);
        defaultUser.setName("Default User");
        defaultUser.setEmail("[email protected]");
        return defaultUser;
    }
}

这个例子使用Resilience4j的@CircuitBreaker注解来实现熔断机制。当getUser方法抛出异常时，熔断器会根据配置的阈值来判断是否需要打开熔断。如果熔断打开，后续的请求将直接调用getUserFallback方法，返回默认值。

限流： 使用限流器（Rate Limiter）来限制接口的访问频率，防止恶意请求或突发流量压垮系统。可以使用Guava RateLimiter或Sentinel等框架来实现限流。

@RestController
@RequestMapping("/users")
public class UserController {

    @Autowired
    private UserService userService;

    private final RateLimiter rateLimiter = RateLimiter.create(100); // 每秒允许100个请求

    @GetMapping("/{id}")
    public ResponseEntity<User> getUser(@PathVariable Long id) {
        if (!rateLimiter.tryAcquire()) {
            return ResponseEntity.status(HttpStatus.TOO_MANY_REQUESTS).body(null); // 返回429 Too Many Requests
        }

        User user = userService.getUser(id);
        if (user == null) {
            return ResponseEntity.notFound().build();
        }
        return ResponseEntity.ok(user);
    }
}

这个例子使用Guava RateLimiter来限制getUser接口的访问频率。如果请求频率超过了限制，将返回429 Too Many Requests错误。

预热： 在系统启动时，预先加载一些热点数据到缓存中，避免冷启动时的缓存穿透。可以使用Spring的ApplicationRunner或CommandLineRunner接口来实现预热。

@Component
public class CacheInitializer implements ApplicationRunner {

    @Autowired
    private UserService userService;

    @Override
    public void run(ApplicationArguments args) throws Exception {
        // 预热热点数据
        for (long i = 1; i <= 100; i++) {
            userService.getUser(i);
        }
        System.out.println("缓存预热完成");
    }
}

这个例子在系统启动时，预先加载了ID为1到100的用户信息到缓存中。

四、总结

防御措施	描述	适用场景	优点	缺点
随机过期时间	为缓存设置随机的过期时间，避免集中过期。	缓解集中过期导致的缓存雪崩。	简单易用，对现有代码改动较小。	不能完全解决缓存雪崩问题，只能分散过期时间。
互斥锁	当缓存失效时，只允许一个线程去数据库查询数据并更新缓存，其他线程等待。	防止大量请求同时访问数据库。	可以有效防止缓存击穿，保证数据一致性。	性能较低，会阻塞其他线程。
多级缓存	使用多层缓存架构，例如：本地缓存 + 分布式缓存。	提高缓存命中率，降低数据库压力。	可以有效提高性能，降低数据库压力。	实现复杂，需要维护多层缓存。
服务降级	当缓存系统出现故障时，采取服务降级策略，例如：返回默认值、返回错误页面、限制访问频率等。	在缓存系统故障时，保证服务的可用性。	可以保证服务的基本可用性，避免系统崩溃。	可能会影响用户体验。
熔断机制	使用熔断器来防止服务雪崩。当数据库压力过大时，熔断器会切断对数据库的访问，避免数据库被压垮。	防止数据库被压垮。	可以保护数据库，避免系统崩溃。	可能会影响用户体验。
限流	使用限流器来限制接口的访问频率，防止恶意请求或突发流量压垮系统。	防止恶意请求或突发流量压垮系统。	可以保护系统，避免被恶意请求或突发流量压垮。	可能会影响正常用户的访问。
预热	在系统启动时，预先加载一些热点数据到缓存中，避免冷启动时的缓存穿透。	避免冷启动时的缓存穿透。	可以提高系统启动后的性能。	需要提前知道热点数据。

五、多重保障，确保系统稳定

通过上述一系列的策略，我们可以构建一个相对完善的缓存雪崩防御体系。需要注意的是，没有银弹，需要根据实际业务场景选择合适的策略，并不断优化和调整。

监控： 建立完善的监控体系，实时监控缓存命中率、数据库压力、接口响应时间等指标，及时发现问题。
压力测试： 定期进行压力测试，模拟高并发场景，检验防御体系的有效性。
演练： 定期进行故障演练，模拟缓存服务器宕机、数据库故障等情况，提高应对突发事件的能力。

希望今天的分享能帮助大家更好地理解和解决Spring Boot REST接口中的缓存雪崩问题。谢谢大家！

六、核心思想：从容应对并发，构建稳定系统

总而言之，解决缓存雪崩的关键在于预防和应对。预防是避免集中过期，应对是在缓存失效时，能够通过多级缓存、服务降级、熔断、限流等手段来保证系统的可用性。只有构建一个多层次、多维度的防御体系，才能从容应对高并发场景，构建一个稳定的系统。

Spring Boot REST接口并发与缓存雪崩：分布式防御方案讲座

发表回复 取消回复

发表回复取消回复