redis缓存使用

于 2023-09-19 13:39:31 发布
阅读量170 收藏 2
点赞数 2
文章标签： 缓存 redis 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenshuyao1/article/details/133002343
版权

添加缓存

查询数据库之前先查询缓存，缓存命中就返回数据，未命中，再查询数据库，并将查询到的数据存入缓存

缓存更新流程

@Transactional
    public Result updateShop(Shop shop) {
        Long id = shop.getId();
        // 判断id合法性
        if (id == null) {
            return Result.fail("店铺id不能为空");
        }
        // 1.更新数据库数据
        updateById(shop);
        // 2.删除缓存数据
        stringRedisTemplate.delete(RedisConstants.CACHE_SHOP_KEY + shop.getId());
        return Result.ok();
    }

缓存穿透流程

 private Result selectThrough(Long id) {
        String shopKey = RedisConstants.CACHE_SHOP_KEY + id;
        // 1.先查询缓存
        Map<Object, Object> shopMap = stringRedisTemplate.opsForHash().entries(shopKey);
        // 2.缓存是否命中
        if(MapUtil.isNotEmpty(shopMap) && shopMap.containsKey("id")){
            // 3.命中，并且数据不为""，直接返回
            Shop shop = BeanUtil.fillBeanWithMap(shopMap, new Shop(), false);
            return Result.ok(shop);
        }
        // 3.1命中，但是数据为""
        if(MapUtil.isNotEmpty(shopMap) && !shopMap.containsKey(id)){
            // 返回错误信息，
            return Result.fail("店铺信息不存在");
        }
        // 4.缓存未命中，再查询数据库
        Shop shop = getById(id);
        // 5.数据库是否命中
        if (shop == null) {
            // 6.未命中，存入缓存""值，设置ttl，返回错误信息
            HashMap<Object, Object> map = MapUtil.newHashMap();
            map.put("","");
            stringRedisTemplate.opsForHash()
                    .putAll(shopKey, map);
            stringRedisTemplate.expire(shopKey,RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);
            return Result.fail("店铺信息不存在");
        }
        // 6.命中，存入缓存，设置ttl，并返回数据
        // 将shop转换为map
        Map<String, Object> map = BeanUtil.beanToMap(shop, new HashMap<>(),
                new CopyOptions()
                        .setIgnoreNullValue(true)
                        .setFieldValueEditor((field, value) ->{
                          /*  setFieldValueEditor优先级要高于ignoreNullValue导致前者首先被触发，
                          因此出现空指针问题。
                          所以需要在setFieldValueEditor中手动判空。
    */                        if(value != null) {
                                return value.toString();
                            }
                            return null;
                        })
        );
        stringRedisTemplate.opsForHash()
                .putAll(shopKey, map);
        stringRedisTemplate.expire(shopKey,RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
        return Result.ok(shop);
    }

缓存雪崩

private Result selectWithMutex(Long id) {
        String shopKey = RedisConstants.CACHE_SHOP_KEY + id;
        // 1.先查询缓存
        Map<Object, Object> shopMap = stringRedisTemplate.opsForHash().entries(shopKey);
        // 2.缓存是否命中
        if(MapUtil.isNotEmpty(shopMap) && shopMap.containsKey("id")){
            // 3.命中，并且数据不为""，直接返回
            Shop shop = BeanUtil.fillBeanWithMap(shopMap, new Shop(), false);
            return Result.ok(shop);
        }
        // 3.1命中，但是数据为""
        if(MapUtil.isNotEmpty(shopMap) && !shopMap.containsKey(id)){
            // 返回错误信息，
            return Result.fail("店铺信息不存在");
        }
        Shop shop = null;
        String lockKey = LOCK_SHOP_KEY + id;
        try {
            // 4.缓存未命中，尝试获取锁
            boolean isLock = tryLock(lockKey);
            if (!isLock){
                // 4.1.没有获取到锁，就休眠一段时间
                Thread.sleep(100);
                // 4.2再次读取缓存
                return selectWithMutex(id);
            }
            // 5.获取到锁，就从数据库查询数据
            shop = getById(id);
            // 5.1数据库是否命中
            if (shop == null) {
                // 6.未命中，存入缓存""值，设置ttl
                 HashMap<Object, Object> map = MapUtil.newHashMap();
                 map.put("","");
                stringRedisTemplate.opsForHash()
                        .putAll(shopKey, map);
                stringRedisTemplate.expire(shopKey,RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);
                return Result.fail("店铺信息不存在");
            }
            // 6.命中，存入缓存，设置ttl
            // 将shop转换为map
            Map<String, Object> map = BeanUtil.beanToMap(shop, new HashMap<>(),
                    new CopyOptions()
                            .setIgnoreNullValue(true)
                            .setFieldValueEditor((field, value) ->{
                              /*  setFieldValueEditor优先级要高于ignoreNullValue导致前者首先被触发，
                              因此出现空指针问题。
                              所以需要在setFieldValueEditor中手动判空。
        */                        if(value != null) {
                                    return value.toString();
                                }
                                return null;
                            })
            );
            stringRedisTemplate.opsForHash()
                    .putAll(shopKey, map);
            stringRedisTemplate.expire(shopKey,RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
        } catch (InterruptedException e) {
           throw new RuntimeException(e);
        } finally {
            // 7.释放锁
            unLock(lockKey);
        }

        return Result.ok(shop);
    }

    private boolean tryLock(String key){
        Boolean flag = stringRedisTemplate.opsForHash().putIfAbsent(key, "1", "1");
        stringRedisTemplate.expire(key,RedisConstants.LOCK_SHOP_TTL,TimeUnit.SECONDS);
        return BooleanUtil.isTrue(flag);

    }
    private void unLock(String key){
        stringRedisTemplate.delete(key);
    }

缓存击穿-互斥锁

缓存击穿-逻辑过期

​​​​​​​

@Component
@Data
public class CacheService {
    private final StringRedisTemplate stringRedisTemplate;

    /**
     * 任意对象序列化为json
     */
    public <R,I> void setStr(String keyPrefix, I id, R r, Long expire, TimeUnit unit){
        stringRedisTemplate.opsForValue().set(keyPrefix + id,JSONUtil.toJsonStr(r),expire,unit);
    }
    // json反序列化
    public <R,I> R getStr(String keyPrefix, I id, Class<R> type){
        String json = stringRedisTemplate.opsForValue().get(keyPrefix + id);
        return JSONUtil.toBean(json, type);
    }

    public void setWithLogicalExpire(String key, Object value, Long time, TimeUnit unit) {
        // 设置逻辑过期
        RedisData redisData = new RedisData();
        redisData.setData(value);
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(unit.toSeconds(time)));
        // 写入Redis
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
    }

    // 缓存穿透
    public  <R,I> R selectWithThrough(String keyPrefix, I id, Class<R> type,
                                      Function<I,R> dbFallBack,
                                      Long expire,
                                      TimeUnit unit
                                      ) {
        String key = keyPrefix + id;
        // 1.先查询缓存
        String json = stringRedisTemplate.opsForValue().get(key);
        // 2.缓存是否命中
        if(StrUtil.isNotBlank(json)){
            // 3.命中，并且数据不为""，直接返回
            return BeanUtil.toBean(json,type);
        }
        // 3.1命中，但是数据为""
        if(json != null){
            // 返回错误信息，
            return null;
        }
        // 4.缓存未命中，再查询数据库
        R r = dbFallBack.apply(id);
        // 5.数据库是否命中
        if (r == null) {
            // 6.未命中，存入缓存""值，设置ttl，返回错误信息
            stringRedisTemplate.opsForValue().set(key,"",expire,unit);
            return null;
        }
        // 6.命中，存入缓存，设置ttl，并返回数据
        // 将shop转换为map
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(r));
        return r;
    }
    private static final String LOCK_SHOP_KEY = "lock:shop:";
    // 缓存击穿-互斥锁
    public <R,I> R selectWithMutex(
            String keyPrefix, I id, Class<R> type,
                                  Function<I,R> dbFallBack,
                                  Long expire,
                                  TimeUnit Unit) {
        String key =  keyPrefix + id;
        // 1.先查询缓存
        String json = stringRedisTemplate.opsForValue().get(key);
        // 2.缓存是否命中
        if(StrUtil.isNotBlank(json)){
            // 3.命中，并且数据不为""，直接返回
            R r = JSONUtil.toBean(json, type);
            return r;
        }
        // 3.1命中，但是数据为""
        if(json != null){
            // 返回错误信息，
            return null;
        }
        R r = null;
        String lockKey = LOCK_SHOP_KEY + id;
        try {
            // 4.缓存未命中，尝试获取锁
            boolean isLock = tryLock(lockKey);
            if (!isLock){
                // 4.1.没有获取到锁，就休眠一段时间
                Thread.sleep(100);
                // 4.2再次读取缓存
                return selectWithMutex(keyPrefix,id,type,dbFallBack,expire,Unit);
            }
            // 5.获取到锁，就从数据库查询数据
            r = dbFallBack.apply(id);
            Thread.sleep(100);
            // 5.1数据库是否命中
            if (r == null) {
                // 6.未命中，存入缓存""值，设置ttl
                stringRedisTemplate.opsForValue().set(key,"",expire,Unit);
                return null;
            }
            // 6.命中，存入缓存，设置ttl
            // 将shop转换为map
           stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(r),expire,Unit);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            // 7.释放锁
            unLock(lockKey);
        }

        return r;
    }

    private boolean tryLock(String key){
        Boolean flag = stringRedisTemplate.opsForHash().putIfAbsent(key, "1", "1");
        stringRedisTemplate.expire(key,RedisConstants.LOCK_SHOP_TTL,TimeUnit.SECONDS);
        return BooleanUtil.isTrue(flag);

    }
    private void unLock(String key){
        stringRedisTemplate.delete(key);
    }

    private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(1);
    // 缓存击穿-逻辑过期
    public <R,I> R selectWithLogicExpire(
            String keyPrefix, I id, Class<R> type,
            Function<I,R> dbFallBack,
            Long expire,
            TimeUnit Unit) {
        String key =  keyPrefix + id;
        // 1.先查询缓存
        String json = stringRedisTemplate.opsForValue().get(key);
        // 2.缓存是否命中
        if(StrUtil.isBlank(json)){
            // 2.1未命中，直接返回null
            return null;
        }
       // 2.2命中
        // 3.判断key是否过期
        RedisData redisData = JSONUtil.toBean(json, RedisData.class);
        R r = JSONUtil.toBean((JSONObject) redisData.getData(), type);
        LocalDateTime expireTime = redisData.getExpireTime();
        if(expireTime.isAfter(LocalDateTime.now())){
            // 3.1没有过期直接返回数据
            return r;
        }
        // 3.2过期就尝试获取锁
        String lockKey = LOCK_SHOP_KEY + id;
        boolean isLock = tryLock(lockKey);
        // 4.判断是否获取到锁
        if (isLock){
            // 5.获取到锁，就开启一个新的线程来从数据库查询数据
            CACHE_REBUILD_EXECUTOR.submit(() ->{
                try {
                    // 6.查询数据库
                    R newR = dbFallBack.apply(id);
                    // 7.重建缓存
                    setWithLogicalExpire(key,newR,20L,TimeUnit.SECONDS);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                } finally {
                    // 8.释放锁
                    unLock(lockKey);
                }
            });
        }
          // 4.2没有获取到锁，返回过期数据
        return r;
    }
}

