Redis工具类

已于 2022-09-05 11:46:49 修改
阅读量1k 收藏 2
点赞数
文章标签： redis java
于 2022-09-05 11:38:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a416331427/article/details/126701775
版权 
public class RdsUtils {

    @Resource
    private static RedisTemplate redisTemplate;


    /**
     * 设置键值对
     *
     * @param key   键
     * @param value 值
     * @return
     */
    public static Boolean set(String key, String value) {
        try {
            redisTemplate.opsForValue().set(key,value);
            return true;
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return false;
    }


    /**
     * 设置键值对,并给键设置过期时间
     *
     * @param key   键
     * @param value 值
     * @param time  过期时间（单位：秒）
     * @return
     */
    public static Boolean setex(String key, String value, int time) {
        try {
            if(time <= 0 ){
                set(key,value);
            }else{
                redisTemplate.opsForValue().set(key,value,time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return false;
    }


    /**
     * 设置键值对, 如果键已存在则设置失败
     *
     * @param key   键
     * @param value 值
     * @return
     */
    public static Boolean setIfAbsent(String key, String value) {
        try {
            return redisTemplate.opsForValue().setIfAbsent(key,value);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return false;
    }


    /**
     * 通过键获取值
     *
     * @param key 键
     * @return
     */
    public static String get(String key) {
        try {
            return (String)redisTemplate.opsForValue().get(key);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return null;
    }


    /**
     * 一次性获取多个 key 的 value 值
     *
     * @param keys 键集合
     * @return
     */
    public static List mget(String... keys) {
        try {
            if(keys == null || keys.length == 0){
                return null;
            }
            return redisTemplate.opsForValue().multiGet(Arrays.asList(keys));
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return null;
    }


    /**
     * 通过 key 获取 value 的字符数
     *
     * @param key
     * @return
     */
    public static Long strlen(String key) {
        try {
            return redisTemplate.opsForValue().size(key);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return 0L;
    }


    /**
     * 通过 key 获取 value 并截取部分字符串
     * 下标超出范围则返回错误
     *
     * @param key   键
     * @param start 开始下标
     * @param end   结束下标
     * @return
     */
    public static String substr(String key, int start, int end) {
        try {
            String value = get(key);
            if(StringUtils.isEmpty(value)){
                return null;
            }else{
                if(end <= 0){
                    end = value.length();
                }
                return value.substring(start, end);
            }
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return null;
    }


    /**
     * 通过 key 获取 value,并用新值覆盖
     * 返回 旧值
     *
     * @param key   键
     * @param value 新值
     * @return
     */
    public static String getset(String key, String value) {
        try {
            return (String)redisTemplate.opsForValue().getAndSet(key, value);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return null;
    }


    /**
     * 通过 key 获取 value 并在已有基础上追加内容
     * 如果不存在则创建 value
     *
     * @param key   键
     * @param value 追加内容
     * @return
     */
    public static Integer append(String key, String value) {
        try {
            return redisTemplate.opsForValue().append(key, value);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return null;
    }


    /**
     * 通过 key 获取 value 并将 value 当作整数减 1
     *
     * @param key 键
     * @return
     */
    public static Long decr(String key) {
        try {
            return redisTemplate.opsForValue().decrement(key);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return 0L;
    }


    /**
     * 通过 key 获取 value 并将 value 当作整数减去设定值
     *
     * @param key      键
     * @param subValue 设定值
     * @return
     */
    public static Long decr(String key, int subValue) {
        try {
            return redisTemplate.opsForValue().decrement(key,subValue);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return 0L;
    }


    /**
     * 通过 key 获取 value 并将 value 当作整数加 1
     *
     * @param key 键
     * @return
     */
    public static Long incr(String key) {
        try {
            return redisTemplate.opsForValue().increment(key);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return 0L;
    }


    /**
     * 通过 key 获取 value 并将 value 当作整数增加设定值
     *
     * @param key      键
     * @param addValue 增加值
     * @return
     */
    public static Long incr(String key, int addValue) {
        try {
            return redisTemplate.opsForValue().increment(key,addValue);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return 0L;
    }


    /**
     * 通过 key 获取 value 并将 value 当作浮点类型增加设定值
     *
     * @param key      键
     * @param addValue 增加值(浮点类型)
     * @return
     */
    public static Double incrByFloat(String key, float addValue) {
        try {
            return redisTemplate.opsForValue().increment(key,addValue);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return null;
    }


    /**
     * 通过 key 删除相关记录
     *
     * @param key 键
     * @return
     */
    public static Boolean del(String key) {
        try {
            return redisTemplate.delete(key);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return false;
    }


    /**
     * 判断指定 key 是否存在（且未过期）
     *
     * @param key 键
     * @return
     */
    public static Boolean exists(String key) {
        try {
            Boolean exist = redisTemplate.hasKey(key);
            if(exist){
                Long expire = redisTemplate.getExpire(key, TimeUnit.SECONDS);
                if(expire == null || expire == 0L){
                    return false;
                }
            }
            return false;
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return false;
    }


    /**
     * 设置指定 key 的相对过期时间
     *
     * @param key    键
     * @param expire 过期时间(单位：秒)
     * @return
     */
    public static Boolean expire(String key, int expire) {
        try {
            return redisTemplate.expire(key, expire, TimeUnit.SECONDS);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return false;
    }


    /**
     * 设置指定 key 的绝对过期时间
     *
     * @param key    键
     * @param date   过期时间
     * @return
     */
    public static Boolean expireat(String key, Date date) {
        try {
            return redisTemplate.expireAt(key, date);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return false;
    }



    /**
     * 移除给 key 设定的过期时间,使得 key 永不过期
     *
     * @param key 键
     * @return
     */
    public static Boolean persist(String key) {
        try {
            return redisTemplate.persist(key);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return false;
    }


    /**
     * 判断 hash 数据类型是否包含指定项
     *
     * @param key   键
     * @param field 字段
     * @return
     */
    public static Boolean hexists(String key, String field) {
        try {
            return redisTemplate.opsForHash().hasKey(key, field);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return false;
    }


    /**
     * 获得 hash 数据类型中的指定项内容
     *
     * @param key   键
     * @param field 字段
     * @return
     */
    public static Object hget(String key, String field) {
        try {
            return redisTemplate.opsForHash().get(key, field);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return null;
    }


    /**
     * 获取 hash 数据类型中指定 key 的全部项
     *
     * @param key 键
     * @return
     */
    public static Map hgetAll(String key) {
        try {
            return redisTemplate.opsForHash().entries(key);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return null;
    }


    /**
     * 获取 hash 数据类型中的对应项的内容并增加整数值
     *
     * @param key      键
     * @param field    字段
     * @param addValue 增加值
     * @return
     */
    public static Long hincr(String key, String field, int addValue) {
        try {
            return redisTemplate.opsForHash().increment(key, field, addValue);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return null;
    }


    /**
     * 获取 hash 类型数据中的对应项的内容增加浮点数值
     *
     * @param key      键
     * @param field    字段
     * @param addValue 增加值
     * @return
     */
    public static Double hincrByDouble(String key, String field, float addValue) {
        try {
            return redisTemplate.opsForHash().increment(key, field, addValue);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return null;
    }


    /**
     * 获取 hash 数据类型中指定 key 的所有 field 值
     *
     * @param key 键
     * @return
     */
    public static List hkeys(String key) {
        try {
            return redisTemplate.opsForHash().values(key);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return null;
    }


    /**
     * 获取 hash 数据类型中指定 key 的 field 数量
     *
     * @param key 键
     * @return
     */
    public static Long hlen(String key) {
        try {
           return redisTemplate.opsForHash().size(key);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return 0L;
    }


    /**
     * 获取 hash 数据类型中指定 key 和多个 filed 的所有内容
     *
     * @param key    键
     * @param fields 字段集合
     * @return
     */
    public static List hmget(String key, String... fields) {
        try {
            return redisTemplate.opsForHash().multiGet(key, Arrays.asList(fields));
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return null;
    }


    /**
     * 通过 key filed 新增 hash 数据类型数据
     * 如果指定项不存在则新建，已存在则覆盖。
     *
     * @param key   键
     * @param field 字段
     * @param value 值
     * @return
     */
    public static Boolean hset(String key, String field, String value) {
        try {
            redisTemplate.opsForHash().put(key,field,value);
            return true;
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return false;
    }


    /**
     * 通过 key filed 设置 hash 数据类型数据
     * 如果该项已存在则执行失败
     *
     * @param key   键
     * @param field 字段
     * @return
     */
    public static Boolean hsetIfAbsent(String key, String field, String value) {
        try {
            return redisTemplate.opsForHash().putIfAbsent(key, field, value);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return false;
    }


    /**
     * 获取 hash 数据类型指定 key 所有 value
     *
     * @param key 键
     * @return
     */
    public static List hvals(String key) {
        try {
            return redisTemplate.opsForHash().values(key);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return null;
    }


    /**
     * 通过 key 获取 list 数据类型的列表长度
     *
     * @param key 键
     * @return
     */
    public static Long llen(String key) {
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return 0L;
    }


    /**
     * 通过 key 弹出指定 list 列表的头部项
     *
     * @param key 键
     * @return
     */
    public static Object lpop(String key) {
        try {
            return redisTemplate.opsForList().leftPop(key);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return null;
    }


    /**
     * 通过 key 弹出指定 list 列表的尾部项
     *
     * @param key 键
     * @return
     */
    public static Object rpop(String key) {
        try {
            return redisTemplate.opsForList().rightPop(key);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return null;
    }


    /**
     * 通过 key 在指定的 list 列表头部添加 1项
     *
     * @param key   键
     * @param value 值
     * @return
     */
    public static Long lpush(String key, String value) {
        try {
            return redisTemplate.opsForList().leftPush(key,value);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return null;
    }


    /**
     * 通过 key 在指定的 list 列表尾部添加 1项
     *
     * @param key
     * @param value 值
     * @return
     */
    public static Long rpush(String key, String value) {
        try {
            return redisTemplate.opsForList().rightPush(key,value);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return null;
    }


    /**
     * 通过 key 在指定的 list 列表头部添加 1 项
     * 列表不存在时操作无效
     *
     * @param key   键
     * @param value 值
     * @return
     */
    public static Long lpushx(String key, String value) {
        try {
            return redisTemplate.opsForList().leftPushIfPresent(key, value);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return null;
    }


    /**
     * 通过 key 在指定的 list 列表头尾部添加 1 项
     * 如果列表不存在，操作无效
     *
     * @param key   键
     * @param value 值
     * @return
     */
    public static Long rpushx(String key, String value) {
        try {
            return redisTemplate.opsForList().rightPushIfPresent(key, value);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return null;
    }


    /**
     * 通过 key 返回指定 list 列表中的所有数据
     *
     * @param key 键
     * @return
     */
    public static List lrange(String key) {
        try {
            return redisTemplate.opsForList().range(key,0,-1);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return null;
    }


    /**
     * 通过 key 指定下标索引范围内的 list 列表
     *
     * @param key   键
     * @param start 开始下标
     * @param end   结束下标
     * @return
     */
    public static List lrange(String key, int start, int end) {
        try {
            return redisTemplate.opsForList().range(key,start,end);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return null;
    }


    /**
     * 通过 key 在 list 列表指定位置设置列表项，
     * 如果指定位置超过 list 总长度则执行失败
     *
     * @param key   键
     * @param index 指定位置下标
     * @param value 值
     * @return
     */
    public static Boolean lset(String key, int index, String value) {
        try {
            redisTemplate.opsForList().set(key,index,value);
            return true;
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return false;

    }


    /**
     * 通过 key 指定下标索引范围截取 list 列表
     *
     * @param key   键
     * @param start 开始下标
     * @param end   结束下标
     * @return
     */
    public static Boolean ltrim(String key, int start, int end) {
        try {
            redisTemplate.opsForList().trim(key,start,end);
            return true;
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return false;
    }




    /**
     * 将成员元素加入到集合中，若已经存在则将被忽略
     *
     * @param key   键
     * @param field 字段
     * @return
     */
    public static Boolean saddIfAbstrent(String key, String field) {
        try {
            redisTemplate.opsForSet().add(key,field);
            return true;
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return false;
    }


    /**
     * 通过 key 获取 set 数据类型集合中的元素数量
     *
     * @param key
     * @return
     */
    public static Long scard(String key) {
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return 0L;
    }


    /**
     * 通过指定 key 返回给定集合之间的差集
     * 不存在的集合 key 将视为空集
     *
     * @param key1 集合 1 key
     * @param key2 集合 2 key
     * @return
     */
    public static Set sdiff(String key1, String key2) {
        try {
            return redisTemplate.opsForSet().difference(key1, key2);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return null;
    }


    /**
     * 返回给定所有给定集合的交集。
     * 不存在的集合 key 被视为空集。
     * 当给定集合当中有一个空集时，结果也为空集(根据集合运算定律)
     *
     * @param key1 集合 1 key
     * @param key2 集合 2 key
     * @return
     */
    public static Set sinter(String key1, String key2) {
        try {
            return redisTemplate.opsForSet().intersect(key1, key2);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return null;
    }


    /**
     * 返回给定集合的并集
     * 不存在的集合 key 被视为空集
     *
     * @param key1 集合 1 key
     * @param key2 集合 2 key
     * @param keys 多个集合 key 数组
     * @return
     */
    public static Set sunion(String key1, String key2, String... keys) {
        try {
            return redisTemplate.opsForSet().union(key1, key2);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return null;
    }


    /**
     * 将给定集合之间的差集存储在指定的集合中。
     * 如果指定的集合 key 已存在， 则会被覆盖
     *
     * @param key1 指定集合 key
     * @param key2 集合1 key
     * @param key3 集合2 key
     * @return
     */
    public static Long sdiffstore(String key1, String key2, String key3) {
        try {
            return redisTemplate.opsForSet().differenceAndStore(key1, key2,key3);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return null;
    }


    /**
     * 将给定集合之间的交集存储在指定的集合中。
     * 如果指定的集合已经存在，则将其覆盖
     *
     * @param key1 指定集合 key
     * @param key2 集合1 key
     * @param key3 集合2 key
     * @return
     */
    public static Long sinterstore(String key1, String key2, String key3) {
        try {
            return redisTemplate.opsForSet().intersectAndStore(key1, key2,key3);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return null;
    }


    /**
     * 将给定集合的并集存储在指定的集合中。
     * 如果集合已经存在，则将其覆盖
     *
     * @param key1 指定集合 key
     * @param key2 集合1 key
     * @param key3 集合2 key
     * @return
     */
    public static Long sunionstore(String key1, String key2, String key3) {
        try {
            return redisTemplate.opsForSet().unionAndStore(key1, key2,key3);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return null;
    }


    /**
     * 通过 key 判断 field 是否是集合内的元素
     *
     * @param key   键
     * @param field 字段
     * @return
     */
    public static Boolean sismember(String key, String field) {
        try {
             return redisTemplate.opsForSet().isMember(key, field);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return false;
    }


    /**
     * 通过 key 获取指定集合中的所有的成员。
     * 不存在的集合将被视为空集合
     *
     * @param key 键
     * @return
     */
    public static Set smembers(String key) {
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return null;
    }




    /**
     * 通过 key 移除集合中为 field 的元素
     * 不存在的成员元素会被忽略
     *
     * @param key   键
     * @param fields 需要移除的元素
     * @return
     */
    public static Long srem(String key, String...fields) {
        try {
            return redisTemplate.opsForSet().remove(key, fields);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return null;
    }
}

劝退工程师
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
关于redisTemplate.opsForValue().set数据本地redis客户端库中查不到问题的解决记录
北溟南风起
07-23 9207
redisTemplate明明存值完成了结果本地redis数据库客户端查不到，真相找到了......
redisTemplate.opsForValue() 懂这些就够了
思索的涟漪，突破自我
12-20 5499
hello，我是小索奇，redisTemplate.opsForValue() 是 Spring Data Redis 提供的一个操作字符串类型数据的工具方法。通过这个方法，你可以获取一个 ValueOperations 对象，然后使用该对象进行对 Redis 中字符串类型数据的操作，比如存储、读取、删除等。下是 ValueOperations 的一些常用方法哈。
redisTemplate.opsForValue()中方法讲解
热门推荐
FighterLiu的专栏
10-27 3万+
查看源码可以看到redisTemplate.opsForValue()中的方法都定义在ValueOperations<K, V> 中，该接口中一共有17个方法： public interface ValueOperations<K, V> { void set(K key, V value); void set(K key, V value, long timeout, TimeUnit unit); Boolean setIfAbsent(K key, V value);
【Redis】关于redisTemplate.opsForValue().set数据本地redis客户端库中查不到问题的解决记录，或者查到的key或者value是乱码
最新发布
qq_39666711的博客
07-05 504
二进制串，所以通过get name3 未拿到数据，由于我制定了向redis中存储的时候了，key的序列化的方式了，所以这个里面的key 直接就以name3 的形式存储到了redis中，所以此时通过 get name3 能读取到了数据；但是随之另外一个问题出现了，key序列化之后，通过key：name3 能读取到数据了，而且读取到的数据在console中显示正常。然后在本地redis库中，通过key值读取maven工程中刚才通过redisTemplate存储的数值时，发现获取不到，于是我实验了一番。
RedisTemplate的使用之opsForValue
qq_41988770的博客
07-05 7312
RedisTemplate的使用之opsForValue
RedisTemplate中opsForValue和opsForList方法的使用详解
weixin_42258334的博客
06-29 8846
REDIS
redis工具类
11-09
redis工具类,整合springmvc,用来操作redis,获取数据的工具类,包括初始化和具体操作
redis utils 工具类
07-08
Redis Utils工具类是Java开发中常见的一种封装，用于简化与Redis数据库的交互操作。Redis是一种高性能的键值存储系统，广泛应用于缓存、消息队列、数据持久化等多个场景。在Java开发中，为了提高代码的可读性和复用...
redis工具类以及redis 连接池配置
07-01
工具类中包括存放hash表键值对，键值对以map的方式储存，删除键值对，永久存放键值对，设置过期时间，需要的直接去gitHab上看https://github.com/1610220353/advancedGiants/tree/master/src/main
spring-redis工具类
04-22
Spring整合Redis工具类，导入redis依赖，并使用工具类，不必使用RedisTemplate调用redis，并且采用java更常用的方式调用方法。
springboot 集成封装redis工具类redisUtils和单元测试
09-13
文章是redisUtils工具类的封装，和基于springboot环境的单元测试； 文中封装了redis的众多方法，希望对您有所帮助。
Redis工具类.rar
05-28
Redis工具类是为了简化与Redis交互而创建的Java代码库，它可以极大地提高开发效率，帮助开发者快速实现对Redis的操作。以下是一些关于Redis工具类的重要知识点： 1. **连接管理**：Redis工具类通常会包含连接池的...
java中redis工具类
01-27
java中redis工具类 指定缓存失效时间 根据key 获取过期时间，返回0代表为永久有效 判断key是否存在 删除缓存，可以传一个值 或多个 普通缓存获取 普通缓存放入 普通缓存放入并设置时间，time要大于0 如果time小于...
Redis的StringRedisTemplate在SpringBoot中的使用完全整理之opsForValue
baidu_17353319的博客
04-02 1万+
opsForValue() 目录 opsForValue() set(String k,String v) set(String k,String v,long l) set(String k,String v,long l,TimeUtil timeUtil)与set(String k,String v,Duration timeout) setBit(String k,lon...
RedisTemplate redis缓存的基本使用
lixuanhong的博客
10-21 2709
RedisTemplate redis缓存的基本使用
redis指令
wjs10136914的博客
07-21 920
数据库 基于内存的非关系型数据库 速度极快 容量小 所以存高热/常用的数据
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值