批量缓存模版

🕗 发布于 2024-11-10 23:47 缓存 oracle 数据库

批量缓存模版

缓存通常有两种使用方式，一种是Cache-Aside，一种是cache-through。也就是旁路缓存和缓存即数据源。

最典型的Cache-Aside的样例：

//读操作
data = Cache.get(key);
if(data == NULL)
{
    data = SoR.load(key);
    Cache.set(key, data);
}
return data;

比如Spring-Cache就是Cache-Aside，只需要写上load逻辑，加上注解，就可以实现Cache-Aside缓存的效果了。

但是这种缓存存在一个缺陷，如果我们需要获取一批用户信息，碰巧用户的缓存全都失效了（也就是缓存雪崩），就需要去数据库中全部拉出来，那么这样一个本来性能很高的循环，就等同于全部查了数据库，缓存一点儿作用都没了。

批量缓存查询

举个栗子🌰：

批量请求数据：
- 这里的上方绿色矩形框表示一批需要查询的数据项（例如用户ID 1, 2, 3, 4）。
批量从缓存获取数据：
- 请求首先进入缓存层（例如 Redis），通过批量 GET 操作尝试获取所有请求的数据。
- 如果缓存中存在对应数据，则会返回相应的结果；如果缓存中缺少部分数据（例如在缓存中没有 3），那么这些数据就会被标记为“未命中”。
- 图中左侧绿色矩形框 1, 2, 4 表示缓存中命中的数据部分。
批量从数据库加载缺失的数据：
- 对于缓存中未命中的数据（例如 3），系统会通过批量 LOAD 操作从数据库加载。
- 这个步骤不仅可以填充当前请求所需的数据，还可以将这些数据存入缓存中，以便后续请求可以直接从缓存中获取，减少对数据库的访问。
将结果返回给调用方：
- 最终返回完整的数据结果（包括从缓存获取的数据和从数据库加载的数据），完成整个批量查询的流程。

/**
 * 获取用户信息，盘路缓存模式
 */
public Map<Long, User> getUserInfoBatch(Set<Long> uids) {
    //批量组装key
    List<String> keys = uids.stream().map(a -> RedisKey.getKey(RedisKey.USER_INFO_STRING, a)).collect(Collectors.toList());
    //批量get
    List<User> mget = RedisUtils.mget(keys, User.class);
    Map<Long, User> map = mget.stream().filter(Objects::nonNull).collect(Collectors.toMap(User::getId, Function.identity()));
    //发现差集——还需要load更新的uid
    List<Long> needLoadUidList = uids.stream().filter(a -> !map.containsKey(a)).collect(Collectors.toList());
    if (CollUtil.isNotEmpty(needLoadUidList)) {
        //批量load
        List<User> needLoadUserList = userDao.listByIds(needLoadUidList);
        Map<String, User> redisMap = needLoadUserList.stream().collect(Collectors.toMap(a -> RedisKey.getKey(RedisKey.USER_INFO_STRING, a.getId()), Function.identity()));
        RedisUtils.mset(redisMap, 5 * 60);
        //加载回redis
        map.putAll(needLoadUserList.stream().collect(Collectors.toMap(User::getId, Function.identity())));
    }
    return map;
}

对这段代码进行抽象，找到可以进行复用的地方

黄色代表可复用的流程，红色代表需要根据不同的数据进行单独的实现。

首先定义一个顶层的抽象接口

public interface BatchCache<IN, OUT> {
    /**
     * 获取单个
     */
    OUT get(IN req);

    /**
     * 获取批量
     */
    Map<IN, OUT> getBatch(List<IN> req);

    /**
     * 修改删除单个
     */
    void delete(IN req);

    /**
     * 修改删除多个
     */
    void deleteBatch(List<IN> req);
}

再确定骨架

/**
 * Description: Redis String类型的批量缓存框架
 * 这是一个抽象类，用于实现基于Redis的批量缓存框架。
 * 该框架提供了缓存获取、批量获取、删除、批量删除的功能。
 */
public abstract class AbstractRedisStringCache<IN, OUT> implements BatchCache<IN, OUT> {

    private Class<OUT> outClass; // OUT类型的Class对象，用于反射操作，方便从Redis读取数据

