Spring Data Redis 整合springboot

已于 2024-02-01 20:16:32 修改
阅读量536 收藏 8
点赞数 5
分类专栏： redis 文章标签： spring redis
于 2024-01-25 18:04:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52232901/article/details/135850329
版权

整合Redis

配置

首先引入依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

这个依赖是springboot的依赖,所以我们只要有springboot的依赖,就可以直接写这个依赖

Redis配置类

一般来说我们都要配置redis,一个是我们要它的模板,第二是,默认的redis的key,和value的编码不是string的,所以我门要使得它的编码变成string,
我这里让key的编码变成string,value的编码变成json格式


/**
 * @author jjking
 * @date 2024-01-25 16:42
 */
@Configuration
@Slf4j
public class RedisConfiguration {

    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);

        FastJsonRedisSerializer serializer = new FastJsonRedisSerializer(Object.class);

        // 使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(serializer);

        // Hash的key也采用StringRedisSerializer的序列化方式
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(serializer);

        template.afterPropertiesSet();
        return template;
    }
}

这里的FastJsonRedisSerializer 也是我们要自己写的
需要注意的是这里的,json序列器,需要导入阿里巴巴的fastjson

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.79</version>
</dependency>

/**
 * Redis使用FastJson序列化
 * @author 35238
 * @date 2023/7/22 0022 21:12
 */
public class FastJsonRedisSerializer<T> implements RedisSerializer<T>{

    public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");

    private Class<T> clazz;

    static
    {
        ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
    }

    public FastJsonRedisSerializer(Class<T> clazz)
    {
        super();
        this.clazz = clazz;
    }

    @Override
    public byte[] serialize(T t) throws SerializationException
    {
        if (t == null)
        {
            return new byte[0];
        }
        return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
    }

    @Override
    public T deserialize(byte[] bytes) throws SerializationException
    {
        if (bytes == null || bytes.length <= 0)
        {
            return null;
        }
        String str = new String(bytes, DEFAULT_CHARSET);

        return JSON.parseObject(str, clazz);
    }


    protected JavaType getJavaType(Class<?> clazz)
    {
        return TypeFactory.defaultInstance().constructType(clazz);
    }
}

yml配置

  redis:
    host: localhost
    port: 6379
    database: 0

我这里的redis是window的,所以可以直接这么写

工具类

为了编写的方便,因为要是用原生的redistemplate,要写很长一大串,所以还是编写工具类,更好一点

更新一首这里的工具类 2024 2.1,这里更新的是解决缓存击穿 + 缓存穿透的代码,你要想了解这方面的问题的化,可以看我另外以篇博客
https://blog.csdn.net/weixin_52232901/article/details/135960649

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.alibaba.fastjson.JSON;
import com.hmdp.entity.Shop;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundSetOperations;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;
import java.util.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;

/**
 * @author 35238
 * @date 2023/7/22 0022 21:18
 */
@SuppressWarnings(value = { "unchecked", "rawtypes" })
@Component
public class RedisCache {

    @Autowired
    public RedisTemplate redisTemplate;

    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key 缓存的键值
     * @param value 缓存的值
     */
    public <T> void setObject(final String key, final T value)
    {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 缓存逻辑过期时间
     * @param key key
     * @param value value
     * @param timeout 时间
     * @param unit 单位
     * @param <T> 类型
     */
    public <T> void setObjectWithLogicalExpire(final String key, final T value, final Integer timeout, TimeUnit unit)
    {
        RedisData redisData = RedisData.builder()
                .data(value)
                .expireTime(LocalDateTime.now().plusSeconds(unit.toSeconds(timeout)))
                .build();

        redisTemplate.opsForValue().set(key, JSON.toJSONString(redisData));
    }


    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key 缓存的键值
     * @param value 缓存的值
     * @param timeout 时间
     * @param timeUnit 时间颗粒度
     */
    public <T> void setObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit)
    {
        redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
    }


    /**
     * 对map中的某一个值进行递增操作
     * @param key
     * @param hkey
     * @param v 递增的步长
     */
    public void incrementMapValue(String key, String hkey, int v) {
        redisTemplate.opsForHash().increment(key,hkey,v);
    }

