redis缓存

已于 2023-09-02 14:30:57 修改
阅读量374 收藏 2
点赞数
分类专栏： redis 文章标签： 缓存 redis 数据库
于 2023-02-13 16:37:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bubbleJessica/article/details/128999639
版权

缓存就是数据交换的缓冲区，读写性能较高

举例：web应用开发离不开缓存。用户向浏览器发起请求，首先就可以建立浏览器缓存（常见页面静态资源缓存到本地），大大降低网络的延迟，提高页面响应速度，浏览器未命中的数据就会去到tomcat也就是我们编写的java应用（添加应用层缓存：简单来说创建一个map，我们从数据库查到数据放到map里面，以后再来的时候直接从map读给你，这样以来减少数据库的查询，效率提升）一般使用redis，缓存未命中的话请求依然还会落到数据库（数据库添加缓存：索引mysql数据库是一个聚簇索引它会给id创建索引，这些索引数据就可以缓存起来，这样以来当我们根据索引查询数据内存快速检索，得到结果，不用每次读写磁盘，效率大大提升）当然最终数据去查找还是要落到磁盘，还有做些复杂排序，表关联，CPU做运算，数据库还会访问到CPU和磁盘，这个时候自然就会用到CPU多级缓存以及磁盘读写缓存

商品查询缓存

之前直接从数据库查询响应时间长，现在进行redis优化，提高读写效率，降低响应时间

/**
     * 根据id查询商铺信息
     * @param id 商铺id
     * @return 商铺详情数据
     */
    @GetMapping("/{id}")
    public Result queryShopById(@PathVariable("id") Long id) {
        //return Result.ok(shopService.getById(id));
        return shopService.queryById(id);
    }
@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {
    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Override
    public Result queryById(Long id) {
        //  1.从redis中查询商铺缓存
        String key=CACHE_SHOP_KEY+id;
        String shopJson = stringRedisTemplate.opsForValue().get(key);
        // 2.判断是否存在
        if (StrUtil.isNotBlank(shopJson)) {
            // 3.存在，直接返回对象
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return Result.ok(shop);
        }
        // 4.不存在，则去数据库查询
        Shop shop = getById(id);
        // 5.如果找不到，则返回错误信息
        if (shop==null){
            return Result.fail("店铺不存在");
        }
        // 6.如果找到，则把商铺信息存放到redis当中
        stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop));
        // 7.返回
        return Result.ok(shop);
    }
}

明显加快了许多，从1.71s变为15ms 

商铺类型缓存

@RestController
@RequestMapping("/shop-type")
public class ShopTypeController {
    @Resource
    private IShopTypeService typeService;

    @GetMapping("list")
    public Result queryTypeList() {
//        List<ShopType> typeList = typeService
//                .query().orderByAsc("sort").list();
//        return Result.ok(typeList);
        return typeService.queryShopList();
    }
}
@Service
public class ShopTypeServiceImpl extends ServiceImpl<ShopTypeMapper, ShopType> implements IShopTypeService {

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Override
    public Result queryShopList() {
        // 1. 从redis中查询商铺类型列表
        List<String> shopTypes = stringRedisTemplate.opsForList().range(CACHE_SHOP_TYPE_KEY, 0, 9);
        // 2. 命中，返回商铺类型信息
        List<ShopType> shopTypesByRedis = new ArrayList<>();
        if (shopTypes.size() != 0) {
            for (String shopType : shopTypes) {
                ShopType type = JSONUtil.toBean(shopType, ShopType.class);
                shopTypesByRedis.add(type);
            }
            return Result.ok(shopTypesByRedis);
        }
        // 3. 未命中，从数据库中查询商铺类型,并根据sort排序
        List<ShopType> shopTypesByMysql = query().orderByAsc("sort").list();
        // 4. 将商铺类型存入到redis中
        for (ShopType shopType : shopTypesByMysql) {
            String s = JSONUtil.toJsonStr(shopType);
            stringRedisTemplate.opsForList().rightPushAll(CACHE_SHOP_TYPE_KEY,s);
        }
        // 5. 返回商铺类型信息
        return Result.ok(shopTypesByMysql);
    }
}

时间27ms就完成了

缓存更新策略

