缓存的设计与实现

最新推荐文章于 2023-06-07 19:42:13 发布
最新推荐文章于 2023-06-07 19:42:13 发布
阅读量387 收藏
点赞数 1
分类专栏： 学无止境 文章标签： redis 缓存 java 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fangye1/article/details/111408077
版权

参考文章

缓存穿透、缓存击穿、缓存雪崩区别和解决方案

设计思路

没有缓存的时候，获取数据是直接查询数据库的。如果某时间段内并发查询的次数太多，会对数据库造成很大的压力，甚至崩盘。这时我们就会想到使用缓存。查询数据时先查询缓存，如果缓存有则直接还回，如果没有则查询数据库，把结果放入缓存中并返回。下次查询时可以直接从缓存中获取。

现有一商品表 goods ，对goods的查询做redis缓存优化。goods的key,value如下。

key = 固定值+version（可变）+参数  = "cache:goods:" + +version（可变）+参数
value = 从数据库查询的结果。

其中version也是 redis缓存中的值

key = 国定值="cache:goods:version"
value = 1  //初始值1，goods每次增删改，value都加1

思路：

  1. 创建2个注解：CacheVersion ，CyCache

    @interface CacheVersion {versionKey,expireTime=3600}：缓存版本
@interface CyCache {cacheKey,versionKey,expireTime=3600} ：缓存

  2. 创建2个aspect：CacheVersionAspect，CacheAspect

    class CacheVersionAspect：拦截标记了注解CacheVersion 的增删改方法。
	在方法执行，CacheVersion.versionKey对应的缓存加1
class CacheAspect ：拦截标记了注解CyCache的查询方法。
	在执行数据库查询之前先查一下redis缓存(CyCache.cacheKey+version+参数)是否有数据，
	如果有则直接返回，没有则执行查询方法，得到结果后把结果放入redis中并返回。

  3. 给service的增删改方法添加注解@CacheVersion ，给查询方法添加注册@CyCache

    通过@CyCache，查询不用每次查询数据库，可以从redis缓存中获取数据。
通过@CacheVersion，每次增删改后version的值会递增。下次查询时，
（CyCache.key+version+参数）的缓存就没有（因为version的值变了），需要重新查询数据库并缓存。

实现

创建2个注解：CacheVersion ，CyCache

package com.example.demo.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 缓存版本注解
 */
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface CacheVersion {
    /**
     * 版本key
     */
    String[] versionKeys() default {};

    /**
     * 过期时间，单位秒
     */
    int expireTime() default 3600;
}

package com.example.demo.annotation;


import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 缓存注解
 */
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Cache {
    /**
     * 版本key 需要和 CacheVersion。versionKey 一样
     */
    String versionKey() default "";

    /**
     * 数据key的固定值部分
     */
    String cacheKey() default "";

    /**
     * 方法的参数集合
     */
    String[] paramName() default {};

    /**
     * 过期时间，单位秒
     */
    int expireTime() default 3600;
}

创建2个aspect：CacheVersionAspect，CacheAspect

package com.example.demo.aspect;

import com.example.demo.annotation.CacheVersion;
import com.example.demo.cache.CacheClient;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

/**
 * 缓存版本处理切面
 */
@Slf4j
@Component
@Aspect
public class CacheVersionAspect {
    @Resource
    private CacheClient cacheClient;

    @After(value = "@annotation(cacheVersion))")
    public void handlerServiceCacheVersion(JoinPoint point, CacheVersion cacheVersion) {
        try {
            String[] versionKeys = cacheVersion.versionKeys();
            for (String versionKey : versionKeys) {
                cacheClient.increaseCount(versionKey);
                cacheClient.expire(versionKey, cacheVersion.expireTime());
                log.info("update version of : {}", versionKey);
            }
        } catch (Exception e) {
            log.info("缓存异常：", e);
        }
    }
}



package com.example.demo.aspect;


import com.example.demo.annotation.Cache;
import com.example.demo.cache.CacheClient;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

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

