关于Redis(热点数据缓存,分布式锁,缓存安全(穿透,击穿,雪崩))；

已于 2024-07-27 17:03:01 修改
阅读量807 收藏 13
点赞数 30
文章标签： spring java redis 分布式 安全 缓存
于 2024-07-27 16:41:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gzx233/article/details/140737566
版权

热点数据缓存:

为了把一些经常访问的数据，放入缓存中以减少对数据库的访问频率。从而减少数据库的压力，提高程序的性能。【内存中存储】成为缓存;

缓存适合存放的数据:

  1. 查询频率高且修改频率低

  2. 数据安全性低

作为缓存的组件:

  1. redis组件

  2. memory组件

  3. ehcache组件

  4. 等

Redis实现缓存功能
涉及的内容:

spring缓存组件 Redis数据库 AOP面向切面编程

实现:
Spirng缓存组件
//开启缓存注解
@EnableCaching
public class CalassNameApplication {
 public static void main (String[] arge) {
     SpringApplication.run(CalssNameApplication.class,args);
 }
}
添加注解
@Bean
public CacheManager cacheManager(RedisConnectionFactory factory) {
     RedisSerializer<String> redisSerializer = new StringRedisSerializer();
     Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
     //解决查询缓存转换异常的问题
     ObjectMapper om = new ObjectMapper();
     om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
     om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
     jackson2JsonRedisSerializer.setObjectMapper(om);
     // 配置序列化（解决乱码的问题）,过期时间600秒
     RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
             .entryTtl(Duration.ofSeconds(600)) //缓存过期10分钟 ---- 业务需求。
             .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))//设置key的序列化方式
             .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer)) //设置value的序列化
             .disableCachingNullValues();
     RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
             .cacheDefaults(config)
             .build();
     return cacheManager;
}
实现缓存功能
//所在的类和注入
@Service
public class ClazzServiceImpl implements ClazzService {
​
    @Autowired
    private ClazzDao clazzDao;
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
查询

  1. 查询缓存中是否存在名称为cacheNames::key的值

  2. 如果存在则方法不会执行

  3. 如果不存在则执行方法体并把方法的返回结果放入缓存cacheNames::key

//Cacheable:表示查询时使用的注解。
//cacheNames:缓存的名称
//key:缓存的唯一表示值
@Cacheable(cacheNames ={ "clazz"}, key = "#id")
@Override
public Clazz getById(Integer id) {
    //查询数据库
    Clazz clazz = clazzDao.selectById(id);
    return clazz;
}
修改

  1. 先执行方法体

  2. 把方法的返回结果放入缓存中

//CachePut:表示修改时使用的注解.
//cacheNames:缓存的名称
//key:缓存的唯一表示值
@CachePut(cacheNames = "clazz", key = "#clazz.cid")
public Clazz update(Clazz clazz) {
    //修改数据库
    int i = clazzDao.updateById(clazz);
    return clazz;
}
删除

  1. 先执行方法体

  2. 把缓存中名称为cacheNames::key的值删除

//CacheEvict:表示删除时使用的注解
//cacheNames:缓存的名称
//key:缓存的唯一表示值
@CacheEvict(cacheNames = "clazz", key = "#cid")
@Override
public int delete(Integer cid) {
    int i = clazzDao.deleteById(cid);
    return i;
}
原理:
@Service
public class ClazzServiceImpl implements ClazzService {
​
    @Autowired
    private ClazzDao clazzDao;
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    @Override
    public Clazz getById(Integer id) {
        //1.查询redis缓存是否命中
        ValueOperations<String, Object> forValue = redisTemplate.opsForValue();
        Object o = forValue.get("clazz::" + id);
        //表示缓存命中
        if(o!=null){
            return (Clazz) o;
        }
        //查询数据库
        Clazz clazz = clazzDao.selectById(id);
        if(clazz!=null){
            forValue.set("clazz::" + id,clazz);
        }
        return clazz;
    }
​
    @Override
    public Clazz save(Clazz clazz) {
        int insert = clazzDao.insert(clazz);
        return clazz;
    }
​
    @Override
    public Clazz update(Clazz clazz) {
        //修改数据库
        int i = clazzDao.updateById(clazz);
        if(i>0){
            //修改缓存
            redisTemplate.opsForValue().set("clazz::"+clazz.getCid(),clazz);
        }
        return clazz;
    }
​
    @Override
    public int delete(Integer cid) {
        int i = clazzDao.deleteById(cid);
        if(i>0){
            //删除缓存
            redisTemplate.delete("clazz::"+cid);
        }
        return i;
    }
}

分布式锁:

自理解:

分布式:一个网站部署多台服务器

锁:保证线程安全(将并行改为串行)只允许同时只有一个可以访问;

分布式锁:通过共享的锁保证每台服务器都能共享到同一个实时数据(进行操作);

涉及内容:

syn和lock锁 nginx代理群 Redis数据库 看门狗redisson

使用工具:

Jmeter压测工具 nginx代理

Jmeter:

模拟高并发工具

使用:
分布式锁实现:
@Service
public class StockService {
​
 @Autowired
 private StockDao stockDao;
 @Autowired
 private RedissonClient redisson;
​
 //
 public String decrement(Integer productid) {
     RLock lock = redisson.getLock("product::" + productid);
     lock.lock();
     try {
         //根据id查询商品的库存: 提前预热到redis缓存中
         int num = stockDao.findById(productid);
         if (num > 0) {
             //修改库存---incr---定时器[redis  数据库同步]
             stockDao.update(productid);
             System.out.println("商品编号为:" + productid + "的商品库存剩余:" + (num - 1) + "个");
             return "商品编号为:" + productid + "的商品库存剩余:" + (num - 1) + "个";
         } else {
             System.out.println("商品编号为:" + productid + "的商品库存不足。");
             return "商品编号为:" + productid + "的商品库存不足。";
         }
     }finally {
         lock.unlock();
     }
 }
}
原理:

