【RedisUtils工具类专题】SpringBoot中RedisUtils工具类配置及直接使用

已于 2022-04-14 23:46:55 修改
阅读量5.9k 收藏 14
点赞数 8
分类专栏： redis工具 文章标签： java redis
于 2022-04-14 23:12:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53641150/article/details/124180922
版权
本文详细介绍了如何在SpringBoot中配置RedisUtils工具类，该工具类支持静态方法直接调用，适用于多种数据类型的存储操作，包括设置、获取、删除等，并提供了缓存有效期管理。此外，还提供了测试示例，展示如何操作String、List、Map等数据类型。
摘要由CSDN通过智能技术生成

文章目录

前言

本文主要为SpringBoot中RedisUtils工具类配置及直接使用方法的介绍，该工具类无需注入，可直接调用RedisUtils类的静态方法，且对存储类型具有更强的适应性。

一、导入依赖

代码如下：

        <!--redis相关依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--Json相关依赖-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.47</version>
        </dependency>

二、RedisUtil工具类配置

代码如下：

import com.alibaba.fastjson.support.spring.GenericFastJsonRedisSerializer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Component;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@Component
public class RedisUtils02 {
    private static RedisTemplate<String, Object> redisTemplate;
    public static RedisTemplate<String, Object> getRedisTemplate() {
        return redisTemplate;
    }
    @Autowired
    private RedisUtils02(RedisConnectionFactory redisConnectionFactory){
        // redisTemplate模板初始化
        redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        // String的序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // json序列化配置
        GenericFastJsonRedisSerializer jackson2JsonRedisSerializer = new GenericFastJsonRedisSerializer();
        //key采用String的序列化方式
        redisTemplate.setKeySerializer(stringRedisSerializer);
        //hash的key也采用String 的序列化方式
        redisTemplate.setHashKeySerializer(stringRedisSerializer);
        //value的序列化方式采用jackson的方式
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        //hash的value序列化方式采用jackson
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.afterPropertiesSet();
    }

    // =============================common============================
    /**
     * 指定缓存失效时间
     * @param key  键
     * @param time 时间(秒)
     */
    public static boolean expire(String key, long time) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据key 获取过期时间
     * @param key 键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    public static long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }


    /**
     * 判断key是否存在
     * @param key 键
     * @return true 存在 false不存在
     */
    public static boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 删除缓存
     * @param key 可以传一个值 或多个
     */
//    @SuppressWarnings("unchecked")
    public static void del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete(Arrays.asList(key));
