1287人阅读
使用Java操作Redis需要jedis-2.1.0.jar，下载地址：
如果需要使用Redis连接池的话，还需commons-pool-1.5.4.jar，下载地址:
参考api手册：
package com.
import java.util.HashM
import java.util.I
import java.util.L
import java.util.M
import org.junit.B
import org.junit.T
import redis.clients.jedis.J
public class TestRedis {
public void setup() {
//连接redis服务器，192.168.0.100:6379
jedis = new Jedis(&192.168.0.100&, 6379);
//权限认证
jedis.auth(&admin&);
* redis存储字符串
public void testString() {
//-----添加数据----------
jedis.set(&name&,&xinxin&);//向key--&name中放入了value--&xinxin
System.out.println(jedis.get(&name&));//执行结果：xinxin
jedis.append(&name&, & is my lover&); //拼接
System.out.println(jedis.get(&name&));
jedis.del(&name&);
//删除某个键
System.out.println(jedis.get(&name&));
//设置多个键值对
jedis.mset(&name&,&liuling&,&age&,&23&,&qq&,&476777XXX&);
jedis.incr(&age&); //进行加1操作
System.out.println(jedis.get(&name&) + &-& + jedis.get(&age&) + &-& + jedis.get(&qq&));
* redis操作Map
public void testMap() {
//-----添加数据----------
Map&String, String& map = new HashMap&String, String&();
map.put(&name&, &xinxin&);
map.put(&age&, &22&);
map.put(&qq&, &123456&);
jedis.hmset(&user&,map);
//取出user中的name，执行结果:[minxr]--&注意结果是一个泛型的List
//第一个参数是存入redis中map对象的key，后面跟的是放入map中的对象的key，后面的key可以跟多个，是可变参数
List&String& rsmap = jedis.hmget(&user&, &name&, &age&, &qq&);
System.out.println(rsmap);
//删除map中的某个键值
jedis.hdel(&user&,&age&);
System.out.println(jedis.hmget(&user&, &age&)); //因为删除了，所以返回的是null
System.out.println(jedis.hlen(&user&)); //返回key为user的键中存放的值的个数2
System.out.println(jedis.exists(&user&));//是否存在key为user的记录 返回true
System.out.println(jedis.hkeys(&user&));//返回map对象中的所有key
System.out.println(jedis.hvals(&user&));//返回map对象中的所有value
Iterator&String& iter=jedis.hkeys(&user&).iterator();
while (iter.hasNext()){
String key = iter.next();
System.out.println(key+&:&+jedis.hmget(&user&,key));
* jedis操作List
public void testList(){
//开始前，先移除所有的内容
jedis.del(&java framework&);
System.out.println(jedis.lrange(&java framework&,0,-1));
//先向key java framework中存放三条数据
jedis.lpush(&java framework&,&spring&);
jedis.lpush(&java framework&,&struts&);
jedis.lpush(&java framework&,&hibernate&);
//再取出所有数据jedis.lrange是按范围取出，
// 第一个是key，第二个是起始位置，第三个是结束位置，jedis.llen获取长度 -1表示取得所有
System.out.println(jedis.lrange(&java framework&,0,-1));
jedis.del(&java framework&);
jedis.rpush(&java framework&,&spring&);
jedis.rpush(&java framework&,&struts&);
jedis.rpush(&java framework&,&hibernate&);
System.out.println(jedis.lrange(&java framework&,0,-1));
* jedis操作Set
public void testSet(){
jedis.sadd(&user&,&liuling&);
jedis.sadd(&user&,&xinxin&);
jedis.sadd(&user&,&ling&);
jedis.sadd(&user&,&zhangxinxin&);
jedis.sadd(&user&,&who&);
//移除noname
jedis.srem(&user&,&who&);
System.out.println(jedis.smembers(&user&));//获取所有加入的value
System.out.println(jedis.sismember(&user&, &who&));//判断 who 是否是user集合的元素
System.out.println(jedis.srandmember(&user&));
System.out.println(jedis.scard(&user&));//返回集合的元素个数
public void test() throws InterruptedException {
//jedis 排序
//注意，此处的rpush和lpush是List的操作。是一个双向链表（但从表现来看的）
jedis.del(&a&);//先清除数据，再加入数据进行测试
jedis.rpush(&a&, &1&);
jedis.lpush(&a&,&6&);
jedis.lpush(&a&,&3&);
jedis.lpush(&a&,&9&);
System.out.println(jedis.lrange(&a&,0,-1));// [9, 3, 6, 1]
System.out.println(jedis.sort(&a&)); //[1, 3, 6, 9]
//输入排序后结果
System.out.println(jedis.lrange(&a&,0,-1));
public void testRedisPool() {
RedisUtil.getJedis().set(&newname&, &中文测试&);
System.out.println(RedisUtil.getJedis().get(&newname&));
redis连接池
package com.
import redis.clients.jedis.J
import redis.clients.jedis.JedisP
import redis.clients.jedis.JedisPoolC
public final class RedisUtil {
//Redis服务器IP
private static String ADDR = &192.168.0.100&;
//Redis的端口号
private static int PORT = 6379;
//访问密码
private static String AUTH = &admin&;
//可用连接实例的最大数目，默认值为8；
//如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
private static int MAX_ACTIVE = 1024;
//控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8。
private static int MAX_IDLE = 200;
//等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException；
private static int MAX_WAIT = 10000;
private static int TIMEOUT = 10000;
//在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
private static boolean TEST_ON_BORROW =
private static JedisPool jedisPool =
* 初始化Redis连接池
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxActive(MAX_ACTIVE);
config.setMaxIdle(MAX_IDLE);
config.setMaxWait(MAX_WAIT);
config.setTestOnBorrow(TEST_ON_BORROW);
jedisPool = new JedisPool(config, ADDR, PORT, TIMEOUT, AUTH);
} catch (Exception e) {
e.printStackTrace();
* 获取Jedis实例
public synchronized static Jedis getJedis() {
if (jedisPool != null) {
Jedis resource = jedisPool.getResource();
} catch (Exception e) {
e.printStackTrace();
* 释放jedis资源
* @param jedis
public static void returnResource(final Jedis jedis) {
if (jedis != null) {
jedisPool.returnResource(jedis);
MongoDB更类似Mysql，支持字段索引、游标操作，其优势在于查询功能比较强大，擅长查询JSON数据，能存储海量数据，但是不支持事务。
Mysql在大数据量时效率显著下降，MongoDB更多时候作为关系数据库的一种替代。
内存管理机制
Redis数据全部存在内存，定期写入磁盘，当内存不够时，可以选择指定的LRU算法删除数据。
MongoDB数据存在内存，由linux系统mmap实现，当内存不够时，只将热点数据放入内存，其他数据存在磁盘。
支持的数据结构
Redis支持的数据结构丰富，包括string hash list set zset&等。
MongoDB数据结构比较单一，但是支持丰富的数据表达，索引，最类似关系型数据库，支持的查询语言非常丰富。
memcache 卖么凯奇的set
在使用缓存的时候，redis比memcached具有更多的优势，并且支持更多的数据类型
nosql数据库里的redis数据库，，not only sql
Jedis 是 Redis 官方首选的 Java 客户端开发包。
string hash list set zset 五种 serialize
RW-R-R，第一部分RW代表当前用户具有读写的权限。第二部分的R代表当前用户所在的用户组中其他成员只有读得权限，最后一个R
表示额外的其他用户只有读得权限。
二者性能都比较高，应该说都不会是瓶颈。
二者均支持持久化。
&&&&&&&& MongoDB集群技术比较成熟，Redis从3.0开始支持集群。
不适用场景
?& 需要使用复杂sql的操作
?& 事务性系统
从以下几个维度，对 redis、memcache、mongoDB 做了对比。
都比较高，性能对我们来说应该都不是瓶颈。
总体来讲，TPS 方面 redis 和 memcache 差不多，要大于 mongodb。
2、操作的便利性
memcache 单一。（key-value）
redis 丰富一些，数据操作方面，redis 更好一些，较少的网络 IO 次数，同时还提供 list，set，
hash 等的存储。
mongodb 支持丰富的数据表达，索引，最类似，支持的查询语言非常丰富。
3、内存空间的大小和数据量的大小
redis 在 2.0 版本后增加了自己的 VM 特性，突破的限制；可以对 key value 设置过
期时间（类似 memcache）
memcache 可以修改最大可用内存,采用 LRU 算法。Memcached 代理软件 magent，比如建立
10 台 4G 的 Memcache 集群，就相当于有了 40G。 magent -s 10.1.2.1 -s 10.1.2.2:11211 -b
10.1.2.3:14000 mongoDB 适合大数据量的存储，依赖 VM 做，吃内存也比较厉害，服务
不要和别的服务在一起。
4、可用性（单点问题）
对于单点问题，
redis，依赖客户端来实现分布式读写；主从复制时，每次从节点重新连接主节点都要依赖整
个快照,无增量复制，因性能和效率问题，
所以单点问题比较复杂；不支持自动 sharding,需要依赖程序设定一致 hash 机制。
一种替代方案是，不用 redis 本身的复制机制，采用自己做主动复制（多份存储），或者改成
增量复制的方式（需要自己实现），一致性问题和性能的权衡
Memcache 本身没有数据冗余机制，也没必要；对于故障预防，采用依赖成熟的 hash 或者环
状的算法，解决单点故障引起的抖动问题。
mongoDB 支持 master-slave,replicaset（内部采用 paxos 选举算法，自动故障恢复）,auto sharding 机制，对客户端屏蔽了故障转移和切分机制。
5、可靠性（持久化）
redis 支持（快照、AOF）：依赖快照进行持久化，aof 增强了可靠性的同时，对性能有所影
memcache 不支持，通常用在做缓存,提升性能；
MongoDB 从 1.8 版本开始采用 binlog 方式支持持久化的可靠性
6、（事务支持）
Memcache 在并发场景下，用 cas 保证一致性redis 事务支持比较弱，只能保证事务中的每个操作连续执行
mongoDB 不支持事务
7、数据分析
mongoDB 内置了数据分析的功能(mapreduce),其他不支持
8、应用场景
redis：数据量较小的更性能操作和运算上
memcache：用于在动态系统中减少数据库负载，提升性能;做缓存，提高性能（适合读多写
少，对于数据量比较大，可以采用 sharding）
MongoDB:主要解决的访问效率问题。
表格比较：
memcache redis 类型
数据类型 在定义 value 时就要固定数据类型 不需要
有字符串，链表，集 合和有序集合
虚拟内存 不支持 支持
过期策略 支持 支持
分布式 magent master-slave，一主一从或一主多从
存储数据安全 不支持 使用 save 存储到 dump.rdb 中
灾难恢复 不支持 append only file(aof)用于数据恢复
1、类型——memcache 和 redis 都是将数据存放在内存，所以是内存数据库。当然，memcache 也可用于缓存其他东西，例如图片等等。
2、 数据类型——Memcache 在添加数据时就要指定数据的字节长度,而 redis 不需要。
3、 虚拟内存——当物理内存用完时，可以将一些很久没用到的 value 交换到磁盘。
4、 过期策略——memcache 在 set 时就指定，例如 set key1 0 0 8,即永不过期。Redis 可以通
过例如 expire 设定，例如 expire name 10。
5、 分布式——设定 memcache 集群，利用 magent 做一主多从;redis 可以做一主多从。都可
以一主一从。
6、 存储数据安全——memcache 断电就断了，数据没了；redis 可以定期 save 到磁盘。
7、 灾难恢复——memcache 同上，redis 丢了后可以通过 aof 恢复。
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：90792次
积分：1650
积分：1650
排名：千里之外
原创：84篇
(1)(7)(10)(1)(2)(1)(2)(1)(1)(1)(1)(1)(2)(2)(2)(5)(1)(1)(2)(4)(1)(1)(2)(3)(1)(1)(2)(4)(22)
(window.slotbydup = window.slotbydup || []).push({
id: '4740881',
container: s,
size: '200,200',
display: 'inlay-fix'详解JavaEE 使用 Redis 数据库进行内容缓存和高访问负载
作者：郭朝
字体：[ ] 类型：转载 时间：
本篇文章主要介绍了JavaEE 使用 Redis 数据库进行内容缓存和高访问负载，具有一定的参考价值，有兴趣的可以了解一下
NoSQL（Not Only SQL），泛指非关系型数据库，是为了处理高并发读写、海量数据的高效率存储和访问、高扩展性和高可用性而产生的。
键值对(Key-Value)存储
Redis、Voldemort、Berkeley DB
内容缓存、处理高访问负载
一系列键值对
存储的数据缺少结构化
列存储数据库
Cassandra、HBase、Riak
分布式文件系统
以列簇式存储，将同一列数据存在一起
查询速度快，可扩展性强，更容易进行分布式扩展
功能相对局限
文档型数据库
MongoDB、CouchDB
一系列键值对
数据结构要求不严格
查询性能不高，缺乏统一的查询语法
图形数据库
Neo4j、InfoGrid
社交网络，推荐系统，专注于构建关系图谱
利用图结构相关算法
需要对整个图做计算才能得出结果，不容易做分布式的集群方案
本篇将主要阐述如何使用 Redis（）数据库进行内容缓存和高访问负载，redis 使用 C 语言开发的一个开源的高性能的键值对数据库，通过提供多种键值数据类型来适应不同场景下的存储需求，目前 Redis 支持的键值数据类型有很多种，比如字符串类型、列表类型、有序集合类型、散列类型、集合类型。Redis 官方也给我们提供了一些测试数据，有 50 个并发程序来执行 10 万次请求，Redis 读的速度达到了 11 万次/秒，写的速度达到了 8.1 万次/秒。
Redis 最广泛的应用场景就是使用它作为缓存（新闻或商品内容、聊天式的在线好友列表），除此还有任务队列（秒杀、抢购）、网站访问统计、数据过期处理（可以精确到毫秒）、应用排行榜、分布式集群架构中的 session 分离等。
1.Linux下安装Redis数据库
$ scp ~/Downloads/redis-4.0.1.tar.gz root@192.168.2.10:/usr/local //上传安装包
$ ssh root@192.168.2.10
# yum -y install gcc gcc-c++ autoconf automake
//gcc、gcc-c++的库文件
# cd /usr/local
# tar -zxvf redis-4.0.1.tar.gz
# cd redis-4.0.1
//切换到该目录下
//编译，将.c文件编译为.o文件
# make PREFIX=/usr/local/redis install
//指定路径安装
# cd /usr/local
//如果存在redis文件夹，则安装成功
其中 /usr/local/redis/bin/ 下包含：
redis-benchmark
//性能测试的一个工具
redis-check-aof
//aof文件修复的一个工具 redis-check-aof --fix appendonlly.aof
redis-check-dump
//rdb文件检查的一个工具，rdb文件为Redis默认数据库文件
redis-check-rdb
//rdb文件修复的一个工具 redis-check-rdb --fix dump.rdb
//命令行的一个客户端
redis-sentinel -& redis-server
redis-server
//redis服务器启动的命令
接下来继续我们的命令：
# cd redis-4.0.1
# cp redis.conf /usr/local/redis
# cd /usr/local/redis
# vim redis.conf
//编辑Redis的配置文件
具体配置步骤：
1）绑定你的授权ip地址：修改69行的 bind 127.0.0.1 为 bind [host]（绑定到所有网络: 注释掉69行的 bind 127.0.0.1）
2）关闭保护模式：将88行的 protected-mode yes 修改为 daemonize no
3）配置后台启动：将136行的 daemonize no 修改为 daemonize yes
4）配置 Redis 持久化: RDB方式（默认支持，不需要配置）和AOF方式（将509行的appendonly no 修改为 appendonly yes，538-540为同步策略的设置，开启 appendfsync always，注释 appendfsync everysec，always为没修改一次就同步，everysec为每一秒同步，no为不同步，为了安全此处选择 always）。
编辑完成后退出 vim，之后还需要开放 Redis 的 6379 端口：
# vim /etc/sysconfig/iptables
//打开Linux防火墙的设置
//增加代码 -A INPUT -p tcp -m state --state NEW -m tcp --dport 6379 -j ACCEPT
//退出 vim，执行防火墙重启命令
# service iptables restart
# ./bin/redis-server ./redis.conf //启动redis服务器，可以通过 ps -ef | grep -i redis 查看启动是否成功
还有一些其他 Redis 命令如下：
# ./bin/redis-cli shutdown
//停止redis服务器
# ./bin/redis-cli
//打开redis命令行客户端
2.Redis的数据结构
需要知道的是，Redis 的 Key 设置不要过长也不要过短，要有统一的命名规范。先看一下 keys 的操作：
$ ssh root@192.168.2.10
# /usr/local/redis/bin/redis-cli
//显示所有的key
& keys my?
//显示以my开头的所有key
& del my1 my2 my3
//删除my1、my2、my3
& exists my1
//检查是否存在，存在返回1，不存在返回0
//获取key的value值
& rename my1 my2
//重命名my1为my2
& expire my1 1000
//设置key过期时间，单位秒
//剩余超时时间，没有设置则返回-1
& type my1
//获取key对应value的类型
1.存储字符串 String
二进制是安全的，存入和获取的数据相同；Value 最多可以容纳的数据长度是 521 M。存储 String 常用的命令：
& set name zhangsan
//赋值 set [key][value]
& get name
//取值 get [key]
& getset name lisi
//取值并赋值
& del name
//删除 del [key]
& incr num
//数值递增1，如果没有就默认创建0并递增1 incr [key]
& decr num
//数值递减1，如果没有就默认创建0并递减1
& incrby num2 5
//数值递增指定值，如果没有就默认创建0 incrby [key][指定值]
& decrby num2 5
//数值递减指定值，如果没有就默认创建0 decrby [key][指定值]
& append num3 5
//插入指定内容，如果有则追加内容，如果没有则新创建 append [key][插入值]
2.存储哈希 Hash
存储 Hash 可以看成是 String Key 和 String Value 的 Map 容器，适合存储 值-对象 的信息，例如用户名、密码、年龄等等，每一个 Hash 可以存储
个键值对。存储 Hash 常用的命令：
& hset myhash username tom
//赋值单个属性 hset [key][Hash键值对]
& hmset myhash username tom2 rose age 20 //赋值多个属性 hmset [key][Hash键值对1] rose [Hash键值对2]
& hget myhash username
//获取单个属性 hget [key][key2]
& hmget myhash username age
//获取多个属性 hget [key][key2][key3]
& hgetall myhash
//获取全部值
& hdel myhash username age
//删除多个属性
& del myhash
//删除整个集合
& hincrby myhash age 5
//增加属性值
& hexists myhash username
//判断某个属性中的key是否存在，存在返回1，不存在返回0
& hlen myhash
//获取属性个数 hlen [key1]
& hkeys myhash
//获取所有属性名称 hkeys [key1]
3.存储字符串列表 List
在 Redis 中，List（ArrayList 使用数组方式，LinkedList 使用双向链表方式）顺序是按照插入顺序排序的一个字符串链表，和数据结构中的普通链表是一样的，可以在它的头部和尾部添加新的元素，在插入的时候，如果该 key 不存在，那么 Redis 就会为这个键创建一个新的链表，相反，如果链表中所有元素都被移除了，那么该键也会被从数据库中删除。存储 List 常用的命令：
& lpush mylist a b c
//从双向链表的头部开始添加，如果mylist不存在则创建 lpush [key][value1][value2]..
& lpushx mylist d
//从双向链表的头部开始添加，如果mylist不存在则不插入
& rpush mylist 1 2 3
//从双向链表的尾部开始添加
& lrange mylist 0 5
//查看链表 lrange [key][开始位置][结束位置]
& lpop mylist
//弹出双向链表的头部元素，弹出后，双向链表中就没有这个元素了
& rpop mylist
//弹出双向链表的尾部元素
& rpoplpush mylist1 mylist2
//将mylist1里面头部元素弹出插入mylist2头部
& llen mylist
//获取元素个数 llen [key]
& lrem mylist 1 2
//从头到尾删除1个2 lrem [key][删除的个数][删除的元素]
& lrem mylist -1 2
//从尾到头删除1个2
& lrem mylist 0 2
//从尾到头删除所有2
& lset mylist 3 k
//第三个value值设置为k
& linsert mylist before b 11 //第一个b之前插入11
& linsert mylist after b 22
//第一个b之后插入22
rpoplpush 命令在消息发布系统中的使用场景：
4.存储字符串集合 Set
和 List 类型不同的是，Set 集合中不允许出现重复的元素，无序的，Set 可以包含的最大元素数量是 。存储 Set 常用的命令：
& sadd myset a b c
//向Set中添加了三个值 sadd [key][Set集合值]
& srem myset a b
//删除指定元素
& smembers myset
//查看Set中元素 smembers [key]
& sismember myset c
//判断Set中是否存在c，存在返回1，不存在返回0
& sdiff myset myset2
//返回两个Set集合的差集运算
& sdiffstore my my1 my2
//将两个Set集合的差集存储到另一个集合(my)中
& sinter myset myset2
//返回两个Set集合的交集运算
& sunion myset myset2
//返回两个Set集合的并集运算
& scard myset
//返回Set集合成员数量
& srandmember myset
//随机返回Set中一个成员
5.存储有序字符串集合 SortedSet
SortedSet 中的成员在集合中的位置是有序的。存储 SortedSet 常用的命令：
& zadd mysort 65 aa 85 bb 95 cc //有序添加元素 zadd [key][姓名 分数][姓名 分数]...
& zscore mysort aa
//获得分数
& zcard mysort
//返回集合成员数量
& zrem mysort tom cc
//删除元素
& zrange mysort 0 -1
//范围查询，-1表示最后，显示姓名
& zrange mysort 0 -1 withscores //范围查询，姓名分数都会显示
& zrevrange mysort 0 -1 withscores //范围查询，由大到小排序显示
& zremrangebyrank mysort 0 2
//按照排序的范围进行删除，0～2位置
& zremrangebyscore mysort 70 90 //按照分数进行删除，70～90
& zrangebyscore mysort 0 90
//按照分数查0～90之间的
& zrangebyscore mysort 0 90 withscores limit 0 2 //按照分数查0～90之间的，由大到小排序，只显示前2个
& zcount mysort 60 100
//获取60～100之间的个数
SortedSet 可以应用于游戏的积分排行榜、构建索引数据。
3.Redis的多数据库和事务
一个 Redis 实例最多可以提供16个数据库（0-15），默认连接第 0 号数据库，也可以通过select 选择数据库：
& select 1
//选择1号数据库
& move myset 2
//移动myset到2号数据库
支持事务（所有命令都将串行化执行）的操作：
//开启事务
//提交事务
//回滚事务
4.使用Jedis操作Redis数据库
Jedis（）是 Redis 官方首选的 Java 客户端开发包，
需要添加 Maven 依赖：
&!-- jedis --&
&dependency&
&groupId&redis.clients&/groupId&
&artifactId&jedis&/artifactId&
&version&2.9.0&/version&
&type&jar&/type&
&scope&compile&/scope&
&/dependency&
普通方式操作 Redis：
Jedis jedis =
jedis = new Jedis("123.57.73.52",6379);
jedis.set("name", "zhangsan");
//保存数据
String value = jedis.get("name");
//获取数据
System.out.println(value);
} catch (Exception e) {
e.printStackTrace();
} finally {
jedis.close();
//释放资源
使用 Jedis 连接池操作 Redis：
//获得连接池的配置对象
JedisPoolConfig config = new JedisPoolConfig();
//设置最大连接数, 默认8个
config.setMaxTotal(8);
//设置最大空闲连接数, 默认8个
config.setMaxIdle(8);
//获得连接池
JedisPool jedisPool = new JedisPool(config, "123.57.73.52",6379);
//获得核心对象
Jedis jedis =
jedis = jedisPool.getResource();
jedis.set("name2", "lisi");
//保存数据
String value = jedis.get("name2");
//获取数据
System.out.println(value);
} catch (Exception e) {
e.printStackTrace();
} finally {
jedis.close();
//释放资源
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持脚本之家。
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具Java操作Redis
目前Jedis是官方推荐的比较好的Redis操作API包，我们这里结合Spring来看下如何使用Redis这一神器。
1、在pom文件中引入jredis包：
redis.clients
2、在Spring的resource目录中增加Redis的配置文件/src/main/resources/redis.properties
# Redis settings
redis.host=192.168.56.101
redis.port=6379
redis.pass=lxh
redis.timeout=0
redis.maxIdle=300
redis.maxActive=600
redis.maxWait=1000
redis.testOnBorrow=true
3、在Spring的配置文件中配置好Redis的相关Bean注入：
4、获取Redis客户端对象的类
package com.redis.demo.service.
import org.slf4j.L
import org.slf4j.LoggerF
import org.springframework.beans.factory.annotation.A
import org.springframework.stereotype.R
import com.redis.demo.service.RedisS
import redis.clients.jedis.ShardedJ
import redis.clients.jedis.ShardedJedisP
@Repository(&redisService&)
public class RedisServiceImpl implements RedisService {
private static final Logger log = LoggerFactory.getLogger(RedisServiceImpl.class);
@Autowired
private ShardedJedisPool shardedJedisP
public ShardedJedis getRedisClient() {
ShardedJedis shardJedis = shardedJedisPool.getResource();
return shardJ
} catch (Exception e) {
log.error(&getRedisClent error&, e);
public void returnResource(ShardedJedis shardedJedis) {
shardedJedisPool.returnResource(shardedJedis);
public void returnResource(ShardedJedis shardedJedis, boolean broken) {
if (broken) {
shardedJedisPool.returnBrokenResource(shardedJedis);
shardedJedisPool.returnResource(shardedJedis);
5、RedisClient类中实现Redis的相关操作
package com.redis.
import java.util.C
import java.util.L
import java.util.M
import java.util.S
import org.slf4j.L
import org.slf4j.LoggerF
import org.springframework.beans.factory.annotation.A
import com.redis.demo.service.impl.RedisServiceI
import redis.clients.jedis.BinaryClient.LIST_POSITION;
import redis.clients.jedis.J
import redis.clients.jedis.JedisShardI
import redis.clients.jedis.ShardedJ
import redis.clients.jedis.ShardedJedisP
import redis.clients.jedis.SortingP
import redis.clients.jedis.T
public class RedisClient {
private static final Logger log = LoggerFactory.getLogger(RedisClient.class);
@Autowired
private RedisServiceImpl redisS
public void disconnect() {
ShardedJedis shardedJedis = redisService.getRedisClient();
shardedJedis.disconnect();
* 设置单个值
public String set(String key, String value) {
String result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.set(key, value);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
* 获取单个值
public String get(String key) {
String result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.get(key);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Boolean exists(String key) {
Boolean result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.exists(key);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public String type(String key) {
String result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.type(key);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
* 在某段时间后失效
public Long expire(String key, int seconds) {
Long result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.expire(key, seconds);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
* 在某个时间点失效
public Long expireAt(String key, long time) {
Long result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.expireAt(key, time);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Long ttl(String key) {
Long result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.ttl(key);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public boolean setbit(String key, long offset, boolean value) {
ShardedJedis shardedJedis = redisService.getRedisClient();
boolean result =
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.setbit(key, offset, value);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public boolean getbit(String key, long offset) {
ShardedJedis shardedJedis = redisService.getRedisClient();
boolean result =
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.getbit(key, offset);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public long setrange(String key, long offset, String value) {
ShardedJedis shardedJedis = redisService.getRedisClient();
long result = ;
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.setrange(key, offset, value);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public String getrange(String key, long startOffset, long endOffset) {
ShardedJedis shardedJedis = redisService.getRedisClient();
String result =
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.getrange(key, startOffset, endOffset);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public String getSet(String key, String value) {
String result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.getSet(key, value);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Long setnx(String key, String value) {
Long result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.setnx(key, value);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public String setex(String key, int seconds, String value) {
String result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.setex(key, seconds, value);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Long decrBy(String key, long integer) {
Long result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.decrBy(key, integer);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Long decr(String key) {
Long result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.decr(key);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Long incrBy(String key, long integer) {
Long result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.incrBy(key, integer);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Long incr(String key) {
Long result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.incr(key);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Long append(String key, String value) {
Long result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.append(key, value);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public String substr(String key, int start, int end) {
String result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.substr(key, start, end);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Long hset(String key, String field, String value) {
Long result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.hset(key, field, value);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public String hget(String key, String field) {
String result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.hget(key, field);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Long hsetnx(String key, String field, String value) {
Long result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.hsetnx(key, field, value);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public String hmset(String key, Map hash) {
String result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.hmset(key, hash);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public List hmget(String key, String... fields) {
List result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.hmget(key, fields);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Long hincrBy(String key, String field, long value) {
Long result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.hincrBy(key, field, value);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Boolean hexists(String key, String field) {
Boolean result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.hexists(key, field);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Long del(String key) {
Long result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.del(key);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Long hdel(String key, String field) {
Long result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.hdel(key, field);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Long hlen(String key) {
Long result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.hlen(key);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Set hkeys(String key) {
Set result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.hkeys(key);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public List hvals(String key) {
List result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.hvals(key);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Map hgetAll(String key) {
Map result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.hgetAll(key);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
* 在redis list尾部增加一个String
public Long rpush(String key, String string) {
Long result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.rpush(key, string);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
* 在redis list头部增加一个String
public Long lpush(String key, String string) {
Long result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.lpush(key, string);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Long llen(String key) {
Long result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.llen(key);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public List lrange(String key, long start, long end) {
List result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.lrange(key, start, end);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public String ltrim(String key, long start, long end) {
String result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.ltrim(key, start, end);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public String lIndex(String key, long index) {
String result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.lindex(key, index);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public String lset(String key, long index, String value) {
String result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.lset(key, index, value);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Long lrem(String key, long count, String value) {
Long result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.lrem(key, count, value);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
* 从redis list头部取出一个key
public String lpop(String key) {
String result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.lpop(key);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
* 从redis list尾部取出一个key
public String rpop(String key) {
String result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.rpop(key);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Long sadd(String key, String member) {
Long result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.sadd(key, member);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Set smembers(String key) {
Set result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.smembers(key);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Long srem(String key, String member) {
ShardedJedis shardedJedis = redisService.getRedisClient();
Long result =
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.srem(key, member);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public String spop(String key) {
ShardedJedis shardedJedis = redisService.getRedisClient();
String result =
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.spop(key);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Long scard(String key) {
ShardedJedis shardedJedis = redisService.getRedisClient();
Long result =
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.scard(key);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Boolean sismember(String key, String member) {
ShardedJedis shardedJedis = redisService.getRedisClient();
Boolean result =
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.sismember(key, member);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public String srandmember(String key) {
ShardedJedis shardedJedis = redisService.getRedisClient();
String result =
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.srandmember(key);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Long zadd(String key, double score, String member) {
Long result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.zadd(key, score, member);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Set zrange(String key, int start, int end) {
Set result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.zrange(key, start, end);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Long zrem(String key, String member) {
Long result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.zrem(key, member);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Double zincrby(String key, double score, String member) {
Double result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.zincrby(key, score, member);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Long zrank(String key, String member) {
Long result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.zrank(key, member);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Long zrevrank(String key, String member) {
Long result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.zrevrank(key, member);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Set zrevrange(String key, int start, int end) {
Set result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.zrevrange(key, start, end);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Set zrangeWithScores(String key, int start, int end) {
Set result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.zrangeWithScores(key, start, end);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Set zrevrangeWithScores(String key, int start, int end) {
Set result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.zrevrangeWithScores(key, start, end);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Long zcard(String key) {
Long result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.zcard(key);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Double zscore(String key, String member) {
Double result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.zscore(key, member);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public List sort(String key) {
List result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.sort(key);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public List sort(String key, SortingParams sortingParameters) {
List result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.sort(key, sortingParameters);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Long zcount(String key, double min, double max) {
Long result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.zcount(key, min, max);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Set zrangeByScore(String key, double min, double max) {
Set result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.zrangeByScore(key, min, max);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Set zrevrangeByScore(String key, double max, double min) {
Set result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.zrevrangeByScore(key, max, min);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Set zrangeByScore(String key, double min, double max,
int offset, int count) {
Set result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.zrangeByScore(key, min, max, offset, count);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Set zrevrangeByScore(String key, double max, double min,
int offset, int count) {
Set result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis
.zrevrangeByScore(key, max, min, offset, count);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Set zrangeByScoreWithScores(String key, double min, double max) {
Set result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.zrangeByScoreWithScores(key, min, max);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Set zrevrangeByScoreWithScores(String key, double max,
double min) {
Set result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.zrevrangeByScoreWithScores(key, max, min);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Set zrangeByScoreWithScores(String key, double min,
double max, int offset, int count) {
Set result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.zrangeByScoreWithScores(key, min, max,
offset, count);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Set zrevrangeByScoreWithScores(String key, double max,
double min, int offset, int count) {
Set result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.zrevrangeByScoreWithScores(key, max, min,
offset, count);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Long zremrangeByRank(String key, int start, int end) {
Long result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.zremrangeByRank(key, start, end);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Long zremrangeByScore(String key, double start, double end) {
Long result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.zremrangeByScore(key, start, end);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Long linsert(String key, LIST_POSITION where, String pivot,
String value) {
Long result =
ShardedJedis shardedJedis = redisService.getRedisClient();
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.linsert(key, where, pivot, value);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
@SuppressWarnings(&deprecation&)
public List pipelined(ShardedJedisPipeline shardedJedisPipeline) {
ShardedJedis shardedJedis = redisService.getRedisClient();
List result =
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.pipelined(shardedJedisPipeline);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Jedis getShard(String key) {
ShardedJedis shardedJedis = redisService.getRedisClient();
Jedis result =
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.getShard(key);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public JedisShardInfo getShardInfo(String key) {
ShardedJedis shardedJedis = redisService.getRedisClient();
JedisShardInfo result =
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.getShardInfo(key);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public String getKeyTag(String key) {
ShardedJedis shardedJedis = redisService.getRedisClient();
String result =
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.getKeyTag(key);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Collection getAllShardInfo() {
ShardedJedis shardedJedis = redisService.getRedisClient();
Collection result =
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.getAllShardInfo();
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);
public Collection getAllShards() {
ShardedJedis shardedJedis = redisService.getRedisClient();
Collection result =
if (shardedJedis == null) {
boolean flag =
result = shardedJedis.getAllShards();
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
redisService.returnResource(shardedJedis, flag);}