【Redis学习】Redis的安装、管理、适用场合以及使用

分手后的思念是犯贱 2022-08-21 03:27 213阅读 0赞

1、Redis概述

我们知道，内存是电脑主板上的存储部件，用于存储当前正在使用的数据和程序，CPU可以与内存直接沟通，所以访问速速非常高；而外存数据必须加载到内存以后程序才能使用。如果把CPU当做一个吃货，那么内存是碗，而外存是锅，这个吃货再能吃，也得先把饭从锅里盛到碗里再下嘴，而不能直接跳到锅里大快朵颐。但是很多时候CPU吃的并不爽，一是因为碗不够大，没吃两嘴就没了；二是从锅里往碗里盛饭是个比较耗时的过程，等待很痛苦。正经点说，就是内存大小、I/O速度、网络响应时间等常常成为应用系统的性能瓶颈。

传统的关系型数据库如MySQL、Oracle、DB2等，数据存储在磁盘的文件系统中，增删改查需要频繁地在内存与外存之间交换数据，很费时间。

在以上背景下，小巧而功能强大的存储结构，用于在内存中管理数据量不太大但是访问量特别大的热点数据—Redis应运而生。

Redis是一个开源的使用C语言编写、开源、支持网络、可基于内存亦可持久化的日志型、高性能的Key-Value数据库，并提供多种语言的API。它通常被称为数据结构服务器，因为值（value）可以是 字符串(String)、哈希(Map)、 列表(list)、集合(sets) 和 有序集合(sorted sets)等类型。

Redis是Remote Dictionary Server的简称，是一个由意大利人Salvatore Sanfilippo开发的key-value存储系统，具有极高的读写性能，读的速度可达110000次/s，写的速度可达81000次/s 。

与Redis类似的产品还有memcache，同样是一个基于内存的key-value存储系统，但是由于memcache数据结构单一，数据安全性低下等原因，大有被Redis取而代之的趋势。

Redis 与其他 key - value 缓存产品相比，有以下特点：

1、Redis支持数据的持久化，周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，重启的时候可以再次加载进行使用。

3、Redis支持数据的备份，即master-slave模式的数据备份。

5、Redis还支持 publish/subscribe, 通知, key过期等高级特性。

互联网发展到现在，仅靠传统的关系型数据库已经远不能应对各种变态的需求，一个大型的互联网应用往往需要各类数据库相互合作，才能达到高可用、高性能的标准。

这里写图片描述

比如，使用MySQL/Oracle/DB2管理核心数据，使用Memcache/Redis管理热点数据，使用Hbase/Hadoop管理海量数据……总之，在合适的地方选择合适的数据库。

2、Redis的安装和部署

以2.8.6为例进行下述的操作及说明。

2.1 Centos安装部署

安装步骤如下：

第一步：
//将redis-2.8.6.tar.gz安装包解压缩
tar -zxvf redis-2.8.17.tar.gz

第二步：
//)进入redis-2.8.6目录
cd redis-2.8.17

第三步：
//执行make命令进行编译
make

第四步：
编译结束之后，配置redis.conf文件，将“daemonize”属性设置为“yes”，表示我们会以后台进程形式启动Redis服务；将“port”属性设置为指定的端口，这里默认为“6379”；将“logfile”属性设置为指定的日志路径，其余的属性可以保持默认

第五步：
使用命令src/redis-server ./redis.conf启动Redis服务，启动之后，可以在刚才配置的日志路径中看到如下类似信息：

这里写图片描述

第六步：
执行客户端命令，验证服务是否正常：

这里写图片描述

第七步：
执行以下命令src/redis-cli shutdown，停止Redis服务。

  1. $ps -ef | grep redis
  2. root     23422 19813  0 10:59 pts/5    00:00:08 redis-server *:6379
  4. $sudo redis-cli  shutdown
  5. [23422] 05 Mar 12:11:29.301 # User requested shutdown...
  6. [23422] 05 Mar 12:11:29.301 * Saving the final RDB snapshot before exiting.
  7. [23422] 05 Mar 12:11:29.314 * DB saved on disk
  8. [23422] 05 Mar 12:11:29.314 # Redis is now ready to exit, bye bye...
  9. [1]+  Done                    sudo redis-server  (wd: ~/soft/redis-2.10.3)
  10. (wd now: ~/soft/redis-2.8.17)
  12. $ps -ef | grep redis
  13. jihite 30563 19813  0 12:11 pts/5    00:00:00 grep redis

注意：如果设置了密码后，redis-cli是无法关掉Redis服务的，必须加上ip、port、passwd：

  1. sudo redis-cli -h host -p port -a passwd shutdown
  2. //退出客户端
  3. QUIT

3、redis.conf配置文件说明

就像pom.xml是maven最重要的配置文件一样，redis.conf也是redis最重要的配置文件，下面我么来学习一下它的参数说明：






























































































































属性 说明
daemonize 如果值是yes，则启动服务的时候是后台守护进程的形式，如果是no，则相反
pidfile 指定存储Redis进程号的文件路径
port 指定当前Redis服务的端口，默认为6379
tcp-backlog 此参数确定了TCP连接中已完成队列(完成三次握手之后)的长度， 当然此值必须不大于Linux系统定义的/proc/sys/net/core/somaxconn值，默认是511，而Linux的默认参数值是128。当系统并发量大并且客户端速度缓慢的时候，可以将这二个参数一起参考设定。
timeout 客户端和Redis服务端的连接超时时间，默认是0，表示永不超时
tcp-keepalive 如果值非0，单位是秒，表示将周期性的使用SO_KEEPALIVE检测客户端是否还处于健康状态，避免服务器一直阻塞，官方给出的建议值是60S
loglevel Redis总共支持四个级别：debug、verbose、notice、warning。Debug：记录很多信息，用于开发和测试；Varbose：有用的信息，不像debug会记录那么多；Notice：普通的verbose，常用于生产环境；Warning：只有非常重要或者严重的信息会记录到日志；默认是notice级别。
logfile 日志的存储路径
databases 可用的数据库数，默认值为16，默认数据库为0，数据库范围在0-（database-1）之间，个人觉得DB的概念类似于命名空间
save 保存数据库快照信息到磁盘，其对应的值有两个，比如save 300 10表示：300秒内至少有300个key被改变时，触发保存信息到磁盘的事件
stop-writes-on-bgsave-error 当持久化出现错误之后，是否继续提供写服务
rdbcompression 持久化到RDB文件时，是否压缩，“yes”为压缩，“no”则反之
rdbchecksum 读取和写入的时候是否支持CRC64校验，默认是开启的
dbfilename 镜像文件的名字
dir 当前工作目录，配置文件和镜像文件等都在此目录下
masterauth 设置访问master服务器的密码
slave-serve-stale-data 当slave服务器和master服务器失去连接后，或者当数据正在复制传输的时候，如果此参数值设置“yes”，slave服务器可以继续接受客户端的请求，否则，会返回给请求的客户端如下信息“SYNC with master in progress”
slave-read-only 是否允许slave服务器节点只提供读服务
repl-disable-tcp-nodelay 指定向slave同步数据时，是否禁用socket的NO_DELAY选项。若配置为“yes”，则禁用NO_DELAY，则TCP协议栈会合并小包统一发送，这样可以减少主从节点间的包数量并节省带宽，但会增加数据同步到slave的时间。若配置为“no”，表明启用NO_DELAY，则TCP协议栈不会延迟小包的发送时机，这样数据同步的延时会减少，但需要更大的带宽。通常情况下，应该配置为no以降低同步延时，但在主从节点间网络负载已经很高的情况下，可以配置为yes。
slave-priority 指定slave的优先级。在不只1个slave存在的部署环境下，当master宕机时，Redis Sentinel会将priority值最小的slave提升为master。需要注意的是，若该配置项为0，则对应的slave永远不会自动提升为master。
appendonly 开启append only 模式之后，redis 会把所接收到的每一次写操作请求都追加到appendonly.aof 文件中，当redis 重新启动时，会从该文件恢复出之前的状态。但是这样会造成appendonly.aof 文件过大，所以redis 还支持了BGREWRITEAOF 指令，对appendonly.aof 进行重新整理。默认是不开启的。
appendfilename 默认为appendonly.aof。
appendfsync 设置aof的同步频率，有三种选择always、everysec、no，默认是everysec表示每秒同步一次。
no-appendfsync-on-rewrite 指定是否在后台aof文件rewrite期间调用fsync，默认为no，表示要调用fsync（无论后台是否有子进程在刷盘）。Redis在后台写RDB文件或重写afo文件期间会存在大量磁盘IO，此时，在某些linux系统中，调用fsync可能会阻塞。
auto-aof-rewrite-percentage 指定Redis重写aof文件的条件，默认为100，表示与上次rewrite的aof文件大小相比，当前aof文件增长量超过上次afo文件大小的100%时，就会触发background rewrite。若配置为0，则会禁用自动rewrite
auto-aof-rewrite-min-size 指定触发rewrite的aof文件大小。若aof文件小于该值，即使当前文件的增量比例达到auto-aof-rewrite-percentage的配置值，也不会触发自动rewrite。即这两个配置项同时满足时，才会触发rewrite。
lua-time-limit 一个Lua脚本最长的执行时间，单位为毫秒，如果为0或负数表示无限执行时间，默认为5000
notify-keyspace-events 见参考3，按键通知事件
aof-rewrite-incremental-fsync aof rewrite过程中,是否采取增量文件同步策略,默认为“yes”。 rewrite过程中,每32M数据进行一次文件同步,这样可以减少aof大文件写入对磁盘的操作次数