    /**
     * 构造方法
     * 利用反射机制获取泛型OUT的具体类型。
     * 这样在Redis操作时可以知道OUT类型，用于数据转换。
     */
    protected AbstractRedisStringCache() {
        ParameterizedType genericSuperclass = (ParameterizedType) this.getClass().getGenericSuperclass();
        this.outClass = (Class<OUT>) genericSuperclass.getActualTypeArguments()[1];
    }

    /**
     * 抽象方法：获取缓存键
     * 子类需要实现，用于根据请求参数生成唯一的Redis缓存键。
     * @param req 请求参数
     * @return Redis键
     */
    protected abstract String getKey(IN req);

    /**
     * 抽象方法：获取缓存的过期时间
     * 子类需要实现，定义缓存的有效期。
     * @return 过期时间（以秒为单位）
     */
    protected abstract Long getExpireSeconds();

    /**
     * 抽象方法：批量加载数据
     * 当缓存中没有对应数据时，通过该方法从数据库或其他存储加载数据。
     * @param req 请求参数列表
     * @return 加载后的数据映射
     */
    protected abstract Map<IN, OUT> load(List<IN> req);

    /**
     * 单个数据的缓存获取方法
     * 使用getBatch方法来获取单个数据的缓存内容。
     * @param req 单个请求参数
     * @return 单个请求对应的OUT对象
     */
    @Override
    public OUT get(IN req) {
        return getBatch(Collections.singletonList(req)).get(req);
    }

    /**
     * 批量获取缓存数据的方法
     * 该方法尝试从缓存中批量获取请求数据，缺失的数据将从数据库加载并写入缓存。
     * @param req 请求参数列表
     * @return 返回请求参数和对应OUT对象的映射
     */
    @Override
    public Map<IN, OUT> getBatch(List<IN> req) {
        if (CollectionUtil.isEmpty(req)) { // 防御性编程，避免空请求列表的处理
            return new HashMap<>();
        }

        // 去重，避免重复的请求参数
        req = req.stream().distinct().collect(Collectors.toList());

        // 组装Redis键列表
        List<String> keys = req.stream().map(this::getKey).collect(Collectors.toList());

        // 批量从Redis获取缓存数据
        List<OUT> valueList = RedisUtils.mget(keys, outClass);

        // 计算差集，找出缓存中未命中的请求
        List<IN> loadReqs = new ArrayList<>();
        for (int i = 0; i < valueList.size(); i++) {
            if (Objects.isNull(valueList.get(i))) { // 如果某项数据未命中缓存，则添加到loadReqs
                loadReqs.add(req.get(i));
            }
        }

        Map<IN, OUT> load = new HashMap<>();
        // 如果有未命中缓存的数据，则从数据库加载并写入缓存
        if (CollectionUtil.isNotEmpty(loadReqs)) {
            load = load(loadReqs); // 批量从数据库加载数据
            Map<String, OUT> loadMap = load.entrySet().stream()
                    .map(a -> Pair.of(getKey(a.getKey()), a.getValue())) // 为每个数据生成对应的Redis键值对
                    .collect(Collectors.toMap(Pair::getFirst, Pair::getSecond));
            RedisUtils.mset(loadMap, getExpireSeconds()); // 批量写入Redis，设置过期时间
        }

        // 将缓存命中和重新加载的数据合并成最终结果
        Map<IN, OUT> resultMap = new HashMap<>();
        for (int i = 0; i < req.size(); i++) {
            IN in = req.get(i);
            OUT out = Optional.ofNullable(valueList.get(i)) // 优先使用缓存中的数据
                    .orElse(load.get(in)); // 如果缓存中没有，则使用加载的数据
            resultMap.put(in, out); // 将结果放入resultMap
        }
        return resultMap;
    }

    /**
     * 删除单个数据的缓存
     * 使用deleteBatch方法删除单个数据的缓存
     * @param req 单个请求参数
     */
    @Override
    public void delete(IN req) {
        deleteBatch(Collections.singletonList(req));
    }

    /**
     * 批量删除缓存数据的方法
     * @param req 请求参数列表
     */
    @Override
    public void deleteBatch(List<IN> req) {
        // 根据请求参数生成对应的Redis键列表
        List<String> keys = req.stream().map(this::getKey).collect(Collectors.toList());
        RedisUtils.del(keys); // 从Redis批量删除这些键
    }
}

