Redis学习，
1 概述
目前多数的NoSql数据库本质上都是键值对形式，Redis也不例外。作为缓存数据库的一种，和Memcached相比，有以下几种主要的优点：
(1)速度上，Redis要比Memcached快，这是基于一些Benchmarks的测试结果得出的，而且在内存使用上，Redis突破了物理内存限制，可以使用虚拟内存；
(2)数据类型比Memcached要多，Redis支持List、Set、SortedSet、HashMap等多种数据结构；
(3)持久化方面，Memcached没有相应的持久化机制，而Redis有RDB快照和AOF日志两种形式结合做持久化，很大限度上保证了数据的持久化和安全性，不像Memcached断电后全都没了。
Redis不失为Memcached的一种良好的替代方案。
MongoDB是一种适合做格式化文档的存储及查询的NoSql数据库，它可以可以用来做海量数据存储，毕竟是一种硬盘数据库，和Redis这种缓存数据库没什么可比性。网上那么多讨论的，这里就不说了，见参考文档1。
Redis也可以在硬盘上存储数据以及跨节点复制数据，也可以用来做队列系统，据说GitHub就采用Redis作为其基础架构。
2 安装部署
目前官方发布的最新稳定版是2.8.6，我们就以它为例进行下述的操作及说明。
2.1 Centos安装部署
安装步骤如下：
(1)将redis-2.8.6.tar.gz安装包拷贝到我们的指定目录下；
(2)使用命令tar -zxvf redis-2.8.6.tar.gz将tar包解压缩，得到redis-2.8.6目录；
(3)进入redis-2.8.6目录，执行make命令进行编译；
(4)编译结束之后，配置redis.conf文件，将“daemonize”属性设置为“yes”，表示我们会以后台进程形式启动Redis服务；将“port”属性设置为指定的端口，这里默认为“6379”；将“logfile”属性设置为指定的日志路径，其余的属性可以保持默认。
(5)使用命令src/redis-server ./redis.conf启动Redis服务，启动之后，可以在刚才配置的日志路径中看到如下类似信息：
这个帅气的图标就是Redis的LOGO了。
(6)执行客户端命令，验证服务是否正常：
(7)Redis服务停止命令，src/redis-cli shutdown
2.2 conf配置文件说明
刚才在部署的时候，提到了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大文件写入对磁盘的操作次数
|
3 基本原理
Redis是C编写的，对外开放的List、Set、SortedSet等数据结构都有着自己独到的实现和算法，其内部的实现原理见参考4，这里就不卖弄了，我也在学习。
需求推动技术的进步，Redis可以应用在如下几种场景中：
(1)取最新N个数据操作
(2)排行榜操作，Top N
(3)需要精准设定过期时间的应用
(4)计数器应用
(5)获取某段时间内所有数据的排重值，uniq操作
(6)实时系统
(7)发布/订阅系统
(8)队列系统
(9)缓存
具体的场景分析见参考9。
4 客户端操作
使用src/redis-cli可以打开客户端对话框，输入命令即可。目前Redis支持String、Map、List、Set、SortedSets等五种数据结构以及支持订阅、事务等操作。每种命令的操作及详细解释见参考8。
5 Java操作Redis
目前Jedis是官方推荐的比较好的Redis操作API包，我们这里结合Spring来看下如何使用Redis这一神器。
首先在pom文件中引入jredis包：
1 <dependency>
2 <groupId>redis.clients</groupId>
3 <artifactId>jedis</artifactId>
4 <version>2.1.0</version>
5 </dependency>
其次，在Spring的resource目录中增加Redis的配置文件/src/main/resources/redis.properties
1 # Redis settings
2 redis.host=192.168.1.106
3 redis.port=6379
4 redis.pass=
5 redis.timeout=0
6
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">
10
11 <context:property-placeholder location="classpath:redis.properties" />
12 <context:component-scan base-package="com.scott.demo" />
13
14 <bean class="org.springframework.context.annotation.CommonAnnotationBeanPostProcessor" />
15
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>
24
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 package com.scott.demo.redis.service.impl;
2
3 import org.slf4j.Logger;
4 import org.slf4j.LoggerFactory;
5 import org.springframework.beans.factory.annotation.Autowired;
6 import org.springframework.stereotype.Repository;
7
8 import com.scott.demo.redis.service.RedisService;
9
10 import redis.clients.jedis.ShardedJedis;
11 import redis.clients.jedis.ShardedJedisPool;
12
13 /**
14 * @author Scott
15 * @date 2014年2月23日
16 * @description
17 */
18 @Repository("redisService")
19 public class RedisServiceImpl implements RedisService {
20
21 private static final Logger log = LoggerFactory.getLogger(RedisServiceImpl.class);
22
23 @Autowired
24 private ShardedJedisPool shardedJedisPool;
25
26 public ShardedJedis getRedisClient() {
27 try {
28 ShardedJedis shardJedis = shardedJedisPool.getResource();
29 return shardJedis;
30 } catch (Exception e) {
31 log.error("getRedisClent error", e);
32 }
33 return null;
34 }
35
36 public void returnResource(ShardedJedis shardedJedis) {
37 shardedJedisPool.returnResource(shardedJedis);
38 }
39
40 public void returnResource(ShardedJedis shardedJedis, boolean broken) {
41 if (broken) {
42 shardedJedisPool.returnBrokenResource(shardedJedis);
43 } else {
44 shardedJedisPool.returnResource(shardedJedis);
45 }
46 }
47
48 }
根据上述类，可以在下面的RedisClient类中实现Redis的相关操作：
![]()
1 package com.scott.demo.redis;
2
3 import java.util.Collection;
4 import java.util.List;
5 import java.util.Map;
6 import java.util.Set;
7
8 import org.slf4j.Logger;
9 import org.slf4j.LoggerFactory;
10 import org.springframework.beans.factory.annotation.Autowired;
11
12 import com.scott.demo.redis.service.impl.RedisServiceImpl;
13
14 import redis.clients.jedis.BinaryClient.LIST_POSITION;
15 import redis.clients.jedis.Jedis;
16 import redis.clients.jedis.JedisShardInfo;
17 import redis.clients.jedis.ShardedJedis;
18 import redis.clients.jedis.ShardedJedisPipeline;
19 import redis.clients.jedis.SortingParams;
20 import redis.clients.jedis.Tuple;
21
22 /**
23 * @author Scott
24 * @date 2014年2月23日
25 * @description
26 */
27 public class RedisClient {
28
29 private static final Logger log = LoggerFactory.getLogger(RedisClient.
class);
30
31 @Autowired
32 private RedisServiceImpl redisService;
33
34 public void disconnect() {
35 ShardedJedis shardedJedis =
redisService.getRedisClient();
36 shardedJedis.disconnect();
37 }
38
39 /**
40 * 设置单个值
41 */
42 public String set(String key, String value) {
43 String result =
null;
44
45 ShardedJedis shardedJedis =
redisService.getRedisClient();
46 if (shardedJedis ==
null) {
47 return result;
48 }
49 boolean flag =
false;
50 try {
51 result =
shardedJedis.set(key, value);
52 }
catch (Exception e) {
53 log.error(e.getMessage(), e);
54 flag =
true;
55 }
finally {
56 redisService.returnResource(shardedJedis, flag);
57 }
58 return result;
59 }
60
61 /**
62 * 获取单个值
63 */
64 public String get(String key) {
65 String result =
null;
66 ShardedJedis shardedJedis =
redisService.getRedisClient();
67 if (shardedJedis ==
null) {
68 return result;
69 }
70
71 boolean flag =
false;
72 try {
73 result =
shardedJedis.get(key);
74
75 }
catch (Exception e) {
76 log.error(e.getMessage(), e);
77 flag =
true;
78 }
finally {
79 redisService.returnResource(shardedJedis, flag);
80 }
81 return result;
82 }
83
84 public Boolean exists(String key) {
85 Boolean result =
false;
86 ShardedJedis shardedJedis =
redisService.getRedisClient();
87 if (shardedJedis ==
null) {
88 return result;
89 }
90 boolean flag =
false;
91 try {
92 result =
shardedJedis.exists(key);
93 }
catch (Exception e) {
94 log.error(e.getMessage(), e);
95 flag =
true;
96 }
finally {
97 redisService.returnResource(shardedJedis, flag);
98 }
99 return result;
100 }
101
102 public String type(String key) {
103 String result =
null;
104 ShardedJedis shardedJedis =
redisService.getRedisClient();
105 if (shardedJedis ==
null) {
106 return result;
107 }
108 boolean flag =
false;
109 try {
110 result =
shardedJedis.type(key);
111
112 }
catch (Exception e) {
113 log.error(e.getMessage(), e);
114 flag =
true;
115 }
finally {
116 redisService.returnResource(shardedJedis, flag);
117 }
118 return result;
119 }
120
121 /**
122 * 在某段时间后失效
123 */
124 public Long expire(String key,
int seconds) {
125 Long result =
null;
126 ShardedJedis shardedJedis =
redisService.getRedisClient();
127 if (shardedJedis ==
null) {
128 return result;
129 }
130 boolean flag =
false;
131 try {
132 result =
shardedJedis.expire(key, seconds);
133
134 }
catch (Exception e) {
135 log.error(e.getMessage(), e);
136 flag =
true;
137 }
finally {
138 redisService.returnResource(shardedJedis, flag);
139 }
140 return result;
141 }
142
143 /**
144 * 在某个时间点失效
145 */
146 public Long expireAt(String key,
long time) {
147 Long result =
null;
148 ShardedJedis shardedJedis =
redisService.getRedisClient();
149 if (shardedJedis ==
null) {
150 return result;
151 }
152 boolean flag =
false;
153 try {
154 result =
shardedJedis.expireAt(key, time);
155
156 }
catch (Exception e) {
157 log.error(e.getMessage(), e);
158 flag =
true;
159 }
finally {
160 redisService.returnResource(shardedJedis, flag);
161 }
162 return result;
163 }
164
165 public Long ttl(String key) {
166 Long result =
null;
167 ShardedJedis shardedJedis =
redisService.getRedisClient();
168 if (shardedJedis ==
null) {
169 return result;
170 }
171 boolean flag =
false;
172 try {
173 result =
shardedJedis.ttl(key);
174
175 }
catch (Exception e) {
176 log.error(e.getMessage(), e);
177 flag =
true;
178 }
finally {
179 redisService.returnResource(shardedJedis, flag);
180 }
181 return result;
182 }
183
184 public boolean setbit(String key,
long offset,
boolean value) {
185
186 ShardedJedis shardedJedis =
redisService.getRedisClient();
187 boolean result =
false;
188 if (shardedJedis ==
null) {
189 return result;
190 }
191 boolean flag =
false;
192 try {
193 result =
shardedJedis.setbit(key, offset, value);
194 }
catch (Exception e) {
195 log.error(e.getMessage(), e);
196 flag =
true;
197 }
finally {
198 redisService.returnResource(shardedJedis, flag);
199 }
200 return result;
201 }
202
203 public boolean getbit(String key,
long offset) {
204 ShardedJedis shardedJedis =
redisService.getRedisClient();
205 boolean result =
false;
206 if (shardedJedis ==
null) {
207 return result;
208 }
209 boolean flag =
false;
210
211 try {
212 result =
shardedJedis.getbit(key, offset);
213 }
catch (Exception e) {
214 log.error(e.getMessage(), e);
215 flag =
true;
216 }
finally {
217 redisService.returnResource(shardedJedis, flag);
218 }
219 return result;
220 }
221
222 public long setrange(String key,
long offset, String value) {
223 ShardedJedis shardedJedis =
redisService.getRedisClient();
224 long result = 0
;
225 if (shardedJedis ==
null) {
226 return result;
227 }
228 boolean flag =
false;
229 try {
230 result =
shardedJedis.setrange(key, offset, value);
231 }
catch (Exception e) {
232 log.error(e.getMessage(), e);
233 flag =
true;
234 }
finally {
235 redisService.returnResource(shardedJedis, flag);
236 }
237 return result;
238 }
239
240 public String getrange(String key,
long startOffset,
long endOffset) {
241 ShardedJedis shardedJedis =
redisService.getRedisClient();
242 String result =
null;
243 if (shardedJedis ==
null) {
244 return result;
245 }
246 boolean flag =
false;
247 try {
248 result =
shardedJedis.getrange(key, startOffset, endOffset);
249
250 }
catch (Exception e) {
251 log.error(e.getMessage(), e);
252 flag =
true;
253 }
finally {
254 redisService.returnResource(shardedJedis, flag);
255 }
256 return result;
257 }
258
259 public String getSet(String key, String value) {
260 String result =
null;
261 ShardedJedis shardedJedis =
redisService.getRedisClient();
262 if (shardedJedis ==
null) {
263 return result;
264 }
265 boolean flag =
false;
266 try {
267 result =
shardedJedis.getSet(key, value);
268 }
catch (Exception e) {
269 log.error(e.getMessage(), e);
270 flag =
true;
271 }
finally {
272 redisService.returnResource(shardedJedis, flag);
273 }
274 return result;
275 }
276
277 public Long setnx(String key, String value) {
278 Long result =
null;
279 ShardedJedis shardedJedis =
redisService.getRedisClient();
280 if (shardedJedis ==
null) {
281 return result;
282 }
283 boolean flag =
false;
284 try {
285 result =
shardedJedis.setnx(key, value);
286 }
catch (Exception e) {
287 log.error(e.getMessage(), e);
288 flag =
true;
289 }
finally {
290 redisService.returnResource(shardedJedis, flag);
291 }
292 return result;
293 }
294
295 public String setex(String key,
int seconds, String value) {
296 String result =
null;
297 ShardedJedis shardedJedis =
redisService.getRedisClient();
298 if (shardedJedis ==
null) {
299 return result;
300 }
301 boolean flag =
false;
302 try {
303 result =
shardedJedis.setex(key, seconds, value);
304
305 }
catch (Exception e) {
306 log.error(e.getMessage(), e);
307 flag =
true;
308 }
finally {
309 redisService.returnResource(shardedJedis, flag);
310 }
311 return result;
312 }
313
314 public Long decrBy(String key,
long integer) {
315 Long result =
null;
316 ShardedJedis shardedJedis =
redisService.getRedisClient();
317 if (shardedJedis ==
null) {
318 return result;
319 }
320 boolean flag =
false;
321 try {
322 result =
shardedJedis.decrBy(key, integer);
323
324 }
catch (Exception e) {
325 log.error(e.getMessage(), e);
326 flag =
true;
327 }
finally {
328 redisService.returnResource(shardedJedis, flag);
329 }
330 return result;
331 }
332
333 public Long decr(String key) {
334 Long result =
null;
335 ShardedJedis shardedJedis =
redisService.getRedisClient();
336 if (shardedJedis ==
null) {
337 return result;
338 }
339 boolean flag =
false;
340 try {
341 result =
shardedJedis.decr(key);
342
343 }
catch (Exception e) {
344 log.error(e.getMessage(), e);
345 flag =
true;
346 }
finally {
347 redisService.returnResource(shardedJedis, flag);
348 }
349 return result;
350 }
351
352 public Long incrBy(String key,
long integer) {
353 Long result =
null;
354 ShardedJedis shardedJedis =
redisService.getRedisClient();
355 if (shardedJedis ==
null) {
356 return result;
357 }
358 boolean flag =
false;
359 try {
360 result =
shardedJedis.incrBy(key, integer);
361
362 }
catch (Exception e) {
363 log.error(e.getMessage(), e);
364 flag =
true;
365 }
finally {
366 redisService.returnResource(shardedJedis, flag);
367 }
368 return result;
369 }
370
371 public Long incr(String key) {
372 Long result =
null;
373 ShardedJedis shardedJedis =
redisService.getRedisClient();
374 if (shardedJedis ==
null) {
375 return result;
376 }
377 boolean flag =
false;
378 try {
379 result =
shardedJedis.incr(key);
380
381 }
catch (Exception e) {
382 log.error(e.getMessage(), e);
383 flag =
true;
384 }
finally {
385 redisService.returnResource(shardedJedis, flag);
386 }
387 return result;
388 }
389
390 public Long append(String key, String value) {
391 Long result =
null;
392 ShardedJedis shardedJedis =
redisService.getRedisClient();
393 if (shardedJedis ==
null) {
394 return result;
395 }
396 boolean flag =
false;
397 try {
398 result =
shardedJedis.append(key, value);
399
400 }
catch (Exception e) {
401 log.error(e.getMessage(), e);
402 flag =
true;
403 }
finally {
404 redisService.returnResource(shardedJedis, flag);
405 }
406 return result;
407 }
408
409 public String substr(String key,
int start,
int end) {
410 String result =
null;
411 ShardedJedis shardedJedis =
redisService.getRedisClient();
412 if (shardedJedis ==
null) {
413 return result;
414 }
415 boolean flag =
false;
416 try {
417 result =
shardedJedis.substr(key, start, end);
418
419 }
catch (Exception e) {
420 log.error(e.getMessage(), e);
421 flag =
true;
422 }
finally {
423 redisService.returnResource(shardedJedis, flag);
424 }
425 return result;
426 }
427
428 public Long hset(String key, String field, String value) {
429 Long result =
null;
430 ShardedJedis shardedJedis =
redisService.getRedisClient();
431 if (shardedJedis ==
null) {
432 return result;
433 }
434 boolean flag =
false;
435 try {
436 result =
shardedJedis.hset(key, field, value);
437
438 }
catch (Exception e) {
439 log.error(e.getMessage(), e);
440 flag =
true;
441 }
finally {
442 redisService.returnResource(shardedJedis, flag);
443 }
444 return result;
445 }
446
447 public String hget(String key, String field) {
448 String result =
null;
449 ShardedJedis shardedJedis =
redisService.getRedisClient();
450 if (shardedJedis ==
null) {
451 return result;
452 }
453 boolean flag =
false;
454 try {
455 result =
shardedJedis.hget(key, field);
456
457 }
catch (Exception e) {
458 log.error(e.getMessage(), e);
459 flag =
true;
460 }
finally {
461 redisService.returnResource(shardedJedis, flag);
462 }
463 return result;
464 }
465
466 public Long hsetnx(String key, String field, String value) {
467 Long result =
null;
468 ShardedJedis shardedJedis =
redisService.getRedisClient();
469 if (shardedJedis ==
null) {
470 return result;
471 }
472 boolean flag =
false;
473 try {
474 result =
shardedJedis.hsetnx(key, field, value);
475
476 }
catch (Exception e) {
477 log.error(e.getMessage(), e);
478 flag =
true;
479 }
finally {
480 redisService.returnResource(shardedJedis, flag);
481 }
482 return result;
483 }
484
485 public String hmset(String key, Map<String, String>
hash) {
486 String result =
null;
487 ShardedJedis shardedJedis =
redisService.getRedisClient();
488 if (shardedJedis ==
null) {
489 return result;
490 }
491 boolean flag =
false;
492 try {
493 result =
shardedJedis.hmset(key, hash);
494
495 }
catch (Exception e) {
496 log.error(e.getMessage(), e);
497 flag =
true;
498 }
finally {
499 redisService.returnResource(shardedJedis, flag);
500 }
501 return result;
502 }
503
504 public List<String>
hmget(String key, String... fields) {
505 List<String> result =
null;
506 ShardedJedis shardedJedis =
redisService.getRedisClient();
507 if (shardedJedis ==
null) {
508 return result;
509 }
510 boolean flag =
false;
511 try {
512 result =
shardedJedis.hmget(key, fields);
513
514 }
catch (Exception e) {
515 log.error(e.getMessage(), e);
516 flag =
true;
517 }
finally {
518 redisService.returnResource(shardedJedis, flag);
519 }
520 return result;
521 }
522
523 public Long hincrBy(String key, String field,
long value) {
524 Long result =
null;
525 ShardedJedis shardedJedis =
redisService.getRedisClient();
526 if (shardedJedis ==
null) {
527 return result;
528 }
529 boolean flag =
false;
530 try {
531 result =
shardedJedis.hincrBy(key, field, value);
532
533 }
catch (Exception e) {
534 log.error(e.getMessage(), e);
535 flag =
true;
536 }
finally {
537 redisService.returnResource(shardedJedis, flag);
538 }
539 return result;
540 }
541
542 public Boolean hexists(String key, String field) {
543 Boolean result =
false;
544 ShardedJedis shardedJedis =
redisService.getRedisClient();
545 if (shardedJedis ==
null) {
546 return result;
547 }
548 boolean flag =
false;
549 try {
550 result =
shardedJedis.hexists(key, field);
551
552 }
catch (Exception e) {
553 log.error(e.getMessage(), e);
554 flag =
true;
555 }
finally {
556 redisService.returnResource(shardedJedis, flag);
557 }
558 return result;
559 }
560
561 public Long del(String key) {
562 Long result =
null;
563 ShardedJedis shardedJedis =
redisService.getRedisClient();
564 if (shardedJedis ==
null) {
565 return result;
566 }
567 boolean flag =
false;
568 try {
569 result =
shardedJedis.del(key);
570
571 }
catch (Exception e) {
572 log.error(e.getMessage(), e);
573 flag =
true;
574 }
finally {
575 redisService.returnResource(shardedJedis, flag);
576 }
577 return result;
578 }
579
580 public Long hdel(String key, String field) {
581 Long result =
null;
582 ShardedJedis shardedJedis =
redisService.getRedisClient();
583 if (shardedJedis ==
null) {
584 return result;
585 }
586 boolean flag =
false;
587 try {
588 result =
shardedJedis.hdel(key, field);
589
590 }
catch (Exception e) {
591 log.error(e.getMessage(), e);
592 flag =
true;
593 }
finally {
594 redisService.returnResource(shardedJedis, flag);
595 }
596 return result;
597 }
598
599 public Long hlen(String key) {
600 Long result =
null;
601 ShardedJedis shardedJedis =
redisService.getRedisClient();
602 if (shardedJedis ==
null) {
603 return result;
604 }
605 boolean flag =
false;
606 try {
607 result =
shardedJedis.hlen(key);
608
609 }
catch (Exception e) {
610 log.error(e.getMessage(), e);
611 flag =
true;
612 }
finally {
613 redisService.returnResource(shardedJedis, flag);
614 }
615 return result;
616 }
617
618 public Set<String>
hkeys(String key) {
619 Set<String> result =
null;
620 ShardedJedis shardedJedis =
redisService.getRedisClient();
621 if (shardedJedis ==
null) {
622 return result;
623 }
624 boolean flag =
false;
625 try {
626 result =
shardedJedis.hkeys(key);
627
628 }
catch (Exception e) {
629 log.error(e.getMessage(), e);
630 flag =
true;
631 }
finally {
632 redisService.returnResource(shardedJedis, flag);
633 }
634 return result;
635 }
636
637 public List<String>
hvals(String key) {
638 List<String> result =
null;
639 ShardedJedis shardedJedis =
redisService.getRedisClient();
640 if (shardedJedis ==
null) {
641 return result;
642 }
643 boolean flag =
false;
644 try {
645 result =
shardedJedis.hvals(key);
646
647 }
catch (Exception e) {
648 log.error(e.getMessage(), e);
649 flag =
true;
650 }
finally {
651 redisService.returnResource(shardedJedis, flag);
652 }
653 return result;
654 }
655
656 public Map<String, String>
hgetAll(String key) {
657 Map<String, String> result =
null;
658 ShardedJedis shardedJedis =
redisService.getRedisClient();
659 if (shardedJedis ==
null) {
660 return result;
661 }
662 boolean flag =
false;
663 try {
664 result =
shardedJedis.hgetAll(key);
665
666 }
catch (Exception e) {
667 log.error(e.getMessage(), e);
668 flag =
true;
669 }
finally {
670 redisService.returnResource(shardedJedis, flag);
671 }
672 return result;
673 }
674
675 /**
676 * 在redis list尾部增加一个String
677 * */
678 public Long rpush(String key, String string) {
679 Long result =
null;
680 ShardedJedis shardedJedis =
redisService.getRedisClient();
681 if (shardedJedis ==
null) {
682 return result;
683 }
684 boolean flag =
false;
685 try {
686 result =
shardedJedis.rpush(key, string);
687
688 }
catch (Exception e) {
689 log.error(e.getMessage(), e);
690 flag =
true;
691 }
finally {
692 redisService.returnResource(shardedJedis, flag);
693 }
694 return result;
695 }
696
697 /**
698 * 在redis list头部增加一个String
699 * */
700 public Long lpush(String key, String string) {
701 Long result =
null;
702 ShardedJedis shardedJedis =
redisService.getRedisClient();
703 if (shardedJedis ==
null) {
704 return result;
705 }
706 boolean flag =
false;
707 try {
708 result =
shardedJedis.lpush(key, string);
709
710 }
catch (Exception e) {
711 log.error(e.getMessage(), e);
712 flag =
true;
713 }
finally {
714 redisService.returnResource(shardedJedis, flag);
715 }
716 return result;
717 }
718
719 public Long llen(String key) {
720 Long result =
null;
721 ShardedJedis shardedJedis =
redisService.getRedisClient();
722 if (shardedJedis ==
null) {
723 return result;
724 }
725 boolean flag =
false;
726 try {
727 result =
shardedJedis.llen(key);
728
729 }
catch (Exception e) {
730 log.error(e.getMessage(), e);
731 flag =
true;
732 }
finally {
733 redisService.returnResource(shardedJedis, flag);
734 }
735 return result;
736 }
737
738 public List<String> lrange(String key,
long start,
long end) {
739 List<String> result =
null;
740 ShardedJedis shardedJedis =
redisService.getRedisClient();
741 if (shardedJedis ==
null) {
742 return result;
743 }
744 boolean flag =
false;
745 try {
746 result =
shardedJedis.lrange(key, start, end);
747
748 }
catch (Exception e) {
749 log.error(e.getMessage(), e);
750 flag =
true;
751 }
finally {
752 redisService.returnResource(shardedJedis, flag);
753 }
754 return result;
755 }
756
757 public String ltrim(String key,
long start,
long end) {
758 String result =
null;
759 ShardedJedis shardedJedis =
redisService.getRedisClient();
760 if (shardedJedis ==
null) {
761 return result;
762 }
763 boolean flag =
false;
764 try {
765 result =
shardedJedis.ltrim(key, start, end);
766
767 }
catch (Exception e) {
768 log.error(e.getMessage(), e);
769 flag =
true;
770 }
finally {
771 redisService.returnResource(shardedJedis, flag);
772 }
773 return result;
774 }
775
776 public String lIndex(String key,
long index) {
777 String result =
null;
778 ShardedJedis shardedJedis =
redisService.getRedisClient();
779 if (shardedJedis ==
null) {
780 return result;
781 }
782 boolean flag =
false;
783 try {
784 result =
shardedJedis.lindex(key, index);
785
786 }
catch (Exception e) {
787 log.error(e.getMessage(), e);
788 flag =
true;
789 }
finally {
790 redisService.returnResource(shardedJedis, flag);
791 }
792 return result;
793 }
794
795 public String lset(String key,
long index, String value) {
796 String result =
null;
797 ShardedJedis shardedJedis =
redisService.getRedisClient();
798 if (shardedJedis ==
null) {
799 return result;
800 }
801 boolean flag =
false;
802 try {
803 result =
shardedJedis.lset(key, index, value);
804
805 }
catch (Exception e) {
806 log.error(e.getMessage(), e);
807 flag =
true;
808 }
finally {
809 redisService.returnResource(shardedJedis, flag);
810 }
811 return result;
812 }
813
814 public Long lrem(String key,
long count, String value) {
815 Long result =
null;
816 ShardedJedis shardedJedis =
redisService.getRedisClient();
817 if (shardedJedis ==
null) {
818 return result;
819 }
820 boolean flag =
false;
821 try {
822 result =
shardedJedis.lrem(key, count, value);
823
824 }
catch (Exception e) {
825 log.error(e.getMessage(), e);
826 flag =
true;
827 }
finally {
828 redisService.returnResource(shardedJedis, flag);
829 }
830 return result;
831 }
832
833 /**
834 * 从redis list头部取出一个key
835 * */
836 public String lpop(String key) {
837 String result =
null;
838 ShardedJedis shardedJedis =
redisService.getRedisClient();
839 if (shardedJedis ==
null) {
840 return result;
841 }
842 boolean flag =
false;
843 try {
844 result =
shardedJedis.lpop(key);
845
846 }
catch (Exception e) {
847 log.error(e.getMessage(), e);
848 flag =
true;
849 }
finally {
850 redisService.returnResource(shardedJedis, flag);
851 }
852 return result;
853 }
854
855 /**
856 * 从redis list尾部取出一个key
857 * */
858 public String rpop(String key) {
859 String result =
null;
860 ShardedJedis shardedJedis =
redisService.getRedisClient();
861 if (shardedJedis ==
null) {
862 return result;
863 }
864 boolean flag =
false;
865 try {
866 result =
shardedJedis.rpop(key);
867
868 }
catch (Exception e) {
869 log.error(e.getMessage(), e);
870 flag =
true;
871 }
finally {
872 redisService.returnResource(shardedJedis, flag);
873 }
874 return result;
875 }
876
877 public Long sadd(String key, String member) {
878 Long result =
null;
879 ShardedJedis shardedJedis =
redisService.getRedisClient();
880 if (shardedJedis ==
null) {
881 return result;
882 }
883 boolean flag =
false;
884 try {
885 result =
shardedJedis.sadd(key, member);
886
887 }
catch (Exception e) {
888 log.error(e.getMessage(), e);
889 flag =
true;
890 }
finally {
891 redisService.returnResource(shardedJedis, flag);
892 }
893 return result;
894 }
895
896 public Set<String>
smembers(String key) {
897 Set<String> result =
null;
898 ShardedJedis shardedJedis =
redisService.getRedisClient();
899 if (shardedJedis ==
null) {
900 return result;
901 }
902 boolean flag =
false;
903 try {
904 result =
shardedJedis.smembers(key);
905
906 }
catch (Exception e) {
907 log.error(e.getMessage(), e);
908 flag =
true;
909 }
finally {
910 redisService.returnResource(shardedJedis, flag);
911 }
912 return result;
913 }
914
915 public Long srem(String key, String member) {
916 ShardedJedis shardedJedis =
redisService.getRedisClient();
917
918 Long result =
null;
919 if (shardedJedis ==
null) {
920 return result;
921 }
922 boolean flag =
false;
923 try {
924 result =
shardedJedis.srem(key, member);
925 }
catch (Exception e) {
926 log.error(e.getMessage(), e);
927 flag =
true;
928 }
finally {
929 redisService.returnResource(shardedJedis, flag);
930 }
931 return result;
932 }
933
934 public String spop(String key) {
935 ShardedJedis shardedJedis =
redisService.getRedisClient();
936 String result =
null;
937 if (shardedJedis ==
null) {
938 return result;
939 }
940 boolean flag =
false;
941 try {
942 result =
shardedJedis.spop(key);
943 }
catch (Exception e) {
944 log.error(e.getMessage(), e);
945 flag =
true;
946 }
finally {
947 redisService.returnResource(shardedJedis, flag);
948 }
949 return result;
950 }
951
952 public Long scard(String key) {
953 ShardedJedis shardedJedis =
redisService.getRedisClient();
954 Long result =
null;
955 if (shardedJedis ==
null) {
956 return result;
957 }
958 boolean flag =
false;
959 try {
960 result =
shardedJedis.scard(key);
961
962 }
catch (Exception e) {
963 log.error(e.getMessage(), e);
964 flag =
true;
965 }
finally {
966 redisService.returnResource(shardedJedis, flag);
967 }
968 return result;
969 }
970
971 public Boolean sismember(String key, String member) {
972 ShardedJedis shardedJedis =
redisService.getRedisClient();
973 Boolean result =
null;
974 if (shardedJedis ==
null) {
975 return result;
976 }
977 boolean flag =
false;
978 try {
979 result =
shardedJedis.sismember(key, member);
980 }
catch (Exception e) {
981 log.error(e.getMessage(), e);
982 flag =
true;
983 }
finally {
984 redisService.returnResource(shardedJedis, flag);
985 }
986 return result;
987 }
988
989 public String srandmember(String key) {
990 ShardedJedis shardedJedis =
redisService.getRedisClient();
991 String result =
null;
992 if (shardedJedis ==
null) {
993 return result;
994 }
995 boolean flag =
false;
996 try {
997 result =
shardedJedis.srandmember(key);
998 }
catch (Exception e) {
999 log.error(e.getMessage(), e);
1000 flag =
true;
1001 }
finally {
1002 redisService.returnResource(shardedJedis, flag);
1003 }
1004 return result;
1005 }
1006
1007 public Long zadd(String key,
double score, String member) {
1008 Long result =
null;
1009 ShardedJedis shardedJedis =
redisService.getRedisClient();
1010 if (shardedJedis ==
null) {
1011 return result;
1012 }
1013 boolean flag =
false;
1014 try {
1015 result =
shardedJedis.zadd(key, score, member);
1016 }
catch (Exception e) {
1017 log.error(e.getMessage(), e);
1018 flag =
true;
1019 }
finally {
1020 redisService.returnResource(shardedJedis, flag);
1021 }
1022 return result;
1023 }
1024
1025 public Set<String> zrange(String key,
int start,
int end) {
1026 Set<String> result =
null;
1027 ShardedJedis shardedJedis =
redisService.getRedisClient();
1028 if (shardedJedis ==
null) {
1029 return result;
1030 }
1031 boolean flag =
false;
1032 try {
1033 result =
shardedJedis.zrange(key, start, end);
1034 }
catch (Exception e) {
1035 log.error(e.getMessage(), e);
1036 flag =
true;
1037 }
finally {
1038 redisService.returnResource(shardedJedis, flag);
1039 }
1040 return result;
1041 }
1042
1043 public Long zrem(String key, String member) {
1044 Long result =
null;
1045 ShardedJedis shardedJedis =
redisService.getRedisClient();
1046 if (shardedJedis ==
null) {
1047 return result;
1048 }
1049 boolean flag =
false;
1050 try {
1051 result =
shardedJedis.zrem(key, member);
1052 }
catch (Exception e) {
1053 log.error(e.getMessage(), e);
1054 flag =
true;
1055 }
finally {
1056 redisService.returnResource(shardedJedis, flag);
1057 }
1058 return result;
1059 }
1060
1061 public Double zincrby(String key,
double score, String member) {
1062 Double result =
null;
1063 ShardedJedis shardedJedis =
redisService.getRedisClient();
1064 if (shardedJedis ==
null) {
1065 return result;
1066 }
1067 boolean flag =
false;
1068 try {
1069
1070 result =
shardedJedis.zincrby(key, score, member);
1071
1072 }
catch (Exception e) {
1073 log.error(e.getMessage(), e);
1074 flag =
true;
1075 }
finally {
1076 redisService.returnResource(shardedJedis, flag);
1077 }
1078 return result;
1079 }
1080
1081 public Long zrank(String key, String member) {
1082 Long result =
null;
1083 ShardedJedis shardedJedis =
redisService.getRedisClient();
1084 if (shardedJedis ==
null) {
1085 return result;
1086 }
1087 boolean flag =
false;
1088 try {
1089
1090 result =
shardedJedis.zrank(key, member);
1091
1092 }
catch (Exception e) {
1093 log.error(e.getMessage(), e);
1094 flag =
true;
1095 }
finally {
1096 redisService.returnResource(shardedJedis, flag);
1097 }
1098 return result;
1099 }
1100
1101 public Long zrevrank(String key, String member) {
1102 Long result =
null;
1103 ShardedJedis shardedJedis =
redisService.getRedisClient();
1104 if (shardedJedis ==
null) {
1105 return result;
1106 }
1107 boolean flag =
false;
1108 try {
1109
1110 result =
shardedJedis.zrevrank(key, member);
1111
1112 }
catch (Exception e) {
1113 log.error(e.getMessage(), e);
1114 flag =
true;
1115 }
finally {
1116 redisService.returnResource(shardedJedis, flag);
1117 }
1118 return result;
1119 }
1120
1121 public Set<String> zrevrange(String key,
int start,
int end) {
1122 Set<String> result =
null;
1123 ShardedJedis shardedJedis =
redisService.getRedisClient();
1124 if (shardedJedis ==
null) {
1125 return result;
1126 }
1127 boolean flag =
false;
1128 try {
1129
1130 result =
shardedJedis.zrevrange(key, start, end);
1131
1132 }
catch (Exception e) {
1133 log.error(e.getMessage(), e);
1134 flag =
true;
1135 }
finally {
1136 redisService.returnResource(shardedJedis, flag);
1137 }
1138 return result;
1139 }
1140
1141 public Set<Tuple> zrangeWithScores(String key,
int start,
int end) {
1142 Set<Tuple> result =
null;
1143 ShardedJedis shardedJedis =
redisService.getRedisClient();
1144 if (shardedJedis ==
null) {
1145 return result;
1146 }
1147 boolean flag =
false;
1148 try {
1149
1150 result =
shardedJedis.zrangeWithScores(key, start, end);
1151
1152 }
catch (Exception e) {
1153 log.error(e.getMessage(), e);
1154 flag =
true;
1155 }
finally {
1156 redisService.returnResource(shardedJedis, flag);
1157 }
1158 return result;
1159 }
1160
1161 public Set<Tuple> zrevrangeWithScores(String key,
int start,
int end) {
1162 Set<Tuple> result =
null;
1163 ShardedJedis shardedJedis =
redisService.getRedisClient();
1164 if (shardedJedis ==
null) {
1165 return result;
1166 }
1167 boolean flag =
false;
1168 try {
1169
1170 result =
shardedJedis.zrevrangeWithScores(key, start, end);
1171
1172 }
catch (Exception e) {
1173 log.error(e.getMessage(), e);
1174 flag =
true;
1175 }
finally {
1176 redisService.returnResource(shardedJedis, flag);
1177 }
1178 return result;
1179 }
1180
1181 public Long zcard(String key) {
1182 Long result =
null;
1183 ShardedJedis shardedJedis =
redisService.getRedisClient();
1184 if (shardedJedis ==
null) {
1185 return result;
1186 }
1187 boolean flag =
false;
1188 try {
1189
1190 result =
shardedJedis.zcard(key);
1191
1192 }
catch (Exception e) {
1193 log.error(e.getMessage(), e);
1194 flag =
true;
1195 }
finally {
1196 redisService.returnResource(shardedJedis, flag);
1197 }
1198 return result;
1199 }
1200
1201 public Double zscore(String key, String member) {
1202 Double result =
null;
1203 ShardedJedis shardedJedis =
redisService.getRedisClient();
1204 if (shardedJedis ==
null) {
1205 return result;
1206 }
1207 boolean flag =
false;
1208 try {
1209
1210 result =
shardedJedis.zscore(key, member);
1211
1212 }
catch (Exception e) {
1213 log.error(e.getMessage(), e);
1214 flag =
true;
1215 }
finally {
1216 redisService.returnResource(shardedJedis, flag);
1217 }
1218 return result;
1219 }
1220
1221 public List<String>
sort(String key) {
1222 List<String> result =
null;
1223 ShardedJedis shardedJedis =
redisService.getRedisClient();
1224 if (shardedJedis ==
null) {
1225 return result;
1226 }
1227 boolean flag =
false;
1228 try {
1229
1230 result =
shardedJedis.sort(key);
1231
1232 }
catch (Exception e) {
1233 log.error(e.getMessage(), e);
1234 flag =
true;
1235 }
finally {
1236 redisService.returnResource(shardedJedis, flag);
1237 }
1238 return result;
1239 }
1240
1241 public List<String>
sort(String key, SortingParams sortingParameters) {
1242 List<String> result =
null;
1243 ShardedJedis shardedJedis =
redisService.getRedisClient();
1244 if (shardedJedis ==
null) {
1245 return result;
1246 }
1247 boolean flag =
false;
1248 try {
1249
1250 result =
shardedJedis.sort(key, sortingParameters);
1251
1252 }
catch (Exception e) {
1253 log.error(e.getMessage(), e);
1254 flag =
true;
1255 }
finally {
1256 redisService.returnResource(shardedJedis, flag);
1257 }
1258 return result;
1259 }
1260
1261 public Long zcount(String key,
double min,
double max) {
1262 Long result =
null;
1263 ShardedJedis shardedJedis =
redisService.getRedisClient();
1264 if (shardedJedis ==
null) {
1265 return result;
1266 }
1267 boolean flag =
false;
1268 try {
1269
1270 result =
shardedJedis.zcount(key, min, max);
1271
1272 }
catch (Exception e) {
1273 log.error(e.getMessage(), e);
1274 flag =
true;
1275 }
finally {
1276 redisService.returnResource(shardedJedis, flag);
1277 }
1278 return result;
1279 }
1280
1281 public Set<String> zrangeByScore(String key,
double min,
double max) {
1282 Set<String> result =
null;
1283 ShardedJedis shardedJedis =
redisService.getRedisClient();
1284 if (shardedJedis ==
null) {
1285 return result;
1286 }
1287 boolean flag =
false;
1288 try {
1289
1290 result =
shardedJedis.zrangeByScore(key, min, max);
1291
1292 }
catch (Exception e) {
1293 log.error(e.getMessage(), e);
1294 flag =
true;
1295 }
finally {
1296 redisService.returnResource(shardedJedis, flag);
1297 }
1298 return result;
1299 }
1300
1301 public Set<String> zrevrangeByScore(String key,
double max,
double min) {
1302 Set<String> result =
null;
1303 ShardedJedis shardedJedis =
redisService.getRedisClient();
1304 if (shardedJedis ==
null) {
1305 return result;
1306 }
1307 boolean flag =
false;
1308 try {
1309
1310 result =
shardedJedis.zrevrangeByScore(key, max, min);
1311
1312 }
catch (Exception e) {
1313 log.error(e.getMessage(), e);
1314 flag =
true;
1315 }
finally {
1316 redisService.returnResource(shardedJedis, flag);
1317 }
1318 return result;
1319 }
1320
1321 public Set<String> zrangeByScore(String key,
double min,
double max,
1322 int offset,
int count) {
1323 Set<String> result =
null;
1324 ShardedJedis shardedJedis =
redisService.getRedisClient();
1325 if (shardedJedis ==
null) {
1326 return result;
1327 }
1328 boolean flag =
false;
1329 try {
1330
1331 result =
shardedJedis.zrangeByScore(key, min, max, offset, count);
1332
1333 }
catch (Exception e) {
1334 log.error(e.getMessage(), e);
1335 flag =
true;
1336 }
finally {
1337 redisService.returnResource(shardedJedis, flag);
1338 }
1339 return result;
1340 }
1341
1342 public Set<String> zrevrangeByScore(String key,
double max,
double min,
1343 int offset,
int count) {
1344 Set<String> result =
null;
1345 ShardedJedis shardedJedis =
redisService.getRedisClient();
1346 if (shardedJedis ==
null) {
1347 return result;
1348 }
1349 boolean flag =
false;
1350 try {
1351
1352 result =
shardedJedis
1353 .zrevrangeByScore(key, max, min, offset, count);
1354
1355 }
catch (Exception e) {
1356 log.error(e.getMessage(), e);
1357 flag =
true;
1358 }
finally {
1359 redisService.returnResource(shardedJedis, flag);
1360 }
1361 return result;
1362 }
1363
1364 public Set<Tuple> zrangeByScoreWithScores(String key,
double min,
double max) {
1365 Set<Tuple> result =
null;
1366 ShardedJedis shardedJedis =
redisService.getRedisClient();
1367 if (shardedJedis ==
null) {
1368 return result;
1369 }
1370 boolean flag =
false;
1371 try {
1372
1373 result =
shardedJedis.zrangeByScoreWithScores(key, min, max);
1374
1375 }
catch (Exception e) {
1376 log.error(e.getMessage(), e);
1377 flag =
true;
1378 }
finally {
1379 redisService.returnResource(shardedJedis, flag);
1380 }
1381 return result;
1382 }
1383
1384 public Set<Tuple> zrevrangeByScoreWithScores(String key,
double max,
1385 double min) {
1386 Set<Tuple> result =
null;
1387 ShardedJedis shardedJedis =
redisService.getRedisClient();
1388 if (shardedJedis ==
null) {
1389 return result;
1390 }
1391 boolean flag =
false;
1392 try {
1393
1394 result =
shardedJedis.zrevrangeByScoreWithScores(key, max, min);
1395
1396 }
catch (Exception e) {
1397 log.error(e.getMessage(), e);
1398 flag =
true;
1399 }
finally {
1400 redisService.returnResource(shardedJedis, flag);
1401 }
1402 return result;
1403 }
1404
1405 public Set<Tuple> zrangeByScoreWithScores(String key,
double min,
1406 double max,
int offset,
int count) {
1407 Set<Tuple> result =
null;
1408 ShardedJedis shardedJedis =
redisService.getRedisClient();
1409 if (shardedJedis ==
null) {
1410 return result;
1411 }
1412 boolean flag =
false;
1413 try {
1414
1415 result =
shardedJedis.zrangeByScoreWithScores(key, min, max,
1416 offset, count);
1417
1418 }
catch (Exception e) {
1419 log.error(e.getMessage(), e);
1420 flag =
true;
1421 }
finally {
1422 redisService.returnResource(shardedJedis, flag);
1423 }
1424 return result;
1425 }
1426
1427 public Set<Tuple> zrevrangeByScoreWithScores(String key,
double max,
1428 double min,
int offset,
int count) {
1429 Set<Tuple> result =
null;
1430 ShardedJedis shardedJedis =
redisService.getRedisClient();
1431 if (shardedJedis ==
null) {
1432 return result;
1433 }
1434 boolean flag =
false;
1435 try {
1436
1437 result =
shardedJedis.zrevrangeByScoreWithScores(key, max, min,
1438 offset, count);
1439
1440 }
catch (Exception e) {
1441 log.error(e.getMessage(), e);
1442 flag =
true;
1443 }
finally {
1444 redisService.returnResource(shardedJedis, flag);
1445 }
1446 return result;
1447 }
1448
1449 public Long zremrangeByRank(String key,
int start,
int end) {
1450 Long result =
null;
1451 ShardedJedis shardedJedis =
redisService.getRedisClient();
1452 if (shardedJedis ==
null) {
1453 return result;
1454 }
1455 boolean flag =
false;
1456 try {
1457
1458 result =
shardedJedis.zremrangeByRank(key, start, end);
1459
1460 }
catch (Exception e) {
1461 log.error(e.getMessage(), e);
1462 flag =
true;
1463 }
finally {
1464 redisService.returnResource(shardedJedis, flag);
1465 }
1466 return result;
1467 }
1468
1469 public Long zremrangeByScore(String key,
double start,
double end) {
1470 Long result =
null;
1471 ShardedJedis shardedJedis =
redisService.getRedisClient();
1472 if (shardedJedis ==
null) {
1473 return result;
1474 }
1475 boolean flag =
false;
1476 try {
1477
1478 result =
shardedJedis.zremrangeByScore(key, start, end);
1479
1480 }
catch (Exception e) {
1481 log.error(e.getMessage(), e);
1482 flag =
true;
1483 }
finally {
1484 redisService.returnResource(shardedJedis, flag);
1485 }
1486 return result;
1487 }
1488
1489 public Long linsert(String key, LIST_POSITION where, String pivot,
1490 String value) {
1491 Long result =
null;
1492 ShardedJedis shardedJedis =
redisService.getRedisClient();
1493 if (shardedJedis ==
null) {
1494 return result;
1495 }
1496 boolean flag =
false;
1497 try {
1498
1499 result =
shardedJedis.linsert(key, where, pivot, value);
1500
1501 }
catch (Exception e) {
1502 log.error(e.getMessage(), e);
1503 flag =
true;
1504 }
finally {
1505 redisService.returnResource(shardedJedis, flag);
1506 }
1507 return result;
1508 }
1509
1510
1511 @SuppressWarnings("deprecation"
)
1512 public List<Object>
pipelined(ShardedJedisPipeline shardedJedisPipeline) {
1513 ShardedJedis shardedJedis =
redisService.getRedisClient();
1514 List<Object> result =
null;
1515 if (shardedJedis ==
null) {
1516 return result;
1517 }
1518 boolean flag =
false;
1519 try {
1520 result =
shardedJedis.pipelined(shardedJedisPipeline);
1521 }
catch (Exception e) {
1522 log.error(e.getMessage(), e);
1523 flag =
true;
1524 }
finally {
1525 redisService.returnResource(shardedJedis, flag);
1526 }
1527 return result;
1528 }
1529
1530 public Jedis getShard(String key) {
1531 ShardedJedis shardedJedis =
redisService.getRedisClient();
1532 Jedis result =
null;
1533 if (shardedJedis ==
null) {
1534 return result;
1535 }
1536 boolean flag =
false;
1537 try {
1538 result =
shardedJedis.getShard(key);
1539 }
catch (Exception e) {
1540 log.error(e.getMessage(), e);
1541 flag =
true;
1542 }
finally {
1543 redisService.returnResource(shardedJedis, flag);
1544 }
1545 return result;
1546 }
1547
1548 public JedisShardInfo getShardInfo(String key) {
1549 ShardedJedis shardedJedis =
redisService.getRedisClient();
1550 JedisShardInfo result =
null;
1551 if (shardedJedis ==
null) {
1552 return result;
1553 }
1554 boolean flag =
false;
1555 try {
1556 result =
shardedJedis.getShardInfo(key);
1557 }
catch (Exception e) {
1558 log.error(e.getMessage(), e);
1559 flag =
true;
1560 }
finally {
1561 redisService.returnResource(shardedJedis, flag);
1562 }
1563 return result;
1564 }
1565
1566 public String getKeyTag(String key) {
1567 ShardedJedis shardedJedis =
redisService.getRedisClient();
1568 String result =
null;
1569 if (shardedJedis ==
null) {
1570 return result;
1571 }
1572 boolean flag =
false;
1573 try {
1574 result =
shardedJedis.getKeyTag(key);
1575 }
catch (Exception e) {
1576 log.error(e.getMessage(), e);
1577 flag =
true;
1578 }
finally {
1579 redisService.returnResource(shardedJedis, flag);
1580 }
1581 return result;
1582 }
1583
1584 public Collection<JedisShardInfo>
getAllShardInfo() {
1585 ShardedJedis shardedJedis =
redisService.getRedisClient();
1586 Collection<JedisShardInfo> result =
null;
1587 if (shardedJedis ==
null) {
1588 return result;
1589 }
1590 boolean flag =
false;
1591 try {
1592 result =
shardedJedis.getAllShardInfo();
1593
1594 }
catch (Exception e) {
1595 log.error(e.getMessage(), e);
1596 flag =
true;
1597 }
finally {
1598 redisService.returnResource(shardedJedis, flag);
1599 }
1600 return result;
1601 }
1602
1603 public Collection<Jedis>
getAllShards() {
1604 ShardedJedis shardedJedis =
redisService.getRedisClient();
1605 Collection<Jedis> result =
null;
1606 if (shardedJedis ==
null) {
1607 return result;
1608 }
1609 boolean flag =
false;
1610 try {
1611 result =
shardedJedis.getAllShards();
1612
1613 }
catch (Exception e) {
1614 log.error(e.getMessage(), e);
1615 flag =
true;
1616 }
finally {
1617 redisService.returnResource(shardedJedis, flag);
1618 }
1619 return result;
1620 }
1621
1622 }
View Code
使用的时候，直接调用此类中对应的方法即可。
Redis的内部实现是C写的，有必要好好看看里面究竟是怎么实现的。
6 参考
(1)Redis和MongoDB比较：
http://taotao1240.blog.51cto.com/731446/755173
(2)Redis官方下载地址：
http://redis.cn/download.html
(3) 按键通知事件
http://redis.mjplay.com.cn/topic/notification.html
(4)Redis内部实现
http://www.redisbook.com/en/latest/
(5)Redis持久化
http://blog.nosqlfan.com/html/3813.html
(6)Redis的AOF详细解读
http://www.wzxue.com/redis%E6%A0%B8%E5%BF%83%E8%A7%A3%E8%AF%BB-aof%E4%B8%8Erewrite%E6%9C%BA%E5%88%B6/
(7)Redis失效机制解析
http://blog.nosqlfan.com/html/4218.html
(8)Redis命令列表
http://redis.cn/commands.html
(9)Redis应用场景
http://www.coderli.com/redis-application-scenarios
(10)Jedis下载地址：
https://github.com/xetorthio/jedis
-------------------------------------------------------------------------------
如果您看了本篇博客,觉得对您有所收获，请点击右下角的 [推荐]
如果您想转载本博客，请注明出处
如果您对本文有意见或者建议，欢迎留言
感谢您的阅读，请关注我的后续博客
http://www.htsjk.com/redis/10489.html
www.htsjk.Com
true
http://www.htsjk.com/redis/10489.html
NewsArticle
Redis学习， 1 概述 目前多数的NoSql数据库本质上都是键值对形式，Redis也不例外。作为缓存数据库的一种，和Memcached相比，有以下几种主要的优点： (1)速度上，Redis要比Memcached快，这是基...
本站文章为和通数据库网友分享或者投稿，欢迎任何形式的转载，但请务必注明出处.
同时文章内容如有侵犯了您的权益，请联系QQ：970679559，我们会在尽快处理。