SpringBoot中操作spring redis的工具类

最新推荐文章于 2024-05-19 11:00:57 发布
最新推荐文章于 2024-05-19 11:00:57 发布
阅读量437 收藏
点赞数 1
分类专栏： SpringBoot Redis 文章标签： redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BADAO_LIUMANG_QIZHI/article/details/108335645
版权

场景

SpringBoot+Vue+Redis实现前后端分离的字典缓存机制：

https://blog.csdn.net/badao_liumang_qizhi/article/details/108333996

在SpringBoot后台中会使用到Redis去缓存一些数据。

Windows下Redis服务端的安装与配置

https://blog.csdn.net/BADAO_LIUMANG_QIZHI/article/details/107486313

注：

博客：
https://blog.csdn.net/badao_liumang_qizhi
关注公众号
霸道的程序猿
获取编程相关电子书、教程推送与免费下载。

实现

首先pom文件中引入相关依赖。

  <!-- redis 缓存操作 -->
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-redis</artifactId>
  </dependency>

然后在application.yml配置Redis服务端的连接

# Spring配置
spring:
  # 资源信息
  messages:
    # 国际化资源文件路径
    basename: i18n/messages
  profiles:
    active: druid
  # 文件上传
  servlet:
     multipart:
       # 单个文件大小
       max-file-size:  10MB
       # 设置总上传的文件大小
       max-request-size:  20MB
  # 服务模块
  devtools:
    restart:
      # 热部署开关
      enabled: true
  # redis 配置
  redis:
    # 地址
    #本地测试用
    host: 127.0.0.1
    port: 6379
    password: 123456
    # 连接超时时间
    timeout: 10s
    lettuce:
      pool:
        # 连接池中的最小空闲连接
        min-idle: 0
        # 连接池中的最大空闲连接
        max-idle: 8
        # 连接池的最大数据库连接数
        max-active: 8
        # #连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: -1ms

这里配置的Redis服务端是我自己的本地

然后封装一个Spring Redis的工具类 用来对Redis 进行缓存和获取数据等。

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
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.ListOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;

/**
 * spring redis 工具类
 *
 **/
@SuppressWarnings(value = { "unchecked", "rawtypes" })
@Component
public class RedisCache
{
    @Autowired
    public RedisTemplate redisTemplate;

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

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

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

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

    /**
     * 删除集合对象
     *
     * @param collection
     */
    public void deleteObject(Collection collection)
    {
        redisTemplate.delete(collection);
    }

    /**
     * 缓存List数据
     *
     * @param key 缓存的键值
     * @param dataList 待缓存的List数据
     * @return 缓存的对象
     */
    public <T> ListOperations<String, T> setCacheList(String key, List<T> dataList)
    {
        ListOperations listOperation = redisTemplate.opsForList();
        if (null != dataList)
        {
            int size = dataList.size();
            for (int i = 0; i < size; i++)
            {
                listOperation.leftPush(key, dataList.get(i));
            }
        }
        return listOperation;
    }

    /**
     * 获得缓存的list对象
     *
     * @param key 缓存的键值
     * @return 缓存键值对应的数据
     */
    public <T> List<T> getCacheList(String key)
    {
        List<T> dataList = new ArrayList<T>();
        ListOperations<String, T> listOperation = redisTemplate.opsForList();
        Long size = listOperation.size(key);

        for (int i = 0; i < size; i++)
        {
            dataList.add(listOperation.index(key, i));
        }
        return dataList;
    }