//                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }

    /**
     * 获取并删除缓存
     * @param key 键
     * @return 值
     */
    public static Object getAndDelete(String key) {
        try{
            return key == null ? null : get(key);
        }finally {
            del(key);
        }
    }

    // ============================String=============================

    /**
     * 普通缓存获取
     * @param key 键
     * @return 值
     */
    public static Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 普通缓存放入
     * @param key   键
     * @param value 值
     * @return true成功 false失败
     */

    public static boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 普通缓存放入并设置时间
     * @param key   键
     * @param value 值
     * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */

    public static boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 递增
     * @param key   键
     * @param delta 要增加几(大于0)
     */
    public static long incr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }


    /**
     * 递减
     * @param key   键
     * @param delta 要减少几(小于0)
     */
    public static long decr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }


    // ================================Map=================================

    /**
     * HashGet
     * @param key  键 不能为null
     * @param item 项 不能为null
     */
    public static Object hget(String key, String item) {
        return redisTemplate.opsForHash().get(key, item);
    }

    /**
     * 获取hashKey对应的所有键值
     * @param key 键
     * @return 对应的多个键值
     */
    public static Map<Object, Object> hmget(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * HashSet
     * @param key 键
     * @param map 对应多个键值
     */
    public static boolean hmset(String key, Map<String, Object> map) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * HashSet 并设置时间
     * @param key  键
     * @param map  对应多个键值
     * @param time 时间(秒)
     * @return true成功 false失败
     */
    public static boolean hmset(String key, Map<String, Object> map, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForHash().putAll(key, map);
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 向一张hash表中放入数据,如果不存在将创建
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @return true 成功 false失败
     */
    public static boolean hset(String key, String item, Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
     * @return true 成功 false失败
     */
    public static boolean hset(String key, String item, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForHash().put(key, item, value);
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除hash表中的值
     *
     * @param key  键 不能为null
     * @param item 项 可以使多个 不能为null
     */
    public static void hdel(String key, Object... item) {
        redisTemplate.opsForHash().delete(key, item);
    }


    /**
     * 判断hash表中是否有该项的值
     *
     * @param key  键 不能为null
     * @param item 项 不能为null
     * @return true 存在 false不存在
     */
    public static boolean hHasKey(String key, String item) {
        return redisTemplate.opsForHash().hasKey(key, item);
    }


    /**
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
     *
     * @param key  键
     * @param item 项
     * @param by   要增加几(大于0)
     */
    public static double hincr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }


    /**
     * hash递减
     *
     * @param key  键
     * @param item 项
     * @param by   要减少记(小于0)
     */
    public static double hdecr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, -by);
    }


    // ============================set=============================

    /**
     * 根据key获取Set中的所有值
     * @param key 键
     */
    public static Set<Object> sGet(String key) {
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }


    /**
     * 根据value从一个set中查询,是否存在
     *
     * @param key   键
     * @param value 值
     * @return true 存在 false不存在
     */
    public static boolean sHasKey(String key, Object value) {
        try {
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 将数据放入set缓存
     *
     * @param key    键
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public static long sSet(String key, Object... values) {
        try {
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }


    /**
     * 将set数据放入缓存
     *
     * @param key    键
     * @param time   时间(秒)
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public static long sSetAndTime(String key, long time, Object... values) {
        try {
            Long count = (long)values.length;
            if (time > 0) {
                count = redisTemplate.opsForSet().add(key, values);
                expire(key, time);
            }
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }


    /**
     * 获取set缓存的长度
     *
     * @param key 键
     */
    public static long sGetSetSize(String key) {
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }


    /**
     * 移除值为value的
     *
     * @param key    键
     * @param values 值 可以是多个
     * @return 移除的个数
     */

    public static long setRemove(String key, Object... values) {
        try {
            return redisTemplate.opsForSet().remove(key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    // ===============================list=================================

    /**
     * 获取list缓存的内容
     *
     * @param key   键
     * @param start 开始
     * @param end   结束 0 到 -1代表所有值
     */
    public static List<Object> lGet(String key, long start, long end) {
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }


    /**
     * 获取list缓存的长度
     *
     * @param key 键
     */
    public static long lGetListSize(String key) {
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }


    /**
     * 通过索引 获取list中的值
     *
     * @param key   键
     * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
     */
    public static Object lGetIndex(String key, long index) {
        try {
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }


    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     */
    public static boolean lSet(String key, Object value) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 将list放入缓存
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     */
    public static boolean lSet(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForList().rightPush(key, value);
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }

    }


    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @return true 存放成功 false存放失败
     */
    public static boolean lSet(String key, List<Object> value) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }

    }


    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     * @return true 存放成功 false存放失败
     */
    public static boolean lSet(String key, List<Object> value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForList().rightPushAll(key, value);
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 根据索引修改list中的某条数据
     *
     * @param key   键
     * @param index 索引
     * @param value 值
     * @return true 存放成功 false存放失败
     */

    public static boolean lUpdateIndex(String key, long index, Object value) {
        try {
            redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 移除N个值为value
     *
     * @param key   键
     * @param count 移除多少个
     * @param value 值
     * @return 移除的个数
     */

    public static long lRemove(String key, long count, Object value) {
        try {
            return redisTemplate.opsForList().remove(key, count, value);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
}

三、工具类测试

代码如下：

// 测试String数组
String[] value = new String[]{"a","b","c","d"};
RedisUtils.set("key",value);
List<String> valueNew = (List<String>)RedisUtils.get("key");
// 测试Object类
User user = new User();
user.setId("1");
user.setUsername("zs");
user.setPassword("123");
RedisUtils.set("key",value);
User valueNew = (User)RedisUtils.get("key");

总结

本文主要为SpringBoot中RedisUtils工具类配置及直接使用方法的介绍，主要有以下特点：

  1. 该工具类无需注入，直接调用RedisUtils类的静态方法即可；
  2. 该工具类可对String数组进行存储（不论是数组还是集合，其反序列化后都是JSONArray.class类型，其实现了List接口，可按照集合处理）；
  3. 该工具类对set/get方法要求也不太敏感（比如SimpleGrantedAuthority.class有role属性，但是没有其set/get方法，也可以序列化和反序列化）。
时间？空间？
关注
专栏目录
SpringBoot中操作spring redis的工具类
BADAO_LIUMANG_QIZHI的博客
09-01 465
场景 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.
Redis在SpringBoot中的常用操作，并内含RedisUtils工具类。
毛虫-strive-blogs
12-21 2532
文章目录Redis介绍在SpringBoot工程中使用Redis1、引入依赖2、配置application.yaml配置文件3、测试RedisTemplate常用方法对象的存取测试Redis配置类封装RedisUtils测试工具类RedisUtils Redis介绍 Redis是一个开源的高性能的NOSQl数据库，其存储方式为Key-value的方式。 redis与其他key-value缓存产品有以下三个特点： Redis支持数据的持久化，可以将内存中的数据保存在磁盘中，从起点额时候可以再次加载进行使用
SpringBoot整合Redis缓存的方式
YOUNGljx的博客
03-19 226
Redis重点知识 Redis 是一个高性能的key-value非关系性数据库(NoSql)。 Redis可以存储键与5种不同数据结构类型之间的映射: String（字符串）、List（列表）、Set（集合）、Hash（散列）和 Zset（有序集合） Redis 教程 Redis介绍、安装部署、操作 SpringBoot 中使用Redis缓存 方案一：Spring Data Redis <!...
【工具类】RedisUtil
最新发布
司徒剑南的博客
07-30 224
关于Redis的操作的工具类
SpringBoot实战：整合Redis、mybatis，封装RedisUtils工具类等（附源码）
Java知音
12-25 1335
作者：陈彦斌cnblogs.com/chenyanbin/p/13515268.html创建SpringBoot项目 在线创建方式网址：https://start.spring.io/然...
Java代码编写Redis简易项目
学弟不想努力了
09-04 1217
用java编写redis简易项目 阅读该篇文章 首先确保电脑本地安装有redis， 如果使用的是服务器上的redis，请修改application.properties配置信息 一、创建SpringBoot项目 二、引入maven <dependencies> <!-- springboot --> <dependency> ...
SpringBoot操作Redis工具类--RedisUtil
SampsonKong的博客
01-09 1284
SpringBoot操作Redis工具类--RedisUtil
redis工具类
【轰炸机】的博客
09-04 535
redis 工具类
SpringBoot使用Redis做缓存，RedisUtil
大漠孤烟
07-03 609
首先，引入jar包，然后配置一个配置类，然后写个utils工具类，然后使用。 ======================================================= <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> &l
springboot 集成封装redis工具类redisUtils和单元测试
09-13
文章是redisUtils工具类的封装，和基于springboot环境的单元测试； 文中封装了redis的众多方法，希望对您有所帮助。
RedisUtils.java
09-03
redis封装类----用于简化redis的操作，实现快速使用redis的作用
springboot StringRedisTemplate redis工具类
11-30
redis工具类，继承StringRedisTemplate类，重写父类方法操作redis
可能是方法最全Redis静态工具类（RedisUtils.java）
06-28
可能是最全的Redis静态工具类，拿来即用，随时随地RedisUtils.方法名()存取数据，每个方法都有对应的注释，快速上手！
SpringBoot整合Redis、mybatis实战，封装RedisUtils工具类.docx
06-26
这个工具类通常会包含如`set`、`get`、`del`等方法，以方便在业务代码中调用。以下是一个简单的RedisUtil示例： ```java import org.springframework.beans.factory.annotation.Autowired; import org.spring...
【SpringBoot】34、SpringBoot整合Redis实现序列化存储Java对象
热门推荐
Asurplus
10-23 21万+
前面我们已经介绍过【SpringBoot】十七、SpringBoot 中整合 Redis，我们可以看出，在 SpringBoot 对 Redis 做了一系列的自动装配，使用还是非常方便的 一、背景 1、思考‘ 通过我们前面的学习，我们已经可以往 Redis 中存入字符串，那么我们要往 Redis 中存入 Java 对象该怎么办呢？ 2、方案 我们可以将 Java 对象转化为 JSON 对象，然后转为 JSON 字符串，存入 Redis，那么我们从 Redis 中取出该数据的时候，我们也只能取出字符串，并转
RedisUtils
的博客
04-10 288
public class RedisService { private static RedisService redisService ; public JedisPool jedisPool; public RedisService(){ redisinit(); } public static RedisService getInstance(){ synch...
解决redis \xac\xed\x00\x05t\x00\x04 自定义RedisTemplate
weixin_44371237的博客
02-07 1349
通过自定义RedisTemplate解决 package com.springboot.config; import com.fasterxml.jackson.annotation.JsonAutoDetect; import com.fasterxml.jackson.annotation.PropertyAccessor; import com.fasterxml.jackson.databind.ObjectMapper; import org.springframework.context.an
SpringBoot 中操作 Redis 及工具类的封装
m0_71777195的博客
05-06 1120
在我们项目开发中总是免不了会使用缓存，Redis现在基本是我们公司中非常常见的缓存方案，包括在用户token的缓存，热点信息的缓存等，这篇文章主要讲讲在SpringBoot项目中如何去操作Redis，及最后工具类的封装。
redis工具类springboot
08-11
回答: 在Spring Boot项目中集成Redis，并封装Redis工具类可以简化操作并提高代码的可读性。首先，我们需要在项目的pom.xml文件中引入相关依赖，如下所示: ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> ``` 这将会自动引入Spring Data Redis的依赖，使我们能够轻松地使用RedisTemplate进行操作。接下来，我们需要创建一个Redis工具类，该类封装了一系列对Redis的常用操作方法，例如设置值、获取值、删除值等。通过封装，我们可以将Redis的操作统一放在工具类中，提高代码的可维护性和可读性。最后，我们还需要解决Redis在存储中文时可能出现的乱码问题。可以通过在Redis配置文件中设置编码方式来解决这个问题，例如在application.properties中添加以下配置: ``` spring.redis.charset=UTF-8 ``` 这样就可以确保在Redis存储中文时不会出现乱码的情况。总之，通过集成Redis和封装Redis工具类，我们可以方便地在Spring Boot项目中使用Redis进行数据缓存和持久化操作。<span class="em">1</span> #### 引用[.reference_title] - *1* [redis工具类（springboot）](https://blog.csdn.net/qq_37140416/article/details/106572815)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT0_1"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值