  1. 加入syn和lock锁;

    syn和lock虽然解决了并发问题,但是项目部署时可能要部署集群模式。

     public String decrement(Integer productid) {
        //根据id查询商品的库存
        int num = stockDao.findById(productid);
        synchronized (this) {
​
            if (num > 0) {
                //修改库存
                stockDao.update(productid);
                System.out.println("商品编号为:" + productid + "的商品库存剩余:" + (num - 1) + "个");
                return "商品编号为:" + productid + "的商品库存剩余:" + (num - 1) + "个";
            } else {
                System.out.println("商品编号为:" + productid + "的商品库存不足。");
                return "商品编号为:" + productid + "的商品库存不足。";
            }
        }
    }

  1. nginx集群部署并使用redis解决分布式锁文件;

    打开并使用nginx代理集群exe文件;

    nginx(详细操作见linux笔记内):
    代理集群使用
    配置文件:nginx/conf/nginx.conf
    @Service
public class StockService {
​
    @Autowired
    private StockDao stockDao;
    @Autowired
    private StringRedisTemplate redisTemplate;
    //
    public String decrement(Integer productid) {
        ValueOperations<String, String> opsForValue = redisTemplate.opsForValue();
        //1.获取共享锁资源
        Boolean flag = opsForValue.setIfAbsent("product::" + productid, "1111", 30, TimeUnit.SECONDS);
        //表示获取锁成功
        if(flag) {
            try {
                //根据id查询商品的库存
                int num = stockDao.findById(productid);
                if (num > 0) {
                    //修改库存
                    stockDao.update(productid);
                    System.out.println("商品编号为:" + productid + "的商品库存剩余:" + (num - 1) + "个");
                    return "商品编号为:" + productid + "的商品库存剩余:" + (num - 1) + "个";
                } else {
                    System.out.println("商品编号为:" + productid + "的商品库存不足。");
                    return "商品编号为:" + productid + "的商品库存不足。";
                }
            }finally {
                //释放锁资源
                redisTemplate.delete("product::"+productid);
            }
        }else{
            //休眠100毫秒 在继续抢锁
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            return decrement(productid);
        }
    }
}

  1. redis超时问题[业务代码执行时间超过了上锁时间]