@Slf4j
@Component
@Aspect
public class CacheAspect {
    @Resource
    private CacheClient cacheClient;

    public CacheAspect() {
    }

    @Around(value = "@annotation(cache))")
    public Object handlerServiceCache(ProceedingJoinPoint point, Cache cache) {
        try {
            //获取参数拼凑的key
            String paramKey = getParamKey(point, cache.paramName());
            //获取version的key
            String versionKey = getCacheVersion(cache);
            //dataKey= cache.cacheKey + 参数拼凑的key +version的key
            String dataKey = cache.cacheKey() + paramKey + versionKey;

            // 处理缓存
            Object data = cacheClient.get(dataKey);
            if (data != null) {
                System.out.println("从缓存中获取数据，key = " + dataKey);
                return data;
            }
            data = point.proceed();
            if (data != null) {
                cacheClient.set(dataKey, data);
                cacheClient.expire(dataKey, cache.expireTime());
            }
            return data;
        } catch (Throwable e) {
            log.error("缓存异常：", e);
        }
        return null;
    }

    /**
     * 获取version的key
     */
    private String getCacheVersion(Cache cache) {
        String versionKey = cache.versionKey();
        if (StringUtils.isBlank(versionKey)) {
            return "";
        }
        Integer cacheVersion;
        if (cacheClient.get(versionKey) == null) {
            cacheVersion = cacheClient.increaseCount(versionKey);
        } else {
            cacheVersion = (Integer) cacheClient.get(versionKey);
        }
        cacheClient.expire(versionKey, cache.expireTime());
        return ":" + cacheVersion.toString();
    }

    /**
     * 获取参数拼凑的key
     */
    private String getParamKey(ProceedingJoinPoint point, String[] params) {
        if (params == null || params.length == 0) {
            return "";
        }
        StringBuilder keyExtra = new StringBuilder();
        try {
            Map<String, Object> nameAndArgs = this.getFieldsName(point, point.getArgs());
            for (String param : params) {
                if (nameAndArgs.get(param) != null) {
                    keyExtra.append(":").append(nameAndArgs.get(param));
                }
            }
        } catch (Exception e) {
            log.info("缓存异常：", e);
        }
        return keyExtra.toString();
    }

    /**
     * 基于Aspect，java1.8以上用java自带的参数反射，以下用spring的实现，似乎跟javassist一样
     */
    private Map<String, Object> getFieldsName(ProceedingJoinPoint point, Object[] args) {
        Map<String, Object> map = new HashMap<>();
        Signature signature = point.getSignature();
        MethodSignature methodSignature = (MethodSignature) signature;
        String[] names = methodSignature.getParameterNames();
        for (int i = 0; i < args.length; i++) {
            map.put(names[i], args[i]);
        }
        return map;
    }

}

给service的增删改方法添加注解@CacheVersion ，给查询方法添加注册@CyCache

package com.example.demo.service;

import com.example.demo.annotation.Cache;
import com.example.demo.annotation.CacheVersion;
import com.example.demo.demain.Good;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

@Service
public class GoodService {
    private Integer goodNum = 2;
    private String description = "好商品";


    @Cache(cacheKey = "cache:good", versionKey = "cache:good:version", paramName = {"name"})
    public List<Good> getGoodList(String name) {
        System.out.println("从数据库中获取数据");
        List<Good> goods = new ArrayList<>();
        for (int i = 1; i <= goodNum; i++) {
            Good good = Good.builder().id(i).name(i + "号商品").price(2000L).description(i + "号商品 " + description).build();
            goods.add(good);
        }
        return goods;
    }

    @CacheVersion(versionKeys = {"cache:good:version"})
    public void addGood() {
        System.out.println("增长商品");
        goodNum++;
    }

    @CacheVersion(versionKeys = {"cache:good:version"})
    public void deleteGood() {
        System.out.println("减少商品");
        goodNum--;
    }

