多级缓存建设方案

已于 2023-05-10 20:16:30 修改
阅读量1.5k 收藏 2
点赞数 1
分类专栏： 系统架构与方案 文章标签： 缓存 数据库 java
于 2023-04-29 11:31:26 首次发布
转载/复制请联系作者:snail.pu@foxmail.com
本文链接：https://blog.csdn.net/bigbug_500/article/details/129741867
版权

项目背景

   xx系统中对容量和耗时有较高要求，以支付优惠立减为例，每个用户咨询可用立减时，都会过一遍全量生效活动。目前日常活动数3000+，目标2w+；日常秒级咨询量1w+，大促22w+。所以如何支撑日常和大促的业务非常具有挑战性。

   对此我们做了很多优化，其中缓存是整个优化的基石。我们对优惠模型、优惠活动预算和优惠周期预算等数据都做了缓存，但在日常开发中存在以下问题：

  1. 没有标准的缓存设计方案，需要翻其他系统的代码去理解怎么做；
  2. 开发成本高，搭建一套缓存要创建多个类，其中较多代码可复用；
  3. 容易踩坑，比如数据一致性问题、缓存击穿、热点key问题等。

   本次缓存设计参考自yy系统，其代码经过了长时间的验证，所以我们希望输出一套缓存标准化方法，尽量满足当前已有业务场景，经过验证后能推广至其他系统，帮助大家夯实缓存系统，为业务发展保驾护航。

多级缓存整体设计

为什么需要多级缓存？

   通过建设 可选的分级缓存结构、各层级缓存数据的不同scope、各层级不同的更新策略 的多级缓存，减少网络IO，极大的提高各个应用节点获取数据的速度。

适用场景

  1. 针对数据变更较少。如大促期间的优惠配置、商户支付规则配置等。
  2. 访问量非常大的。这个概念需要case by case去看，一般是某个接口会对某批数据高频查询使用的场景，数据QPS > 10w or 接口TPS > 10w
  3. 接受较短时间的数据同步延迟的场景。
  4. 不接受 既要 非常满足CAP能力，又要 保证数据吞吐量，还要 多级缓存结构的业务通用性，这是非常不合理的述求，异常情况兼容处理的 ROI 太低，建议由提出这个想法的人来做。分布式多级缓存的 Consistency 和 Availability，只能是尽量满足，如果业务能接受一些技术层面的规则，我们的架构就能在 Consistency 和 Availability 上做的更好。

分级缓存结构

参照已有的系统，有较为常用的三级缓存结构：

  1. 常驻缓存：存放静态数据或热点数据，一般没有超时时间也不会被剔除。为解决变更数据的一致性问题，需要数据推送更新一定成功，定时任务只校验数据一致性问题；
  2. LRU缓存：存放懒加载的热点数据，使用LRU淘汰机制和打散的过期时间维护缓存数据；
  3. 远端缓存：存放近期的全量数据，会设置较长的过期时间，尽量不被击穿，保护数据源；
  4. 数据源：存放全量数据，通常是数据库或者外部查询接口。

各级缓存形成一个数据正金字塔，流量访问倒金字塔，越上层存放着越经常访问的数据，承担着更多的流量。

在这里插入图片描述
说明：

  1. 为什么要常驻缓存和LRU缓存？
    • 预读失效和缓存污染问题
      • 如果只有一个LRU缓存，那么在预热时或批量读取数据时，导致真正的热点数据不在LRU中，导致缓存命中率降低。
    • 两个缓存的设计，参考的是InnoDB和Linux缓存页读取的思路，更多的内容可以参考
  2. 常驻缓存、LRU缓存的数据有什么差异？
    a. 长期来看，常驻缓存和LRU缓存中的数据会呈现互补的关系。

缓存更新机制（Consistency保障）

多级缓存更新设计时，应考虑的问题

先抛出业务问题，再看解决的方案。

  1. DB 数据变更后，如何尽快的让业务使用到最新的数据？
    • 需要主动更新的方式，尽快变更缓存中的数据
  2. 在1更新数据时，由于一些未知因素导致缓存数据更新失败，该如何处理？
    • 为避免部分数据更新成功，部分数据更新失败，需要保证更新操作的原子性，既有更新的操作，有更新失败的回滚操作即可。(不建议对小概率的异常场景，进行过多的设计)
  3. 如何及时发现各级缓存的数据不一致问题和使用情况
    • 主动增量变更数据时，保证操作的原子性
    • 定时任务定时扫描
  4. 为什么不要延时双删？怎么解决在更新数据的同时，把历史数据加载到了缓存中，导致脏数据长时间在Cache中。延时双删方案
    • 本业务方案中，不使用删除的方式，在完成DB的数据变更后，使用更新DB的数据更新到各级缓存，可以解决延时双删方案中，读取并使用老的数据更新缓存的问题。
    • 同步更新DB和Cache 或 延时双删的策略，需按业务场景自行决策。
  5. 如何解决热点key的大批量请求影响系统的运行问题？
    • 热点key一般都会被放在一级常驻缓存中，正常来讲，不影响单台node的运行
    • 若疏忽上面的步骤，且一级LRU缓存中，没有对应的数据，那么将请求到远端缓存中，此时应当可以得到数据，也可以解决热点key问题对应用的影响
    • 若上面两级缓存中都不存在，我们在远端缓存查询DB时，使用分布式排他锁，避免大量请求到DB端，也可以解决绝大部分场景下的热点key问题对应用的影响。

   Consistency 由推拉结合的方式来保障，但不同层级的缓存操作流程不一样，整体架构图如下：