4、Redis管理工具

Redis安装好之后，进入安装目录的src文件夹，会发现里面有6个可执行文件：

它们对应着6个管理Redis的工具：

redis-server
redis-cli
redis-benchmark
redis-check-aof
redis-check-dump
redis-sentinel

4.1 redis-server

该工具用于启动Redis服务器，处理与客户端的对话，一个服务器可以与多个客户端连接。

在终端输入该命令，如果启动成功，就会看到Redis那幅标志性的图片.

4.2 redis-cli

该工具用于启动Redis客户端，发起与服务器的对话。可以使用参数来指定目标服务器的详细信息，例如使用参数“-h”指定服务器IP地址、“-p”指定服务器端口、“-a”指定登录密码等，如：
Redis-cli –h 192.168.1.2 –p 6300

如不指定任何参数，则默认连接127.0.0.1的6379端口。

与Redis服务器取得连接后，就通过指令进行数据的存取、更改等操作了：

  1. 127.0.0.1:6379 > set name tom
  2. OK
  3. 127.0.0.1:6379 > get name
  4. "tom"

4.3 redis-benchmark

该工具用于测试Redis在本机的性能，类似于鲁大师的跑分程序。运行之后会得到一组数据存取效率的报告：

4.4 redis-check-aof

Redis虽然是基于内存的数据库，但是会创建并更新在硬盘上的备份，备份有两种方式，一个是把内存的数据导入dump.rdb文件中，另一中就是将每个执行过的命令记录到AOF文件中。

该工具用于检查、修复AOF文件。

4.5 redis-check-dump

与Redis-check-aof类似，该工具用于检查dump.rdb文件。

4.6 redis-sentinel

该工具提供Redis实例的监控管理、通知和实例失效备援服务，是Redis集群的管理工具，监控各个其他节点的工作情况并且进行故障恢复，来提高集群的高可用性。

5、redis的适用场合

redis开创了一种新的数据存储思路，使用redis我们可以利用redis灵活多变的数据结构和数据操作来进行一些复杂的操作。

下面是redis使用的一些场景：

1、取最新N个数据的操作
比如典型的区你网站的最新评论。通过下面的方式，我们可以将最新的5000条评论的ID放在redis的List集合中，并将超出集合的部分从数据库中获取。

使用LPUSH latest.comments命令，向list集合中插入数据；
插入完成后再用LTRIM latest.comments 0 5000命令使其永远只保存最近5000个ID，然后我们在客户端获取某一页评论时可以用下面的逻辑。

  1. FUNCTION get_latest_comments(start,num_items):
  2.     id_list = redis.lrange("latest.comments",start,start+num_items-1)
  3.     IF id_list.length < num_items
  4.     id_list=SQL_DB("SELECT … ORDER BY time LIMIT …")
  5. END
  6. RETURN id_list
  7. END

如果你还有不同的筛选维度，比如某个分类的最新N条，那么你可以再建一个按此分类的List。只存ID的话，redis是非常高效的。

2、排行榜应用，取TOP N操作
这个需求与上面需求的不同之处在于，前面操作以时间为权重，这个是以某个条件为权重。比如按顶的次数排序，这时候就需要我们的sorted set出来了。将你要排序的值设置成sorted set的score，将具体的数据设置成相应的value，每次只需要执行一条ZADD命令即可。

  1. redis 127.0.0.1:6379> ZADD myset 1 "hello"
  2. (integer) 1
  3. redis 127.0.0.1:6379> ZADD myset 1 "foo"
  4. (integer) 1
  5. redis 127.0.0.1:6379> ZADD myset 2 "world" 3 "bar"
  6. (integer) 2
  7. redis 127.0.0.1:6379> ZRANGE myzset 0 -1 WITHSCORES
  8. 1) "hello"
  9. 2) "1"
  10. 3) "foo"
  11. 4) "1"
  12. 5) "world"
  13. 6) "2"
  14. 7) "bar"
  15. 8) "3"

3、需要精准设定过期时间的应用
比如你可以把上面说到的sorted set的score值设置成过期时间的时间戳，那么就可以简单的通过过期时间排序，定时清除过期数据了。不仅是清除redis中的过期数据，你完全可以把redis里这个过期时间当成是对数据库中数据的索引，用redis来找出哪些数据需要过期删除，然后再精确的从数据库中删除相应的记录。

  1. redis 127.0.0.1:6379> ZADD myset 20171101 "hello"
  2. (integer) 1
  3. redis 127.0.0.1:6379> ZADD myset 20171101 "foo"
  4. (integer) 1
  5. redis 127.0.0.1:6379> ZADD myset 20171103 "world" 20171104 "bar"
  6. (integer) 2
  7. redis 127.0.0.1:6379> ZRANGE myzset 0 -1 WITHSCORES
  8. 1) "hello"
  9. 2) "20171101"
  10. 3) "foo"
  11. 4) "20171101"
  12. 5) "world"
  13. 6) "20171103"
  14. 7) "bar"
  15. 8) "20171104"

4、计数器应用
redis的命令是原子性的，你可以轻松地利用INCR，DECR命令来构建计数器系统。

  1. redis> SET page_view 20
  2. OK
  3. redis> INCR page_view
  4. (integer) 21
  5. redis> GET page_view    # 数字值在 Redis 中以字符串的形式保存
  6. "21"

–对存在的数字值 key 进行 DECR

  1. redis> SET failure_times 10
  2. OK
  3. redis> DECR failure_times
  4. (integer) 9

5、Uniq操作，获取某段时间所有数据排重值
这个实用redis的set数据结构最合适了，只需要不断讲数据往set中扔就行了，set意为集合，所以会自动排重。

6、实时系统，反垃圾系统
通过上面说的set功能，你可以知道一个终端用户是否进行了某个操作，可以找到其操作的集合并进行分析统计对比等。没有做不到，只有想不到。

7、Pub/Sub构建实时消息系统
redis的Pub/Sub可以构建实时的消息系统，比如很多用Pub/Sub构建的实时聊天系统的例子。

8、构建队列系统
使用List可以构建队列系统，使用sorted set甚至可以构建有优先级的队列系统。

9、缓存
这个不必说了，性能优于memcached，数据结构也更多样化。

6、Java操作Redis

我们平时项目中使用最多的就是这个了，redis安装部署完成之后，我们怎么使用Java操作redis呢？

目前Jedis是官方推荐的比较好的Redis操作API包，我们这里结合Spring来看下如何使用Redis这一神器。

首先在pom文件中引入Jedis包：

  1. <dependency>
  2.     <groupId>redis.clients</groupId>
  3.     <artifactId>jedis</artifactId>
  4.     <version>2.1.0</version>
  5. </dependency>

在Spring的resource目录中增加Redis的配置文件redis.properties

  1. # Redis settings
  2.   redis.host=192.168.50.71
  3.   redis.port=6379
  4.   redis.pass=
  5.   redis.timeout=0
  7.   redis.maxIdle=300
  8.   redis.maxActive=600
  9.   redis.maxWait=1000
  10.   redis.testOnBorrow=true

配置Spring文件，完成Redis相关Bean的注入：

  1. <?xml version="1.0" encoding="UTF-8"?>  
  2.   <beans xmlns="http://www.springframework.org/schema/beans"  
  3.       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"  
  4.       xmlns:context="http://www.springframework.org/schema/context"  
  5.       xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"  
  6.       xmlns:aop="http://www.springframework.org/schema/aop"  
  7.       xsi:schemaLocation="  
  8.               http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd  
  9.               http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">  
  11.     <context:property-placeholder location="classpath:redis.properties" />  
  12.     <context:component-scan base-package="com.scott.demo" />
  14.     <bean class="org.springframework.context.annotation.CommonAnnotationBeanPostProcessor" />
  16.      <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
  17.          <property name="maxActive" value="50" />
  18.          <property name="maxIdle" value="8" />
  19.          <property name="maxWait" value="1000" />
  20.          <property name="testOnBorrow" value="true"/>
  21.          <property name="testOnReturn" value="true"/>
  22.          <!-- <property name="testWhileIdle" value="true"/> -->
  23.      </bean>
  25.      <bean id="shardedJedisPool" class="redis.clients.jedis.ShardedJedisPool"  scope="singleton">
  26.          <constructor-arg index="0" ref="jedisPoolConfig" />
  27.          <constructor-arg index="1">
  28.              <list>
  29.                  <bean class="redis.clients.jedis.JedisShardInfo">
  30.                      <constructor-arg name="host" value="${redis.host}" />
  31.                      <constructor-arg name="port" value="${redis.port}" />
  32.                      <constructor-arg name="timeout" value="${redis.timeout}" />
  33.                      <constructor-arg name="weight" value="1" />
  34.                  </bean>
  35.              </list>
  36.          </constructor-arg>
  37.      </bean>
  38.  </beans>