public Result select(Long id) {
        //return selectThrough(id);
        //return selectWithMutex(id);
        // 解决缓存穿透
        //Shop shop = cacheService
                //.selectWithThrough(CACHE_SHOP_KEY, id, Shop.class, this::getById, CACHE_SHOP_TTL, TimeUnit.MINUTES);

        // 互斥锁解决缓存击穿
         //Shop shop = cacheService
                 //.selectWithMutex(CACHE_SHOP_KEY, id, Shop.class, this::getById, CACHE_SHOP_TTL, TimeUnit.MINUTES);

        // 逻辑过期解决缓存击穿
         Shop shop = cacheService
                 .selectWithLogicExpire(CACHE_SHOP_KEY, id, Shop.class, this::getById, 20L, TimeUnit.SECONDS);

        if (shop == null) {
            return Result.fail("店铺不存在！");
        }
        // 7.返回
        return Result.ok(shop);
    }

总结

在将数据存入缓存的时候，我选择的hash，那么就需要将符合的对象转换为对应的数据才能存入缓存中

几个易错点

// 6.命中，存入缓存，设置ttl，并返回数据
        // 将shop转换为map
        Map<String, Object> map = BeanUtil.beanToMap(shop, new HashMap<>(),
                new CopyOptions()
                        .setIgnoreNullValue(true)
                        .setFieldValueEditor((field, value) ->{
                          /*  setFieldValueEditor优先级要高于ignoreNullValue导致前者首先被触发，
                          因此出现空指针问题。
                          所以需要在setFieldValueEditor中手动判空。
    */                        if(value != null) {
                                return value.toString();
                            }
                            return null;
                        })
        );