    /**
     * 缓存Set
     *
     * @param key 缓存键值
     * @param dataSet 缓存的数据
     * @return 缓存数据的对象
     */
    public <T> BoundSetOperations<String, T> setCacheSet(String key, 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> getCacheSet(String key)
    {
        Set<T> dataSet = new HashSet<T>();
        BoundSetOperations<String, T> operation = redisTemplate.boundSetOps(key);
        dataSet = operation.members();
        return dataSet;
    }

    /**
     * 缓存Map
     *
     * @param key
     * @param dataMap
     * @return
     */
    public <T> HashOperations<String, String, T> setCacheMap(String key, Map<String, T> dataMap)
    {
        HashOperations hashOperations = redisTemplate.opsForHash();
        if (null != dataMap)
        {
            for (Map.Entry<String, T> entry : dataMap.entrySet())
            {
                hashOperations.put(key, entry.getKey(), entry.getValue());
            }
        }
        return hashOperations;
    }

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

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

那么在进行设置数据缓存时

    public static void setDictCache(String key, List<SysDictData> dictDatas)
    {
        SpringUtils.getBean(RedisCache.class).setCacheObject(key, dictDatas);
    }

这里的key就是设置的缓存的键，后面的对象的list就是要缓存的数据。

这里获取RedisCache的方式是通过

SpringUtils.getBean(RedisCache.class)

因为这是在一个不受spring管理的工具类中。

如果是在其他受spring管理的bean中的话直接通过注解获取RedisCache即可。

同理在获取缓存的数据时

Object cacheObj = SpringUtils.getBean(RedisCache.class).getCacheObject(getCacheKey(key));

同理其他工具类方法都可使用。

 

霸道流氓气质
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
springboot 集成封装redis工具类redisUtils和单元测试
09-13
文章是redisUtils工具类的封装，和基于springboot环境的单元测试； 文中封装了redis的众多方法，希望对您有所帮助。
Redis工具类，封装了springboot操作redis的基本方法
10-14
Redis工具类，封装了springboot操作redis的基本方法
SpringBoot整合Redis及Redis工具类
weixin_52535099的博客
09-21 1958
SpringBoot整合Redis及Redis工具类（超详细）
SpringBoot 中操作 Redis 及工具类的封装
junkaione的博客
05-19 410
在我们项目开发中总是免不了会使用缓存，Redis现在基本是我们公司中非常常见的缓存方案，包括在用户token的缓存，热点信息的缓存等，这篇文章主要讲讲在SpringBoot项目中如何去操作Redis，及最后工具类的封装。
SpringBoot中Redis工具类
最新发布
哈
05-19 147
【代码】SpringBoot中Redis工具类。
Springboot集成Redis和Redis工具类
Rk的博客
02-13 734
目录 1、导入依赖 2、修改配置文件 3、测试 4、使用redis存入对象 5、redis自定义封装 RedisUtils工具类 1、导入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId>
Redis学习2——SpringBoot整合Redis，Redis工具类
weixin_55850954的博客
05-06 533
依赖和配置 pom.xml SpringBoot整合Redis，需要引入spring-boot-starter-data-redis依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </depen
SpringBoot整合Redis工具类
m0_52653999的博客
05-31 471
可以使用windows版的redis，方便开发顺便安装了一个Redis图形化界面工具，Another Redis Desktop，除了不能在里面输入命令，没什么大问题。
[spring boot] spring boot 中redis 工具类
qq_46269098的博客
03-14 341
spring boot 中redis 工具类
SpringBoot实战：整合Redis、mybatis，封装RedisUtils工具类等（附源码）
2401_84003839的博客
04-30 618
面试前的“练手”还是很重要的，所以开始面试之前一定要准备好啊，不然也是耽搁面试官和自己的时间。我自己是刷了不少面试题的，所以在面试过程中才能够做到心中有数，基本上会清楚面试过程中会问到哪些知识点，高频题又有哪些，所以刷题是面试前期准备过程中非常重要的一点。面试前的“练手”还是很重要的，所以开始面试之前一定要准备好啊，不然也是耽搁面试官和自己的时间。
SpringBoot整合Redis(包含工具类)
半只
07-04 1160
1、SpringBoot pom.xml导入相关依赖依赖 <!--Redis 依赖--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependenc
spring redis 工具类
weixin_48811255的博客
03-16 610
spring redis 工具类。
SpringBoot整合redis及工具类
04-19
接下来，我们关注Redis工具类的实现，这通常包含以下功能： 1. **字符串操作**：存储和获取字符串类型的数据，如`set(key, value)`和`get(key)`方法。可以使用`StringRedisTemplate`的`opsForValue()`方法实现。 2...
SpringBoot使用注解实现 Redis 数据库的切换.zip
04-08
SpringBoot提供了对Redis的自动配置支持，只需要在项目中引入`spring-boot-starter-data-redis`依赖，它会自动配置`RedisConnectionFactory`和`RedisTemplate`等核心组件。在`pom.xml`文件中添加以下依赖： ```xml ...
SpringBoot项目 MybatisPlus使用 Redis缓存.zip
02-13
4. **配置缓存管理器**：在SpringBoot的配置类中，创建一个RedisCacheManager实例，作为Spring的缓存管理器。 5. **开启缓存支持**：在MybatisPlus的配置中，启用全局的缓存策略，指定使用Redis作为缓存。 6. **...
Windows中Redis的下载安装与修改密码并启动
热门推荐
BADAO_LIUMANG_QIZHI的博客
07-21 1万+
场景 Centos中Redis的下载编译与安装(超详细)： https://blog.csdn.net/BADAO_LIUMANG_QIZHI/article/details/103967334 Redis的启动和关闭(前台启动和后台启动)： https://blog.csdn.net/BADAO_LIUMANG_QIZHI/article/details/103972348 RedisDesktopManager客户端可视化工具下载安装与使用： https://blog.csdn.net/BA
Redis启动时提示Creating Server TCP listening socket *:6379: bind: No error
BADAO_LIUMANG_QIZHI的博客
07-31 9063
启动redis-server时需要走配置文件，所以编写了bat脚本启动。这样就不用每次都输命令了。但是某次在双击Bat脚本之后，命令框一闪而过。此时在redis-server.exe所在的目录下打开cmd，输入redis-server.exeredis.windows.conf会提示6379bindNoerror注博客关注公众号霸道的程序猿获取编程相关电子书、教程推送与免费下载。...
Redis的启动和关闭(前台启动和后台启动)
BADAO_LIUMANG_QIZHI的博客
01-14 6321
场景 Centos中Redis的下载编译与安装(超详细)： https://blog.csdn.net/BADAO_LIUMANG_QIZHI/article/details/103967334 在上面安装好Redis后会在安装目录下的bin下自动生成一堆脚本。 其中redis-server就是redis的服务端。 注： 博客：https://blog.csdn.net/ba...
springboot 引入redis工具类
10-15
在使用SpringBoot引入Redis工具类时，首先需要在pom.xml文件中添加以下依赖： ```xml <dependencies> <!-- SpringBoot Data Redis --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <!-- Redis --> <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> </dependency> </dependencies> ``` 接下来，在SpringBoot的配置类中添加Redis的配置信息，通常是application.properties或application.yml文件。示例： ```properties # Redis配置 spring.redis.host=127.0.0.1 spring.redis.port=6379 spring.redis.database=0 spring.redis.password= spring.redis.timeout=30000 ``` 然后，创建一个RedisUtil工具类，用来封装Redis的常用操作方法。可以使用Jedis库对Redis进行操作。示例： ```java import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.redis.core.StringRedisTemplate; import org.springframework.stereotype.Component; @Component public class RedisUtil { @Autowired private StringRedisTemplate stringRedisTemplate; // 存储键值对 public void set(String key, String value) { stringRedisTemplate.opsForValue().set(key, value); } // 获取键对应的值 public String get(String key) { return stringRedisTemplate.opsForValue().get(key); } // 删除键值对 public void delete(String key) { stringRedisTemplate.delete(key); } // 判断键是否存在 public boolean exists(String key) { return stringRedisTemplate.hasKey(key); } } ``` 最后，可以在其他的Spring组件中使用RedisUtil来进行Redis操作。示例： ```java import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; @RestController @RequestMapping("/example") public class ExampleController { @Autowired private RedisUtil redisUtil; @RequestMapping("/test") public String test() { // 存储键值对 redisUtil.set("key", "value"); // 获取键对应的值 String value = redisUtil.get("key"); return value; } } ``` 这样，就可以在SpringBoot中引入Redis工具类，并进行常用的Redis操作了。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

霸道流氓气质

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

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

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

打赏作者

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

抵扣说明：

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

余额充值