    /**
     * 设置有效时间
     *
     * @param key Redis键
     * @param timeout 超时时间
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout)
    {
        return expire(key, timeout, TimeUnit.SECONDS);
    }

    /**
     * 设置有效时间
     *
     * @param key Redis键
     * @param timeout 超时时间
     * @param unit 时间单位
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout, final TimeUnit unit)
    {
        return redisTemplate.expire(key, timeout, unit);
    }

    /**
     * 获得缓存的基本对象。
     *
     * @param key 缓存键值
     * @return 缓存键值对应的数据
     */
    public <T> T getObject(final String key)
    {
        ValueOperations<String, T> operation = redisTemplate.opsForValue();
        return operation.get(key);
    }



    public <R,ID> R getObjectWithPassThrough(String keyPrefix, ID id, Class<R> type, Function<ID,R> dbFallback,
                                             final Integer timeout, final TimeUnit unit) {
        //查redis
        String key = keyPrefix + id;
        String json = this.getObject(key);

        //缓存有,直接返回
        R r = null;
        if(StrUtil.isNotBlank(json)) {
            r = JSONUtil.toBean(json,type);
            return r;
        }

        //判断是否是我们自己写的""
        if(json != null) {
            return null;
        }

        //不存在
        r = dbFallback.apply(id);

        if(Objects.isNull(r)) {
            //导入空值,进入缓存
            this.setObject(key,"",timeout,unit);
            return null;
        }

        //存入缓存
        this.setObject(key,JSON.toJSONString(r));

        return r;
    }

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


    /**
     * 解决缓存击穿 逻辑过期
     * @param keyPrefix 需要缓存的key的前缀
     * @param lockKey 锁的key
     * @param id 标识
     * @param type 需要缓存的key的所属的实体类的class
     * @param dbFallback db回调函数
     * @param timeout 时间
     * @param unit 单位
     * @param <R>
     * @param <ID>
     * @return
     */
    public <R,ID> R getObjectWithLogicalExpire(String keyPrefix,String lockKey, ID id, Class<R> type, Function<ID,R> dbFallback,
                                             final Integer timeout, final TimeUnit unit) {
        //查redis
        String key = keyPrefix + id;
        String json = getObject(key);

        //缓存没有,返回空,因为是热点数据
        R r = null;
        //这里的未命中,包括了null和空串
        if(StrUtil.isBlank(json)) {
            return null;
        }


        //先查缓存是否逻辑过期
        RedisData redisData = JSONUtil.toBean(json, RedisData.class);
        r = JSONUtil.toBean((JSONObject) redisData.getData(),type);

        //如果过期了,就去获取锁
        if(LocalDateTime.now().isAfter(redisData.getExpireTime())) {
            boolean isLock = this.tryLock(lockKey, "1");

            //如果获取成功了,就去开启一个独立的线程
            if(isLock) {
                //开启一个独立线程,去解决问题
                CACHE_REBUILD_EXECUTOR.submit(() -> {
                    try {
                        R r1 = dbFallback.apply(id);
                        setObjectWithLogicalExpire(key,r1,timeout,unit);
                    } catch (Exception e) {
                        throw new RuntimeException();
                    } finally {
                        //释放锁
                        unlock(lockKey);
                    }
                });
            }
        }

        //最后都是返回旧数据,牺牲一致性
        return r;
    }


    /**
     * 解决缓存击穿 互斥锁实现
     * @param keyPrefix 需要缓存的key的前缀
     * @param lockKey 锁的key
     * @param id 标识
     * @param type 需要缓存的key的所属的实体类的class
     * @param dbFallback db回调函数
     * @param timeout 时间
     * @param unit 单位
     * @param <R>
     * @param <ID>
     * @return
     */
    public <R,ID> R getObjectWithMutex(String keyPrefix,String lockKey, ID id, Class<R> type, Function<ID,R> dbFallback,
                                               final Integer timeout, final TimeUnit unit) {
        //查redis
        String key = keyPrefix + id;
        String json = getObject(key);

        //缓存有,直接返回
        R r = null;
        if(StrUtil.isNotBlank(json)) {
            return JSONUtil.toBean(json,type);
        }

        //判断是否是我们自己写的""
        if(json != null) {
            return null;
        }

        try {
            //尝试第一次获取锁
            boolean isLock = tryLock(lockKey , "1");

            //没有获取到锁,休眠一段时间
            if(!isLock) {
                //休眠
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //重试,递归,休眠一段时间,看是否能拿到缓存,还拿不到继续获取锁,看看自己能不能重建
                return getObjectWithMutex(keyPrefix,lockKey, id, type, dbFallback,timeout,unit);
            }

            //不存在
            r = dbFallback.apply(id);

            if(Objects.isNull(r)) {
                //导入空值,进入缓存
                setObject(key,"",timeout, unit);
                return null;
            }

            //存入缓存
            setObject(key,JSON.toJSONString(r));
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            //释放锁
            unlock(lockKey);
        }

        return r;
    }


