redis工具类,依赖spring-data-redis

最新推荐文章于 2023-02-17 16:53:41 发布
最新推荐文章于 2023-02-17 16:53:41 发布
阅读量389 收藏
点赞数
分类专栏： redis

接口类

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;

public interface RedisCacheService {
     public boolean expire(String key, long time);
     public long getExpire(String key);
     public boolean hasKey(String key);
     public void del(String... key);
     public Object get(String key);
     public boolean set(String key, Object value);
     public boolean set(String key, Object value, long time);
     public long incr(String key, long delta);
     public long decr(String key, long delta);
     public Object hget(String key, String item);
     public Map<Object, Object> hmget(String key);
     public boolean hmset(String key, Map<String, Object> map);
     public boolean hmset(String key, Map<String, Object> map, long time);
     public boolean hset(String key, String item, Object value);
     public boolean hset(String key, String item, Object value, long time);
     public void hdel(String key, Object... item) ;
     public boolean hHasKey(String key, String item);
     public double hincr(String key, String item, double by);
     public double hdecr(String key, String item, double by);
     public Set<Object> sGet(String key);
     public boolean sHasKey(String key, Object value);
     public long sSet(String key, Object... values);
     public long sSetAndTime(String key, long time, Object... values);
     public long sGetSetSize(String key);
     public long setRemove(String key, Object... values);
     public List<Object> lGet(String key, long start, long end);
     public long lGetListSize(String key);
     public Object lGetIndex(String key, long index);
     public boolean lSet(String key, Object value);
     public boolean lSet(String key, Object value, long time);
     public boolean lSet(String key, List<Object> value);
     public boolean lSet(String key, List<Object> value, long time);
     public boolean lUpdateIndex(String key, long index, Object value);
     public long lRemove(String key, long count, Object value);
     // add by huanglei 20180905 12:57
     public Object sSet(String key, final List<String> list);
}
 

实现类
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import javax.security.auth.callback.Callback;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import com.unisk.longlhg.redis.RedisCacheService;

/**
 * Redis Util
 * @author huanglei
 * @date 2018年8月24日
 *
 */
@Service
public class RedisCacheServiceImpl implements RedisCacheService{
    
    @Autowired @Qualifier("jedisTemplate")
    private RedisTemplate<String, Object> redisTemplate;
    
    /**
     * 指定缓存失效时间
     * 
     * @param key
     *            键
     * @param time
     *            时间(秒)
     * @return
     */
    public 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 long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

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

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

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

    /**
     * 普通缓存放入
     * 
     * @param key
     *            键
     * @param value
     *            值
     * @return true成功 false失败
     */
    public 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 boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

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

    /**
     * 递减
     * 
     * @param key
     *            键
     * @param by
     *            要减少几(小于0)
     * @return
     */
    public 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
     * @return 值
     */
    public Object hget(String key, String item) {
        return redisTemplate.opsForHash().get(key, item);
    }

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

