Redis项目实战--商户查询缓存

最新推荐文章于 2024-06-14 10:22:17 发布
最新推荐文章于 2024-06-14 10:22:17 发布
阅读量681 收藏 26
点赞数 26
文章标签： 缓存 redis 数据库 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wjf83902/article/details/138763927
版权

一、商户查询缓存要实现的内容

1、添加Redis缓存

2、缓存更新策略

3、缓存穿透

4、缓存雪崩

5、缓存击穿

6、缓存工具封装

二、根据id查询商品时添加Redis缓存

2.1 根据id查询商铺缓存流程

2.2 代码实现 

 @Override
    public Result queryById(Long id) {
        // 1、从redis查询商铺缓存
        String shopJson = stringRedisTemplate.opsForValue().get(RedisConstants.CACHE_SHOP_KEY+id);
        // 2、判断是否存在
        if(StrUtil.isNotBlank(shopJson)){
            // 3、存在  直接返回
            //将json字符串反序列化成java对象
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return Result.ok(shop);
        }
        // 4、不存在，根据id查询数据库
        Shop shop = getById(id);
        if(shop==null){
            // 5、不存在：返回错误
            return Result.fail("店铺不存在");
        }
        // 6、存在，写入redis缓存
        stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY+id,JSONUtil.toJsonStr(shop));
        // 7、返回
        return Result.ok(shop);
    }

 2.3 知识点

        1、java对象与json对象的转换 ---- 利用 hutool 中的  JSONUtil 工具类

 //将json字符串反序列化成java对象
 Shop shop = JSONUtil.toBean(shopJson, Shop.class);
//将java对象序列化成json对象
JSONUtil.toJsonStr(shop)

三、缓存更新策略 

        缓存更新策略有三种：内存淘汰、超时剔除、主动更新。

        1、内存淘汰： 不用自己维护，利用Redis的内存淘汰机制，当内存不足时自动淘汰部分数据。下次查询时更新缓存。 

        一致性 ：差                      维护成本：无

        2、超时剔除：给缓存数据添加TTL时间，到期后自动删除缓存。下次查询时更新缓存。

        一致性 ：一般                  维护成本：低

        3、主动更新：编写业务逻辑，在修改数据库的同时，更新缓存。

        一致性：好                      维护成本：高

        业务场景：

        低一致性需求：使用内存淘汰机制。例如店铺类型的查询缓存

        高一致性需求：主动更新，并以超时剔除作为兜底方案。例如店铺详情查询的缓存

3.1 主动更新策略 

3.1.1 常用策略

        由缓存的调用者，在更新数据库的同时更新缓存。

3.1.2 操作缓存和数据库时有三个问题需要考虑

        1、删除缓存还是更新缓存？

        （1）更新缓存：每次更新数据库都更新缓存，无效写操作较多

        （2）删除缓存：更新数据库时让缓存失效，查询时再更新缓存（常用）

        2、如何保证缓存与数据库的操作的同时成功或失败？

        （1）单体系统，将缓存与数据库操作放在一个事务

        （2）分布式系统，利用TCC等分布式事务方案

        3、先操作缓存还是先操作数据库

        （1）先删除缓存，再操作数据库

        （2）先操作数据库，再删除缓存（常用）

3.2 缓存更新策略的最佳实践方案

1. 低一致性需求：使用 Redis 自带的内存淘汰机制
2. 高一致性需求：主动更新，并以超时剔除作为兜底方案
读操作：
• 缓存命中则直接返回
• 缓存未命中则查询数据库，并写入缓存，设定超时时间
写操作：
• 先写数据库，然后再删除缓存
• 要确保数据库与缓存操作的原子性

3.3 给查询的缓存添加超时剔除和主动更新的策略 

        1、需求：

        ① 根据id查询店铺时，如果缓存未命中，则查询数据库，将数据库结果写到缓存，并设置超时时间。

 stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY+id,JSONUtil.toJsonStr(shop),RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);

        ② 根据id修改店铺时，先修改数据库，再删除缓存。 

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

3.4 知识点 

        1、删除Redis中的缓存 

 stringRedisTemplate.delete(RedisConstants.CACHE_SHOP_KEY+shop.getId());

四、缓存穿透 

4.1 缓存穿透定义 和 解决方案

        1、解决缓存空对象的缺点的方式：每次新增数据时，主动的将数据插入到redis缓存中，覆盖之前的null。 

        2、布隆过滤器中存放的是一个个字节，并非真正的数据。

