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 }
使用的时候，直接调用此类中对应的方法即可。
Redis的内部实现是C写的，有必要好好看看里面究竟是怎么实现的。
6 参考
(1)Redis和MongoDB比较：
http://taotao1240.blog.51cto.com/731446/755173
(2)Redis官方下载地址：
(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详细解读
(7)Redis失效机制解析
http://blog.nosqlfan.com/html/4218.html
(8)Redis命令列表
(9)Redis应用场景
http://www.coderli.com/redis-application-scenarios
(10)Jedis下载地址：
https://github.com/xetorthio/jedis
-------------------------------------------------------------------------------
如果您看了本篇博客,觉得对您有所收获，请点击右下角的 [推荐]
如果您想转载本博客，请注明出处
如果您对本文有意见或者建议，欢迎留言
感谢您的阅读，请关注我的后续博客