Redis的使用场景——热点数据缓存

于 2024-07-25 21:10:25 发布
阅读量1.8k 收藏 17
点赞数 37
文章标签： 缓存 redis 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_59099003/article/details/140700120
版权

热点数据缓存

Redis的使用场景——热点数据的缓存

1.1 什么是缓存

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

1.2 缓存的原理

  1. 查询缓存中是否存在对应的数据
  2. 如果缓存中有，即命中，直接返回给程序
  3. 如果没有明中，访问查询数据库
  4. 把查询的数据返回给程序，并同时将查询的数据放入缓存

在这里插入图片描述

1.3 什么样的数据适合放入缓存中

  1. 查询频率高且修改频率低的
  2. 数据安全性低的

1.4 哪个组件可以作为缓存

  1. redis组件
  2. memory组件
  3. ehcache组件等

1.5 java使用redis如何实现缓存

准备

  1. 首先创建一个springboot项目

    在这里插入图片描述

  2. 配置文件

    server.port=端口号
#数据源
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/数据库名称?serverTimezone=Asia/Shanghai
spring.datasource.username=用户名
spring.datasource.password=密码

#mybatis配置文件
mybatis.mapper-locations=classpath:mapper/*.xml

#日志
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

#redis
spring.redis.host=IP地址
spring.redis.port=6379
spring.redis.database=4

  3. 修改mysql依赖，添加mybatis-plus的依赖

    <!--mysql依赖-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--mybatisplus依赖-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.4</version>
        </dependency>

  4. 创建实体类

    @Data
@AllArgsConstructor
@NoArgsConstructor
@TableName("class")
public class Clazz {
    //设置为主键且自增
    @TableId(type = IdType.AUTO)
    private Integer cid;
    private String cname;
    private String teacher;
}

  5. 创建dao层接口

    @Repository
public interface ClazzDao extends BaseMapper<Clazz> {
}

  6. 创建service层和业务实现类

    • 接口

      public interface ClazzService {
    //添加
    public Clazz insert(Clazz clazz);
    //删除
    public int del(Integer id);
    //修改
    public Clazz updateById(Clazz clazz);
    //查询
    public Clazz getById(Integer id);
}

    • 业务实现类

      @Service
public class ClazzServiceImpl implements ClazzService {
    @Autowired
    private ClazzDao clazzDao;
    //查询
    @Override
    public Clazz getById(Integer id) {
        //查询数据库
        Clazz clazz = clazzDao.selectById(id);
        return clazz;
    }
    //增加
    @Override
    public Clazz insert(Clazz clazz) {
        clazzDao.insert(clazz);
        return clazz;
    }
    //删除
    @Override
    public int del(Integer id) {
        int i = clazzDao.deleteById(id);
        return i;
    }

    @Override
    public Clazz updateById(Clazz clazz) {
        //修改数据库
        int i = clazzDao.updateById(clazz);
        return clazz;
    }

  7. controller控制层

    @RestController
@RequestMapping("/clazz")
public class ClazzController {
    @Autowired
    private ClazzService clazzService;

    //添加
    @PostMapping("/insert")
    public Clazz insert(@RequestBody Clazz clazz){
        return clazzService.insert(clazz);
    }

    //根据id查询
    @GetMapping("/getById/{id}")
    public Clazz getById(@PathVariable Integer id){
        Clazz clazz = clazzService.getById(id);
        return clazz;
    }
    //删除
    @DeleteMapping("/del/{id}")
    public Integer del(@PathVariable Integer id){
        int del = clazzService.del(id);
        return del;
    }
    //编辑
    @PutMapping("/update")
    public Clazz update(@RequestBody Clazz clazz){
        return clazzService.updateById(clazz);
    }
}

  8. 在main主函数中添加注入dao

    @SpringBootApplication
@MapperScan("com.zmq.dao")
public class SpringbootRedis02Application {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootRedis02Application.class, args);
    }
}

缓存处理在service层处理优化。【优化查、改、删方法】

  1. 在service业务处理类中注入Redis对象

    //在service层添加redis缓存
    @Autowired
    private RedisTemplate<String,Object> redisTemplate;

  2. 因为使用redisTemplate，需要序列化，所以，配置序列化配置工具类

    @Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        template.setConnectionFactory(redisConnectionFactory);
        template.setKeySerializer(jackson2JsonRedisSerializer);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.setHashKeySerializer(jackson2JsonRedisSerializer);
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

1.5.1 查询

  1. 获取redis操作字符串的对象
  2. 首先在Redis缓存中查询，如果有直接返回，不需要在访问数据库查询——get方法
  3. 如果Redis缓存中没有，再查询数据库，若在数据库中查询到，就将该数据添加到缓存中——set方法
//查询
    @Override
    public Clazz getById(Integer id) {
        //获取redis操作字符串的对象
        ValueOperations<String, Object> forValue = redisTemplate.opsForValue();
        //1.查询redis缓存是否命中
        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;
    }

1.5.2 修改

若修改操作成功，返回值大于0，就将其数据同步到缓存中——set方法

 @Override
    public Clazz updateById(Clazz clazz) {
        //修改数据库
        int i = clazzDao.updateById(clazz);
        if(i>0){
            //修改缓存
            redisTemplate.opsForValue().set("clazz::"+clazz.getCid(),clazz);
        }
        return clazz;
    }

1.5.3 删除

若数据库删除操作成功，返回值大于0，就根据id删除缓存中该数据——delete方法

 @Override
    public int delete(Integer cid) {
        int i = clazzDao.deleteById(cid);
        if(i>0){
            //删除缓存
            redisTemplate.delete("clazz::"+cid);
        }
        return i;
    }

1.6 使用缓存注解完成缓存功能

发现：业务层代码除了要维护核心业务功能外，额外还要维护缓存的代码

如何解决：使用AOP面向切面编程——注解

步骤：

  1. 添加配置spring使用的缓存组件
  2. 开启注解驱动——@EnableCaching

配置文件

@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;
    }

开启注解驱动

@SpringBootApplication
@MapperScan("com.zmq.dao")
@EnableCaching
public class SpringbootRedis02Application {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootRedis02Application.class, args);
    }
}

1.6.1 查询——@Cacheable

//查询
    @Cacheable(cacheNames ={ "clazz"}, key = "#id")
    @Override
    public Clazz getById(Integer id) {
        //查询数据库
        Clazz clazz = clazzDao.selectById(id);
        return clazz;
    }

Cacheable:表示查询时使用的注解

cacheNames：缓存的名称

key：缓存的唯一标识

在方法体之前执行

  1. 查询缓存中是否存在名称为cacheNames::key的值
  2. 如果存在则方法不会执行
  3. 如果不存在，则执行方法体并把方法的返回结果放入缓存中cacheNames::key

1.6.2 修改——@CachePut

 @CachePut(cacheNames = "clazz", key = "#clazz.cid")
    @Override
    public Clazz updateById(Clazz clazz) {
        //修改数据库
        int i = clazzDao.updateById(clazz);
        return clazz;
    }

CachePut：表示修改时使用的注解

  1. 先执行方法体
  2. 把方法的返回结果放入缓存中

1.6.3 删除——@CacheEvict

  @CacheEvict(cacheNames = "clazz", key = "#id")
    @Override
    public int delete(Integer cid) {
        int i = clazzDao.deleteById(cid);
        return i;
    }

CacheEvict：表示删除时使用的注解 Evict：驱逐

  1. 先执行方法体
  2. 把缓存中名称为cacheNames::key的值删除
晚安720
关注
  • 37
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Redis学习（七）｜如何保证Redis中的数据都是热点数据
weixin_44435110的博客
05-06 1307
MySQL里有2000w数据，redis中只存20w的数据，如何保证redis中的数据都是热点数据? 这个问题涉及到在一个数据量差异很大的情况下，如何有效地管理和保证Redis中的数据都是热点数据。让我们逐步分析
Redis——Redis缓存与数据库数据一致性问题
庄小焱
03-15 1315
摘要 主要介绍redis的高并发的架构的原理和使用的场景实现。解决的分布式数据不一致问题的最基本的原理是采用的是原子性操作问题。在redis中主要是依赖于的是Lua来实现的。 1、高并发场景秒杀下单超卖，使用的Redis的来实现的分布式锁的原理 1使用的JVM的锁的结构（但是在目前线上都是的集群模型的内容，所以会导致的这样的数据不一致问题。）synchronized锁问题 或者是使用的的是主线程来实现这样的一个结构。通过控制时间，但是还是存在的问题。 如果存在一个线程出现的bug的时候：设置一个
Redis热点数据和冷数据的理解
weixin_40587144的博客
03-16 606
Redis热点数据和冷数据的理解
redis 热点数据 缓存
热门推荐
大数据
08-06 2万+
Redis 是什么 Redis 的五种基本类型 STRING LIST SET HASH ZSET 键的过期时间 发布与订阅 事务 持久化 快照持久化 AOF 持久化 复制 从服务器连接主服务器的过程 主从链 处理故障 分片 事件 事件类型 事件的调度与执行 Redis 与 Memcached 的区别 Redis 适用场景 ...
Redis是如何缓存热点数据的
qq_46130027的博客
07-23 1223
总的来说，Redis 之所以能够高效地缓存热点数据，主要得益于其快速的内存读写能力，合理的过期策略和淘汰策略，以及灵活的分布式特性。这使得 Redis 成为广泛应用于缓存层的强大工具。
【Redis热点数据缓存】
Java程序员廖志伟
12-07 2372
我是廖志伟，一名Java开发工程师、幕后大佬社区创始人、Java领域优质创作者、CSDN博客专家。拥有多年一线研发经验，研究过各种常见框架及中间件的底层源码，对于大型分布式、微服务、三高架构（高性能、高并发、高可用）有过实践架构经验。
使用redis对热点数据进行缓存
weixin_53693850的博客
09-07 1146
虽然它本身并没有提供缓存的实现，但是它提供了一整套的接口和代码规范、配置、注解等，这样它就可以整合各种缓存方案了，比如 Redis、Ehcache，我们也就不用关心操作缓存的细节。本人做的是一个博客系统，使用redis对文章的信息进行缓存，比如说要去查询最热文章，首页的文章展示，对项目的查询接口的数据我们可以将其放入缓存中，这样子不仅可以做到查询速度快，当有大量的用户请求该接口时还能够减轻数据库的负担，提高博客浏览的速度。key缓存的key规则，可以使用springEL表达式，默认是方法参数组合。
Redis使用场景---热点数据缓存
最新发布
2401_85014515的博客
07-25 737
redis应用场景,热点数据缓存 缓存（Cache）是计算机科学中的一种技术，旨在提高数据访问速度。它是一种临时存储机制，用于存储常用或近期访问的数据，以便快速访问，减少延迟。
Redis缓存数据库热点数据处理
小小大青春
05-12 4718
***首先明确Redis数据缓存的作用以及大致流程*** 当用户请求到达时，首先用户访问的是Redis缓存数据库（读操作），当Redis中无用户查询数据时，会进行数据库的访问（我使用的是Mysql数据库）。 那么疑问来了，很多时候，大家都在说Redis中存放的数据为热点数据，只是一种缓存技术，并不能充当数据库使用，那么是如何，判别，Redis中数据为热点数据。 首先当用户进行（读操作）请求的时候...
Redis深入学习——缓存
weixin_51998662的博客
11-13 1077
Redis深入学习——缓存 Redis的缓存击穿、缓存穿透、缓存雪崩问题 缓存击穿 缓存击穿指的是有一个热点数据的key在缓存中失效时，大量的请求将会直接访问到数据库，会使数据库层面的压力大大增加。 解决方案： Key在缓存中最常见的失效问题就是key设置了过期时间，过期时间到了，key失效了，针对这一层面，我们可以将这个热点数据的key的过期时间设置为永不过期。但是这样会导致redis占用的内存逐渐增加，降低内存利用率。 所以还可以利用互斥锁，保证同一时间内只有...
Redis缓存及热点key问题解决方案
08-19
主要介绍了Redis缓存及热点key问题解决方案,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
分布式系统架构——使用Redis做MyBatis的二级缓存 - CSDN博客1
08-03
分布式系统架构中，使用Redis作为MyBatis的二级缓存是一种常见的优化策略，旨在提高数据访问性能并降低数据库负载。MyBatis是一个流行的Java持久层框架，它允许开发者编写SQL语句并将其与Java代码集成，提供了一种...
redis系列1——基本数据结构
xiaodigua1024的博客
03-07 166
redis基本数据结构包含string（字符串）、hash（哈希）、list（列表）、set（集合）、zset（有序集合）、Bitmaps（位图）、HyperLogLog(基数统计算法)、GEO（地理信息定位）。
flask-web 缓存Redis——架构、缓存模式、淘汰策略、雪崩、穿透
Shallow的博客
07-20 589
一、缓存的架构 计算机体系结构中的缓存： 多级缓存 构建本地缓存方法： 使用全局变量，一般适用于保存非常非常高频的数据 项目的方案 SQLAlchemy起到一定的本地缓存作用 在同一请求中多次相同的查询只查询数据库一次，SQLAlchemy做了本地缓存（类似Django中的Queryset查询结果集），queryset 查询集(查询结果集) 其中一个作用就是缓存 (起到了本地缓存的作用) 使用Redis构建一层缓存，可以用redis cluster 作为一级外部分布式缓存 二、缓存数据 缓存数据的
Redis如何存储热点数据
sql计算日期到当前日期的年份
02-13 742
Redis如何存储热点数据
Redis架构篇 - 热点数据
The Secret
02-21 595
本文介绍Redis热点数据
mySQL里有2000w数据，redis中只存20w的数据，如何保证redis中的数据都是热点数据
我是纯豆腐的博客
10-09 1万+
相关知识：redis 内存数据集大小上升到一定大小的时候，就会施行数据淘汰策略。 redis 提供 6种数据淘汰策略： voltile-lru：从已设置过期时间的数据集（server.db[i].expires）中挑选最近最少使用的数据淘汰 volatile-ttl：从已设置过期时间的数据集（server.db[i].expires）中挑选将要过期的数据淘汰 volatile-random
【SpringBoot13】SpringBoot中整合Redis实现热点数据缓存
wufaqidong1的博客
03-10 629
【代码】【SpringBoot13】SpringBoot中整合Redis实现热点数据缓存。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值