在这里插入图片描述

通过业务平台被动的数据变更流程

在这里插入图片描述
备注：

  1. 蓝色为业务管理系统，绿色为应用服务

多级缓存主动增量更新机制

请添加图片描述

备注：

  1. 缓存穿透问题的解决：
    • 查询前校验key的合法性
    • 设置守护值，设置一个较短的过期时间
    • 在查询DB的前一级缓存中添加锁（分布式或单机锁），控制缓存击穿。只解决DB层的缓存击穿，其他缓存层级间不处理该问题
  2. 缓存雪崩问题的解决：
    • 设置过期时间时，添加了随机值

定时器缓存核对任务

  1. 通过指定的策略（loop：30min），扫描缓存中的所有Key，并和DB的数据源进行对比；若数据有差异，则抛出告警，不更新缓存；
  2. 记录各个缓存层级基础信息，如命中率、内存使用情况、key情况等

缓存预热加载机制

  1. 注册应用启动事件，预热失败时，阻塞应用的启动，由人工来排查原因
  2. 通过缓存管理器中的LevelCacheManager#levelCacheLoad(Collection< K > keys)，将不同的缓存进行刷新，流程：
    getAll >> get >> memCache >> lruCache >> remoteCache >> dataSrouce >> putRemoteCache >> putLruCache
    • 参数keys的捞取策略，默认最近最新1k条数据，可以在管理器中指定方案
  3. 常驻缓存的内容是提前分析出来，通过缓存管理器主动加载数据

类结构设计

抽象分级缓存组件主要由三个部分组成：

  1. 缓存：定义了缓存的标准方法，实现类主要有常驻缓存、LRU缓存、远端缓存
  2. 数据源：定义了数据源的标准方法，目前仅查询方法；
  3. 分级缓存管理器：定义了分级缓存系统的标准方法，包括查询方法、缓存更新方法、各级缓存获取方法。

请添加图片描述

​ 另外用单例模式分别实现了DummyCache和DummyDataSource，用于实现缓存层级可选。如果没有定义某一级缓存，则其功能默认由Dummy实例承载，Dummy实例本身不做任何事情，所以自动将请求向下传递，直到某一真实层级。

缓存抽象类设计：

/**
 * 抽象缓存
 * @author 
 * @version $Id: AbstractCache.java, v 0.1 2022/9/20 11:27  Exp $
 * @see Cache
 */
public abstract class AbstractCache<K, V> implements Cache<K, V> {

    /**
     * LOGGER
     */
    protected final Logger logger;

    /**
     * 缓存名称
     */
    private final String   cacheName;

    /**
     * 构造函数
     * @param logger 日志
     * @param cacheName 缓存名称
     */
    public AbstractCache(Logger logger, String cacheName) {
        this.logger = logger;
        this.cacheName = cacheName;
    }

    /**
     * 从缓存中查询，为null则不存在
     * @see Cache#exists(Object)
     */
    @Override
    public boolean exists(K key) {
        return get(key) != null;
    }

    /**
     * 提供穿透保护，保护值不为null表示开启
     * @see Cache#get(Object) 
     */
    @Override
    public V get(K key) {
        if (!checkKey(key)) {
            return null;
        }
        V val = getPurely(key);
        if (val != null) {
            hit(key, val);
            return val;
        }
        miss(key);
        return getGuardValue();
    }

    /**
     * 直接获取
     * @param key 缓存键
     * @return 缓存值
     */
    protected abstract V getPurely(K key);

    /**
     * 命中时的处理
     * @param key 缓存键
     * @param val 缓存值
     */
    protected void hit(K key, V val) {
    }

    /**
     * 未命中时的处理
     * @param key 缓存键
     */
    protected void miss(K key) {
    }

    /**
     * 获取穿透保护值，为null表示不开启
     * @return 保护值，一般为不可变常量
     */
    protected V getGuardValue() {
        return null;
    }

    /**
     * 先直接查询，为null则用加载器加载。没有加锁，谨慎使用默认实现
     * @see Cache#get(Object, ValueLoader) 
     */
    @Override
    public V get(K key, ValueLoader<K, V> loader) {
        if (!checkKey(key)) {
            return null;
        }

        // 优先调用get，使用保护值
        V val = get(key);
        if (val != null) {
            return val;
        }

        // 走到这里说明没有保护值，需要加载，并放入缓存
        val = loader.load(key);
        // 由子类checkVal
        put(key, val);
        return val;
    }

    /**
     * 迭代缓存键列表单个查询
     * @see Cache#getAll(Collection) 
     */
    @Override
    public Map<K, V> getAll(Collection<K> keys) {
        Map<K, V> valMap = new HashMap<>();
        if (CollectionUtils.isEmpty(keys)) {
            return valMap;
        }
        keys.forEach(key -> AssetMapUtil.putValueExceptNull(valMap, key, get(key)));
        return valMap;
    }