先操作缓存和先操作数据库（胜出）两者异常情况 （其中操作数据库出现异常需满足以下条件：线程1开始执行时刚好出现缓存失效，然后步骤1和步骤4这段微妙的时间内线程2刚好发生更新数据库和删除缓存）线程安全考虑

@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {
    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Transactional
    @Override
    public Result update(Shop shop) {
        Long id = shop.getId();
        if (id==null){
            return Result.fail("商铺Id不能为空");
        }
        // 先操作数据库
        updateById(shop);
        // 再删除缓存
        stringRedisTemplate.delete(CACHE_SHOP_KEY+id);
        return Result.ok();
    }
}
@RestController
@RequestMapping("/shop")
public class ShopController {

    @Resource
    public IShopService shopService;
/**
     * 更新商铺信息
     * @param shop 商铺数据
     * @return 无
     */
    @PutMapping
    public Result updateShop(@RequestBody Shop shop) {
        // 写入数据库
        // shopService.updateById(shop);
        return shopService.update(shop);
    }
}

由于修改信息得在管理端执行，为了方便，我们在postman测试 

数据库查验由原来的102变为103 且redis已经删除缓存了 

此时重新刷一下网站http://127.0.0.1:8080/shop-detail.html?id=1 ​​​​​​

​​​​​​由原来102茶餐厅变为103餐厅，redis更新缓存 

缓存穿透

缓存穿透是指客户端请求的数据在缓存中和数据库都不存在，这样缓存永远不会生效，这些请求都会打到数据库带来巨大压力 （优先选择方案一）

@Override
    public Result queryById(Long id) {
        //  1.从redis中查询商铺缓存
        String key=CACHE_SHOP_KEY+id;
        String shopJson = stringRedisTemplate.opsForValue().get(key);
        // 2.1 判断是否存在（数据真实存在）
        if (StrUtil.isNotBlank(shopJson)) {
            // 3.1 存在，直接返回对象
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return Result.ok(shop);
        }
        // 3.2 存在（数据为空字符串），返回错误信息
        // 等价于"".equals(shopJson)
        if (shopJson!=null){
            return Result.fail("店铺信息不存在");
        }
        // 4.不存在，则去数据库查询
        Shop shop = getById(id);
        // 5.如果找不到，则返回错误信息
        if (shop==null){
            // 将空值写入redis
            stringRedisTemplate.opsForValue().set(key,"",CACHE_NULL_TTL,TimeUnit.MINUTES);
            // 返回错误信息
            return Result.fail("店铺不存在");
        }
        // 6.如果找到，则把商铺信息存放到redis当中
        stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop),CACHE_SHOP_TTL,TimeUnit.MINUTES);
        // 7.返回
        return Result.ok(shop);
    }

 

第一次请求不存在的id时，它会查询数据库，如果找不到会把空值存放到redis缓存当中，下次继续访问该id时，就不会查询数据库，直接从缓存那里返回错误信息

缓存穿透主动的解决方案

  1. 增强id的复杂度，避免被猜测id规律
  2. 做好数据的基础格式校验
  3. 加强用户权限校验
  4. 做好热点参数的限流

缓存雪崩

缓存雪崩是指在同一时段大量的缓存key同时失效或者redis服务宕机，导致大量请求到达数据库，带来巨大压力

缓存击穿

缓存击穿也叫热点Key问题，就是一个被高并发访问并且缓存重建业务较复杂的key突然失效了，无数的请求访问会在瞬间给数据库带来巨大的冲击

案例：基于互斥锁方式解决缓存击穿问题（一致性）

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

 

    // 尝试获取锁
    private boolean tryLock(String key){
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
        // 直接返回会做拆箱，有可能返回空指针，所以使用工具类
        return BooleanUtil.isTrue(flag);
    }

    // 释放锁
    private void unlock(String key){
        stringRedisTemplate.delete(key);
    }