获取Redis客户端对象的类：

  1. import org.slf4j.Logger;
  2.   import org.slf4j.LoggerFactory;
  3.   import org.springframework.beans.factory.annotation.Autowired;
  4.   import org.springframework.stereotype.Repository;
  5.   import com.scott.demo.redis.service.RedisService;
  6.   import redis.clients.jedis.ShardedJedis;
  7.   import redis.clients.jedis.ShardedJedisPool;
  9.  @Repository("redisService")
  10.  public class RedisServiceImpl implements RedisService {
  13.      private static final Logger log = LoggerFactory.getLogger(RedisServiceImpl.class);
  15.      @Autowired
  16.      private ShardedJedisPool shardedJedisPool;
  18.      public ShardedJedis getRedisClient() {
  19.          try {
  20.              ShardedJedis shardJedis = shardedJedisPool.getResource();
  21.              return shardJedis;
  22.          } catch (Exception e) {
  23.              log.error("getRedisClent error", e);
  24.          }
  25.          return null;
  26.      }
  28.      public void returnResource(ShardedJedis shardedJedis) {
  29.          shardedJedisPool.returnResource(shardedJedis);
  30.      }
  32.      public void returnResource(ShardedJedis shardedJedis, boolean broken) {
  33.          if (broken) {
  34.              shardedJedisPool.returnBrokenResource(shardedJedis);
  35.          } else {
  36.              shardedJedisPool.returnResource(shardedJedis);
  37.          }
  38.      }
  40.   }