    /**
     * @see Cache#put(Object, Object) 
     */
    @Override
    public void put(K key, V val) {
        put(key, val, expireTimeFor(val));
    }

    /**
     * 迭代缓存键值对Map单个存入缓存
     * @see Cache#putAll(Map) 
     */
    @Override
    public void putAll(Map<K, V> valMap) {
        AssetDefaultUtil.defaultMap(valMap).forEach(this::put);
    }

    /**
     * 迭代缓存键单个删除
     * @see Cache#removeAll(Collection) 
     */
    @Override
    public void removeAll(Collection<K> keys) {
        if (CollectionUtils.isEmpty(keys)) {
            return;
        }
        keys.forEach(this::remove);
    }

    /**
     * 校验缓存键合法
     * @param key 缓存键
     * @return true=合法
     */
    public boolean checkKey(K key) {
        return key != null;
    }

    /**
     * 校验缓存值合法
     * @param val 缓存值
     * @return true=合法
     */
    public boolean checkVal(V val) {
        return val != null;
    }

    /**
     * 获取过期时间
     * <ul>
     *     <li>根据缓存值判断过期时间，穿透保护值可以设置较短时间</li>
     *     <li>除了常驻缓存，过期时间都要大于0</li>
     * </ul>
     * @param val 缓存值
     * @return 过期时间
     */
    public abstract long expireTimeFor(V val);

    /**
     * 校验过期时间
     * @param expireTime 过期时间，单位毫秒
     * @return true通过
     */
    protected boolean checkExpireTime(long expireTime) {
        return expireTime > 0L;
    }

    /**
     * Getter method for property <tt>cacheName</tt>.
     *
     * @return property value of cacheName
     */
    public String getCacheName() {
        return cacheName;
    }

}

抽象数据源:

/**
 * 抽象数据源
 * @author 
 * @version $Id: AbstractDataSource.java, v 0.1 2022/9/20 11:48  Exp $
 * @see DataSource
 */
public abstract class AbstractDataSource<K, V> implements DataSource<K, V> {

    /**
     * LOGGER
     */
    protected final Logger logger;

    /**
     * 数据源名称
     */
    private final String   dataSourceName;

    /**
     * 构造函数
     * @param logger 日志
     * @param dataSourceName 数据源名称
     */
    public AbstractDataSource(Logger logger, String dataSourceName) {
        this.logger = logger;
        this.dataSourceName = dataSourceName;
    }

    /**
     * 提供穿透保护，保护值不为null表示开启
     * @see Cache#get(Object)
     */
    @Override
    public V get(K key) {
        if (!checkKey(key)) {
            return null;
        }
        V val = getPurely(key);
        if (val != null) {
            hit(key, val);
            return val;
        }
        miss(key);
        return getGuardValue();
    }

    /**
     * 直接获取
     * @param key 缓存键
     * @return 缓存值
     */
    protected abstract V getPurely(K key);

    /**
     * 命中时的处理
     * @param key 缓存键
     * @param val 缓存值
     */
    protected void hit(K key, V val) {
    }

    /**
     * 未命中时的处理
     * @param key 缓存键
     */
    protected void miss(K key) {
    }

    /**
     * 获取穿透保护值，为null表示不开启
     * @return 保护值，一般为不可变常量
     */
    protected V getGuardValue() {
        return null;
    }

    /**
     * @see DataSource#getAll(Collection)  
     */
    @Override
    public Map<K, V> getAll(Collection<K> keys) {
        Map<K, V> valMap = new HashMap<>();
        if (CollectionUtils.isEmpty(keys)) {
            return valMap;
        }
        keys.forEach(key -> AssetMapUtil.putValueExceptNull(valMap, key, get(key)));
        return valMap;
    }

    /**
     * 校验缓存键合法
     * @param key 缓存键
     * @return true=合法
     */
    public boolean checkKey(K key) {
        return key != null;
    }

    /**
     * Getter method for property <tt>dataSourceName</tt>.
     *
     * @return property value of dataSourceName
     */
    public String getDataSourceName() {
        return dataSourceName;
    }

}

抽象分级缓存管理器

/**
 * 抽象分级缓存系统，层级可选。只支持读，更新缓存时要区分单机和全局操作
 * <ul>
 *     <li>一级：常驻缓存</li>
 *     <li>二级：LRU缓存</li>
 *     <li>三级：远端缓存</li>
 *     <li>兜底：数据源</li>
 * </ul>
 * @author 
 * @version $Id: AbstractLevelCacheManager.java, v 0.1 2022/9/19 21:58  Exp $
 * @see Cache
 * @see LevelCacheManager
 */
public abstract class AbstractLevelCacheManager<K, V> implements LevelCacheManager<K, V> {

    /**
     * LOGGER
     */
    protected final Logger     logger;

    /**
     * 管理器名称
     */
    private final String       managerName;

    /**
     * 常驻缓存
     * <ul>
     *     <li>存放不过期数据</li>
     *     <li>不设置过期时间，最好设置最大容量</li>
     *     <li>一般由DRM推送加载</li>
     *     <li>缓存更新时，如果常驻缓存中存在也会更新</li>
     * </ul>
     */
    protected Cache<K, V>      memCache    = DummyCache.getInstance();