    /**
     * HashSet
     * 
     * @param key
     *            键
     * @param map
     *            对应多个键值
     * @return true 成功 false 失败
     */
    public 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 boolean hmset(String key, Map<String, Object> map, long time) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     * 
     * @param key
     *            键
     * @param item
     *            项
     * @param value
     *            值
     * @return true 成功 false失败
     */
    public 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 boolean hset(String key, String item, Object value, long time) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

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

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

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

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

    
    
    
    // ============================set=============================
    /**
     * 根据key获取Set中的所有值
     * 
     * @param key
     *            键
     * @return
     */
    public 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 boolean sHasKey(String key, Object value) {
        try {
            //System.out.println(key + value);
            //System.out.println(key + value+"--------------------->"+redisTemplate.opsForSet().isMember(key, value));
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将数据放入set缓存
     * 
     * @param key
     *            键
     * @param values
     *            值 可以是多个
     * @return 成功个数
     */
    public long sSet(String key, Object... values) {
        try {
            
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    
    public Object sSet(String key, final List<String> list) {
        final StringRedisSerializer stringRedisSerializer = (StringRedisSerializer) redisTemplate.getKeySerializer();
         final RedisSerializer<String> valueSerializer = (RedisSerializer<String>) redisTemplate.getValueSerializer();
        //获取key对应的byte[]
        final byte[] rawKey = stringRedisSerializer.serialize(key);
        redisTemplate.executePipelined(new RedisCallback() {
            @Override
            public Object doInRedis(RedisConnection connection)
                    throws DataAccessException {
                for (String str : list) {
                    byte[] rawStr =valueSerializer.serialize(str);
                    connection.sAdd(rawKey,rawStr);
                }
                connection.closePipeline();
                return null;
            }
        });
        
        return null;
        
    }

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

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

    /**
     * 移除值为value的
     * 
     * @param key
     *            键
     * @param values
     *            值 可以是多个
     * @return 移除的个数
     */
    public long setRemove(String key, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().remove(key, values);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    
    
    
    
    // ===============================list=================================

    /**
     * 获取list缓存的内容
     * 
     * @param key
     *            键
     * @param start
     *            开始
     * @param end
     *            结束 0 到 -1代表所有值
     * @return
     */
    public 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
     *            键
     * @return
     */
    public 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倒数第二个元素，依次类推
     * @return
     */
    public 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
     *            值
     * @param time
     *            时间(秒)
     * @return
     */
    public 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
     *            时间(秒)
     * @return
     */
    public boolean lSet(String key, Object value, long time) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            if (time > 0)
                expire(key, time);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

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

    /**
     * 根据索引修改list中的某条数据
     * 
     * @param key
     *            键
     * @param index
     *            索引
     * @param value
     *            值
     * @return
     */
    public 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 long lRemove(String key, long count, Object value) {
        try {
            Long remove = redisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }


}
 

 

老僧已死成新塔
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
redis依赖_微服务: SpringBoot 集成 Redis
weixin_39962341的博客
12-08 3046
简介 忙碌了一周，感觉只有此刻写文字的时间才是最惬意的。最近工作比较忙，文章更新的较慢还望大家多多见谅?‍！在阅读下面的内容之前，希望你已经安装并且做好了学习 Spring Boot 集成 Redis 的准备了。如果你还没有搭建 Redis 环境，Win10-安装-Redis 这篇文章或许可以帮到您。在 Spring Boot 1.x 版本中默认的 Redis 客户端是 Jedis 实现...
spring-data-redis RedisTemplateUtils工具类
iteye_3489的博客
08-29 449
package com.lh.core.core.util; import java.util.Arrays; import java.util.concurrent.TimeUnit; import org.springframework.data.redis.core.RedisTemplate; import com.rd.ifaes.common.dict.Expir...
Spring Redis配置、工具类
m0_74141658的博客
02-17 88
【代码】Spring Redis配置、工具类。
SpringDataRedis依赖
aikong3218的博客
09-24 691
<dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.9</version>...
Redis 与Spring-data-redis 整合后封装的工具类
weixin_30575309的博客
09-09 227
此工具类方法是使用了redis 与spring 整合后，才可以使用的工具类，将 spring-data-redis 一些我们开发中常用的方法进行了封装，方便我们日常开发中进行调用： package com.project.utils; import java.util.Map; import java.util.Set; import java.util.concurrent...
spring-data-redis.jar包
10-13
spring和redis缓存工具类包
spring data redis api jar
03-18
spring data redis api jar
spring boot结合Redis实现工具类的方法示例
08-26
在本文中，我们将深入探讨如何在Spring Boot应用中结合Redis实现一个工具类，以便更方便地...通过配置依赖、设置连接参数以及编写工具类方法，我们可以轻松地将Redis集成到Spring Boot应用中，实现高效的数据缓存功能。
44-Spring Boot使用Redis管理Session1
08-08
首先，启用Redis作为Session存储需要引入`spring-session-data-redis`依赖。在`pom.xml`或`build.gradle`文件中添加相应的依赖项，确保Spring Boot能够支持Redis Session管理。 ```xml <groupId>org.spring...
redis操作工具类
04-15
springboot集成spring-boot-starter-data-redis的StringRedisTemplate实现
springMVC集成spring-data-redis
08-01
redis-service_pubsub.rar。 springMVC集成spring-data-redis实现发布订阅。
redis 依赖_实例讲解Springboot以Repository方式整合Redis
weixin_39759107的博客
12-07 416
1 简介Redis是高性能的NoSQL数据库，经常作为缓存流行于各大互联网架构中。本文将介绍如何在Springboot中整合Spring Data Redis，使用Repository的方式操作。代码结构如下：2 整合过程2.1 安装Redis数据库为了节省时间，就直接通过Docker来安装了，可以参考文章：Docker安装Redis并介绍漂亮的可视化客户端进行操作[1]，可以快速安装并使用客户端...
springdata整合redis
qq_57517269的博客
03-14 1660
springdata整合redis步骤 首先pom文件引入依赖与yml文件配置redis相关信息 导入pom依赖 <!--spring-data redis依赖--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifac
13-SpringBoot整合redis
DevOps海洋的渔夫@专栏
03-06 430
13-SpringBoot整合redisSpringBoot整合redis实现步骤①搭建SpringBoot工程②引入redis起步依赖③配置redis相关属性④注入RedisTempla...
Error:(5, 43) java: 程序包org.springframework.data.redis.core不存在
klz
05-15 8641
springboot+springsecurity+jwt+redis集成的时候RediUtil报错 网上有的人说是依赖版本问题，有的人说将@Autowired改为@Resource，都试了，但是没用，哪位大佬知道怎么回事？ 依赖 <!-- redis组件 --> <dependency> <groupId>org.springframework.boot</groupId> &l
redis的使用（四）spring boot 整合redis（Jedis客户端）
CSDN已弃用
06-26 1309
本次记录spring boot 整合redis的配置 1. 引入redis和jedis依赖包 <!-- redis依赖和jedis --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-star...
【SpringBoot笔记22】SpringBoot框架集成Redis数据库
11-07 686
Redis是一个非关系型数据库，它是一个基于内存的数据，所有的操作都是在内存里面完成，所以它的执行效率非常的高，一般实际开发中，都会采用Redis数据库作为缓存组件，SpringBoot框架提供了Redis的starter启动器，下面介绍SpringBoot框架如何集成Redis。一般我们在使用的时候，都会自定义Redis的序列化方式，这样写入redis数据库里面的时候，就可以看的更加直观，而不会是一些看不到的乱码。综上，这篇文章结束了，主要介绍SpringBoot框架如何集成Redis数据库。
java 包依赖_在java中redis的使用、导包依赖、配置、及其封装
weixin_26884391的博客
02-16 678
原标题：在java中redis的使用、导包依赖、配置、及其封装一、在pom.xlm文件中引入依赖包org.springframework.bootspring-boot-starter-data-redisorg.springframework.bootspring-boot-starter-data-redis-reactive二、application.properties文件中配置sprin...
Spring Data Redis（一）-- 解析 RedisTemplate
lizhengyu891231的博客
08-18 393
转载自：https://www.cnkirito.moe/spring-data-redis-1/ 叙述 谈及系统优化，缓存一直是不可或缺的一点。在缓存中间件层面，我们有 MemCache，Redis 等选择；在系统分层层面，又需要考虑多级缓存；在系统可用性层面，又要考虑到缓存雪崩，缓存穿透，缓存失效等常见的缓存问题… 缓存的使用与优化值得我们花费一定的精力去深入理解。《Spring Data Redis》这个系列打算围绕 spring-data-redis 来进行分析，从 hello worl..
spring-boot-starter-data-redis 发行版
最新发布
02-10
spring-boot-starter-data-redis是...总结来说，spring-boot-starter-data-redis是一个方便集成和使用Redis的Spring Boot模块，它简化了Redis的配置和操作，并提供了一系列的注解和工具类来支持Redis的缓存和高级功能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值