zoukankan      html  css  js  c++  java
  • 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

    -------------------------------------------------------------------------------

    如果您看了本篇博客,觉得对您有所收获,请点击右下角的 [推荐]

    如果您想转载本博客,请注明出处

    如果您对本文有意见或者建议,欢迎留言

    感谢您的阅读,请关注我的后续博客

  • 相关阅读:
    代码分层之模拟servlet调用dao
    Request对象和Response对象
    jquery-动画
    jquery-easyui
    phpcms
    Ajax做分页
    phpcms安装
    cms替换主页的步骤
    php 复习
    登录验证——————生成随机数
  • 原文地址:https://www.cnblogs.com/Scott007/p/3565529.html
Copyright © 2011-2022 走看看