n年后又是一条好汉
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
SpringBoot项目 MybatisPlus使用 Redis缓存.zip
02-13
本项目中，我们看到“SpringBoot项目 MybatisPlus使用 Redis缓存.zip”主要涉及了SpringBoot、MybatisPlus和Redis三个核心组件，它们在实际开发中扮演着重要角色。 首先，SpringBoot是Spring框架的一种简化版，它...
Spring Boot 基于注解的 Redis 缓存使用详解
08-30
Spring Boot 基于注解的 Redis 缓存使用详解 一、Spring Boot 中的缓存机制 Spring Boot 提供了多种缓存机制，包括基于注解的缓存机制。在这个机制中，我们可以使用 @Cacheable、@CacheEvict、@CachePut 等注解来...
RedisCache redis工具类
xiguasweet的博客
03-27 4503
public class RedisCache { @Autowired public RedisTemplate redisTemplate; /** * 缓存的基本对象。Integer String 实体类 * * @param key 缓存的键值 * @param value 缓存的值 * @param <...
系统性能优化 1-1 Redis删除key和字符串拼接
小草的博客
09-13 590
个人资源分享网站：首页-小草资源分享网站 1.问题描述 再清除redis缓存的时候，虽然del key名称 用于删除已存在的key,不存在的key会被忽略，但是再循环体里面，会严重影响代码执行效率 原始代码： //查询所有非白名单用户 SysUser sUser=new SysUser(); List<SysUser> userList = userMapper.queryUserAttendanceList(sUser); for(SysUser sysUser:userLis..
Redis常见问题整理（持续更新）
miroCyber的博客
03-26 156
redis是什么？ Redis 是一个基于内存的高性能key-value数据库，将数据加载到内存中，读写效率高于硬盘。 Nosql数据库的优势 1）易扩展 这些类型的数据存储不需要固定的模式，无需多余的操作就可以进行横向的扩展。相对于关系型数据库可以减少表和字段特别多的情况。也无型之间在架构的层面上带来了可扩展的能力 2）大数据量提高性能 3）多样灵活的数据模型 使用redis有哪些好处？ (1)...
Redis缓存配置及使用
u014612889的博客
10-20 2070
一、pom.xml添加依赖 org.springframework.boot spring-boot-starter-redis 1.4.3.RELEASE 二、application.yml添加redis配置 配置如下： cache: type: redis redis: host: 127.0.0.1 port: 6379 pool: max-idle: 20 #连接池中最大空闲连接数 min-idle: 1 #连接池中最小空闲连接数 max-active: 20 #
redis五大类型用法
weixin_34288121的博客
03-25 549
Redis五大类型:字符串（String）、哈希/散列/字典（Hash）、列表（List）、集合（Set）、有序集合（sortedset）五种Controller:@Resource RedisTemplate<String, String> redisTemplate;总括:redisTemplate.opsForValue();//操作字符串redisTemplate.opsFo...
redis缓存 redis缓存
最新发布
06-11
redis缓存 redis缓存
redis本地缓存与redis缓存
02-14
文件名称“RedisCache-master”可能是一个包含Redis缓存相关项目的源代码仓库，里面可能包括了如何配置、使用Redis作为缓存的示例代码，以及如何与本地缓存结合的实践。 总结来说，本地缓存和Redis缓存各有优势，...
Spring Cache手动清理Redis缓存
08-25
在本文中，我们将介绍如何使用Spring Cache手动清理Redis缓存。 首先，我们需要注册RedisTemplate作为Bean，以便使用它来清理缓存。我们可以使用以下代码注册RedisTemplate： ```java @Bean(name = ...
若依缓存使用浅析
qq_39007838的博客
12-15 4485
redis 缓存 若依
Hutool工具包的BeanUtil的beanToMap方法------空指针的问题
qq_47109099的博客
08-04 7456
Hutool工具包的BeanUtil的beanToMap方法------空指针的问题
RedisCache
Leon_Jinhai_Sun的博客
06-05 2308
Redis
缓存（cache、Redis）
weixin_51539416的博客
11-21 818
缓存实例（Cache和Redis）
RedisCache工具类
u013008898的博客
04-08 4150
package com.kejin.utils.redis; import java.util.ArrayList; import java.util.Collection; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Map; import java.u...
分布式缓存Redis Cache
hacker_lli的博客
09-15 6569
本文设计技术点：spring cache, Lettuce, Spring Data Redis 开始之前，有个问题，知道什么是分布式部署吗，分布式部署都用在什么地方 现在的应用大都以微服务的方式进行分布式部署，因此如果仅仅使用本地缓存是满足不了需求的（Infinispan这样基于本地的内存实现的分布式缓存在这里暂不作讨论。。。）针对分布式场景下的缓存应用，我们急需要一个高可用的、快速的、中心化的、分布式的缓存产品。然后在众多此场景的实现产品中，Redis以它众多优秀的特性脱颖而出。 所以，本文集中讲的点都
Redis缓存操作（添加缓存，删除缓存，修改缓存）的代码实现
qq_28945537的博客
03-14 2588
看文章之前你需要了解Redis的数据类型 和数据类型的 相关方法 我这边简单介绍一下： Redis支持五种数据类型：String（字符串），hash（哈希），list（列表），set（集合），zset（有序集合） 相关方法： 1.String（字符串）：String是resid最基本的类型，一个key对应一个value。String类型是二进制安全的。string中可以包含任何数据。 set：添加...
Redis缓存删不掉？查看你的Key序列化方式吧
hober的专栏
05-03 3174
排查问题发现，原来是B系统的Redis key序列化方式与A系统不一致，导致缓存删除失败。
Redis缓存使用步骤
06-02
使用Redis缓存可以按照以下步骤进行： ...以上是一般的Redis缓存使用步骤，具体的实现方式会根据具体的应用场景而有所不同。同时，Redis还可以用作分布式锁、消息队列等功能，可以灵活应用于各种场景中。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值