    使用第三方redisson插件
    <!--引入redisson依赖,看门狗-->
<dependency>
 <groupId>org.redisson</groupId>
 <artifactId>redisson</artifactId>
 <version>3.24.3</version>
</dependency>
    //配置文件
@Configuration
public class RedissonConfig {
​
 @Bean
 public RedissonClient redisson(){
     Config config = new Config();
//        //连接的为redis集群
//        config.useClusterServers()
//                // use "rediss://" for SSL connection
//                .addNodeAddress("redis://127.0.0.1:7181","","","")
//        ;
     //连接单机
     config.useSingleServer().setAddress("redis://172.16.7.18:6379");
     RedissonClient redisson = Redisson.create(config);
     return redisson;
 }
}
    代码实现:
    @Service
public class StockService {
​
    @Autowired
    private StockDao stockDao;
    @Autowired
    private RedissonClient redisson;
​
    //
    public String decrement(Integer productid) {
        RLock lock = redisson.getLock("product::" + productid);
        lock.lock();
        try {
            //根据id查询商品的库存: 提前预热到redis缓存中
            int num = stockDao.findById(productid);
            if (num > 0) {
                //修改库存---incr---定时器[redis  数据库同步]
                stockDao.update(productid);
                System.out.println("商品编号为:" + productid + "的商品库存剩余:" + (num - 1) + "个");
                return "商品编号为:" + productid + "的商品库存剩余:" + (num - 1) + "个";
            } else {
                System.out.println("商品编号为:" + productid + "的商品库存不足。");
                return "商品编号为:" + productid + "的商品库存不足。";
            }
        }finally {
            lock.unlock();
        }
    }
}

问题集:

使用StringRedisTemplate调用get方法获取map数据,使用String接出现

org.springframework.data.redis.RedisSystemException:Error in execution; nested exception is io.lettuce.core.RedisCommandExecutionException: WRONGTYPE Operation against a key holding the wrong kind of value

DefaultSerializer需要一个可序列化的有效负载，但接收到一个类型的对象

java.lang.IllegalArgumentException: DefaultSerializer requires a Serializable payload but received an object of type [com.day51.entity.MyEntity]

缓存安全:

什么是缓存穿透以及如何解决？

缓存穿透: 查询的数据在数据库中不存在缓存中也不存在，这时有人恶意访问这种数据，请求到达数据库。

解决方案 :

第一步:在controller层校验数据。对一些不合法的数据过滤掉.

第二步: 使用bloom布隆过滤器。

第三步: 存放一个空对象，并且设置过期时间不能超过5分钟。

什么是缓存击穿以及如何解决？

缓存击穿: 数据库中存在，但是缓存中该数据过期了。这是有大量的请求访问该过期的数据。压力顶到数据库。

解决方案: [1]使用互斥锁 [2]设置永不过期。

什么是缓存雪崩以及如何解决?

缓存雪崩: 当缓存服务器重启或者大量缓存集中在某一个时间段失效，这样在失效的时候，也会给后端系统(比如DB)带来很大压力。

解决方案: [1] 设置散列的过期时间。 [2]预热数据 [3]搭建redis集群

秋嶋渔
关注
Redis(四)——Redis缓存及分布式锁
yemuxiaweiliang的博客
05-01 1397
Redis(三)——Redis缓存及分布式锁
Redis分布式缓存解决分布式缓存中存在的缓存击穿缓存雪崩缓存穿透等问题-----Redis
春风若有怜花意，可否许我再少年
07-29 1623
Redis分布式缓存解决分布式缓存中存在的缓存击穿缓存雪崩缓存穿透等问题-----Redis
Redis6应用问题解决——缓存穿透，缓存击穿，缓存雪崩，分布式锁
dingxiao123的博客
06-30 460
分布式锁：当在分布式模型下，数据只有一份（或有限制），此时需要利用锁技术来控制某一时刻修改数据的进程数。这种锁即为分布式锁。为了保证一个方法或属性在高并发情况下的同一时间只能被同一个线程执行，在传统单体应用单机部署的情况下，可以使用并发处理相关的功能进行互斥控制。但是，随着业务发展的需要，原单体单机部署的系统被演化成分布式集群系统后，由于分布式系统多线程、多进程并且分布在不同机器上，这将使原单机部署情况下的并发控制锁策略失效，单纯的应用并不能提供分布式锁的能力。为了解决这个问题就。
redis——缓存穿透、缓存击穿、缓存雪崩、分布式锁
Yellow_Star的博客
01-14 1334
redis应用问题解决 缓存穿透 什么是缓存穿透？ 可以参考下图，当客户端发送读的请求过来时，会先访问缓存中的数据，如果不存在则直接去访问MySQL服务器中的数据。这时候如果MySQL服务器中并不存在他请求对应的信息，请求就会反反复复一直访问MySQL服务器，黑客利用此漏洞进行攻击可能压垮数据库。 解决方案 方案一：缓存空值 如果MySQL服务器中不存在相对应的数据，可以将对应的key的value值设置为空，当请求再次访问时可以直接去缓存中读取空值 方案二：布隆过滤器 在访问缓存层和存储层之前，将
redis缓存穿透、击穿、雪崩及解决方案&&分布式锁
weixin_51405802的博客
10-03 393
redis缓存穿透、击穿、雪崩及解决方案&&分布式锁
Redis缓存——（分布式锁）
guochaoHNU的博客
02-22 1311
目录缓存击穿，穿透，雪崩 缓存击穿，穿透，雪崩
Redis的缓存穿透、缓存击穿和缓存雪崩
qq_53464269的博客
08-03 7435
缓存穿透缓存雪崩是指在同一时段大量的缓存key同时失效或者Redis服务宕机，导致大量请求到达数据库，带来巨大压力。缓存雪崩是因为大量的key同时过期所导致的问题，而缓存击穿则是部分key过期导致的严重后果。为什么大量key过期会产生问题而少量的key也会有问题？缓存击穿问题也叫热点Key问题，就是⼀个被高并发访问并且缓存重建业务较复杂的key突然失效了，无数的请求访问会在瞬间给数据库带来巨大的冲击。具体情况如下图所示：上述：假设此时该热点key的TTL时间到（失效了），则查询缓存未命中，会继续。
Redis缓存击穿、缓存穿透和缓存雪崩
果酱 の 博客
07-10 9856
缓存击穿、缓存穿透和缓存雪崩是常见的缓存相关问题，在设计和使用缓存时需要注意避免这些问题的发生。缓存击穿是指在缓存中不存在但数据库中存在的数据，当有大量并发请求同时访问这个不存在的数据时，这些请求会穿透缓存直接访问数据库，导致数据库压力过大，性能下降。缓存穿透是指查询一个不存在的数据，由于缓存和数据库中都不存在该数据，因此每次查询都会直接访问数据库，导致数据库压力过大。在上述示例中，通过生成一个随机值，将缓存数据的过期时间设置为缓存过期时间加上随机值，从而实现数据过期时间的随机化。
Redis的缓存穿透、缓存击穿、缓存雪崩
qq_48595067的博客
07-13 6411
缓存击穿和缓存雪崩都是与缓存相关的常见问题，它们有一些共同点，并可以采用类似的解决方法。
Redis缓存穿透，缓存击穿和缓存雪崩
12-14
在IT行业中，Redis作为一种高...以上是针对Redis缓存系统中可能出现的缓存穿透、缓存击穿和缓存雪崩问题的解决方案。在设计缓存系统时，应当充分考虑这些潜在风险，采取适当的预防措施，以确保系统的稳定性和高可用性。
什么是redis缓存穿透 雪崩 ,如何应对解决 redis缓存穿透 雪崩 的解决办法
01-07
缓存穿透是指用户请求的数据既不在Redis缓存中，也不在数据库中，导致每次请求都需要去数据库查询。这可能由于恶意用户反复请求不存在的数据，或者系统设计缺陷引起。解决缓存穿透的方法有以下几点： 1. **布隆过滤...
Redis实现 分布式缓存、分布式锁
qq_34139393的博客
07-02 724
Redis实现 分布式缓存、分布式锁
springboot实战学习（12）(优化更新用户基本信息接口)(Validation实体参数校验)
岁岁岁平安的博客
10-09 968
本篇博客主要是对用户模块的更新用户基本信息接口的代码的一个小优化（实体参数校验）。其中用到了Spring Validation参数校验框架提供的一些注解（如@NotNull、@NotEmpty、@Email、@Validated）去完成实体类对象的参数校验以及完成了功能的测试...
springboot 通过自定义注解方式动态控制日志级别进行日志的输出或者关闭
A_awen的博客
10-11 384
springboot 通过自定义注解方式动态控制日志级别进行日志的输出或者关闭
Spring Security OAuth2.0认证授权
mry6的博客
10-09 252
Spring Security OAuth2.0认证授权目录基本概念基于Session的认证方式Spring-Security快速上手Spring-Security应用详解分布式系统认证方案OAuth2.0Spring-Security实现分布式系统授权 目录 基本概念 基于Session的认证方式 Spring-Security快速上手 Spring-Security应用详解 分布式系统认证方案 OAuth2.0 Spring-Security实现分布式系统授权
SpringBoot教程（三十二） | SpringBoot集成Skywalking链路跟踪
最新发布
qq_20236937的博客
10-14 527
SpringBoot教程（三十二） | SpringBoot集成Skywalking链路跟踪
教师工作量|基于springBoot的教师工作量管理系统设计与实现(附项目源码+论文+数据库）
提供各种学习资源及帮助
10-10 819
传统信息的管理大部分依赖于管理人员的手工登记与管理，然而，随着近些年信息技术的迅猛发展，让许多比较老套的信息管理模式进行了更新迭代，教师信息因为其管理内容繁杂，管理数量繁多导致手工进行处理不能满足广大用户的需求，因此就应运而生出相应的教师工作量管理系统。本教师工作量管理系统分为管理员还有用户两个权限，管理员可以管理用户的基本信息内容，可以管理公告信息以及公告的租赁信息，能够与用户进行相互交流等操作，用户可以查看教师信息，可以查看公告以及查看管理员回复信息等操作。
Redis缓存下的三大挑战：穿透、击穿与雪崩及其解决方案
然而，随着其广泛应用，也带来了一些关键性问题，包括数据一致性、缓存穿透、缓存击穿和缓存雪崩。这些问题对系统的稳定性和可靠性构成了挑战。 首先，我们来讨论数据一致性问题。虽然这是一个难以完全避免的问题，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值