// 缓存击穿
    public Shop queryWithMutex(Long id){
        //  1.从redis中查询商铺缓存
        String key=CACHE_SHOP_KEY+id;
        String shopJson = stringRedisTemplate.opsForValue().get(key);
        // 2.1 判断是否存在（数据真实存在）
        if (StrUtil.isNotBlank(shopJson)) {
            // 3.1 存在，直接返回对象
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            // return Result.ok(shop);
            return shop;
        }
        // 3.2 存在（数据为空字符串），返回错误信息
        // 等价于"".equals(shopJson)
        if (shopJson!=null){
            // return Result.fail("店铺信息不存在");
            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(20);
                queryWithMutex(id);
            }
            // 4.4 成功，根据id数据库查询
            shop = getById(id);
            // 模拟重建的延时
            Thread.sleep(200);
            // 5.如果找不到，则返回错误信息
            if (shop==null){
                // 将空值写入redis
                stringRedisTemplate.opsForValue().set(key,"",CACHE_NULL_TTL,TimeUnit.MINUTES);
                // 返回错误信息
                // return Result.fail("店铺不存在");
                return null;
            }
            // 6.如果找到，则把商铺信息存放到redis当中
            stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop),CACHE_SHOP_TTL,TimeUnit.MINUTES);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }finally {
            // 7.释放互斥锁
            unlock(lockKey);
        }
        // 8.返回
        // return Result.ok(shop);
        return shop;
    }

注意：获取锁成功应该再次检测redis缓存是否存在，做doublecheck，如果存在则无需重建缓存（这里没有实现）

ctrl+alt+6出现异常选项 

业务逻辑层Service实现 

@Override
    public Result queryById(Long id) {
        // 缓存穿透
        // Shop shop = queryWithPassThrough(id);

        // 缓存击穿
        Shop shop = queryWithMutex(id);
        if (shop==null){
            Result.fail("店铺不存在！");
        }
        return Result.ok(shop);
    }

案例：基于逻辑过期方式解决缓存击穿问题（可用性）

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

第一种方案我们可以使用Shop类继承RedisData类（已经添加过期时间），但是我们要修改原代码（不推荐）

第二种方案我们在RedisData类添加Object data属性 

package com.hmdp.utils;

import lombok.Data;
import java.time.LocalDateTime;

@Data
public class RedisData {
    private LocalDateTime expireTime;
    private Object data;
}

public void saveShop2Redis(Long id,Long expireSeconds){
        //1.查询店铺数据
        Shop shop = getById(id);
        Thread.sleep(200);// 延迟时间，为了验证出些问题
        //2.封装逻辑过期时间
        RedisData redisData = new RedisData();
        redisData.setData(shop);
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds));
        //3.写入redis (key永久有效，过期由我们控制，没有设置TTL
        stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY+id,JSONUtil.toJsonStr(redisData));
    }

测试一下redis缓存 

package com.hmdp;

import com.hmdp.service.impl.ShopServiceImpl;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import javax.annotation.Resource;

@SpringBootTest
class HmDianPingApplicationTests {

    @Resource
    private ShopServiceImpl shopService;

    @Test
    void testSaveShop(){
        shopService.saveShop2Redis(1L,10L);
    }
}

理论上讲永久存在，逻辑上已经过期了 

获取到的锁可能刚好是上一个线程刚重建好缓存释放的 

// 线程池
    private static final ExecutorService CACHE_REBUILD_EXECUTOR= Executors.newFixedThreadPool(10);
// 缓存击穿2
    public Shop queryWithLogicalExpire(Long id){
        //  1.从redis中查询商铺缓存
        String key=CACHE_SHOP_KEY+id;
        String shopJson = stringRedisTemplate.opsForValue().get(key);
        // 2.1 判断是否存在（数据真实存在）
        if (StrUtil.isBlank(shopJson)) {
            // 3.1 存在，直接返回null
            return null;
        }
        // 4.命中，需要先把json反序列化为对象
        RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class);
        // Object data = redisData.getData();
        // 返回的是Object类型但我们需要强转 以便转换成需要Shop类型
        JSONObject data = (JSONObject) redisData.getData();
        Shop shop = JSONUtil.toBean(data, Shop.class);
        LocalDateTime expireTime = redisData.getExpireTime();
        // 5.判断是否过期
        if (expireTime.isAfter(LocalDateTime.now())){
            // 5.1 未过期，直接返回店铺信息（旧的）
            return shop;
        }
        // 5.2 已过期，需要缓存重建
        // 6.缓存重建
        // 6.1 获取互斥锁
        String lockKey= LOCK_SHOP_KEY+id;
        // 6.2 判断是否获取锁成功
        boolean isLock = tryLock(lockKey);
        if (isLock){
            // 这里需要再次检查redis缓存是否过期（获取到的锁刚好是上一个线程缓存重建释放的）
            if (expireTime.isAfter(LocalDateTime.now())){
                // 5.1 未过期，直接返回店铺信息（旧的）
                return shop;
            }
            
            // 6.3 成功，开启独立线程，实现缓存重建
            CACHE_REBUILD_EXECUTOR.submit(()-> {
                try {
                    // 重建缓存
                    this.saveShop2Redis(id,20L);
                }catch (Exception e){
                    throw new RuntimeException(e);
                }finally {
                    // 释放锁
                    unlock(lockKey);
                }
            });
        }
        // 6.4 返回过期的商铺信息
        return shop;
    }