    /**
     * 删除单个对象
     *
     * @param key
     */
    public boolean deleteObject(final String key)
    {
        return redisTemplate.delete(key);
    }

    /**
     * 删除集合对象
     *
     * @param collection 多个对象
     * @return
     */
    public long deleteObject(final Collection collection)
    {
        return redisTemplate.delete(collection);
    }

    /**
     * 缓存List数据
     *
     * @param key 缓存的键值
     * @param dataList 待缓存的List数据
     * @return 缓存的对象
     */
    public <T> long setList(final String key, final List<T> dataList)
    {
        Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
        return count == null ? 0 : count;
    }

    /**
     * 获得缓存的list对象
     *
     * @param key 缓存的键值
     * @return 缓存键值对应的数据
     */
    public <T> List<T> getList(final String key)
    {
        return redisTemplate.opsForList().range(key, 0, -1);
    }

    /**
     * 缓存Set
     *
     * @param key 缓存键值
     * @param dataSet 缓存的数据
     * @return 缓存数据的对象
     */
    public <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet)
    {
        BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
        Iterator<T> it = dataSet.iterator();
        while (it.hasNext())
        {
            setOperation.add(it.next());
        }
        return setOperation;
    }

    /**
     * 获得缓存的set
     *
     * @param key
     * @return
     */
    public <T> Set<T> getSet(final String key)
    {
        return redisTemplate.opsForSet().members(key);
    }

    /**
     * 缓存Map
     *
     * @param key
     * @param dataMap
     */
    public <T> void setMap(final String key, final Map<String, T> dataMap)
    {
        if (dataMap != null) {
            redisTemplate.opsForHash().putAll(key, dataMap);
        }
    }

    /**
     * 获得缓存的Map
     *
     * @param key
     * @return
     */
    public <T> Map<String, T> getMap(final String key)
    {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * 往Hash中存入数据
     *
     * @param key Redis键
     * @param hKey Hash键
     * @param value 值
     */
    public <T> void setMapValue(final String key, final String hKey, final T value)
    {
        redisTemplate.opsForHash().put(key, hKey, value);
    }

    /**
     * 获取Hash中的数据
     *
     * @param key Redis键
     * @param hKey Hash键
     * @return Hash中的对象
     */
    public <T> T getMapValue(final String key, final String hKey)
    {
        HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
        return opsForHash.get(key, hKey);
    }

    /**
     * 删除Hash中的数据
     *
     * @param key
     * @param hkey
     */
    public void delMapValue(final String key, final String hkey)
    {
        HashOperations hashOperations = redisTemplate.opsForHash();
        hashOperations.delete(key, hkey);
    }

    /**
     * 获取多个Hash中的数据
     *
     * @param key Redis键
     * @param hKeys Hash键集合
     * @return Hash对象集合
     */
    public <T> List<T> getMultiMapValue(final String key, final Collection<Object> hKeys)
    {
        return redisTemplate.opsForHash().multiGet(key, hKeys);
    }

    /**
     * 获得缓存的基本对象列表
     *
     * @param pattern 字符串前缀
     * @return 对象列表
     */
    public Collection<String> keys(final String pattern)
    {
        return redisTemplate.keys(pattern);
    }

    /**
     * 尝试获取锁
     * @param pattern key
     * @param value 值
     * @param timeout 过期时间
     * @param timeUnit 时间单位
     * @param <T>
     * @return
     */
    public <T> boolean tryLock(String pattern,T value,Long timeout,TimeUnit timeUnit)
    {
        Boolean flag = redisTemplate.opsForValue().setIfAbsent(pattern, value, timeout, timeUnit);
        return BooleanUtil.isTrue(flag);
    }

    /**
     * 尝试获取锁
     * @param pattern key
     * @param value 值
     * @param <T>
     * @return
     */
    public <T> boolean tryLock(String pattern,T value)
    {
        Boolean flag = redisTemplate.opsForValue().setIfAbsent(pattern, value, 2, TimeUnit.MINUTES);
        return BooleanUtil.isTrue(flag);
    }

    /**
     * 解锁
     * @param pattern
     */
    public void unlock(String pattern) {
        //删除锁
        redisTemplate.delete(pattern);
    }
}