    /**
     * 本地缓存
     * <ul>
     *     <li>存放热点数据，一般要设置较短的过期时间</li>
     *     <li>注意计算容量，避免占用过多内存</li>
     * </ul>
     */
    protected Cache<K, V>      lruCache    = DummyCache.getInstance();

    /**
     * <p>远端缓存</p>
     * <ul>
     *     <li>存放全量数据</li>
     *     <li>一般要设置较长的过期时间，并由消息或定时任务刷新</li>
     * </ul>
     */
    protected Cache<K, V>      remoteCache = DummyCache.getInstance();

    /**
     * 数据源
     */
    protected DataSource<K, V> dataSource  = DummyDataSource.getInstance();

    /**
     * 构造函数
     * @param logger 日志
     * @param managerName 管理器名称
     */
    public AbstractLevelCacheManager(Logger logger, String managerName) {
        this.logger = logger;
        this.managerName = managerName;
    }

    /**
     * 判断分级缓存系统中是否存在缓存键
     * @see Cache#exists(Object)
     */
    public boolean exists(K key) {
        return get(key) != null;
    }

    /**
     * 从分级缓存系统中获取缓存值
     * <ul>
     *     <li>查询路径：常驻缓存 -> 本地缓存 -> 远端缓存 -> 数据源</li>
     *     <li>除常驻缓存外，下一层查询到的值会回填到上一层</li>
     * </ul>
     * @see Cache#get(Object)
     */
    @Override
    public V get(K key) {
        // 校验key是否合法
        if (!checkKey(key)) {
            return null;
        }

        // 从常驻缓存查询
        V val = getMemCache().get(key);
        if (val != null) {
            return val;
        }

        // LRU缓存 -> 远端缓存 -> 数据源
        return getStartFromLru(key);
    }

    /**
     * LRU缓存 -> 远端缓存 -> 数据源
     * @param key 缓存键
     * @return 缓存值
     */
    private V getStartFromLru(K key) {
        return getLruCache().get(key, remoteKey -> getRemoteCache().get(remoteKey,
            dataSourceKey -> getDataSource().get(dataSourceKey)));
    }

    /**
     * 从分级缓存系统中批量获取缓存值
     * @see Cache#getAll(Collection)
     */
    @Override
    public Map<K, V> getAll(Collection<K> keys) {
        Map<K, V> valMap = new HashMap<>();
        if (CollectionUtils.isEmpty(keys)) {
            return valMap;
        }
        keys.forEach(key -> AssetMapUtil.putValueExceptNull(valMap, key, get(key)));
        return valMap;
    }

    /**
     * 从分层缓存中查询，再放入常驻缓存
     * <ul>
     *     <li>不直接从数据源查询，避免全Zone请求太多</li>
     *     <li>穿透保护值也会放入常驻缓存</li>
     * </ul>
     * @see LevelCacheManager#memCacheLoad(Collection)  
     */
    @Override
    public void memCacheLoad(Collection<K> keys) {
        keys = AssetDefaultUtil.defaultList(filterKey(keys));
        List<K> sucKeys = new ArrayList<>();
        keys.forEach(key -> {
            V val = getStartFromLru(key);
            if (val != null) {
                getMemCache().put(key, val);
                sucKeys.add(key);
            }
        });
        AssetLogUtil.info(logger, String.format("[%s]常驻缓存加载成功：%s", managerName, sucKeys));
    }

    /**
     * 由定时任务调用，从远端缓存查询，覆盖LRU缓存
     * <ul>
     *     <li>远端缓存查不到，会从数据源查询，并放入远端缓存</li>
     *     <li>只刷新LRU缓存中已存在的key，避免缓存污染</li>
     * </ul>
     * @see LevelCacheManager#lruCacheRefresh(Collection) 
     */
    @Override
    public void lruCacheRefresh(Collection<K> keys) {
        keys = AssetDefaultUtil.defaultList(filterKey(keys));
        List<K> sucKeys = new ArrayList<>();
        keys.forEach(key -> {
            if (!getLruCache().exists(key)) {
                return;
            }
            V val = getRemoteCache().get(key, dataSourceKey -> getDataSource().get(dataSourceKey));
            if (val != null) {
                getLruCache().put(key, val);
                sucKeys.add(key);
            }
        });
        AssetLogUtil.info(logger, String.format("[%s]常驻缓存加载成功：%s", managerName, sucKeys));
    }

    /**
     * 从数据源查询放入远端缓存
     * @see LevelCacheManager#remoteCacheLoad(Collection)
     */
    @Override
    public void remoteCacheLoad(Collection<K> keys) {
        keys = AssetDefaultUtil.defaultList(filterKey(keys));
        Map<K, V> valMap = AssetDefaultUtil.defaultMap(getDataSource().getAll(keys));
        getRemoteCache().putAll(valMap);
        AssetLogUtil.info(logger, String.format("[%s]远端缓存加载成功：%s", managerName, valMap.keySet()));
    }