100个线程1秒执行，发现一开始查询到的数据还是缓存中的103餐厅，中间某一刻过了200ms后面查询到的才是数据库中的102餐厅 （有一段时间不一致，后面就一致了）发现只进行一次缓存重建

bubbleJessica
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
redis缓存 redis缓存
06-11
redis缓存 redis缓存
redis缓存服务器
12-28
Redis 是一个高性能的键值对数据存储系统，常被用作数据库、缓存和消息中间件。它支持多种数据结构，如字符串、哈希、列表、集合、有序集合，这使得 Redis 在各种场景下有着广泛的应用。Redis 以其内存高速读写性能...
Redis缓存
weixin_54685622的博客
04-08 6232
缓存机制说明 缓存机制原理说明 缓存机制: 缓存中的数据,一定是数据库中的数据,使用缓存主要的目的就是降低用户访问物理设备的频次. 如果数据库记录更新,则缓存应该同步更新. 1.缓存的数据结构 K-V结构进行数据保存 2. 开发语言选择 C语言程序 3. 缓存数据的运行环境在内存中, 断电即擦除. 将内存数据进行持久化操作. 4. 如果不停的添加缓存的记录肯定会造成内存溢出. 定期优化缓存机制. 1.LRU算法 2.LFU算法 3.Random 4.TTL 5. 缓存也需要实现高可用机制.搭建缓存集群.
Redis 缓存
weixin_63831348的博客
06-19 1931
设置JAVARedis 缓存
Redis缓存预热
qq_42108331的博客
07-30 2660
Redis缓存预热
Redis缓存实现及其常见问题解决方案
栗筝i的博客
09-19 2547
Redis 是一个开源的，内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件。Redis 支持多种类型的数据结构，如字符串、哈希、列表、集合、有序集合等。此外，Redis 还提供了一系列的特性，如数据持久化、事务和发布订阅等。 然而，如何利用 Redis 实现高效的缓存机制呢？这就是我们今天要探讨的主题。在这篇文章中，我们将详细介绍 Redis 的缓存实现，包括其读写策略、过期策略和淘汰策略等。我们希望通过这篇文章，帮助读者更好地理解和使用 Redis，从而提高自己的系统性能。
Redis缓存击穿、缓存穿透和缓存雪崩
果酱 の 博客
07-10 9421
缓存击穿、缓存穿透和缓存雪崩是常见的缓存相关问题，在设计和使用缓存时需要注意避免这些问题的发生。缓存击穿是指在缓存中不存在但数据库中存在的数据，当有大量并发请求同时访问这个不存在的数据时，这些请求会穿透缓存直接访问数据库，导致数据库压力过大，性能下降。缓存穿透是指查询一个不存在的数据，由于缓存和数据库中都不存在该数据，因此每次查询都会直接访问数据库，导致数据库压力过大。在上述示例中，通过生成一个随机值，将缓存数据的过期时间设置为缓存过期时间加上随机值，从而实现数据过期时间的随机化。
Redis缓存实现
m0_63469711的博客
01-15 1948
然后查询缓存，构建了一个Redis缓存的键（key），格式为cache:shop:后跟商铺的ID，这里是cache:shop:1，然后尝试从Redis中查询该商铺的缓存数据。通过以上案例初步实现了标准的Redis缓存技术，即查询数据库之前先查询缓存，如果缓存数据存在，则直接从缓存中返回，如果缓存数据不存在，再查询数据库，然后将数据存入redis。当第二次访问该页面时，通过游览器开发者工具可以看到访问该网络包，如图，耗时47毫秒，可以得出，客户端是从缓存数据库中得到的信息，因此使用的时间大大减少。
Redis缓存更新策略以及常见缓存问题
buhuisuanfa的博客
07-17 2119
缓存就是数据交换的缓冲区(Cache)，是存储数据的临时地方，一般读写性能较好，常见缓存：Web应用中缓存有什么作用呢？降低后端负载提高读写效率，降低响应时间数据的一致性成本代码维护成本运维成本。
【Redis缓存】
weixin_54161577的博客
07-06 9348
相比于数据库而言，缓存的操作性能更高，缓存性能高的主要原因有以下几点：1、缓存一般都是key-value查询数据的，因为不像数据库一样还有查询的条件等因素，所以查询的性能一般会比数据库高；2、缓存的数据是存储在内存当中的，而数据库的数据是存储在磁盘当中的，因为内存的操作性能远远大于磁盘，因此缓存的查询效率会高很多；3、缓存更容易做分布式部署（当一台服务器变成多台相连的服务器集群），而数据库一般比较难实现分布式部署，因此缓存的负载和性能更容易平行扩展和增加。缓存大致分为两大类：本地缓存、分布式缓存本地缓存：也
Redis缓存应用场景解析
怎奈你何的博客
10-25 1541
redis
redis本地缓存与redis缓存
02-14
在“redis本地缓存与redis缓存”的主题中，我们将深入探讨这两种缓存方式及其各自的特点。 首先，我们要理解什么是本地缓存。本地缓存指的是将数据存储在应用程序的内存中，通常是Java的HashMap、Guava Cache或C#的...
Spring Cache手动清理Redis缓存
08-25
Spring Cache手动清理Redis缓存 Spring Cache是Spring框架中的一种缓存机制，它可以将缓存数据存储在Redis中。然而，在某些情况下，我们需要手动清理Redis缓存，以便释放内存空间或更新缓存数据。在本文中，我们将...
redis缓存技术
12-14
首先，Redis缓存技术的关键在于它能够快速地存储和检索数据。Redis采用内存存储，这意味着数据读取速度非常快，比传统的磁盘存储数据库快几个数量级。当需要频繁访问的数据存储在Redis中，可以极大地提高应用程序的...
redis的使用场景-热点数据缓存（把经常访问的数据放入缓存减少数据库压力）
Baizeh的博客
07-25 628
一、使用redis实现。一、使用redis实现。
redis的使用场景-分布式锁
最新发布
Baizeh的博客
07-25 311
使用redis的setnx命令放入数据并用此数据当锁完成业务。使用redis的setnx命令放入数据并用此数据当锁完成业务。
redis详解--springboot整合redis
m0_64821020的博客
07-24 583
1. java连接redis 2. springboot整合redis 3. 案例--短信业务
mysql redis缓存
07-20
MySQL和Redis可以结合使用来实现缓存功能，提升系统性能和响应速度。 在使用MySQL和Redis缓存时，通常的做法是将热门或频繁访问的数据存储到Redis缓存中，以减轻MySQL数据库的压力，并提高数据的读取速度。 以下是一个简单的MySQL和Redis缓存的实现示例： 1. 在代码中，首先尝试从Redis缓存中读取数据；如果缓存中存在数据，则直接返回数据给客户端。 2. 如果Redis缓存中不存在数据，则从MySQL数据库中读取数据，并将数据存储到Redis缓存中以供下次使用。 3. 在更新或删除数据时，需要同时更新Redis缓存和MySQL数据库。 这样的设计模式可以有效地减少对MySQL数据库的访问次数，提升系统的性能和响应速度。 需要注意的是，由于Redis是内存数据库，所以需要根据实际情况来决定将哪些数据存储到Redis缓存中。通常适合缓存的数据包括频繁读取且不经常变动的数据，比如配置信息、热门商品、用户信息等。 另外，在使用MySQL和Redis缓存时，需要保持缓存与数据库的一致性。可以通过设置过期时间、定时刷新缓存、使用消息队列等方式来实现缓存的更新和同步。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值