具体的实现类

@Component
public class UserInfoCache extends AbstractRedisStringCache<Long, User> {
    @Autowired
    private UserDao userDao;

    @Override
    protected String getKey(Long uid) {
        return RedisKey.getKey(RedisKey.USER_INFO_STRING, uid);
    }

    @Override
    protected Long getExpireSeconds() {
        return 5 * 60L;
    }

    @Override
    protected Map<Long, User> load(List<Long> uidList) {
        List<User> needLoadUserList = userDao.listByIds(uidList);
        return needLoadUserList.stream().collect(Collectors.toMap(User::getId, Function.identity()));
    }
}

骨架通过实现类的getKey方法来获取到具体的Redis Key，然后实现接口的复用。

缓存雪崩

缓存雪崩的场景解决方案：

缓存失效时间分布随机
缓存预热，在系统启动阶段去mysql拉一次数据load到redis

缓存击穿

缓存击穿的场景解决方案：

空缓存+分布式锁

原文地址：https://blog.csdn.net/2301_79516932/article/details/143667557

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：这是我见过讲解大模型最详细的一本书！学习大模型的建议都去读！
下一篇：线程与进程的区别（面试）

通过物流分拣系统来理解RabbitMQ的消息机制
想象一个物流分拣系统，包裹穿梭于不同的分拣中心和配送站，最后精准地送达客户手中。RabbitMQ的消息传递机制就像这样的物流系统！
阅读更多2024-11-13
vue3中的组件通信方式有哪些？
vue3中常用的组件间通信方式
阅读更多2024-11-13
IT运维的365天--019 用php做一个简单的文件上传工具
前情提要：朋友的工作室，有几个网站分布在不同的服务器上，要经常进行更新，之前是手动复制压缩包到各个服务器去更新（有写了自动更新的Shell脚本）。于是有了这一篇文章。先是在域名的控制台新增一个A记录到
阅读更多2024-11-13
Python学习从0到1 day28 Python 高阶技巧 ⑤ 多线程
现代操作系统比如Mac OS X，UNIX，Linux，Windows等，都是支持“多任务”的操作系统。除了进程外，线程其实也是可以并行执行的，也就是比如一个Python程序,其实是完全可以做到。线程
阅读更多2024-11-13
01.Linux网络设置、FTP
第一张Linux网络设置、FTP
阅读更多2024-11-13
Wxml2Canvas小程序将dom转为图片，bug总结
我在做项目的时候遇到一个需求是将一个动态dom保存成图片这个功能，一开始想着要用canvas一点一点的去画，但是考虑到是动态的，这就导致会很麻烦，所以在网上到处查找资料，先是找到了html2Canva
阅读更多2024-11-13
信息收集、漏洞扫描、漏洞利用、权限提升、数据泄露
权限提升：在获得对目标系统的初步访问权限后，攻击者通常会尝试提升权限，以获得更高的系统控制权。数据泄露：在获得对目标系统的访问权限后，攻击者可能会窃取敏感数据，如用户信息、财务数据、商业机密等。成功的
阅读更多2024-11-13
【数据结构】【线性表】单链表1—概念即创建(附C语言源码)
由于有头结点的单链表具有天然的代码优势，因此在后续的内容中，如没有特殊说明，则代表该单链表为有头结点的单链表。两种，就链表定义而言，不需要头结点也是一个完整的链表，但在实际的运用中发现，没有头结点的单
阅读更多2024-11-13
30IP地址配置
通过今天的课程，你学习了如何在Linux系统中配置IP地址，包括静态配置和动态配置。掌握了这些基本技能后，你可以更好地管理你的Linux系统的网络设置，并确保其能够在网络环境中正常通信。如果你有任何问
阅读更多2024-11-13
kafka消费数据太慢了，给优化下
异步提交偏移量：你当前使用的是 consumer.commitSync() 进行同步提交偏移量，这会阻塞当前线程直到提交完成。合理设置 auto.commit.interval.ms：自动提交偏移量的
阅读更多2024-11-13

批量缓存模版