    @CacheVersion(versionKeys = {"cache:good:version"})
    public void updateGood(Integer id, String description) {
        System.out.println("修改商品描述 description = " + description);
        this.description = description;
    }

}

测试

package com.example.demo.service;

import com.alibaba.fastjson.JSON;
import com.example.demo.demain.Good;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import javax.annotation.Resource;
import java.util.List;

@SpringBootTest
class GoodServiceTest {
    @Resource
    private GoodService goodService;

    @Test
    void getGoodList() {
        System.out.println("第1次查询:");
        List<Good> goods = goodService.getGoodList("你好");
        System.out.println(JSON.toJSONString(goods));
        System.out.println("第2次查询:");
        goods = goodService.getGoodList("你好");
        System.out.println(JSON.toJSONString(goods));

        System.out.println("########## 修改商品 ##########");
        goodService.updateGood(2,"非常好的商品");
        System.out.println("########## 修改商品 ##########");

        System.out.println("修改后第1次查询:");
        goods = goodService.getGoodList("你好");
        System.out.println(JSON.toJSONString(goods));
        System.out.println("修改后第2次查询:");
        goods = goodService.getGoodList("你好");
        System.out.println(JSON.toJSONString(goods));
    }
}

运行结果
在这里插入图片描述

问题

1、缓存雪崩

缓存失效，请求全部到数据库中，很可能就把我们的数据库搞垮，导致整个服务瘫痪！缓存失效可能如下原因：

1，Redis缓存数据时，需设置过期时间，如果大量过期时间相同，极端的情况下，可能会出现这些缓存同时失效，全部请求到数据库中。

2，Redis挂掉了，全部请求到数据库中。
,
如何解决缓存雪崩

第一种情况

在缓存的时候给过期时间加上一个随机值，这样就会大幅度的减少缓存在同一时间过期。

第二种情况可分为 三步处理

事发前：

  1. redis持久化。
  2. 实现Redis的高可用(主从架构+Sentinel 或者Redis Cluster)，避免Redis全部挂掉。
  3. 设置备份缓存，如本地缓存(ehcache)，当redis缓存雪崩后，启用备份缓存。

事发中：

  1. 用 hystrix 对源服务访问进行 限流、降级。降级在高并发系统中是非常正常的：比如推荐服务中，如果个性化推荐服务不可用，可以降级补充热点数据。可参考文章： Hystrix学习总结
  2. 启用备份缓存

事发后：

  1. 立即重启。redis持久化后，redis重启后自动从磁盘上加载数据，快速恢复缓存数据。
2、缓存穿透

缓存穿透是指查询一个一定不存在的数据。由于缓存不命中，并且出于容错考虑，如果从数据库查不到数据则不写入缓存
这将导致这个不存在的数据每次请求都要到数据库去查询，失去了缓存的意义。这就是缓存穿透：请求的数据在缓存大量不命中，导致请求走数据库。缓存穿透如果发生了，也可能把我们的数据库搞垮，导致整个服务瘫痪！

如何解决缓存雪崩

  1. 由于请求的参数是不合法的(每次都请求不存在的参数)，于是我们可以使用布隆过滤器(BloomFilter)或者压缩filter提前拦截，不合法就不让这个请求到数据库层！
  2. 当我们从数据库找不到的时候，我们也将这个空对象设置到缓存里边去。下次再请求的时候，就可以从缓存里边获取了。这种情况我们一般会将空对象设置一个较短的过期时间。
3、缓存击穿

缓存击穿是指缓存中没有但数据库中有的数据（一般是缓存时间到期），这时由于并发用户特别多，同时读缓存没读到数据，又同时去数据库去取数据，引起数据库压力瞬间增大，造成过大压力

如何解决缓存雪崩

  1. 设置热点数据永远不过期。
  2. 加互斥锁，互斥锁参考代码如下：
    在这里插入图片描述

说明：

1）缓存中有数据，直接走上述代码13行后就返回结果了