4.2 利用 缓存空对象 解决缓存穿透 

    @Override
    public Result queryById(Long id) {
        // 1、从redis查询商铺缓存
        String shopJson = stringRedisTemplate.opsForValue().get(RedisConstants.CACHE_SHOP_KEY+id);
        // 2、判断是否存在
        if(StrUtil.isNotBlank(shopJson)){
            // 3、存在 且 shopJson不为空（即redis中存入的不是空值）
            //返回店铺信息
            //将json字符串反序列化成java对象
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return Result.ok(shop);
        }
        // redis中有key 但是对应的value为空
        if(shopJson == null){
            // 返回一个错误信息
            return Result.fail("店铺不存在");
        }
        
        // 4、不存在，根据id查询数据库
        Shop shop = getById(id);
        if(shop==null){
            // 5、不存在：将空值写入redis中
            stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY+id,"",CACHE_NULL_TTL,TimeUnit.MINUTES);
            return Result.fail("店铺不存在");
        }
        // 6、存在，写入redis缓存
        stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY+id,JSONUtil.toJsonStr(shop),RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
        // 7、返回
        return Result.ok(shop);
    }

4.3 总结 

4.4 知识点 

        1、判断String类型是否为空：StrUtil.isNotBlank(shopJson)。当shopJson为null、""、" "是均返回false。

五、缓存雪崩

5.1 缓存雪崩定义 和 解决方案 

六、缓存击穿

6.1 缓存击穿定义 和 解决方案  

6.2 互斥锁 和 逻辑过期 比较

 6.3 互斥锁 和 逻辑过期 优缺点

6.4 基于互斥锁方式解决缓存击穿问题 

        1、需求：修改根据id查询商铺的业务，基于互斥锁方式来解决缓存击穿问题

        2、注意：这里的互斥锁不是我们平常用的synolize锁或者lock锁：这种锁，我们拿到了可以执行代码，没有拿到则继续等待。但我们这个，我们拿到锁和拿不到锁的逻辑是需要我们自己定义的。

        3、自定义互斥锁：利用redis的setnx属性。

        获取锁

  // 获取锁
    private boolean tryLock(String key){
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.MINUTES);
        //注意：不要直接将 Boolean 的值返回，因为这样返回它会进行拆箱，在这个拆箱的过程中，可能会出现空指针
        return BooleanUtil.isTrue(flag);
    }

        释放锁

 // 释放锁
    private void unLock(String key){
        stringRedisTemplate.delete(key);
    }

        利用互斥锁解决缓存击穿

 // 利用 互斥锁解决 缓存击穿问题
    public Shop queryWithMutex(Long id){
        // 1、从redis查询商铺缓存
        String shopJson = stringRedisTemplate.opsForValue().get(RedisConstants.CACHE_SHOP_KEY+id);
        // 2、判断是否存在
        if(StrUtil.isNotBlank(shopJson)){
            // 3、存在 且 shopJson不为空（即redis中存入的不是空值）
            //返回店铺信息
            //将json字符串反序列化成java对象
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return shop;
        }
        // redis中有key 但是对应的value为空
        if(shopJson == null){
            // 返回一个错误信息
            return null;
        }

        // 4、实现缓存重建
        // 4.1、获取互斥锁
        String lockKey = LOCK_SHOP_KEY + id;
        Shop shop = null;
        try {
            boolean isLock = tryLock(lockKey);
            // 4.2、判断是否获取成功
            if(!isLock){
                // 4.3、失败，则休眠并重试
                Thread.sleep(50);
                return queryWithMutex(id);
            }
            // 4.4、成功，根据id查询数据库
            shop = getById(id);
            
            // 模拟重建的延时
            Thread.sleep(200);
            
            if(shop==null){
                // 5、不存在：将空值写入redis中
                stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY+id,"",CACHE_NULL_TTL,TimeUnit.MINUTES);
                return null;
            }
            // 6、存在，写入redis缓存
            stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY+id,JSONUtil.toJsonStr(shop),RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);

        } catch (InterruptedException e) {
           throw new RuntimeException(e);
        } finally {
            // 释放锁
            unLock(lockKey);
        }
        // 7、返回
        return shop;
    }

6.5 基于逻辑过期方式解决缓存击穿问题