然后为了解耦,还要设置一个Redis key的常量类

常量类

/**
 * Redis key值
 * @author jjking
 * @date 2023-12-03 21:18
 */
public class RedisContants {
    //商店状态
    public static final String SHOP_STATUS = "shop:status";
}

这一步按理来说,可以省去,但是为了没那么耦合还是加上,代码又优雅了一点

测试

/**
 * @author jjking
 * @date 2024-01-25 16:34
 */
@RestController
@RequestMapping("/admin/shop")
@Api(tags = "商店相关")
@Slf4j
public class ShopController {

    @Autowired
    private RedisCache redisCache;
    
    @PutMapping("/{status}")
    @ApiOperation("设置营业状态")
    public Result changeStatus(@PathVariable Integer status) {
        log.info("设置营业状态: {}",status == 0 ? "打样" : "营业");
        redisCache.setCacheObject(RedisContants.SHOP_STATUS,status);
        return Result.success();
    }

    @GetMapping("/status")
    @ApiOperation("获得营业状态")
    public Result getStatus() {
        log.info("获得营业状态");
        Integer status = redisCache.getCacheObject(RedisContants.SHOP_STATUS);
        return Result.success(status);
    }
}

这里写了两个状态,我们把状态设置在redis中,因为一般这样的商店状态,是多个端都要的,所以放在redis中,挺合理的,消除了一部分一致性的问题
在这里插入图片描述
值得一说的是,我这里用到的redis的这个客户端还蛮好用的!~