实现redis相关操作的RedisClient类：

  1. import java.util.Collection;
  2. import java.util.List;
  3. import java.util.Map;
  4. import java.util.Set;
  6. import org.slf4j.Logger;
  7. import org.slf4j.LoggerFactory;
  8. import org.springframework.beans.factory.annotation.Autowired;
  10. import com.scott.demo.redis.service.impl.RedisServiceImpl;
  12. import redis.clients.jedis.BinaryClient.LIST_POSITION;
  13. import redis.clients.jedis.Jedis;
  14. import redis.clients.jedis.JedisShardInfo;
  15. import redis.clients.jedis.ShardedJedis;
  16. import redis.clients.jedis.ShardedJedisPipeline;
  17. import redis.clients.jedis.SortingParams;
  18. import redis.clients.jedis.Tuple;
  20. public class RedisClient {
  23.     private static final Logger log = LoggerFactory.getLogger(RedisClient.class);
  25.     @Autowired
  26.     private RedisServiceImpl redisService;
  28.     public void disconnect() {
  29.         ShardedJedis shardedJedis = redisService.getRedisClient();
  30.         shardedJedis.disconnect();
  31.     }
  33.     /**
  34.      * 设置单个值
  35.      */
  36.     public String set(String key, String value) {
  37.         String result = null;
  39.         ShardedJedis shardedJedis = redisService.getRedisClient();
  40.         if (shardedJedis == null) {
  41.             return result;
  42.         }
  43.         boolean flag = false;
  44.         try {
  45.             result = shardedJedis.set(key, value);
  46.         } catch (Exception e) {
  47.             log.error(e.getMessage(), e);
  48.             flag = true;
  49.         } finally {
  50.             redisService.returnResource(shardedJedis, flag);
  51.         }
  52.         return result;
  53.     }
  55.     /**
  56.      * 获取单个值
  57.      */
  58.     public String get(String key) {
  59.         String result = null;
  60.         ShardedJedis shardedJedis = redisService.getRedisClient();
  61.         if (shardedJedis == null) {
  62.             return result;
  63.         }
  65.         boolean flag = false;
  66.         try {
  67.             result = shardedJedis.get(key);
  69.         } catch (Exception e) {
  70.             log.error(e.getMessage(), e);
  71.             flag = true;
  72.         } finally {
  73.             redisService.returnResource(shardedJedis, flag);
  74.         }
  75.         return result;
  76.     }
  78.     public Boolean exists(String key) {
  79.         Boolean result = false;
  80.         ShardedJedis shardedJedis = redisService.getRedisClient();
  81.         if (shardedJedis == null) {
  82.             return result;
  83.         }
  84.         boolean flag = false;
  85.         try {
  86.             result = shardedJedis.exists(key);
  87.         } catch (Exception e) {
  88.             log.error(e.getMessage(), e);
  89.             flag = true;
  90.         } finally {
  91.             redisService.returnResource(shardedJedis, flag);
  92.         }
  93.         return result;
  94.     }
  96.     public String type(String key) {
  97.         String result = null;
  98.         ShardedJedis shardedJedis = redisService.getRedisClient();
  99.         if (shardedJedis == null) {
  100.             return result;
  101.         }
  102.         boolean flag = false;
  103.         try {
  104.             result = shardedJedis.type(key);
  106.         } catch (Exception e) {
  107.             log.error(e.getMessage(), e);
  108.             flag = true;
  109.         } finally {
  110.             redisService.returnResource(shardedJedis, flag);
  111.         }
  112.         return result;
  113.     }
  115.     /**
  116.      * 在某段时间后失效
  117.      */
  118.     public Long expire(String key, int seconds) {
  119.         Long result = null;
  120.         ShardedJedis shardedJedis = redisService.getRedisClient();
  121.         if (shardedJedis == null) {
  122.             return result;
  123.         }
  124.         boolean flag = false;
  125.         try {
  126.             result = shardedJedis.expire(key, seconds);
  128.         } catch (Exception e) {
  129.             log.error(e.getMessage(), e);
  130.             flag = true;
  131.         } finally {
  132.             redisService.returnResource(shardedJedis, flag);
  133.         }
  134.         return result;
  135.     }
  137.     /**
  138.      * 在某个时间点失效
  139.      */
  140.     public Long expireAt(String key, long time) {
  141.         Long result = null;
  142.         ShardedJedis shardedJedis = redisService.getRedisClient();
  143.         if (shardedJedis == null) {
  144.             return result;
  145.         }
  146.         boolean flag = false;
  147.         try {
  148.             result = shardedJedis.expireAt(key, time);
  150.         } catch (Exception e) {
  151.             log.error(e.getMessage(), e);
  152.             flag = true;
  153.         } finally {
  154.             redisService.returnResource(shardedJedis, flag);
  155.         }
  156.         return result;
  157.     }
  159.     public Long ttl(String key) {
  160.         Long result = null;
  161.         ShardedJedis shardedJedis = redisService.getRedisClient();
  162.         if (shardedJedis == null) {
  163.             return result;
  164.         }
  165.         boolean flag = false;
  166.         try {
  167.             result = shardedJedis.ttl(key);
  169.         } catch (Exception e) {
  170.             log.error(e.getMessage(), e);
  171.             flag = true;
  172.         } finally {
  173.             redisService.returnResource(shardedJedis, flag);
  174.         }
  175.         return result;
  176.     }
  178.     public boolean setbit(String key, long offset, boolean value) {
  180.         ShardedJedis shardedJedis = redisService.getRedisClient();
  181.         boolean result = false;
  182.         if (shardedJedis == null) {
  183.             return result;
  184.         }
  185.         boolean flag = false;
  186.         try {
  187.             result = shardedJedis.setbit(key, offset, value);
  188.         } catch (Exception e) {
  189.             log.error(e.getMessage(), e);
  190.             flag = true;
  191.         } finally {
  192.             redisService.returnResource(shardedJedis, flag);
  193.         }
  194.         return result;
  195.     }
  197.     public boolean getbit(String key, long offset) {
  198.         ShardedJedis shardedJedis = redisService.getRedisClient();
  199.         boolean result = false;
  200.         if (shardedJedis == null) {
  201.             return result;
  202.         }
  203.         boolean flag = false;
  205.         try {
  206.             result = shardedJedis.getbit(key, offset);
  207.         } catch (Exception e) {
  208.             log.error(e.getMessage(), e);
  209.             flag = true;
  210.         } finally {
  211.             redisService.returnResource(shardedJedis, flag);
  212.         }
  213.         return result;
  214.     }
  216.     public long setrange(String key, long offset, String value) {
  217.         ShardedJedis shardedJedis = redisService.getRedisClient();
  218.         long result = 0;
  219.         if (shardedJedis == null) {
  220.             return result;
  221.         }
  222.         boolean flag = false;
  223.         try {
  224.             result = shardedJedis.setrange(key, offset, value);
  225.         } catch (Exception e) {
  226.             log.error(e.getMessage(), e);
  227.             flag = true;
  228.         } finally {
  229.             redisService.returnResource(shardedJedis, flag);
  230.         }
  231.         return result;
  232.     }
  234.     public String getrange(String key, long startOffset, long endOffset) {
  235.         ShardedJedis shardedJedis = redisService.getRedisClient();
  236.         String result = null;
  237.         if (shardedJedis == null) {
  238.             return result;
  239.         }
  240.         boolean flag = false;
  241.         try {
  242.             result = shardedJedis.getrange(key, startOffset, endOffset);
  244.         } catch (Exception e) {
  245.             log.error(e.getMessage(), e);
  246.             flag = true;
  247.         } finally {
  248.             redisService.returnResource(shardedJedis, flag);
  249.         }
  250.         return result;
  251.     }
  253.     public String getSet(String key, String value) {
  254.         String result = null;
  255.         ShardedJedis shardedJedis = redisService.getRedisClient();
  256.         if (shardedJedis == null) {
  257.             return result;
  258.         }
  259.         boolean flag = false;
  260.         try {
  261.             result = shardedJedis.getSet(key, value);
  262.         } catch (Exception e) {
  263.             log.error(e.getMessage(), e);
  264.             flag = true;
  265.         } finally {
  266.             redisService.returnResource(shardedJedis, flag);
  267.         }
  268.         return result;
  269.     }
  271.     public Long setnx(String key, String value) {
  272.         Long result = null;
  273.         ShardedJedis shardedJedis = redisService.getRedisClient();
  274.         if (shardedJedis == null) {
  275.             return result;
  276.         }
  277.         boolean flag = false;
  278.         try {
  279.             result = shardedJedis.setnx(key, value);
  280.         } catch (Exception e) {
  281.             log.error(e.getMessage(), e);
  282.             flag = true;
  283.         } finally {
  284.             redisService.returnResource(shardedJedis, flag);
  285.         }
  286.         return result;
  287.     }
  289.     public String setex(String key, int seconds, String value) {
  290.         String result = null;
  291.         ShardedJedis shardedJedis = redisService.getRedisClient();
  292.         if (shardedJedis == null) {
  293.             return result;
  294.         }
  295.         boolean flag = false;
  296.         try {
  297.             result = shardedJedis.setex(key, seconds, value);
  299.         } catch (Exception e) {
  300.             log.error(e.getMessage(), e);
  301.             flag = true;
  302.         } finally {
  303.             redisService.returnResource(shardedJedis, flag);
  304.         }
  305.         return result;
  306.     }
  308.     public Long decrBy(String key, long integer) {
  309.         Long result = null;
  310.         ShardedJedis shardedJedis = redisService.getRedisClient();
  311.         if (shardedJedis == null) {
  312.             return result;
  313.         }
  314.         boolean flag = false;
  315.         try {
  316.             result = shardedJedis.decrBy(key, integer);
  318.         } catch (Exception e) {
  319.             log.error(e.getMessage(), e);
  320.             flag = true;
  321.         } finally {
  322.             redisService.returnResource(shardedJedis, flag);
  323.         }
  324.         return result;
  325.     }
  327.     public Long decr(String key) {
  328.         Long result = null;
  329.         ShardedJedis shardedJedis = redisService.getRedisClient();
  330.         if (shardedJedis == null) {
  331.             return result;
  332.         }
  333.         boolean flag = false;
  334.         try {
  335.             result = shardedJedis.decr(key);
  337.         } catch (Exception e) {
  338.             log.error(e.getMessage(), e);
  339.             flag = true;
  340.         } finally {
  341.             redisService.returnResource(shardedJedis, flag);
  342.         }
  343.         return result;
  344.     }
  346.     public Long incrBy(String key, long integer) {
  347.         Long result = null;
  348.         ShardedJedis shardedJedis = redisService.getRedisClient();
  349.         if (shardedJedis == null) {
  350.             return result;
  351.         }
  352.         boolean flag = false;
  353.         try {
  354.             result = shardedJedis.incrBy(key, integer);
  356.         } catch (Exception e) {
  357.             log.error(e.getMessage(), e);
  358.             flag = true;
  359.         } finally {
  360.             redisService.returnResource(shardedJedis, flag);
  361.         }
  362.         return result;
  363.     }
  365.     public Long incr(String key) {
  366.         Long result = null;
  367.         ShardedJedis shardedJedis = redisService.getRedisClient();
  368.         if (shardedJedis == null) {
  369.             return result;
  370.         }
  371.         boolean flag = false;
  372.         try {
  373.             result = shardedJedis.incr(key);
  375.         } catch (Exception e) {
  376.             log.error(e.getMessage(), e);
  377.             flag = true;
  378.         } finally {
  379.             redisService.returnResource(shardedJedis, flag);
  380.         }
  381.         return result;
  382.     }
  384.     public Long append(String key, String value) {
  385.         Long result = null;
  386.         ShardedJedis shardedJedis = redisService.getRedisClient();
  387.         if (shardedJedis == null) {
  388.             return result;
  389.         }
  390.         boolean flag = false;
  391.         try {
  392.             result = shardedJedis.append(key, value);
  394.         } catch (Exception e) {
  395.             log.error(e.getMessage(), e);
  396.             flag = true;
  397.         } finally {
  398.             redisService.returnResource(shardedJedis, flag);
  399.         }
  400.         return result;
  401.     }
  403.     public String substr(String key, int start, int end) {
  404.         String result = null;
  405.         ShardedJedis shardedJedis = redisService.getRedisClient();
  406.         if (shardedJedis == null) {
  407.             return result;
  408.         }
  409.         boolean flag = false;
  410.         try {
  411.             result = shardedJedis.substr(key, start, end);
  413.         } catch (Exception e) {
  414.             log.error(e.getMessage(), e);
  415.             flag = true;
  416.         } finally {
  417.             redisService.returnResource(shardedJedis, flag);
  418.         }
  419.         return result;
  420.     }
  422.     public Long hset(String key, String field, String value) {
  423.         Long result = null;
  424.         ShardedJedis shardedJedis = redisService.getRedisClient();
  425.         if (shardedJedis == null) {
  426.             return result;
  427.         }
  428.         boolean flag = false;
  429.         try {
  430.             result = shardedJedis.hset(key, field, value);
  432.         } catch (Exception e) {
  433.             log.error(e.getMessage(), e);
  434.             flag = true;
  435.         } finally {
  436.             redisService.returnResource(shardedJedis, flag);
  437.         }
  438.         return result;
  439.     }
  441.     public String hget(String key, String field) {
  442.         String result = null;
  443.         ShardedJedis shardedJedis = redisService.getRedisClient();
  444.         if (shardedJedis == null) {
  445.             return result;
  446.         }
  447.         boolean flag = false;
  448.         try {
  449.             result = shardedJedis.hget(key, field);
  451.         } catch (Exception e) {
  452.             log.error(e.getMessage(), e);
  453.             flag = true;
  454.         } finally {
  455.             redisService.returnResource(shardedJedis, flag);
  456.         }
  457.         return result;
  458.     }
  460.     public Long hsetnx(String key, String field, String value) {
  461.         Long result = null;
  462.         ShardedJedis shardedJedis = redisService.getRedisClient();
  463.         if (shardedJedis == null) {
  464.             return result;
  465.         }
  466.         boolean flag = false;
  467.         try {
  468.             result = shardedJedis.hsetnx(key, field, value);
  470.         } catch (Exception e) {
  471.             log.error(e.getMessage(), e);
  472.             flag = true;
  473.         } finally {
  474.             redisService.returnResource(shardedJedis, flag);
  475.         }
  476.         return result;
  477.     }
  479.     public String hmset(String key, Map<String, String> hash) {
  480.         String result = null;
  481.         ShardedJedis shardedJedis = redisService.getRedisClient();
  482.         if (shardedJedis == null) {
  483.             return result;
  484.         }
  485.         boolean flag = false;
  486.         try {
  487.             result = shardedJedis.hmset(key, hash);
  489.         } catch (Exception e) {
  490.             log.error(e.getMessage(), e);
  491.             flag = true;
  492.         } finally {
  493.             redisService.returnResource(shardedJedis, flag);
  494.         }
  495.         return result;
  496.     }
  498.     public List<String> hmget(String key, String... fields) {
  499.         List<String> result = null;
  500.         ShardedJedis shardedJedis = redisService.getRedisClient();
  501.         if (shardedJedis == null) {
  502.             return result;
  503.         }
  504.         boolean flag = false;
  505.         try {
  506.             result = shardedJedis.hmget(key, fields);
  508.         } catch (Exception e) {
  509.             log.error(e.getMessage(), e);
  510.             flag = true;
  511.         } finally {
  512.             redisService.returnResource(shardedJedis, flag);
  513.         }
  514.         return result;
  515.     }
  517.     public Long hincrBy(String key, String field, long value) {
  518.         Long result = null;
  519.         ShardedJedis shardedJedis = redisService.getRedisClient();
  520.         if (shardedJedis == null) {
  521.             return result;
  522.         }
  523.         boolean flag = false;
  524.         try {
  525.             result = shardedJedis.hincrBy(key, field, value);
  527.         } catch (Exception e) {
  528.             log.error(e.getMessage(), e);
  529.             flag = true;
  530.         } finally {
  531.             redisService.returnResource(shardedJedis, flag);
  532.         }
  533.         return result;
  534.     }
  536.     public Boolean hexists(String key, String field) {
  537.         Boolean result = false;
  538.         ShardedJedis shardedJedis = redisService.getRedisClient();
  539.         if (shardedJedis == null) {
  540.             return result;
  541.         }
  542.         boolean flag = false;
  543.         try {
  544.             result = shardedJedis.hexists(key, field);
  546.         } catch (Exception e) {
  547.             log.error(e.getMessage(), e);
  548.             flag = true;
  549.         } finally {
  550.             redisService.returnResource(shardedJedis, flag);
  551.         }
  552.         return result;
  553.     }
  555.     public Long del(String key) {
  556.         Long result = null;
  557.         ShardedJedis shardedJedis = redisService.getRedisClient();
  558.         if (shardedJedis == null) {
  559.             return result;
  560.         }
  561.         boolean flag = false;
  562.         try {
  563.             result = shardedJedis.del(key);
  565.         } catch (Exception e) {
  566.             log.error(e.getMessage(), e);
  567.             flag = true;
  568.         } finally {
  569.             redisService.returnResource(shardedJedis, flag);
  570.         }
  571.         return result;
  572.     }
  574.     public Long hdel(String key, String field) {
  575.         Long result = null;
  576.         ShardedJedis shardedJedis = redisService.getRedisClient();
  577.         if (shardedJedis == null) {
  578.             return result;
  579.         }
  580.         boolean flag = false;
  581.         try {
  582.             result = shardedJedis.hdel(key, field);
  584.         } catch (Exception e) {
  585.             log.error(e.getMessage(), e);
  586.             flag = true;
  587.         } finally {
  588.             redisService.returnResource(shardedJedis, flag);
  589.         }
  590.         return result;
  591.     }
  593.     public Long hlen(String key) {
  594.         Long result = null;
  595.         ShardedJedis shardedJedis = redisService.getRedisClient();
  596.         if (shardedJedis == null) {
  597.             return result;
  598.         }
  599.         boolean flag = false;
  600.         try {
  601.             result = shardedJedis.hlen(key);
  603.         } catch (Exception e) {
  604.             log.error(e.getMessage(), e);
  605.             flag = true;
  606.         } finally {
  607.             redisService.returnResource(shardedJedis, flag);
  608.         }
  609.         return result;
  610.     }
  612.     public Set<String> hkeys(String key) {
  613.         Set<String> result = null;
  614.         ShardedJedis shardedJedis = redisService.getRedisClient();
  615.         if (shardedJedis == null) {
  616.             return result;
  617.         }
  618.         boolean flag = false;
  619.         try {
  620.             result = shardedJedis.hkeys(key);
  622.         } catch (Exception e) {
  623.             log.error(e.getMessage(), e);
  624.             flag = true;
  625.         } finally {
  626.             redisService.returnResource(shardedJedis, flag);
  627.         }
  628.         return result;
  629.     }
  631.     public List<String> hvals(String key) {
  632.         List<String> result = null;
  633.         ShardedJedis shardedJedis = redisService.getRedisClient();
  634.         if (shardedJedis == null) {
  635.             return result;
  636.         }
  637.         boolean flag = false;
  638.         try {
  639.             result = shardedJedis.hvals(key);
  641.         } catch (Exception e) {
  642.             log.error(e.getMessage(), e);
  643.             flag = true;
  644.         } finally {
  645.             redisService.returnResource(shardedJedis, flag);
  646.         }
  647.         return result;
  648.     }
  650.     public Map<String, String> hgetAll(String key) {
  651.         Map<String, String> result = null;
  652.         ShardedJedis shardedJedis = redisService.getRedisClient();
  653.         if (shardedJedis == null) {
  654.             return result;
  655.         }
  656.         boolean flag = false;
  657.         try {
  658.             result = shardedJedis.hgetAll(key);
  660.         } catch (Exception e) {
  661.             log.error(e.getMessage(), e);
  662.             flag = true;
  663.         } finally {
  664.             redisService.returnResource(shardedJedis, flag);
  665.         }
  666.         return result;
  667.     }
  669.     /**
  670.      * 在redis list尾部增加一个String
  671.      * */
  672.     public Long rpush(String key, String string) {
  673.         Long result = null;
  674.         ShardedJedis shardedJedis = redisService.getRedisClient();
  675.         if (shardedJedis == null) {
  676.             return result;
  677.         }
  678.         boolean flag = false;
  679.         try {
  680.             result = shardedJedis.rpush(key, string);
  682.         } catch (Exception e) {
  683.             log.error(e.getMessage(), e);
  684.             flag = true;
  685.         } finally {
  686.             redisService.returnResource(shardedJedis, flag);
  687.         }
  688.         return result;
  689.     }
  691.     /**
  692.      * 在redis list头部增加一个String
  693.      * */
  694.     public Long lpush(String key, String string) {
  695.         Long result = null;
  696.         ShardedJedis shardedJedis = redisService.getRedisClient();
  697.         if (shardedJedis == null) {
  698.             return result;
  699.         }
  700.         boolean flag = false;
  701.         try {
  702.             result = shardedJedis.lpush(key, string);
  704.         } catch (Exception e) {
  705.             log.error(e.getMessage(), e);
  706.             flag = true;
  707.         } finally {
  708.             redisService.returnResource(shardedJedis, flag);
  709.         }
  710.         return result;
  711.     }
  713.     public Long llen(String key) {
  714.         Long result = null;
  715.         ShardedJedis shardedJedis = redisService.getRedisClient();
  716.         if (shardedJedis == null) {
  717.             return result;
  718.         }
  719.         boolean flag = false;
  720.         try {
  721.             result = shardedJedis.llen(key);
  723.         } catch (Exception e) {
  724.             log.error(e.getMessage(), e);
  725.             flag = true;
  726.         } finally {
  727.             redisService.returnResource(shardedJedis, flag);
  728.         }
  729.         return result;
  730.     }
  732.     public List<String> lrange(String key, long start, long end) {
  733.         List<String> result = null;
  734.         ShardedJedis shardedJedis = redisService.getRedisClient();
  735.         if (shardedJedis == null) {
  736.             return result;
  737.         }
  738.         boolean flag = false;
  739.         try {
  740.             result = shardedJedis.lrange(key, start, end);
  742.         } catch (Exception e) {
  743.             log.error(e.getMessage(), e);
  744.             flag = true;
  745.         } finally {
  746.             redisService.returnResource(shardedJedis, flag);
  747.         }
  748.         return result;
  749.     }
  751.     public String ltrim(String key, long start, long end) {
  752.         String result = null;
  753.         ShardedJedis shardedJedis = redisService.getRedisClient();
  754.         if (shardedJedis == null) {
  755.             return result;
  756.         }
  757.         boolean flag = false;
  758.         try {
  759.             result = shardedJedis.ltrim(key, start, end);
  761.         } catch (Exception e) {
  762.             log.error(e.getMessage(), e);
  763.             flag = true;
  764.         } finally {
  765.             redisService.returnResource(shardedJedis, flag);
  766.         }
  767.         return result;
  768.     }
  770.     public String lIndex(String key, long index) {
  771.         String result = null;
  772.         ShardedJedis shardedJedis = redisService.getRedisClient();
  773.         if (shardedJedis == null) {
  774.             return result;
  775.         }
  776.         boolean flag = false;
  777.         try {
  778.             result = shardedJedis.lindex(key, index);
  780.         } catch (Exception e) {
  781.             log.error(e.getMessage(), e);
  782.             flag = true;
  783.         } finally {
  784.             redisService.returnResource(shardedJedis, flag);
  785.         }
  786.         return result;
  787.     }
  789.     public String lset(String key, long index, String value) {
  790.         String result = null;
  791.         ShardedJedis shardedJedis = redisService.getRedisClient();
  792.         if (shardedJedis == null) {
  793.             return result;
  794.         }
  795.         boolean flag = false;
  796.         try {
  797.             result = shardedJedis.lset(key, index, value);
  799.         } catch (Exception e) {
  800.             log.error(e.getMessage(), e);
  801.             flag = true;
  802.         } finally {
  803.             redisService.returnResource(shardedJedis, flag);
  804.         }
  805.         return result;
  806.     }
  808.     public Long lrem(String key, long count, String value) {
  809.         Long result = null;
  810.         ShardedJedis shardedJedis = redisService.getRedisClient();
  811.         if (shardedJedis == null) {
  812.             return result;
  813.         }
  814.         boolean flag = false;
  815.         try {
  816.             result = shardedJedis.lrem(key, count, value);
  818.         } catch (Exception e) {
  819.             log.error(e.getMessage(), e);
  820.             flag = true;
  821.         } finally {
  822.             redisService.returnResource(shardedJedis, flag);
  823.         }
  824.         return result;
  825.     }
  827.     /**
  828.      * 从redis list头部取出一个key
  829.      * */
  830.     public String lpop(String key) {
  831.         String result = null;
  832.         ShardedJedis shardedJedis = redisService.getRedisClient();
  833.         if (shardedJedis == null) {
  834.             return result;
  835.         }
  836.         boolean flag = false;
  837.         try {
  838.             result = shardedJedis.lpop(key);
  840.         } catch (Exception e) {
  841.             log.error(e.getMessage(), e);
  842.             flag = true;
  843.         } finally {
  844.             redisService.returnResource(shardedJedis, flag);
  845.         }
  846.         return result;
  847.     }
  849.     /**
  850.      * 从redis list尾部取出一个key
  851.      * */
  852.     public String rpop(String key) {
  853.         String result = null;
  854.         ShardedJedis shardedJedis = redisService.getRedisClient();
  855.         if (shardedJedis == null) {
  856.             return result;
  857.         }
  858.         boolean flag = false;
  859.         try {
  860.             result = shardedJedis.rpop(key);
  862.         } catch (Exception e) {
  863.             log.error(e.getMessage(), e);
  864.             flag = true;
  865.         } finally {
  866.             redisService.returnResource(shardedJedis, flag);
  867.         }
  868.         return result;
  869.     }
  871.     public Long sadd(String key, String member) {
  872.         Long result = null;
  873.         ShardedJedis shardedJedis = redisService.getRedisClient();
  874.         if (shardedJedis == null) {
  875.             return result;
  876.         }
  877.         boolean flag = false;
  878.         try {
  879.             result = shardedJedis.sadd(key, member);
  881.         } catch (Exception e) {
  882.             log.error(e.getMessage(), e);
  883.             flag = true;
  884.         } finally {
  885.             redisService.returnResource(shardedJedis, flag);
  886.         }
  887.         return result;
  888.     }
  890.     public Set<String> smembers(String key) {
  891.         Set<String> result = null;
  892.         ShardedJedis shardedJedis = redisService.getRedisClient();
  893.         if (shardedJedis == null) {
  894.             return result;
  895.         }
  896.         boolean flag = false;
  897.         try {
  898.             result = shardedJedis.smembers(key);
  900.         } catch (Exception e) {
  901.             log.error(e.getMessage(), e);
  902.             flag = true;
  903.         } finally {
  904.             redisService.returnResource(shardedJedis, flag);
  905.         }
  906.         return result;
  907.     }
  909.     public Long srem(String key, String member) {
  910.         ShardedJedis shardedJedis = redisService.getRedisClient();
  912.         Long result = null;
  913.         if (shardedJedis == null) {
  914.             return result;
  915.         }
  916.         boolean flag = false;
  917.         try {
  918.             result = shardedJedis.srem(key, member);
  919.         } catch (Exception e) {
  920.             log.error(e.getMessage(), e);
  921.             flag = true;
  922.         } finally {
  923.             redisService.returnResource(shardedJedis, flag);
  924.         }
  925.         return result;
  926.     }
  928.     public String spop(String key) {
  929.         ShardedJedis shardedJedis = redisService.getRedisClient();
  930.         String result = null;
  931.         if (shardedJedis == null) {
  932.             return result;
  933.         }
  934.         boolean flag = false;
  935.         try {
  936.             result = shardedJedis.spop(key);
  937.         } catch (Exception e) {
  938.             log.error(e.getMessage(), e);
  939.             flag = true;
  940.         } finally {
  941.             redisService.returnResource(shardedJedis, flag);
  942.         }
  943.         return result;
  944.     }
  946.     public Long scard(String key) {
  947.         ShardedJedis shardedJedis = redisService.getRedisClient();
  948.         Long result = null;
  949.         if (shardedJedis == null) {
  950.             return result;
  951.         }
  952.         boolean flag = false;
  953.         try {
  954.             result = shardedJedis.scard(key);
  956.         } catch (Exception e) {
  957.             log.error(e.getMessage(), e);
  958.             flag = true;
  959.         } finally {
  960.             redisService.returnResource(shardedJedis, flag);
  961.         }
  962.         return result;
  963.     }
  965.     public Boolean sismember(String key, String member) {
  966.         ShardedJedis shardedJedis = redisService.getRedisClient();
  967.         Boolean result = null;
  968.         if (shardedJedis == null) {
  969.             return result;
  970.         }
  971.         boolean flag = false;
  972.         try {
  973.             result = shardedJedis.sismember(key, member);
  974.         } catch (Exception e) {
  975.             log.error(e.getMessage(), e);
  976.             flag = true;
  977.         } finally {
  978.             redisService.returnResource(shardedJedis, flag);
  979.         }
  980.         return result;
  981.     }
  983.     public String srandmember(String key) {
  984.         ShardedJedis shardedJedis = redisService.getRedisClient();
  985.         String result = null;
  986.         if (shardedJedis == null) {
  987.             return result;
  988.         }
  989.         boolean flag = false;
  990.         try {
  991.             result = shardedJedis.srandmember(key);
  992.         } catch (Exception e) {
  993.             log.error(e.getMessage(), e);
  994.             flag = true;
  995.         } finally {
  996.             redisService.returnResource(shardedJedis, flag);
  997.         }
  998.         return result;
  999.     }
  1001.     public Long zadd(String key, double score, String member) {
  1002.         Long result = null;
  1003.         ShardedJedis shardedJedis = redisService.getRedisClient();
  1004.         if (shardedJedis == null) {
  1005.             return result;
  1006.         }
  1007.         boolean flag = false;
  1008.         try {
  1009.             result = shardedJedis.zadd(key, score, member);
  1010.         } catch (Exception e) {
  1011.             log.error(e.getMessage(), e);
  1012.             flag = true;
  1013.         } finally {
  1014.             redisService.returnResource(shardedJedis, flag);
  1015.         }
  1016.         return result;
  1017.     }
  1019.     public Set<String> zrange(String key, int start, int end) {
  1020.         Set<String> result = null;
  1021.         ShardedJedis shardedJedis = redisService.getRedisClient();
  1022.         if (shardedJedis == null) {
  1023.             return result;
  1024.         }
  1025.         boolean flag = false;
  1026.         try {
  1027.             result = shardedJedis.zrange(key, start, end);
  1028.         } catch (Exception e) {
  1029.             log.error(e.getMessage(), e);
  1030.             flag = true;
  1031.         } finally {
  1032.             redisService.returnResource(shardedJedis, flag);
  1033.         }
  1034.         return result;
  1035.     }
  1037.     public Long zrem(String key, String member) {
  1038.         Long result = null;
  1039.         ShardedJedis shardedJedis = redisService.getRedisClient();
  1040.         if (shardedJedis == null) {
  1041.             return result;
  1042.         }
  1043.         boolean flag = false;
  1044.         try {
  1045.             result = shardedJedis.zrem(key, member);
  1046.         } catch (Exception e) {
  1047.             log.error(e.getMessage(), e);
  1048.             flag = true;
  1049.         } finally {
  1050.             redisService.returnResource(shardedJedis, flag);
  1051.         }
  1052.         return result;
  1053.     }
  1055.     public Double zincrby(String key, double score, String member) {
  1056.         Double result = null;
  1057.         ShardedJedis shardedJedis = redisService.getRedisClient();
  1058.         if (shardedJedis == null) {
  1059.             return result;
  1060.         }
  1061.         boolean flag = false;
  1062.         try {
  1064.             result = shardedJedis.zincrby(key, score, member);
  1066.         } catch (Exception e) {
  1067.             log.error(e.getMessage(), e);
  1068.             flag = true;
  1069.         } finally {
  1070.             redisService.returnResource(shardedJedis, flag);
  1071.         }
  1072.         return result;
  1073.     }
  1075.     public Long zrank(String key, String member) {
  1076.         Long result = null;
  1077.         ShardedJedis shardedJedis = redisService.getRedisClient();
  1078.         if (shardedJedis == null) {
  1079.             return result;
  1080.         }
  1081.         boolean flag = false;
  1082.         try {
  1084.             result = shardedJedis.zrank(key, member);
  1086.         } catch (Exception e) {
  1087.             log.error(e.getMessage(), e);
  1088.             flag = true;
  1089.         } finally {
  1090.             redisService.returnResource(shardedJedis, flag);
  1091.         }
  1092.         return result;
  1093.     }
  1095.     public Long zrevrank(String key, String member) {
  1096.         Long result = null;
  1097.         ShardedJedis shardedJedis = redisService.getRedisClient();
  1098.         if (shardedJedis == null) {
  1099.             return result;
  1100.         }
  1101.         boolean flag = false;
  1102.         try {
  1104.             result = shardedJedis.zrevrank(key, member);
  1106.         } catch (Exception e) {
  1107.             log.error(e.getMessage(), e);
  1108.             flag = true;
  1109.         } finally {
  1110.             redisService.returnResource(shardedJedis, flag);
  1111.         }
  1112.         return result;
  1113.     }
  1115.     public Set<String> zrevrange(String key, int start, int end) {
  1116.         Set<String> result = null;
  1117.         ShardedJedis shardedJedis = redisService.getRedisClient();
  1118.         if (shardedJedis == null) {
  1119.             return result;
  1120.         }
  1121.         boolean flag = false;
  1122.         try {
  1124.             result = shardedJedis.zrevrange(key, start, end);
  1126.         } catch (Exception e) {
  1127.             log.error(e.getMessage(), e);
  1128.             flag = true;
  1129.         } finally {
  1130.             redisService.returnResource(shardedJedis, flag);
  1131.         }
  1132.         return result;
  1133.     }
  1135.     public Set<Tuple> zrangeWithScores(String key, int start, int end) {
  1136.         Set<Tuple> result = null;
  1137.         ShardedJedis shardedJedis = redisService.getRedisClient();
  1138.         if (shardedJedis == null) {
  1139.             return result;
  1140.         }
  1141.         boolean flag = false;
  1142.         try {
  1144.             result = shardedJedis.zrangeWithScores(key, start, end);
  1146.         } catch (Exception e) {
  1147.             log.error(e.getMessage(), e);
  1148.             flag = true;
  1149.         } finally {
  1150.             redisService.returnResource(shardedJedis, flag);
  1151.         }
  1152.         return result;
  1153.     }
  1155.     public Set<Tuple> zrevrangeWithScores(String key, int start, int end) {
  1156.         Set<Tuple> result = null;
  1157.         ShardedJedis shardedJedis = redisService.getRedisClient();
  1158.         if (shardedJedis == null) {
  1159.             return result;
  1160.         }
  1161.         boolean flag = false;
  1162.         try {
  1164.             result = shardedJedis.zrevrangeWithScores(key, start, end);
  1166.         } catch (Exception e) {
  1167.             log.error(e.getMessage(), e);
  1168.             flag = true;
  1169.         } finally {
  1170.             redisService.returnResource(shardedJedis, flag);
  1171.         }
  1172.         return result;
  1173.     }
  1175.     public Long zcard(String key) {
  1176.         Long result = null;
  1177.         ShardedJedis shardedJedis = redisService.getRedisClient();
  1178.         if (shardedJedis == null) {
  1179.             return result;
  1180.         }
  1181.         boolean flag = false;
  1182.         try {
  1184.             result = shardedJedis.zcard(key);
  1186.         } catch (Exception e) {
  1187.             log.error(e.getMessage(), e);
  1188.             flag = true;
  1189.         } finally {
  1190.             redisService.returnResource(shardedJedis, flag);
  1191.         }
  1192.         return result;
  1193.     }
  1195.     public Double zscore(String key, String member) {
  1196.         Double result = null;
  1197.         ShardedJedis shardedJedis = redisService.getRedisClient();
  1198.         if (shardedJedis == null) {
  1199.             return result;
  1200.         }
  1201.         boolean flag = false;
  1202.         try {
  1204.             result = shardedJedis.zscore(key, member);
  1206.         } catch (Exception e) {
  1207.             log.error(e.getMessage(), e);
  1208.             flag = true;
  1209.         } finally {
  1210.             redisService.returnResource(shardedJedis, flag);
  1211.         }
  1212.         return result;
  1213.     }
  1215.     public List<String> sort(String key) {
  1216.         List<String> result = null;
  1217.         ShardedJedis shardedJedis = redisService.getRedisClient();
  1218.         if (shardedJedis == null) {
  1219.             return result;
  1220.         }
  1221.         boolean flag = false;
  1222.         try {
  1224.             result = shardedJedis.sort(key);
  1226.         } catch (Exception e) {
  1227.             log.error(e.getMessage(), e);
  1228.             flag = true;
  1229.         } finally {
  1230.             redisService.returnResource(shardedJedis, flag);
  1231.         }
  1232.         return result;
  1233.     }
  1235.     public List<String> sort(String key, SortingParams sortingParameters) {
  1236.         List<String> result = null;
  1237.         ShardedJedis shardedJedis = redisService.getRedisClient();
  1238.         if (shardedJedis == null) {
  1239.             return result;
  1240.         }
  1241.         boolean flag = false;
  1242.         try {
  1244.             result = shardedJedis.sort(key, sortingParameters);
  1246.         } catch (Exception e) {
  1247.             log.error(e.getMessage(), e);
  1248.             flag = true;
  1249.         } finally {
  1250.             redisService.returnResource(shardedJedis, flag);
  1251.         }
  1252.         return result;
  1253.     }
  1255.     public Long zcount(String key, double min, double max) {
  1256.         Long result = null;
  1257.         ShardedJedis shardedJedis = redisService.getRedisClient();
  1258.         if (shardedJedis == null) {
  1259.             return result;
  1260.         }
  1261.         boolean flag = false;
  1262.         try {
  1264.             result = shardedJedis.zcount(key, min, max);
  1266.         } catch (Exception e) {
  1267.             log.error(e.getMessage(), e);
  1268.             flag = true;
  1269.         } finally {
  1270.             redisService.returnResource(shardedJedis, flag);
  1271.         }
  1272.         return result;
  1273.     }
  1275.     public Set<String> zrangeByScore(String key, double min, double max) {
  1276.         Set<String> result = null;
  1277.         ShardedJedis shardedJedis = redisService.getRedisClient();
  1278.         if (shardedJedis == null) {
  1279.             return result;
  1280.         }
  1281.         boolean flag = false;
  1282.         try {
  1284.             result = shardedJedis.zrangeByScore(key, min, max);
  1286.         } catch (Exception e) {
  1287.             log.error(e.getMessage(), e);
  1288.             flag = true;
  1289.         } finally {
  1290.             redisService.returnResource(shardedJedis, flag);
  1291.         }
  1292.         return result;
  1293.     }
  1295.     public Set<String> zrevrangeByScore(String key, double max, double min) {
  1296.         Set<String> result = null;
  1297.         ShardedJedis shardedJedis = redisService.getRedisClient();
  1298.         if (shardedJedis == null) {
  1299.             return result;
  1300.         }
  1301.         boolean flag = false;
  1302.         try {
  1304.             result = shardedJedis.zrevrangeByScore(key, max, min);
  1306.         } catch (Exception e) {
  1307.             log.error(e.getMessage(), e);
  1308.             flag = true;
  1309.         } finally {
  1310.             redisService.returnResource(shardedJedis, flag);
  1311.         }
  1312.         return result;
  1313.     }
  1315.     public Set<String> zrangeByScore(String key, double min, double max,
  1316.             int offset, int count) {
  1317.         Set<String> result = null;
  1318.         ShardedJedis shardedJedis = redisService.getRedisClient();
  1319.         if (shardedJedis == null) {
  1320.             return result;
  1321.         }
  1322.         boolean flag = false;
  1323.         try {
  1325.             result = shardedJedis.zrangeByScore(key, min, max, offset, count);
  1327.         } catch (Exception e) {
  1328.             log.error(e.getMessage(), e);
  1329.             flag = true;
  1330.         } finally {
  1331.             redisService.returnResource(shardedJedis, flag);
  1332.         }
  1333.         return result;
  1334.     }
  1336.     public Set<String> zrevrangeByScore(String key, double max, double min,
  1337.             int offset, int count) {
  1338.         Set<String> result = null;
  1339.         ShardedJedis shardedJedis = redisService.getRedisClient();
  1340.         if (shardedJedis == null) {
  1341.             return result;
  1342.         }
  1343.         boolean flag = false;
  1344.         try {
  1346.             result = shardedJedis
  1347.                     .zrevrangeByScore(key, max, min, offset, count);
  1349.         } catch (Exception e) {
  1350.             log.error(e.getMessage(), e);
  1351.             flag = true;
  1352.         } finally {
  1353.             redisService.returnResource(shardedJedis, flag);
  1354.         }
  1355.         return result;
  1356.     }
  1358.     public Set<Tuple> zrangeByScoreWithScores(String key, double min, double max) {
  1359.         Set<Tuple> result = null;
  1360.         ShardedJedis shardedJedis = redisService.getRedisClient();
  1361.         if (shardedJedis == null) {
  1362.             return result;
  1363.         }
  1364.         boolean flag = false;
  1365.         try {
  1367.             result = shardedJedis.zrangeByScoreWithScores(key, min, max);
  1369.         } catch (Exception e) {
  1370.             log.error(e.getMessage(), e);
  1371.             flag = true;
  1372.         } finally {
  1373.             redisService.returnResource(shardedJedis, flag);
  1374.         }
  1375.         return result;
  1376.     }
  1378.     public Set<Tuple> zrevrangeByScoreWithScores(String key, double max,
  1379.             double min) {
  1380.         Set<Tuple> result = null;
  1381.         ShardedJedis shardedJedis = redisService.getRedisClient();
  1382.         if (shardedJedis == null) {
  1383.             return result;
  1384.         }
  1385.         boolean flag = false;
  1386.         try {
  1388.             result = shardedJedis.zrevrangeByScoreWithScores(key, max, min);
  1390.         } catch (Exception e) {
  1391.             log.error(e.getMessage(), e);
  1392.             flag = true;
  1393.         } finally {
  1394.             redisService.returnResource(shardedJedis, flag);
  1395.         }
  1396.         return result;
  1397.     }
  1399.     public Set<Tuple> zrangeByScoreWithScores(String key, double min,
  1400.             double max, int offset, int count) {
  1401.         Set<Tuple> result = null;
  1402.         ShardedJedis shardedJedis = redisService.getRedisClient();
  1403.         if (shardedJedis == null) {
  1404.             return result;
  1405.         }
  1406.         boolean flag = false;
  1407.         try {
  1409.             result = shardedJedis.zrangeByScoreWithScores(key, min, max,
  1410.                     offset, count);
  1412.         } catch (Exception e) {
  1413.             log.error(e.getMessage(), e);
  1414.             flag = true;
  1415.         } finally {
  1416.             redisService.returnResource(shardedJedis, flag);
  1417.         }
  1418.         return result;
  1419.     }
  1421.     public Set<Tuple> zrevrangeByScoreWithScores(String key, double max,
  1422.             double min, int offset, int count) {
  1423.         Set<Tuple> result = null;
  1424.         ShardedJedis shardedJedis = redisService.getRedisClient();
  1425.         if (shardedJedis == null) {
  1426.             return result;
  1427.         }
  1428.         boolean flag = false;
  1429.         try {
  1431.             result = shardedJedis.zrevrangeByScoreWithScores(key, max, min,
  1432.                     offset, count);
  1434.         } catch (Exception e) {
  1435.             log.error(e.getMessage(), e);
  1436.             flag = true;
  1437.         } finally {
  1438.             redisService.returnResource(shardedJedis, flag);
  1439.         }
  1440.         return result;
  1441.     }
  1443.     public Long zremrangeByRank(String key, int start, int end) {
  1444.         Long result = null;
  1445.         ShardedJedis shardedJedis = redisService.getRedisClient();
  1446.         if (shardedJedis == null) {
  1447.             return result;
  1448.         }
  1449.         boolean flag = false;
  1450.         try {
  1452.             result = shardedJedis.zremrangeByRank(key, start, end);
  1454.         } catch (Exception e) {
  1455.             log.error(e.getMessage(), e);
  1456.             flag = true;
  1457.         } finally {
  1458.             redisService.returnResource(shardedJedis, flag);
  1459.         }
  1460.         return result;
  1461.     }
  1463.     public Long zremrangeByScore(String key, double start, double end) {
  1464.         Long result = null;
  1465.         ShardedJedis shardedJedis = redisService.getRedisClient();
  1466.         if (shardedJedis == null) {
  1467.             return result;
  1468.         }
  1469.         boolean flag = false;
  1470.         try {
  1472.             result = shardedJedis.zremrangeByScore(key, start, end);
  1474.         } catch (Exception e) {
  1475.             log.error(e.getMessage(), e);
  1476.             flag = true;
  1477.         } finally {
  1478.             redisService.returnResource(shardedJedis, flag);
  1479.         }
  1480.         return result;
  1481.     }
  1483.     public Long linsert(String key, LIST_POSITION where, String pivot,
  1484.             String value) {
  1485.         Long result = null;
  1486.         ShardedJedis shardedJedis = redisService.getRedisClient();
  1487.         if (shardedJedis == null) {
  1488.             return result;
  1489.         }
  1490.         boolean flag = false;
  1491.         try {
  1493.             result = shardedJedis.linsert(key, where, pivot, value);
  1495.         } catch (Exception e) {
  1496.             log.error(e.getMessage(), e);
  1497.             flag = true;
  1498.         } finally {
  1499.             redisService.returnResource(shardedJedis, flag);
  1500.         }
  1501.         return result;
  1502.     }
  1505.     @SuppressWarnings("deprecation")
  1506.     public List<Object> pipelined(ShardedJedisPipeline shardedJedisPipeline) {
  1507.         ShardedJedis shardedJedis = redisService.getRedisClient();
  1508.         List<Object> result = null;
  1509.         if (shardedJedis == null) {
  1510.             return result;
  1511.         }
  1512.         boolean flag = false;
  1513.         try {
  1514.             result = shardedJedis.pipelined(shardedJedisPipeline);
  1515.         } catch (Exception e) {
  1516.             log.error(e.getMessage(), e);
  1517.             flag = true;
  1518.         } finally {
  1519.             redisService.returnResource(shardedJedis, flag);
  1520.         }
  1521.         return result;
  1522.     }
  1524.     public Jedis getShard(String key) {
  1525.         ShardedJedis shardedJedis = redisService.getRedisClient();
  1526.         Jedis result = null;
  1527.         if (shardedJedis == null) {
  1528.             return result;
  1529.         }
  1530.         boolean flag = false;
  1531.         try {
  1532.             result = shardedJedis.getShard(key);
  1533.         } catch (Exception e) {
  1534.             log.error(e.getMessage(), e);
  1535.             flag = true;
  1536.         } finally {
  1537.             redisService.returnResource(shardedJedis, flag);
  1538.         }
  1539.         return result;
  1540.     }
  1542.     public JedisShardInfo getShardInfo(String key) {
  1543.         ShardedJedis shardedJedis = redisService.getRedisClient();
  1544.         JedisShardInfo result = null;
  1545.         if (shardedJedis == null) {
  1546.             return result;
  1547.         }
  1548.         boolean flag = false;
  1549.         try {
  1550.             result = shardedJedis.getShardInfo(key);
  1551.         } catch (Exception e) {
  1552.             log.error(e.getMessage(), e);
  1553.             flag = true;
  1554.         } finally {
  1555.             redisService.returnResource(shardedJedis, flag);
  1556.         }
  1557.         return result;
  1558.     }
  1560.     public String getKeyTag(String key) {
  1561.         ShardedJedis shardedJedis = redisService.getRedisClient();
  1562.         String result = null;
  1563.         if (shardedJedis == null) {
  1564.             return result;
  1565.         }
  1566.         boolean flag = false;
  1567.         try {
  1568.             result = shardedJedis.getKeyTag(key);
  1569.         } catch (Exception e) {
  1570.             log.error(e.getMessage(), e);
  1571.             flag = true;
  1572.         } finally {
  1573.             redisService.returnResource(shardedJedis, flag);
  1574.         }
  1575.         return result;
  1576.     }
  1578.     public Collection<JedisShardInfo> getAllShardInfo() {
  1579.         ShardedJedis shardedJedis = redisService.getRedisClient();
  1580.         Collection<JedisShardInfo> result = null;
  1581.         if (shardedJedis == null) {
  1582.             return result;
  1583.         }
  1584.         boolean flag = false;
  1585.         try {
  1586.             result = shardedJedis.getAllShardInfo();
  1588.         } catch (Exception e) {
  1589.             log.error(e.getMessage(), e);
  1590.             flag = true;
  1591.         } finally {
  1592.             redisService.returnResource(shardedJedis, flag);
  1593.         }
  1594.         return result;
  1595.     }
  1597.     public Collection<Jedis> getAllShards() {
  1598.         ShardedJedis shardedJedis = redisService.getRedisClient();
  1599.         Collection<Jedis> result = null;
  1600.         if (shardedJedis == null) {
  1601.             return result;
  1602.         }
  1603.         boolean flag = false;
  1604.         try {
  1605.             result = shardedJedis.getAllShards();
  1607.         } catch (Exception e) {
  1608.             log.error(e.getMessage(), e);
  1609.             flag = true;
  1610.         } finally {
  1611.             redisService.returnResource(shardedJedis, flag);
  1612.         }
  1613.         return result;
  1614.     }
  1616. }

发表评论

表情：
评论列表 （有 0 条评论，213人围观）

还没有评论，来说两句吧...

相关阅读

    相关 volatile的适用场合

    1对变量的写入操作不依赖其当前值 不满足：number++/count = count\5等 满足Boolean变量、记录温度变化的变量等 2.该变量没有包含在具有其他变

    怼烎@怼烎@/ 0 赞/ 217 阅读

    相关 Redis的适用场景

    Redis最适合所有数据in-momory的场景，虽然Redis也提供持久化功能，但实际更多的是一个disk-backed的功能，跟传统意义上的持久化有比较大的差别，那么可能大

    爱被打了一巴掌爱被打了一巴掌/ 0 赞/ 280 阅读