需求：修改根据id查询商铺的业务，基于逻辑过期方式来解决缓存击穿问题

        1、将数据和逻辑过期时间保存到redis中

    private void saveShop2Redis(Long id,Long expireSeconds){
        // 1、查询店铺数据
        Shop shop = getById(id);
        // 2、封装逻辑过期时间
        RedisData redisData = new RedisData();
        redisData.setData(shop);
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds));
        // 3、写入Redis
        stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY+id,JSONUtil.toJsonStr(redisData));
    }

        2、编写测试类测试saveShop2Redis()方法是否可行

@SpringBootTest
class HmDianPingApplicationTests {
    @Resource
    private ShopServiceImpl shopService;
    
    @Test
    void testSaveShop(){
        shopService.saveShop2Redis(1L,10L);
    }
}

        3、编写逻辑过期代码

// 创建线程池
    private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);

    // 利用 逻辑过期 解决 缓存击穿问题
    public Shop queryWithLogicalExpire(Long id){
        // 1、从redis查询商铺缓存
        String shopJson = stringRedisTemplate.opsForValue().get(CACHE_SHOP_KEY+id);
        // 2、判断是否存在 -- 缓存是否命中
        if(StrUtil.isBlank(shopJson)){
           // 未命中，直接返回null
            return null;
        }

        // 3、命中 -- 需要判断逻辑时间是否过期
        //  现将json反序列化为对象，获得里面的过期时间
        RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class);
        //获取商铺信息
        JSONObject data = (JSONObject)redisData.getData();
        Shop shop = JSONUtil.toBean(data, Shop.class);
        LocalDateTime expireTime = redisData.getExpireTime();

        //判断逻辑时间是否过期
        if(expireTime.isAfter(LocalDateTime.now())){
            // 3.1、未过期，直接返回商品信息
            return shop;
        }
        // 3.2、 过期、需要缓存重建
        // 4、缓存重建
        // 4.1、获取互斥锁
        String lockKey = LOCK_SHOP_KEY + id;
        // 4.2、判断是否获取锁成功
        boolean isLock = tryLock(lockKey);
        // 4.2、判断是否获取成功
        if(isLock){
            //TODO 4.3、成功 开启独立线程，实现缓存重建  --- 利用线程池
            CACHE_REBUILD_EXECUTOR.submit(()->{
                //缓存重建
                try {
                    this.saveShop2Redis(id,20L);
                } catch (Exception e) {
                   throw new RuntimeException();
                } finally {
                    //释放锁
                    unLock(lockKey);
                }

            });
        }

        // 4.4、返回过期的商铺信息
        return shop;
    }

6.6 知识点 

        1、 redis的setnx属性。对于相同的key，value只能保存一次，之后不能修改。可以用它来设计自定义锁

        2、对于返回值boolean类型的数据返回时，不要直接返回Boolean（其封装类），因为这样返回它会进行拆箱，在这个拆箱的过程中，可能会出现空指针。如tryLock()方法。

        3、idea生成try-catch快捷键：alt+ctrl+l

        4、lamdom表达式

        5、 创建线程池，并在线程池中开启独立线程，实现缓存重建。

            CACHE_REBUILD_EXECUTOR.submit(()->{
                //缓存重建
                try {
                    this.saveShop2Redis(id,20L);
                } catch (Exception e) {
                   throw new RuntimeException();
                } finally {
                    //释放锁
                    unLock(lockKey);
                }

            });

七、缓存工具封装 

7.1 说明 

        目前我们暂时只封装4种方法：

        1、将任意对象序列化为json并存储在string类型的key中，并且可以设置TTL过期时间。

        2、将任意对象序列化为json并存储在string类型的key中，并且可以设置逻辑过期时间，用于处理缓存击穿问题。

        3、根据指定的key查询缓存，并反序列化为指定类型，利用缓存空值的方式解决缓存穿透问题。

        4、根据指定的key查询缓存，并反序列化为指定类型，利用逻辑过期的方式解决缓存击穿问题。

package com.hmdp.utils;

import cn.hutool.core.util.BooleanUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import com.hmdp.entity.Shop;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;

import static com.hmdp.utils.RedisConstants.CACHE_NULL_TTL;
import static com.hmdp.utils.RedisConstants.CACHE_SHOP_KEY;
import static com.hmdp.utils.RedisConstants.LOCK_SHOP_KEY;

@Slf4j
@Component
public class CacheClient {

    private final StringRedisTemplate stringRedisTemplate;

    public CacheClient(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }

    /**
     * 将任意对象序列化为json并存储在string类型的key中，并且可以设置TTL过期时间。
     *
     * **/
    public void set(String key, Object value, Long time, TimeUnit unit){
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value),time,unit);
    }

    /**
     * 将任意对象序列化为json并存储在string类型的key中，并且可以设置逻辑过期时间，用于处理缓存击穿问题。
     *
     * **/
    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)));
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
    }

    /**
     * 根据指定的key查询缓存，并反序列化为指定类型，利用缓存空值的方式解决缓存穿透问题。
     * @param keyPrefix redis中每个key的前缀
     * @param type
     * */
    public <R,ID> R queryWithPassThrough(
            String keyPrefix, ID id, Class<R> type, Function<ID,R> dbFallback, Long time, TimeUnit unit){
        String key = keyPrefix + id;
        // 1、从redis查询商铺缓存
        String json = stringRedisTemplate.opsForValue().get(key);
        // 2、判断是否存在
        if(StrUtil.isNotBlank(json)){
            // 3、存在 且 json不为空（即redis中存入的不是空值）
            //将json字符串反序列化成java对象
            return JSONUtil.toBean(json, type);
        }
        // redis中有key 但是对应的value为空
        if(json == null){
            // 返回一个错误信息
            return null;
        }

        // 4、不存在，根据id查询数据库
        R r = dbFallback.apply(id);
        if(r==null){
            // 5、不存在：将空值写入redis中
            stringRedisTemplate.opsForValue().set(key,"",CACHE_NULL_TTL,TimeUnit.MINUTES);
            return null;
        }
        // 6、存在，写入redis缓存
        this.set(key,r,time,unit);
        // 7、返回
        return r;
    }


    /**
     * 根据指定的key查询缓存，并反序列化为指定类型，利用逻辑过期的方式解决缓存击穿问题
     * @param keyPrefix redis中每个key的前缀
     * @param type
     * 
     * @param Function<ID,R> 中的ID表示参数、R表示函数的返回类型
     * */

    // 创建线程池
    private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);

    // 利用 逻辑过期 解决 缓存击穿问题
    public  <R,ID> R  queryWithLogicalExpire(String keyPrefix,ID id,Class<R> type,Function<ID,R> dbFallback,Long time, TimeUnit unit){
        String key = keyPrefix + id;
        // 1、从redis查询商铺缓存
        String json = stringRedisTemplate.opsForValue().get(CACHE_SHOP_KEY+id);
        // 2、判断是否存在 -- 缓存是否命中
        if(StrUtil.isBlank(json)){
            // 未命中，直接返回null
            return null;
        }

        // 3、命中 -- 需要判断逻辑时间是否过期
        //  现将json反序列化为对象，获得里面的过期时间
        RedisData redisData = JSONUtil.toBean(json, RedisData.class);
        //获取商铺信息
        JSONObject data = (JSONObject)redisData.getData();
        R r = JSONUtil.toBean(data, type);
        LocalDateTime expireTime = redisData.getExpireTime();

        //判断逻辑时间是否过期
        if(expireTime.isAfter(LocalDateTime.now())){
            // 3.1、未过期，直接返回商品信息
            return r;
        }
        // 3.2、 过期、需要缓存重建
        // 4、缓存重建
        // 4.1、获取互斥锁
        String lockKey = LOCK_SHOP_KEY + id;
        // 4.2、判断是否获取锁成功
        boolean isLock = tryLock(lockKey);
        // 4.2、判断是否获取成功
        if(isLock){
            //TODO 4.3、成功 开启独立线程，实现缓存重建  --- 利用线程池
            CACHE_REBUILD_EXECUTOR.submit(()->{
                //缓存重建
                try {
                    // 先查数据库
                    R r1 = dbFallback.apply(id);
                    // 写入redis
                    this.setWithLogicalExpire(key,r1,time,unit);
                } catch (Exception e) {
                    throw new RuntimeException();
                } finally {
                    //释放锁
                    unLock(lockKey);
                }

            });
        }

        // 4.4、返回过期的商铺信息
        return r;
    }

    // 获取锁
    private boolean tryLock(String key){
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.MINUTES);
        //注意：不要直接将 Boolean 的值返回，因为这样返回它会进行拆箱，在这个拆箱的过程中，可能会出现空指针
        return BooleanUtil.isTrue(flag);
    }

    // 释放锁
    private void unLock(String key){
        stringRedisTemplate.delete(key);
    }
}

        调用工具类

    @Resource
    private CacheClient cacheClient;

    @Override
    public Result queryById(Long id) {
        // 利用 缓存空对象解决 缓存穿透问题
       // Shop shop = queryWithPassThrough(id);
        //Shop shop = cacheClient.queryWithPassThrough(CACHE_SHOP_KEY,id,Shop.class,id2->getById(id2),CACHE_SHOP_TTL,TimeUnit.MINUTES);

        // 利用互斥锁方式解决缓存击穿
//        Shop shop = queryWithMutex(id);

        // 利用逻辑过期方式解决缓存击穿
       // Shop shop = queryWithLogicalExpire(id);
        Shop shop = cacheClient.queryWithLogicalExpire(CACHE_SHOP_KEY,id,Shop.class,id2->getById(id2),CACHE_SHOP_TTL,TimeUnit.MINUTES);

        // 7、返回
        return Result.ok(shop);
    }