    /**
     * 直接查询加载整个分级缓存
     * @see LevelCacheManager#levelCacheLoad(Collection)
     */
    @Override
    public void levelCacheLoad(Collection<K> keys) {
        keys = AssetDefaultUtil.defaultList(filterKey(keys));
        Map<K, V> valMap = AssetDefaultUtil.defaultMap(getAll(keys));
        AssetLogUtil.info(logger, String.format("[%s]分级缓存加载成功：%s", managerName, valMap.keySet()));
    }

    /**
     * 校验缓存键合法
     * @param key 缓存键
     * @return true=合法
     */
    protected abstract boolean checkKey(K key);

    /**
     * 过滤不合法的键
     * @param keys 键列表
     * @return 过滤后的键列表
     */
    protected List<K> filterKey(Collection<K> keys) {
        if (CollectionUtils.isEmpty(keys)) {
            return new ArrayList<>();
        }
        return keys.stream().filter(this::checkKey).collect(Collectors.toList());
    }

    /**
     * 获取常驻缓存
     * @return 常驻缓存
     */
    public Cache<K, V> getMemCache() {
        return memCache;
    }

    /**
     * 获取LRU缓存
     * @return LRU缓存
     */
    public Cache<K, V> getLruCache() {
        return lruCache;
    }

    /**
     * 获取远端缓存
     * @return 远端缓存
     */
    public Cache<K, V> getRemoteCache() {
        return remoteCache;
    }

    /**
     * 获取数据源
     * @return 数据源
     */
    public DataSource<K, V> getDataSource() {
        return dataSource;
    }

    /**
     * Getter method for property <tt>managerName</tt>.
     *
     * @return property value of managerName
     */
    public String getManagerName() {
        return managerName;
    }

}

实现案例

业务信息实体缓存管理器

/**
 * 权益业务信息配置缓存管理器
 * @author 
 * @version $Id: AssetBizInfoConfigCacheManager.java, v 0.1 2022/9/20 11:36  Exp $
 */