2）缓存中没有数据，第1个进入的线程，获取锁并从数据库去取数据，没释放锁之前，其他并行进入的线程会等待100ms，再重新去缓存取数据。这样就防止都去数据库重复取数据，重复往缓存中更新数据情况出现。

3）当然这是简化处理，理论上如果能根据key值加锁就更好了，就是线程A从数据库取key1的数据并不妨碍线程B取key2的数据，上面代码明显做不到这点。

枫叶-哈哈
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【Redis】Redis最佳实践：键值设计
qq_50675319的博客
09-29 2563
无论是哪种数据类型， key都是string类型，string类型的底层编码包含int、embstr和raw三种。如果key中全是数字，那么就会直接以int类型去存储，而int占用的空间也是最小的，当然出于业务需求，我们不可能将key设计为一个全数字的，而如果不是纯数字，底层存储的就是SDS内容，如果小于44字节，就会使用embstr类型，embstr在内存中是一段连续的存储空间，内存占用相对raw来说较小，而当字节数大于44字节时，会转为raw模式存储，在raw模式下，内存空间不是连续的，而是采用一个指针
缓存与数据库双写不一致解决方案
foreveyking的博客
09-24 1145
前提 保证最终一致性的解决方案是缓存设置过期时间。一下方案讨论的是不依赖于给缓存设置过期时间的情况。 方案一：先更新缓存，再更新数据库 不推荐。 先更新缓存若更新数据库失败，还需再更新缓存。 方案二：先更新数据库，再更新缓存 不推荐。 同时有请求A和请求B进行更新操作，请求A与B在不同线程，可能会出现： 请求A更新了数据库 请求B更新了数据库 请求B更新了缓存 请求A更新了缓存 这就出现请求A更新缓存应该比请求B更新缓存早才对，但是因为网络等原因，B却比A更早更新了缓存。这就导致了脏数
picACG本地缓存目录_如果20万用户同时访问一个热点缓存，如何优化你的缓冲架构？...
weixin_39898011的博客
11-03 332
目录（1）为什么要用缓存集群（2）20万用户同时访问一个热点缓存的问题（3）基于流式计算技术的缓存热点自动发现（4）热点缓存自动加载为JVM本地缓存（5）限流熔断保护（6）总结（1）为什么要用缓存集群这篇文章，咱们来聊聊热点缓存的架构优化问题。其实使用缓存集群的时候，最怕的就是热key、大value这两种情况，那啥叫热key大value呢？简单来说，热key，就是你的缓存集群中的某个key瞬间被数...
Redis缓存Key设置
LiZhen314的博客
03-11 1939
目录 背景： 持仓缓存key设置方法及出现问题： 原因分析和解决方案： Redis缓存注意点： 背景： 春节活动期间，为了提高业务接口的平均响应时间，给业务相关接口加缓存。 持仓缓存key设置方法及出现问题： 缓存key设置方法：key用接口对应的“包名+类名+方法名+userId”设置，例如： /h5/regular/finance/myfixedfinances（用户定期总资产）缓存key为：com.XXXUserCenterController.getMyFixedProjectInf
Redis里面的Key设计
jakelihua
06-07 955
本文讲解Redis里面的Key设计。
Java测井平台高效数据操作缓存设计与实现.pdf
最新发布
12-29
Java测井平台高效数据操作缓存设计与实现 本文主要介绍了Java测井平台高效数据操作缓存设计与实现，旨在解决不同语言交互处理软件跨平台集成时原有缓存功能不能被继承使用的技术难题。文章首先介绍了基于广义测井...
多处理器共享缓存设计与实现.pdf
09-25
多处理器共享缓存设计与实现.pdf
简单的PHP缓存设计实现代码
10-28
本文将深入探讨一种基于文件系统的简单PHP缓存设计及其实现方式，具体通过比较文件的修改时间和当前时间来决定是否需要重新生成内容。 首先，我们来看一下提供的代码片段： ```php // 设置缓存过期时间，单位为秒...
架构设计之分布式缓存
03-02
1：前言我们在开发系统的过程中，缓存是个有用的模块。下面我就把我们的缓存模块给大家做个简单介绍。2：类图3：简单介绍缓存分为两个部分。一个是缓存结构一个是存储结构...待改进的地方：缓存没有实现一些像FIFO,LFU,
应用系统缓存设计思路与方案
04-11
"应用系统缓存设计思路与方案" 缓存是一种常见的技术，用于提高系统读性能。特别是在读多写少的应用场景中，缓存可以极大地降低数据库的压力。例如，在用户余额信息表中，我们可以在缓存中建立uid到money 的键值对...
一种基于FPGA实现的高速缓存设计
01-19
为了解决嵌入式实时数据采集系统中，高速采集数据量大，而处理器的处理速度有限的矛盾，保证数据不丢失并提高处理器的数据吞吐率，文中提出一种基于FPGA(现场可编程门阵列) 实现的FIFO(先入先出存储器) 结构设计，它...
分布式数据缓存系统的设计与实现
03-06
布模式的分布式缓存，复制缓存和分布式缓存，采用JGroups 技术实现集群内节点间的通信及数据迁移，通过可靠性服务模块控制完成整个系统的数据冗余备份和失败恢复功能。经测 试，本文设计的分布式数据缓存系统提供了...
设计LRU缓存结构Python实现
02-12
设计LRU(最近最少使用)缓存结构，该结构在构造时确定大小，假设大小为 capacity ，操作次数是 n ，并有如下功能: 1. Solution(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存 2. get(key)：如果关键字 ...
fifo.rar_VHDL实现缓存
09-20
在数字系统设计中，缓存（Cache）是一种用于提高数据访问速度的技术，它通过存储最近频繁使用的数据来减少主存与处理器之间的数据传输延迟。在 FPGA 或 ASIC 设计中，VHDL（Very High Speed Integrated Circuit ...
实现多级缓存架构设计方案.docx
05-17
**实现多级缓存架构设计方案概述** TMC，即透明多级缓存，是由有赞PaaS团队开发的，旨在解决公司内部应用的缓存管理问题，特别是针对高并发下的热点访问。传统的分布式缓存解决方案，如CodisProxy + Redis或zanKV，...
高并发应用中的缓存设计和实现
a1472750149的博客
10-31 838
高并发应用中的挑战 随着互联网快速发展、传统行业IT转型，很多应用的流量越来越高，高并发成为服务端中的一个重要挑战，在高并发场景下，只使用数据库来承担流量， 会遇到各种各样的问题和挑战。 本文分为三个部分，首先我们了解下高并发场景下常见的一些关于缓存的问题，然后给出一些通用的缓存设计模式解决方案，最后我们分析一下知乎中的一些功能点进行技术方案设计。 估算一个场景的浏览量功能需要的资源 现在我们用知乎这个app来分析，以实现其中的浏览量功能为例，来看一下我们可能会遇到哪些问题。 我们要实现的浏览
统一缓存处理 AOP
lingchen1120的博客
12-18 743
使用 Redis 做缓存， 并实现统一的缓存处理 (AOP)
如何保证Redis缓存和数据库一致性
csdn_life18的博客
03-15 842
这里可以结合使用canal(阿里的一款开源框架)，通过该框架可以对MySQL的binlog进行订阅，而canal正是模仿了mysql的slave数据库的备份请求，使得Redis的数据更新达到了相同的效果。，或者是分布式队列按顺序去操作数据库或者 Redis，带来的副作用就是：数据库本来是并发的，现在变成串行的了，加锁或者排队执行的方案降低了系统性能，所以这个方案看起来不太可行。其实这种机制，很类似MySQL的主从备份机制，因为MySQL的主备也是通过binlog来实现的数据一致性。
如何保证Redis缓存和数据库一致性？
future_5的博客
05-05 150
Redis缓存和数据库的一致性

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值