7.2 知识类

        1、泛型 ：查询时由于返回值的类型和ID的类型是不确定的，因此返回值的类型需要使用泛型。【<R,ID> R】【ID id,Class<R> type】

        2、函数式编程 ： 我们封装工具类的时候，涉及到了数据库查询（不同的业务，查询自己的数据库），故在工具类中我们并不知道数据库如何进行查询的，因此利用参数由调用者告诉我们如何查。查数据库是一个函数，因此传入一个函数。【Function<ID,R> dbFallback】

        3、lamden表达式 ：

wjf83902
关注
  • 26
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
tomcat-redis-session-manager-2.0.0.jar
04-26
tomcat-redis-session-manager-2.0.0.jar
redis 分布式缓存实战-redis 事务
01-26
redis 事务单独的隔离操作：事务中的所有命令都会序列化、按顺序执行。事务在执行过程中，不会被其他客户端发送过来的命令请求所打断。
Redis---------实现查询缓存业务
qq_62366797的博客
05-01 762
Redis---------实现查询缓存
Another-Redis-Desktop-Manager.1.5.6
07-22
官网下载太慢，这里做了提取，可以在这里下载
redis++使用说明,windows下编译redis-plus-plus
06-13
redis++使用说明,windows下编译redis-plus-plus
redis分布式缓存实战-redis事务
02-24
redis事务单独的隔离操作：事务中的所有命令都会序列化、按顺序执行。事务在执行过程中，不会被其他客户端发送过来的命令请求所打断。　　redis事务没有隔离级别的概念：队列中的命令没有提交之前都不会实际的被执行，因为事务提交前任何指令都不会被实际执行，也就不存在“事务内的查询看到事务里的更新，在事务外查询不能看到”。　　redis事务不保证原子性：redis同一个事务中如果有一条命令运行时执行失败，其后的命令仍然会被执行，没有回滚。　　Multi、Exec、Discard和Watch是Redis事务的相关命令。　　Multi：标记一个事务块的开始。Multi命令用于开启一个事务，它总是返回OK
Redis项目实战——商户查询缓存
weixin_46838605的博客
08-29 725
部分热点key（被高并发访问且缓存重建业务较复杂的key）在缓存中失效或过期，如果第一次请求未命中，会去数据库查询并写入缓存，但若在此期间有大量同样的请求涌入，就会有大量请求涌到数据库要求查询，给数据库造成巨大压力。客户端请求的数据在缓存和数据库中都没有，无法建立缓存，如果多次请求这个不存在的数据，这些请求就会全部打到数据库，给数据库造成压力。大量redis缓存中的key同时失效或过期，或者redis服务器宕机，大量请求直接到达数据库，给数据库造成巨大压力。宕机一个redis还有其他redis。
【Redis】基于Redis实现查询缓存
Infinity的博客
03-16 555
缓存击穿问题也叫热点Key问题，就是一个被高并发访问并且缓存重建业务较复杂的key突然失效了，无数的请求访问会在瞬间给数据库带来巨大的冲击。缓存雪崩是指在同一时段大量的缓存key同时失效或者Redis服务宕机，导致大量请求到达数据库，带来巨大压力。用户请求的数据在缓存中和数据库中都不存在，不断发起这样的请求，给数据库带来巨大压力。主动更新一般是由缓存的调用者，在更新数据库的同时，更新缓存。缓存穿透产生的原因是什么？缓存穿透的解决方案有哪些？
搞懂分布式技术13：缓存的那些事
Java技术江湖
06-23 1529
缓存和它的那些淘汰算法们 为什么我们需要缓存？ 很久很久以前，在还没有缓存的时候……用户经常是去请求一个对象，而这个对象是从数据库去取，然后，这个对象变得越来越大，这个用户每次的请求时间也越来越长了，这也把数据库弄得很痛苦，他无时不刻不在工作。所以，这个事情就把用户和数据库弄得很生气，接着就有可能发生下面两件事情： １.用户很烦，在抱怨，甚至不去用这个应用了（这是大多数情况下都会发生的...
redis-stack-server 7.2.0 安装包合集
04-03
redis-stack-server-7.2.0-v9.arm64.snap redis-stack-server-7.2.0-v9.bionic.arm64.tar.gz redis-stack-server-7.2.0-v9.bionic.x86_64.tar.gz redis-stack-server-7.2.0-v9.bullseye.x86_64.tar.gz redis-stack-...
黑马redis实战-商户查询缓存
qq_43156556的博客
04-10 637
商户查询缓存 本文的主题是商铺缓存。主要包括：添加商铺缓存到 redis，实现缓存和数据库的一致， redis 缓存面临的三个问题的解决：缓存穿透，缓存雪崩，缓存击穿 实现效果： 1. 添加商户缓存 需求分析：根据 id 查询商铺，若 redis 中有商铺缓存，直接返回。否则查询数据库并将商铺信息缓存到 redis 中 代码实现： ① Controller 层，获取url中的请求参数 “id” // ShopController.java /** * 根据id查询商铺信息 * @pa
Redis实战篇--商户查询缓存
qq_51729037的博客
01-28 144
Redis实战篇--商户查询缓存
Redis实战------黑马点评2 商户查询缓存
m0_74642813的博客
01-10 149
前言什么是缓存?就像自行车,越野车的避震器举个例子:越野车,山地自行车,都拥有"避震器",防止车体加速后因惯性,在酷似"U"字母的地形上飞跃,硬着陆导致的损害,像个弹簧一样;同样,实际开发中,系统也需要"避震器",防止过高的数据访问猛冲系统,导致其操作线程无法及时处理信息而瘫痪;这在实际开发中对企业讲,对产品口碑,用户评价都是致命的;所以企业非常重视缓存技术;缓存(Cache),就是数据交换的缓冲区,俗称的缓存就是缓冲区内的数据。
Redis实战—黑马点评项目—商户查询缓存
LHB123456789L的博客
03-19 223
商户查询缓存 笔记
Redis实战2-商铺缓存、优惠券秒杀
m0_48328683的博客
11-10 55
缓存就是数据交换的缓冲区，是存贮数据的临时地方，一般读写性能高。缓存的作用：降低后端负载、提高读写效率、降低响应时间缓存的成本：数据一致性成本、代码维护成本、运维成本。
数据实时性与缓存协同实践
九天的专栏
06-11 752
在实践中，数据实时性和缓存的协同作用可以通过合理的缓存策略和数据更新机制实现，以确保系统在提供实时数据的同时，保持高效的性能和可靠性。
《优化接口设计的思路》系列：第1篇—什么是接口缓存
青茶
06-14 197
一、缓存的定义： 缓存是一种存储数据的技术，用于提高数据访问的速度和效率。缓存通常存储在内存中，因为内存访问速度远快于磁盘和网络。数据接口通常会使用缓存技术，以降低对后端数据存储和处理的压力，提高系统性能。 当我们访问一个页面以后，这个页面中的静态资源(如图片、HTML文件、JavaScript文件等)往往会被浏览器保存下来，这个过程称为缓存(cache)。这么做是为了使用户再次访问相同页面的时候，这些静态资源不用从服务器重新下载到本地，而从缓存中直接读取，这样就加快了页面访问的速度，同时减轻了服务
WordPress如何删除内存中的缓存？
最新发布
boke112的博客
06-14 345
今天boke112百科将某篇文章修改分类和内容更新后，发现文章底部的相关文章显示的内容跟文章分类、标签毫无关系，还是显示原来的旧内容。后来查看YIA主题相关文章的代码，才发现相关文章的数据保存到内存中的，而且是永不过期，特别是在WordPress网站使用了Memcached后更是如此。
ubuntu20.04安装 redis-plus-plus
05-29
要在Ubuntu 20.04上安装redis-plus-plus，可以按照以下步骤进行操作： 1. 安装hiredis库 redis-plus-plus依赖于hiredis库，因此需要先安装hiredis库。可以使用以下命令安装： ``` sudo apt-get update sudo apt-...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值