【SpringBoot篇】解决缓存击穿问题② — 基于逻辑过期方式

在微服务架构中，缓存无疑是提升系统性能的重要手段。然而，随着业务的发展，缓存的有效管理也变得越来越复杂。其中，缓存击穿问题是一个值得关注的现象。所谓缓存击穿，指的是当某个热点数据在缓存失效后，多个请求同时访问数据库，从而导致数据库负载剧增，影响系统的性能。

为了解决这个问题，SpringBoot 提供了一种逻辑过期的解决方案。逻辑过期是通过给缓存数据增加一个时间戳来标记数据的“过期”状态，而不是立即删除缓存。当请求到达时，可以通过判断缓存中数据的时间戳来决定是直接返回缓存数据，还是重新加载数据并更新缓存。

下面我们将通过代码示例来演示如何使用逻辑过期的方式来解决缓存击穿问题。

1. 数据模型

首先，我们定义一个简单的用户模型 User，它的字段包括 ID 和 NAME。

public class User {
    private Long id;
    private String name;

    // getters and setters
}

2. 服务层

接下来，我们创建一个服务类 UserService，用于处理用户的信息。

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

import java.util.concurrent.TimeUnit;

@Service
public class UserService {

    // 模拟一个数据库
    private static final Map<Long, User> userDatabase = new HashMap<>();

    static {
        userDatabase.put(1L, new User(1L, "Alice"));
        userDatabase.put(2L, new User(2L, "Bob"));
        // 更多用户数据
    }

    @Cacheable(value = "userCache", key = "#id")
    public User getUserById(Long id) {
        // 模拟数据库查询
        try {
            TimeUnit.SECONDS.sleep(2); // 模拟延迟
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return userDatabase.get(id);
    }
}

3. 添加逻辑过期

在 UserService 中，我们可以通过添加额外的字段来实现逻辑过期，例如在缓存数据中加入一个过期时间戳。

import java.util.concurrent.atomic.AtomicReference;

public class CachedUser {
    private User user;
    private long expirationTime;

    public CachedUser(User user, long expirationTime) {
        this.user = user;
        this.expirationTime = expirationTime;
    }

    public User getUser() {
        return user;
    }

    public boolean isExpired() {
        return System.currentTimeMillis() > expirationTime;
    }
}

4. 更新服务层

接下来，我们需要更新 getUserById 方法，以便使用逻辑过期的方式来获取用户信息。

import org.springframework.stereotype.Service;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

@Service
public class UserService {

    private final Map<Long, CachedUser> cache = new ConcurrentHashMap<>();

    public User getUserById(Long id) {
        CachedUser cachedUser = cache.get(id);

        // 查看缓存是否存在且未过期
        if (cachedUser != null && !cachedUser.isExpired()) {
            return cachedUser.getUser();
        }

        // 缓存失效，去数据库查
        User user = queryUserFromDatabase(id);

        // 将新数据加入缓存，设置过期时间
        long expirationTime = System.currentTimeMillis() + TimeUnit.SECONDS.toMillis(30); // 30秒过期
        cache.put(id, new CachedUser(user, expirationTime));

        return user;
    }

    private User queryUserFromDatabase(Long id) {
        // 模拟数据库延迟
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return userDatabase.get(id);
    }
}

5. 总结

通过以上代码，我们成功实现了逻辑过期的方式来解决缓存击穿问题。在系统高并发情况下，即使热点数据的缓存失效，依然可以有效地减少对数据库的压力，从而提升整体性能。

在实际开发中，需要根据具体的业务场景来适当调整过期时间和缓存策略，以达到最佳效果。希望本文能够为你理解和解决缓存击穿问题提供一些帮助。