public class AssetBizInfoConfigCacheManager extends
                                            AbstractLevelCacheManager<AssetBizInfoConfigCacheKey, AssetBizInfoConfigCacheVal> {

    /**
     * TBase客户端
     */
    private TbaseCacheClient                       tbaseCacheClient;

    /**
     * 权益业务信息配置仓储
     */
    private AssetBizInfoConfigRepository           assetBizInfoConfigRepository;

    /**
     * 缓存穿透保护值
     */
    public static final AssetBizInfoConfigCacheVal GUARD_VALUE = AssetBizInfoConfigCacheVal
        .getImmutableInstance(-1L, new Date(0));

    /**
     * 构造函数
     */
    public AssetBizInfoConfigCacheManager() {
        super(LoggerFactory.getLogger(ASSET_BIZ_INFO_CACHE_DIGEST_LOGGER), "权益业务信息配置缓存管理器");
        buildMemCache();
        buildLruCache();
        buildRemoteCache();
        buildDataSource();
    }

    /**
     * @see AbstractLevelCacheManager#checkKey(Object)
     */
    @Override
    protected boolean checkKey(AssetBizInfoConfigCacheKey key) {
        return key != null;
    }

    /**
     * 初始化常驻缓存
     */
    private void buildMemCache() {
        this.memCache = new AbstractMemCache<AssetBizInfoConfigCacheKey, AssetBizInfoConfigCacheVal>(
            logger, "权益业务信息配置常驻缓存") {
            /**
             * @see AbstractMemCache#initMemCache() 
             */
            @Override
            protected ConcurrentMap<AssetBizInfoConfigCacheKey, AssetBizInfoConfigCacheVal> initMemCache() {
                return new ConcurrentLinkedHashMap.Builder<AssetBizInfoConfigCacheKey, AssetBizInfoConfigCacheVal>()
                    .maximumWeightedCapacity(VccCacheConfigDrmResource.getInstance()
                        .getAssetBizInfoConfigMemCacheMaxSize())
                    .build();
            }

            /**
             * @see com.alipay.assettoolkit.component.levelcache.AbstractCache#hit(Object, Object)  
             */
            @Override
            protected void hit(AssetBizInfoConfigCacheKey key, AssetBizInfoConfigCacheVal val) {
                assetBizInfoConfigHitCountTmp.hitInMemory();
            }
        };
    }

    /**
     * 初始化本地缓存
     */
    private void buildLruCache() {
        this.lruCache = new AbstractLruCache<AssetBizInfoConfigCacheKey, AssetBizInfoConfigCacheVal>(
            logger, "权益业务信息配置本地缓存") {
            /**
             * @see AbstractLruCache#initLruCache() 
             */
            @Override
            protected TimeoutCache<AssetBizInfoConfigCacheKey, AssetBizInfoConfigCacheVal> initLruCache() {
                return new TimeoutCache.Builder<AssetBizInfoConfigCacheKey, AssetBizInfoConfigCacheVal>()
                    .maximumWeightedCapacity(VccCacheConfigDrmResource.getInstance()
                        .getAssetBizInfoConfigLruCacheMaxSize())
                    .build();
            }

            /**
             * 5+10打散，LRU会有Trigger刷新，所以弱依赖过期时间，降低对tbase调用量
             * @see com.alipay.assettoolkit.component.levelcache.AbstractCache#expireTimeFor(Object) 
             */
            @Override
            public long expireTimeFor(AssetBizInfoConfigCacheVal val) {
                return TimeUnit.SECONDS
                    .toMillis(
                        VccCacheConfigDrmResource.getInstance()
                            .getAssetBizInfoConfigLruCacheExpireTime()
                              + RandomUtils.nextInt(10 * 60));
            }

            /**
             * @see com.alipay.assettoolkit.component.levelcache.AbstractCache#hit(Object, Object) 
             */
            @Override
            protected void hit(AssetBizInfoConfigCacheKey key, AssetBizInfoConfigCacheVal val) {
                assetBizInfoConfigHitCountTmp.hitLruCache();
            }
        };
    }

    /**
     * 初始化远端缓存
     */
    private void buildRemoteCache() {
        this.remoteCache = new AbstractRemoteCache<AssetBizInfoConfigCacheKey, AssetBizInfoConfigCacheVal>(
            logger, "权益业务信息配置远端缓存") {
            /**
             * @see com.alipay.assettoolkit.component.levelcache.AbstractCache#getPurely(Object) 
             */
            @Override
            public AssetBizInfoConfigCacheVal getPurely(AssetBizInfoConfigCacheKey key) {
                CasValue<Serializable> val = tbaseCacheClient.getts(buildCacheKey(key));
                return val == null ? null : (AssetBizInfoConfigCacheVal) val.getValue();
            }

            /**
             * @see AbstractRemoteCache#expireTimeFor(Object) 
             */
            @Override
            public long expireTimeFor(AssetBizInfoConfigCacheVal val) {
                // 10天+1小时打散。穿透保护值也按10天过期，业务场景上不会出现后面又能查到的情况
                return VccCacheConfigDrmResource.getInstance()
                    .getAssetBizInfoRemoteCacheExpireTime() + RandomUtils.nextInt(60 * 60);
            }

            /**
             * @see com.alipay.assettoolkit.component.levelcache.AbstractCache#hit(Object, Object)
             */
            @Override
            protected void hit(AssetBizInfoConfigCacheKey key, AssetBizInfoConfigCacheVal val) {
                assetBizInfoConfigHitCountTmp.hitTair();
            }

            /**
             * @see com.alipay.assettoolkit.component.levelcache.Cache#put(Object, Object, long)
             */
            @Override
            public void put(AssetBizInfoConfigCacheKey key, AssetBizInfoConfigCacheVal val,
                            long expireTime) {
                if (checkKey(key) && checkVal(val) && checkExpireTime(expireTime)) {
                    tbaseCacheClient.setts(buildCacheKey(key), val, val.getGmtModified().getTime(),
                        0, (int) expireTime);
                }
            }

            /**
             * 构建tbase缓存建
             * @param key 缓存键
             * @return tbase缓存键
             */
            private String buildCacheKey(AssetBizInfoConfigCacheKey key) {
                return PREFIX_ASSET_BIZ_INFO_CONFIG + key.getUniqueKey();
            }

            /**
             * @see com.alipay.assettoolkit.component.levelcache.Cache#remove(Object) 
             */
            @Override
            public void remove(AssetBizInfoConfigCacheKey key) {
                if (checkKey(key)) {
                    tbaseCacheClient.del(buildCacheKey(key));
                }
            }
        };
    }

    /**
     * 初始化数据源
     */
    private void buildDataSource() {
        this.dataSource = new AbstractDataSource<AssetBizInfoConfigCacheKey, AssetBizInfoConfigCacheVal>(
            logger, "权益业务信息配置数据源") {
            /**
             * @see DataSource#get(Object) 
             */
            @Override
            public AssetBizInfoConfigCacheVal getPurely(AssetBizInfoConfigCacheKey key) {
                AssetBizInfoConfigModel model = assetBizInfoConfigRepository.query(key.getInfoKey(),
                    key.getInfoType());
                if (model == null || model.noNeedWriteCache()) {
                    LogUtil.warn(logger,
                        String.format("[%s]该信息配置不存在或无需写入缓存：%s", getManagerName(), model));
                    return null;
                }
                return toCacheVal(model);
            }

            /**
             * @see AbstractDataSource#hit(Object, Object) 
             */
            @Override
            protected void hit(AssetBizInfoConfigCacheKey key, AssetBizInfoConfigCacheVal val) {
                assetBizInfoConfigHitCountTmp.hitDb();
            }

            /**
             * @see AbstractDataSource#miss(Object) 
             */
            @Override
            protected void miss(AssetBizInfoConfigCacheKey key) {
                LogUtil.warn(logger, String.format("[%s]缓存被穿透[%s][%s]，使用保护值", getManagerName(),
                    key.getInfoKey(), key.getInfoType()));
            }

            /**
             * @see AbstractDataSource#getGuardValue() 
             */
            @Override
            protected AssetBizInfoConfigCacheVal getGuardValue() {
                return GUARD_VALUE;
            }

            /**
             * 转为CacheVal
             */
            private AssetBizInfoConfigCacheVal toCacheVal(AssetBizInfoConfigModel model) {
                AssetBizInfoConfigCacheVal val = new AssetBizInfoConfigCacheVal();
                val.setEntityCount(model.getEntityCount());
                val.setGmtModified(model.getGmtModified());
                return val;
            }
        };
    }

    /**
     * Setter method for property <tt>tbaseCacheClient</tt>.
     *
     * @param tbaseCacheClient value to be assigned to property tbaseCacheClient
     */
    public void setTbaseCacheClient(TbaseCacheClient tbaseCacheClient) {
        this.tbaseCacheClient = tbaseCacheClient;
    }

    /**
     * Setter method for property <tt>assetBizInfoConfigRepository</tt>.
     *
     * @param assetBizInfoConfigRepository value to be assigned to property assetBizInfoConfigRepository
     */
    public void setAssetBizInfoConfigRepository(AssetBizInfoConfigRepository assetBizInfoConfigRepository) {
        this.assetBizInfoConfigRepository = assetBizInfoConfigRepository;
    }

}