憨憨小江
关注
  • 5
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
解析SpringBoot整合SpringDataRedis的过程
08-19
主要介绍了SpringBoot整合SpringDataRedis的过程，本文通过图文并茂的形式给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
SpringBoot整合spring data Redis
weixin_45822542的博客
12-06 327
SpringBoot整合spring data Redis redis-sb-demo02：pom.xml中添加redis坐标 <!-- 配置使用redis启动器 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency&gt
redis整合Springboot
叶
02-09 1448
redis集成Springboot注解式使用
SpringBoot整合spring data Redis(掌握)
weixin_44915822的博客
12-02 1604
SpringBoot整合spring data Redis(掌握) redis-sb-demo02：pom.xml中添加redis坐标 <!-- 配置使用redis启动器 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </depende
SpringBoot进阶（七）SpringBoot整合SpringData Redis
jwang的博客
09-13 309
前言 本章讲解SpringBoot整合SpringData Redis的相关知识 方法 1.概念 在SpringData章节，我讲解了有关SpringData Redis的相关知识，之前整合的是Spring。那么我们使用了SpringBoot之后呢，要该怎么整合SpringData Redis呢?这就是接下来要说的内容。 需要事先安装好Redis，该步骤不在赘述。 2.整合...
springboot整合spring-data-redis
本郡主是喵
06-18 1208
打开redis可视化客户端，发现我们成功存入数据，但是是java字节数据。如何解决？先看下图。
SpringDataRedis
weixin_43811057的博客
05-17 3323
SpringData是Spring中数据操作的模块，包含对各种数据库的集成，其中对Redis的集成模块就叫做SpringDataRedis，官网地址提供了对不同Redis客户端的整合（Lettuce和Jedis）提供了RedisTemplate统一API来操作Redis支持Redis的发布订阅模型支持Redis哨兵和Redis集群支持基于Lettuce的响应式编程支持基于JDK、JSON、字符串、Spring对象的数据序列化及反序列化。
SpringBoot整合SpringDataRedis
全栈测试笔记
01-25 574
SpringDataRedis简介 Spring-data-redis是spring大家族的一部分，提供了在spring应用中通过简单的配置访问redis服务，对reids底层开发包(比如jedis)进行了高度封装，RedisTemplate提供了redis各种操作、异常处理及序列化。 基于上一篇 SpringBoot开发Restful API及使用jmeter测试，https://www.cn...
SpringBoot整合Spring Data Redis
liulang68的博客
09-19 1463
Redis和MongoDB一样是一个主流的非关系型数据库。 Redis和MongoDB不一样的是Redis没有表的结构(没有创建数据表这个操作)，直接以key:value的形式去存储就可以了。 c# 连接Redis报错：WRONGTYPE Operation against a key holding the wrong kind of value：类型搞混弄出的错误 参考文章：https://www.cnblogs.com/Taburensheng/p/6170821.html <dependen
Spring Boot3整合Redis
蒾酒的博客
02-07 6362
⛰️个人主页: 蒾酒🔥系列专栏：《spring boot实战》目录前置条件1.导依赖2.配置连接信息以及连接池参数3.配置序列化方式4.编写测试已经初始化好一个spring boot项目且版本为3X，项目可正常启动。作者版本为3.2.2初始化教程：新版idea(2023)创建spring boot3项目-CSDN博客https://blog.csdn.net/qq_62262918/article/details/135785412?spm=1001.2014.3001.5501pom.xml:
Redis和SpringBoot整合
DrLai的博客
04-09 1933
在SpringBoot中一般使用RedisTemplate提供的方法来操作Redis。那么使用SpringBoot整合Redis需要那些步骤呢? 文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 1 JedisPoolConfig(这个是配置连接池) 2 RedisConnectionFactory这个是配置连接信息，这里的RedisConnectionFactory是一个接 口，我们需要使用它的实现类，在Spr...
springboot整合spring-data-redis遇到的坑
08-30
使用springboot整合redis,使用默认的序列化配置,然后使用redis-client去查询时查询不到相应的key.问题出在哪，怎么解决呢？下面小编给大家带来了springboot整合spring-data-redis遇到的坑，需要的的朋友参考下吧
springboot整合Redis
08-09
Spring Data Redis 是 Spring 的一部分，提供了在 Spring 应用中通过简单的配置就可以访问 Redis 服务，对 Redis 底层开发包进行了高度封装。在 Spring 项目中，可以使用Spring Data Redis来简化 Redis 操作。 ...
springboot整合redis动态切换每个数据库
06-20
springboot整合redis动态切换每个数据库，
springboot整合redis集群（三种方式）源码
04-01
springboot整合redis集群（三种方式）源码
springboot和html怎么实现文件上传
m0_74749208的博客
05-07 517
文件怎样上传
Spring之Bean生命周期源码解析
dzend的专栏
05-08 840
在Spring框架中，Bean的生命周期是非常重要的，它涉及到Bean的创建、初始化、销毁等过程。通过对Spring之Bean生命周期源码的解析，我们可以更好地理解Spring容器是如何管理Bean的生命周期的。
SpringBootWeb案例
kussm_的博客
05-08 984
主要写一些学到的知识。
RuoYi-Vue-Plus （SpringCache、CacheManager、@Cacheable、缓存雪崩、击穿、穿透）
最新发布
javaxueba的博客
05-09 892
*** 2-自定义缓存管理器 整合spring-cache*/@Bean自定义 管理器PlusSpringCacheManager，实现CacheManager 接口，基于redssion操作缓存/***//*** <p>* 修改 RedissonSpringCacheManager 源码* 重写 cacheName 处理方法 支持多参数*///是否自动配置name//是否允许null//事务提交之后执行// 常用缓存配置 ttl;
redis整合springboot
09-14
在Spring Boot中整合Redis，可以通过以下步骤： 步骤1：添加依赖 在pom.xml文件中添加Redis相关的依赖： ```xml <groupId>org.springframework.boot <artifactId>spring-boot-starter-data-redis ``` 步骤2：...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

憨憨小江

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值