从实现案例可以看到，搭建一个缓存系统，只需要创建一个类，实现一些必要的功能，减少了代码量，提升了可维护性。

心得

   分级缓存组件定义了一套标准的缓存系统实现方案，尽可能在内聚代码时，提供较好的扩展性。设计时考虑到了缓存常见问题的解决方案，比如返回伪数据解决缓存穿透问题、加本地锁解决热点key问题，另外提供了配套的缓存刷新方案，以保证数据一致性。

   但是使用过程中发现，要使用这套分级缓存组件，必须要理解上层抽象类的逻辑，才能知道怎么做才是正确的。找到内聚和扩展的平衡点，是一件比较难的事。如果重新设计，可能会考虑内聚更少一点，把更多的动作交给实现者掌控，才能让实现者更放心。

   另外实现三级缓存虽然只需要写一个public类，但还是要写四个匿名类，这里是我不太满意的地方，未来想要优化下，比如使用方法级注解，只需要几个方法即可实现简单的分级缓存系统。

后续改进Action ：

  1. 堆内缓存，数据量需要合理设置，否则将加重GC的负担。可以考虑将一级常驻缓存、一级LRU缓存放在堆外缓存中。
  2. 一级LRU缓存，可以使用带过期时间的LRU淘汰策略来缓存数据，避免 LUR 中长期存在未淘汰且未被使用的数据。
  3. 简化集成方的接入成本。

参考文献：

GuavaCache GitHub Wiki
GuavaCache中文文档
缓存常见问题与解决方案

BigBug_500
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
SpringCloud Alibaba 实战之《性能为王：微服务架构中的多级缓存设计》
小米吃辣椒的博客
05-28 315
前一讲我们学习了利用 Seata 构建微服务环境的分布式事务架构，通过完整的案例也了解了 Seata 的执行过程。 本讲咱们探讨缓存这个话题，看在微服务环境下如何设计有效的多级缓存架构。本讲涉及三方面内容： Web 应用的客户端缓存； 应用层静态资源缓存； 服务层多级缓存。 首先，咱们先讲解微服务架构的多级缓存设计。 微服务架构中的多级缓存设计 提到缓存，想必每一位软件工程师都不陌生，它是目前架构设计中提高性能最直接的方式。这里我们举个例子： Redis 缓存 假设应用程序将原始数据存储
多级缓存设计
maowenbei的博客
09-18 305
多级缓存设计的学习笔记 整理一下实际工程中用到过的一些缓存。作为一个后端程序员，用了反向顺序，从应用层开始写到浏览器层。 多级缓存设计的学习笔记 1. 应用层缓存 1.1 堆内缓存 Guava cache 1.2 堆外缓存 1.3 本地磁盘缓存 1.4 分布式缓存 1.4.1 Redis 1.4.2 Memcached 2. 接入层缓存，Nginx Nginx 缓存配置 3...
缓存一致性解决方案
最新发布
alpha-α
05-29 169
线程A先写，database = 99，（注：在线程A写期间，再执行读操作，此时database = 99，cache = 100，实际读取到的都是不一致数据）注意：需要衡量时间N的大小，N太小，导致删除操作在线程B更新cache操纵之前，导致无法删除脏数据，N太大，导致在N期间读取的缓存都是脏数据。解决方法：延时删除，线程A更新完数据库后，停留时间N，然后删除缓存，此时缓存为空，数据库数据为最新值。线程A -> 线程B 更新数据data-1，data: 100->99->98。
多级缓存架构设计
白鸽
12-22 675
根据请求访问DNS节点， 自动转发到上海CDN节点，检查资源是否被缓存，若已缓存则返回资源否则回源北京提取到并缓存到上海CDN节点，再由上海CDN节点进行返回。进程内缓存：即数据运行时载入程序开辟的缓存中JAVA框架的运用（hibernate，mybatis一二级缓存，springmvc页面缓存）集群情况下，本地缓存+redis+数据库， 一个节点下的实例更新，要通知同意节点下其它实例缓存更新（包含本地缓存）如果没有本地缓存实际上redis就能解决，毕竟是多对一，而不是多对多。进程外缓存：redis。
基于Spring Boot的多级缓存系统设计
nbsaas-boot基于Request-Response的企业级快速开发框架
02-20 1139
创建一个缓存管理类，用于配置多级缓存，指定各级缓存的顺序和策略。import com// 配置Caffeine缓存 CaffeineCacheManager cacheManager = new CaffeineCacheManager("caffeineCache" , "yourCacheName");
性能为王：微服务架构中的多级缓存设计
03-25 631
1、Web应用的客户端缓存 2、应用层静态资源缓存 3、服务层多级缓存 Web层缓存 应用层缓存 在互联网应用中，因为CDN设计多地域多节点组网前期投入成本较高，更多的中小型企业会选择阿里云、腾讯云等提供的CDN服务。 服务层缓存 适合多级缓存的场景 ...
远程监控系统建设方案.docx
07-11
远程监控系统建设方案的核心是构建一个高效、稳定且经济的监控网络，以实现多级管理和控制。以下是根据提供的文件内容提炼出的相关知识点： 1. **功能集成**：系统设计需考虑未来的扩容和升级需求，利用现有网络...
一种多级无缓存高阶路由器的设计与实现.pdf
10-08
为了克服上述挑战，本文提出了一种多级无缓存高阶路由器的设计方案。该设计采用多级Clos网络作为内部架构，并且每个层级都配备有相应的仲裁模块来调度数据包请求。数据包的缓存被放置在输入/输出端口处，从而实现了...
智慧政务云与大数据方案.pptx
10-10
- OTS开放结构化数据服务和OCS开放缓存服务：处理半结构化数据和临时性数据需求。 - 分布式应用框架和流计算服务：处理大数据实时分析和处理任务。 - VPC虚拟网络和MQ消息中间件：构建安全隔离的网络环境，支持异步...
新一代运营商CRM&BOSS架构和解决方案.pptx
10-10
数据架构采用分布式数据库和内存缓存技术，处理非结构化数据，提高数据处理速度和可用性。 10. **云化基础设施**： 基于X86的开放式计算资源池和存储资源池的建设，引入高速网络和SSD存储技术，增强网络能力和...
CDN调度管理平台建设解决方案共23页.pptx
04-25
CDN（内容分发网络）调度管理平台是...综上所述，CDN调度管理平台的建设方案旨在构建一个高效、智能、安全的内容分发网络，提高用户访问体验，降低服务器压力，同时提供强大的监控和管理功能，确保整个系统的稳定运行。
巧妙设计多级缓存，为数据库减负
02-25
自古兵家多谋，《谋攻篇》，“故上兵伐谋，其次伐交，其次伐兵，其下攻城。攻城之法，为不得已”，可见攻城之计有很多种，而爬墙攻城是最不明智的做法，军队疲惫受损、钱粮损耗、百姓遭殃。故而我们有很多迂回之策，谋略、外交、军事手段等等，每一种都比攻城的代价小，更轻量级，缓存设计亦是如此。其实高并发应对的解决方案不是互联网独创的，计算机先祖们很早就对类似的场景做了方案。比如《计算机组成原理》这样提到的CPU缓存概念:它是一种高速缓存，容量比内存小但是速度却快很多，这种缓存的出现主要是为了解决CPU运算速度远大于内存读写速度，甚至达到千万倍的问题。传统的CPU通过fsb直连内存的方式显然就会因为内存访问的等
聊聊微服务架构中的多级缓存设计（建议收藏）
csdn1234561231的博客
01-03 401
今天我们来聊聊缓存这个话题，看看在微服务环境下如何设计有效的多级缓存架构。主要涉及三方面内容：Web 应用的客户端缓存；应用层静态资源缓存；服务层多级缓存。首先，咱们先讲解微服务架构的多级缓存设计。
高性能系统架构设计之：多级缓存
Java Punk
08-11 2891
大流量下的多级缓存设计，大致有五大策略：HTTP 缓存，CDN 缓存，Ngginx负载均衡缓存，Cache进程内缓存，Redis分布式缓存。
实现多级缓存的架构设计方案
weixin_45727359的博客
12-01 215
- 目录 -为什么要做 TMC多级缓存解决方案的痛点TMC 整体架构TMC 本地缓存如何透明整体结构热点发现整体流程数据收集热度滑窗热度汇聚热点探测特性总结实战效果快手商家某...
多级缓存基础架构组件设计
qq_41214487的博客
09-21 733
实现多级缓存组件
高并发系统设计 --多级缓存
qq_61039408的博客
01-15 752
为了提高系统的性能，一般会引入“缓存机制”，将部分热点数据存入缓存中，用空间换取时间，以达到快速响应的目的。我们对缓存的认知停留在redis，但其实缓存远远不是只有redis的，从客户端发起请求开始，缓存就已经开始了。这就是所谓的多级缓存，其中的缓存策略，算法也各不相同，但是都有共同点，我们学习某一个缓存的策略，其实对每一层级的都是有效的，本质是一样的。
redis的多级缓存
09-11
Redis的多级缓存指的是在系统中同时使用多个层次的缓存，其中Redis作为其中一级缓存的一种。在多级缓存中，Redis通常用作一个高速且可靠的缓存层，可以在内存中存储大量的数据，并提供快速的数据读取和写入操作。 ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值