} } }

    spring和redis的整合-超出昨天的本身系列(7)

    添加时间:2013-7-29 点击量:

    超出昨天的本身系列(7)


     扯淡:


       比来一向在慢慢多进修各个组件,本身搭建出一些设法。是一个浏览的过程,慢慢意识到常识是可以融汇贯通,触类旁通的,不过前提如同是研究的斗劲深,有了本身的见地。自认为进修才能不咋地,速度慢不说,还轻易放弃,大多半时辰都是回头捡起来补的那种景象。


      所以,我想:自我把守的才能是否决意了一小我进修的高度,也限制了见识的高度呢?


      跟着年数的增长,越来越感觉进修常识的那种急迫性,专业方面的,自我教养方面的,都须要急迫的获得满足。我知道很多人其实已经放弃看书了,根蒂根基刷刷微博,看看消息,就满足本身的浏览了。但有时辰,静下心来的时辰,很本身的内心上什么也没有,懊悔本身没种棵树,或掘口井什么的。


      不知道你们是否有如许的感触感染?



    主题:(以下例子都应用maven构建)


      redis的常识:官网


      1,哄骗spring-data-redis整合


      项目应用的pom.xml:




    <project xmlns=http://maven.apache.org/POM/4.0.0 xmlns:xsi=http://www.w3.org/2001/XMLSchema-instance
    
    xsi:schemaLocation
    =http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd>
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.x.redis</groupId>
    <artifactId>Spring_redis</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>Spring_redis</name>
    <url>http://maven.apache.org</url>

    <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
    <dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-redis</artifactId>
    <version>1.0.2.RELEASE</version>
    </dependency>
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>3.1.2.RELEASE</version>
    </dependency>


    <dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>2.1.0</version>
    </dependency>

    <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.8.2</version>
    <scope>test</scope>
    </dependency>
    <dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.6.1</version>
    </dependency>
    <!-- 将现有的jakarta commons logging的调用转换成lsf4j的调用。 -->
    <dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>jcl-over-slf4j</artifactId>
    <version>1.6.1</version>
    </dependency>
    <!-- Hack:确保commons-logging的jar包不被引入,不然将和jcl-over-slf4j冲突 -->
    <dependency>
    <groupId>commons-logging</groupId>
    <artifactId>commons-logging</artifactId>
    <version>1.1.1</version>
    <scope>provided</scope>
    </dependency>
    <!-- slf4j的实现:logback,用来庖代log4j。更快、更强! -->
    <dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>0.9.24</version>
    <scope>runtime</scope>
    </dependency>
    </dependencies>
    </project>


    View Code

      除了log项目组,只有一个spring core 和 spring-data-redis了


      项目文件目次布局:


      


      


      applicationContext.xml:


      1,context:property-placeholder 标签用来导入properties文件。从而调换¥{redis.maxIdle}如许的变量。


      2,context:component-scan 是为了在com.x.redis.dao报下的类可以或许实用spring的注解注入的体式格式。


      3,事实上我们只须要把JedisPoolConfig配数来就好了,接下来就是spring的封装了。所以直接看UserDAOImpl的实现就熟悉打听了。



    <?xml version=1.0 encoding=UTF-8?>  
    
    <beans xmlns=http://www.springframework.org/schema/beans
    xmlns:xsi
    =http://www.w3.org/2001/XMLSchema-instance xmlns:p=http://www.springframework.org/schema/p
    xmlns:context
    =http://www.springframework.org/schema/context
    xmlns:jee
    =http://www.springframework.org/schema/jee xmlns:tx=http://www.springframework.org/schema/tx
    xmlns:aop
    =http://www.springframework.org/schema/aop
    xsi:schemaLocation
    =
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
    >

    <context:property-placeholder location=classpath:redis.properties />
    <context:component-scan base-package=com.x.redis.dao>
    </context:component-scan>
    <bean id=poolConfig class=redis.clients.jedis.JedisPoolConfig>
    <property name=maxIdle value=¥{redis.maxIdle} />
    <property name=maxActive value=¥{redis.maxActive} />
    <property name=maxWait value=¥{redis.maxWait} />
    <property name=testOnBorrow value=¥{redis.testOnBorrow} />
    </bean>

    <bean id=connectionFactory class=org.springframework.data.redis.connection.jedis.JedisConnectionFactory
    p:host-name
    =¥{redis.host} p:port=¥{redis.port} p:password=¥{redis.pass} p:pool-config-ref=poolConfig/>

    <bean id=redisTemplate class=org.springframework.data.redis.core.StringRedisTemplate>
    <property name=connectionFactory ref=connectionFactory />
    </bean>

    <bean id=userDAO class=com.x.redis.dao.impl.UserDAOImpl />
    </beans>


      redis.properties:




    # Redis settings
    
    #redis.host=192.168.20.101
    #redis.port=6380
    #redis.pass=foobared
    redis.host=127.0.0.1
    redis.port=6379
    redis.pass=

    redis.maxIdle=300
    redis.maxActive=600
    redis.maxWait=1000
    redis.testOnBorrow=true


    View Code


      UserDAOImpl:


      1,spring对dao层的封装很多用了类似于下面代码的模板体式格式。


      2,RedisTemplate就是spring对redis的一个封装罢了。



    public class UserDAOImpl implements UserDAO {
    

    @Autowired
    protected RedisTemplate<Serializable, Serializable> redisTemplate;

    public void saveUser(final User user) {
    redisTemplate.execute(
    new RedisCallback<Object>() {

    @Override
    public Object doInRedis(RedisConnection connection) throws DataAccessException {
    connection.set(redisTemplate.getStringSerializer().serialize(
    user.uid. + user.getId()),
    redisTemplate.getStringSerializer().serialize(user.getName()));
    return null;
    }
    });
    }

    @Override
    public User getUser(final long id) {
    return redisTemplate.execute(new RedisCallback<User>() {
    @Override
    public User doInRedis(RedisConnection connection) throws DataAccessException {
    byte[] key = redisTemplate.getStringSerializer().serialize(user.uid. + id);
    if (connection.exists(key)) {
    byte[] value = connection.get(key);
    String name
    = redisTemplate.getStringSerializer().deserialize(value);
    User user
    = new User();
    user.setName(name);
    user.setId(id);
    return user;
    }
    return null;
    }
    });
    }

    }


      其他:


      User:




    public class User {
    

    private long id;
    private String name;

    public long getId() {
    return id;
    }

    public void setId(long id) {
    this.id = id;
    }

    public String getName() {
    return name;
    }

    public void setName(String name) {
    this.name = name;
    }
    }


    View Code

      测试代码:



        public static void main(String[] args) {
    
    ApplicationContext ac
    = new ClassPathXmlApplicationContext(classpath:/applicationContext.xml);
    UserDAO userDAO
    = (UserDAO)ac.getBean(userDAO);
    User user1
    = new User();
    user1.setId(
    1);
    user1.setName(
    obama);
    userDAO.saveUser(user1);
    User user2
    = userDAO.getUser(1);
    System.out.println(user2.getName());
    }



      2,晦气用spring-data-redis整合


      小我感觉如许整合灵活度更大,可以或许加倍了然的完成任务。


      pom.xml:




    <project xmlns=http://maven.apache.org/POM/4.0.0 xmlns:xsi=http://www.w3.org/2001/XMLSchema-instance
    
    xsi:schemaLocation
    =http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd>
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.d.work</groupId>
    <artifactId>Redis_Templete</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>Redis_Templete</name>
    <url>http://maven.apache.org</url>

    <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
    <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>3.8.1</version>
    <scope>test</scope>
    </dependency>
    <dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>2.1.0</version>
    </dependency>
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>3.1.2.RELEASE</version>
    </dependency>
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-beans</artifactId>
    <version>3.1.2.RELEASE</version>
    </dependency>
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>3.1.2.RELEASE</version>
    </dependency>
    <dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.6.1</version>
    </dependency>
    <!-- 将现有的jakarta commons logging的调用转换成lsf4j的调用。 -->
    <dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>jcl-over-slf4j</artifactId>
    <version>1.6.1</version>
    </dependency>
    <!-- Hack:确保commons-logging的jar包不被引入,不然将和jcl-over-slf4j冲突 -->
    <dependency>
    <groupId>commons-logging</groupId>
    <artifactId>commons-logging</artifactId>
    <version>1.1.1</version>
    <scope>provided</scope>
    </dependency>
    <!-- slf4j的实现:logback,用来庖代log4j。更快、更强! -->
    <dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>0.9.24</version>
    <scope>runtime</scope>
    </dependency>
    </dependencies>
    </project>


    View Code

      目次布局:


      


      data-source.xml


      1,context:property-placeholder 和 context:component-scan 前面申明过啦。


      2,设备了一个ShardedJedisPool,在jdeis里 还有个JedisPool。这两个的差别:


        一个是分片情势,可以连接有主备的redis办事端,一个是单个的。具体后续进修

     

      3,因为不应用spring-data-redis的封装,所以本身要本身封装一个


    <?xml version=1.0 encoding=UTF-8?>  
    
    <beans xmlns=http://www.springframework.org/schema/beans
    xmlns:xsi
    =http://www.w3.org/2001/XMLSchema-instance xmlns:p=http://www.springframework.org/schema/p
    xmlns:context
    =http://www.springframework.org/schema/context
    xmlns:jee
    =http://www.springframework.org/schema/jee xmlns:tx=http://www.springframework.org/schema/tx
    xmlns:aop
    =http://www.springframework.org/schema/aop
    xsi:schemaLocation
    =
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
    >

    <context:property-placeholder location=classpath:redis.properties />
    <context:component-scan base-package=com.d.work.main>
    </context:component-scan>
    <context:component-scan base-package=com.d.work.redis>
    </context:component-scan>
    <bean id=jedisPoolConfig class=redis.clients.jedis.JedisPoolConfig>
    <property name=maxActive value=50 />
    <property name=maxIdle value=8 />
    <property name=maxWait value=1000 />
    <property name=testOnBorrow value=true/>
    <property name=testOnReturn value=true/>
    <!-- <property name=testWhileIdle value=true/> -->
    </bean>

    <bean id=shardedJedisPool class=redis.clients.jedis.ShardedJedisPool scope=singleton>
    <constructor-arg index=0 ref=jedisPoolConfig />
    <constructor-arg index=1>
    <list>
    <bean class=redis.clients.jedis.JedisShardInfo>
    <constructor-arg name=host value=¥{redis.host} />
    <constructor-arg name=port value=¥{redis.port} />
    <constructor-arg name=timeout value=¥{redis.timeout} />
    <constructor-arg name=weight value=1 />
    </bean>
    </list>
    </constructor-arg>
    </bean>
    </beans>



    RedisDataSource:定义三个办法



    public interface RedisDataSource {
    
    public abstract ShardedJedis getRedisClient();
    public void returnResource(ShardedJedis shardedJedis);
    public void returnResource(ShardedJedis shardedJedis,boolean broken);
    }



    实现redisDataSource:


    1, 注入设备好的ShardedJedisPool,这三个办法的感化:



    getRedisClient()取得redis的客户端,可以履行号令了。

    returnResource(ShardedJedis shardedJedis)将资料返还给pool

    returnResource(ShardedJedis shardedJedis, boolean broken) : 呈现异常后,将资料返还给pool (其实不须要第二个办法)



    @Repository(redisDataSource
    public class RedisDataSourceImpl implements RedisDataSource {

    private static final Logger log = LoggerFactory.getLogger(RedisDataSourceImpl.class);

    @Autowired
    private ShardedJedisPool shardedJedisPool;

    public ShardedJedis getRedisClient() {
    try {
    ShardedJedis shardJedis
    = shardedJedisPool.getResource();
    return shardJedis;
    }
    catch (Exception e) {
    log.error(
    getRedisClent error, e);
    }
    return null;
    }

    public void returnResource(ShardedJedis shardedJedis) {
    shardedJedisPool.returnResource(shardedJedis);
    }

    public void returnResource(ShardedJedis shardedJedis, boolean broken) {
    if (broken) {
    shardedJedisPool.returnBrokenResource(shardedJedis);
    }
    else {
    shardedJedisPool.returnResource(shardedJedis);
    }
    }
    }



    第二层的封装:RedisClientTemplate,例子实现了放值和取值。最后代码供给了全部号令的实现。


      代码就是映射性质的又一次调用jedis的办法罢了,用了个broken来做标示符,决意返还资料的体式格式。


      这一层的目标首要也是让再上层的调用不须要关怀pool中链接的取得和返还题目了。



    @Repository(redisClientTemplate
    public class RedisClientTemplate {

    private static final Logger log = LoggerFactory.getLogger(RedisClientTemplate.class);

    @Autowired
    private RedisDataSource redisDataSource;

    public void disconnect() {
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    shardedJedis.disconnect();
    }

    /
    设置单个值

    @param key
    @param value
    @return
    /
    public String set(String key, String value) {
    String result
    = null;

    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.set(key, value);
    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    /
    获取单个值

    @param key
    @return
    /
    public String get(String key) {
    String result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }

    boolean broken = false;
    try {
    result
    = shardedJedis.get(key);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }
    }


    测试代码:



        public static void main(String[] args) {
    
    ApplicationContext ac
    = new ClassPathXmlApplicationContext(classpath:/data-source.xml);
    RedisClientTemplate redisClient
    = (RedisClientTemplate)ac.getBean(redisClientTemplate);
    redisClient.set(
    a, abc);
    System.out.println(redisClient.get(
    a));
    }


    附上RedisClientTemplate全部实现:




    @Repository(redisClientTemplate
    public class RedisClientTemplate {

    private static final Logger log = LoggerFactory.getLogger(RedisClientTemplate.class);

    @Autowired
    private RedisDataSource redisDataSource;

    public void disconnect() {
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    shardedJedis.disconnect();
    }

    /
    设置单个值

    @param key
    @param value
    @return
    /
    public String set(String key, String value) {
    String result
    = null;

    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.set(key, value);
    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    /
    获取单个值

    @param key
    @return
    /
    public String get(String key) {
    String result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }

    boolean broken = false;
    try {
    result
    = shardedJedis.get(key);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Boolean exists(String key) {
    Boolean result
    = false;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.exists(key);
    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public String type(String key) {
    String result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.type(key);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    /
    在某段时候后实现

    @param key
    @param unixTime
    @return
    /
    public Long expire(String key, int seconds) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.expire(key, seconds);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    /
    在某个时候点失效

    @param key
    @param unixTime
    @return
    /
    public Long expireAt(String key, long unixTime) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.expireAt(key, unixTime);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long ttl(String key) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.ttl(key);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public boolean setbit(String key, long offset, boolean value) {

    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    boolean result = false;
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.setbit(key, offset, value);
    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public boolean getbit(String key, long offset) {
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    boolean result = false;
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;

    try {
    result
    = shardedJedis.getbit(key, offset);
    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public long setrange(String key, long offset, String value) {
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    long result = 0;
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.setrange(key, offset, value);
    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public String getrange(String key, long startOffset, long endOffset) {
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    String result
    = null;
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.getrange(key, startOffset, endOffset);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public String getSet(String key, String value) {
    String result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.getSet(key, value);
    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long setnx(String key, String value) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.setnx(key, value);
    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public String setex(String key, int seconds, String value) {
    String result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.setex(key, seconds, value);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long decrBy(String key, long integer) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.decrBy(key, integer);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long decr(String key) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.decr(key);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long incrBy(String key, long integer) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.incrBy(key, integer);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long incr(String key) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.incr(key);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long append(String key, String value) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.append(key, value);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public String substr(String key, int start, int end) {
    String result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.substr(key, start, end);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long hset(String key, String field, String value) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.hset(key, field, value);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public String hget(String key, String field) {
    String result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.hget(key, field);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long hsetnx(String key, String field, String value) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.hsetnx(key, field, value);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public String hmset(String key, Map<String, String> hash) {
    String result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.hmset(key, hash);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public List<String> hmget(String key, String... fields) {
    List
    <String> result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.hmget(key, fields);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long hincrBy(String key, String field, long value) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.hincrBy(key, field, value);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Boolean hexists(String key, String field) {
    Boolean result
    = false;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.hexists(key, field);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long del(String key) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.del(key);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long hdel(String key, String field) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.hdel(key, field);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long hlen(String key) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.hlen(key);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Set<String> hkeys(String key) {
    Set
    <String> result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.hkeys(key);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public List<String> hvals(String key) {
    List
    <String> result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.hvals(key);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Map<String, String> hgetAll(String key) {
    Map
    <String, String> result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.hgetAll(key);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    // ================list ====== l默示 list或 left, r默示right====================
    public Long rpush(String key, String string) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.rpush(key, string);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long lpush(String key, String string) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.lpush(key, string);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long llen(String key) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.llen(key);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public List<String> lrange(String key, long start, long end) {
    List
    <String> result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.lrange(key, start, end);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public String ltrim(String key, long start, long end) {
    String result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.ltrim(key, start, end);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public String lindex(String key, long index) {
    String result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.lindex(key, index);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public String lset(String key, long index, String value) {
    String result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.lset(key, index, value);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long lrem(String key, long count, String value) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.lrem(key, count, value);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public String lpop(String key) {
    String result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.lpop(key);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public String rpop(String key) {
    String result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.rpop(key);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    //return 1 add a not exist value ,
    //return 0 add a exist value
    public Long sadd(String key, String member) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.sadd(key, member);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Set<String> smembers(String key) {
    Set
    <String> result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.smembers(key);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long srem(String key, String member) {
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();

    Long result
    = null;
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.srem(key, member);
    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public String spop(String key) {
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    String result
    = null;
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.spop(key);
    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long scard(String key) {
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    Long result
    = null;
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.scard(key);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Boolean sismember(String key, String member) {
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    Boolean result
    = null;
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.sismember(key, member);
    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public String srandmember(String key) {
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    String result
    = null;
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.srandmember(key);
    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long zadd(String key, double score, String member) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.zadd(key, score, member);
    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Set<String> zrange(String key, int start, int end) {
    Set
    <String> result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.zrange(key, start, end);
    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long zrem(String key, String member) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.zrem(key, member);
    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Double zincrby(String key, double score, String member) {
    Double result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.zincrby(key, score, member);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long zrank(String key, String member) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.zrank(key, member);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long zrevrank(String key, String member) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.zrevrank(key, member);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Set<String> zrevrange(String key, int start, int end) {
    Set
    <String> result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.zrevrange(key, start, end);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Set<Tuple> zrangeWithScores(String key, int start, int end) {
    Set
    <Tuple> result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.zrangeWithScores(key, start, end);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Set<Tuple> zrevrangeWithScores(String key, int start, int end) {
    Set
    <Tuple> result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.zrevrangeWithScores(key, start, end);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long zcard(String key) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.zcard(key);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Double zscore(String key, String member) {
    Double result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.zscore(key, member);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public List<String> sort(String key) {
    List
    <String> result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.sort(key);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public List<String> sort(String key, SortingParams sortingParameters) {
    List
    <String> result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.sort(key, sortingParameters);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long zcount(String key, double min, double max) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.zcount(key, min, max);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Set<String> zrangeByScore(String key, double min, double max) {
    Set
    <String> result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.zrangeByScore(key, min, max);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Set<String> zrevrangeByScore(String key, double max, double min) {
    Set
    <String> result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.zrevrangeByScore(key, max, min);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Set<String> zrangeByScore(String key, double min, double max, int offset, int count) {
    Set
    <String> result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.zrangeByScore(key, min, max, offset, count);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Set<String> zrevrangeByScore(String key, double max, double min, int offset, int count) {
    Set
    <String> result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.zrevrangeByScore(key, max, min, offset, count);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Set<Tuple> zrangeByScoreWithScores(String key, double min, double max) {
    Set
    <Tuple> result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.zrangeByScoreWithScores(key, min, max);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Set<Tuple> zrevrangeByScoreWithScores(String key, double max, double min) {
    Set
    <Tuple> result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.zrevrangeByScoreWithScores(key, max, min);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Set<Tuple> zrangeByScoreWithScores(String key, double min, double max, int offset, int count) {
    Set
    <Tuple> result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.zrangeByScoreWithScores(key, min, max, offset, count);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Set<Tuple> zrevrangeByScoreWithScores(String key, double max, double min, int offset, int count) {
    Set
    <Tuple> result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.zrevrangeByScoreWithScores(key, max, min, offset, count);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long zremrangeByRank(String key, int start, int end) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.zremrangeByRank(key, start, end);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long zremrangeByScore(String key, double start, double end) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.zremrangeByScore(key, start, end);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long l(String key, LIST_POSITION where, String pivot, String value) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.l(key, where, pivot, value);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public String set(byte[] key, byte[] value) {
    String result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.set(key, value);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public byte[] get(byte[] key) {
    byte[] result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.get(key);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Boolean exists(byte[] key) {
    Boolean result
    = false;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.exists(key);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public String type(byte[] key) {
    String result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.type(key);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long expire(byte[] key, int seconds) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.expire(key, seconds);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long expireAt(byte[] key, long unixTime) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.expireAt(key, unixTime);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long ttl(byte[] key) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.ttl(key);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public byte[] getSet(byte[] key, byte[] value) {
    byte[] result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.getSet(key, value);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long setnx(byte[] key, byte[] value) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.setnx(key, value);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public String setex(byte[] key, int seconds, byte[] value) {
    String result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.setex(key, seconds, value);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long decrBy(byte[] key, long integer) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.decrBy(key, integer);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long decr(byte[] key) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.decr(key);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long incrBy(byte[] key, long integer) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.incrBy(key, integer);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long incr(byte[] key) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.incr(key);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long append(byte[] key, byte[] value) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.append(key, value);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public byte[] substr(byte[] key, int start, int end) {
    byte[] result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.substr(key, start, end);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long hset(byte[] key, byte[] field, byte[] value) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.hset(key, field, value);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public byte[] hget(byte[] key, byte[] field) {
    byte[] result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.hget(key, field);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long hsetnx(byte[] key, byte[] field, byte[] value) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.hsetnx(key, field, value);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public String hmset(byte[] key, Map<byte[], byte[]> hash) {
    String result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.hmset(key, hash);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public List<byte[]> hmget(byte[] key, byte[]... fields) {
    List
    <byte[]> result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.hmget(key, fields);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long hincrBy(byte[] key, byte[] field, long value) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.hincrBy(key, field, value);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Boolean hexists(byte[] key, byte[] field) {
    Boolean result
    = false;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.hexists(key, field);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long hdel(byte[] key, byte[] field) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.hdel(key, field);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long hlen(byte[] key) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.hlen(key);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Set<byte[]> hkeys(byte[] key) {
    Set
    <byte[]> result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.hkeys(key);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Collection<byte[]> hvals(byte[] key) {
    Collection
    <byte[]> result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.hvals(key);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Map<byte[], byte[]> hgetAll(byte[] key) {
    Map
    <byte[], byte[]> result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.hgetAll(key);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long rpush(byte[] key, byte[] string) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.rpush(key, string);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long lpush(byte[] key, byte[] string) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.lpush(key, string);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long llen(byte[] key) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.llen(key);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public List<byte[]> lrange(byte[] key, int start, int end) {
    List
    <byte[]> result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.lrange(key, start, end);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public String ltrim(byte[] key, int start, int end) {
    String result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.ltrim(key, start, end);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public byte[] lindex(byte[] key, int index) {
    byte[] result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.lindex(key, index);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public String lset(byte[] key, int index, byte[] value) {
    String result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.lset(key, index, value);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long lrem(byte[] key, int count, byte[] value) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.lrem(key, count, value);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public byte[] lpop(byte[] key) {
    byte[] result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.lpop(key);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public byte[] rpop(byte[] key) {
    byte[] result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.rpop(key);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long sadd(byte[] key, byte[] member) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.sadd(key, member);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Set<byte[]> smembers(byte[] key) {
    Set
    <byte[]> result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.smembers(key);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long srem(byte[] key, byte[] member) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.srem(key, member);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public byte[] spop(byte[] key) {
    byte[] result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.spop(key);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long scard(byte[] key) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.scard(key);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Boolean sismember(byte[] key, byte[] member) {
    Boolean result
    = false;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.sismember(key, member);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public byte[] srandmember(byte[] key) {
    byte[] result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.srandmember(key);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long zadd(byte[] key, double score, byte[] member) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.zadd(key, score, member);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Set<byte[]> zrange(byte[] key, int start, int end) {
    Set
    <byte[]> result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.zrange(key, start, end);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long zrem(byte[] key, byte[] member) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.zrem(key, member);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Double zincrby(byte[] key, double score, byte[] member) {
    Double result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.zincrby(key, score, member);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long zrank(byte[] key, byte[] member) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.zrank(key, member);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long zrevrank(byte[] key, byte[] member) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.zrevrank(key, member);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Set<byte[]> zrevrange(byte[] key, int start, int end) {
    Set
    <byte[]> result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.zrevrange(key, start, end);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Set<Tuple> zrangeWithScores(byte[] key, int start, int end) {
    Set
    <Tuple> result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.zrangeWithScores(key, start, end);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Set<Tuple> zrevrangeWithScores(byte[] key, int start, int end) {
    Set
    <Tuple> result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.zrevrangeWithScores(key, start, end);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long zcard(byte[] key) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.zcard(key);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Double zscore(byte[] key, byte[] member) {
    Double result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.zscore(key, member);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public List<byte[]> sort(byte[] key) {
    List
    <byte[]> result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.sort(key);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public List<byte[]> sort(byte[] key, SortingParams sortingParameters) {
    List
    <byte[]> result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.sort(key, sortingParameters);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long zcount(byte[] key, double min, double max) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.zcount(key, min, max);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Set<byte[]> zrangeByScore(byte[] key, double min, double max) {
    Set
    <byte[]> result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.zrangeByScore(key, min, max);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Set<byte[]> zrangeByScore(byte[] key, double min, double max, int offset, int count) {
    Set
    <byte[]> result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.zrangeByScore(key, min, max, offset, count);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Set<Tuple> zrangeByScoreWithScores(byte[] key, double min, double max) {
    Set
    <Tuple> result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.zrangeByScoreWithScores(key, min, max);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Set<Tuple> zrangeByScoreWithScores(byte[] key, double min, double max, int offset, int count) {
    Set
    <Tuple> result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.zrangeByScoreWithScores(key, min, max, offset, count);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Set<byte[]> zrevrangeByScore(byte[] key, double max, double min) {
    Set
    <byte[]> result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.zrevrangeByScore(key, max, min);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Set<byte[]> zrevrangeByScore(byte[] key, double max, double min, int offset, int count) {
    Set
    <byte[]> result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.zrevrangeByScore(key, max, min, offset, count);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Set<Tuple> zrevrangeByScoreWithScores(byte[] key, double max, double min) {
    Set
    <Tuple> result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.zrevrangeByScoreWithScores(key, max, min);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Set<Tuple> zrevrangeByScoreWithScores(byte[] key, double max, double min, int offset, int count) {
    Set
    <Tuple> result = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.zrevrangeByScoreWithScores(key, max, min, offset, count);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long zremrangeByRank(byte[] key, int start, int end) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.zremrangeByRank(key, start, end);

    }
    catch (Exception e) {

    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long zremrangeByScore(byte[] key, double start, double end) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.zremrangeByScore(key, start, end);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Long l(byte[] key, LIST_POSITION where, byte[] pivot, byte[] value) {
    Long result
    = null;
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {

    result
    = shardedJedis.l(key, where, pivot, value);

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public List<Object> pipelined(ShardedJedisPipeline shardedJedisPipeline) {
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    List
    <Object> result = null;
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.pipelined(shardedJedisPipeline);
    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Jedis getShard(byte[] key) {
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    Jedis result
    = null;
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.getShard(key);
    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Jedis getShard(String key) {
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    Jedis result
    = null;
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.getShard(key);
    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public JedisShardInfo getShardInfo(byte[] key) {
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    JedisShardInfo result
    = null;
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.getShardInfo(key);
    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public JedisShardInfo getShardInfo(String key) {
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    JedisShardInfo result
    = null;
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.getShardInfo(key);
    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public String getKeyTag(String key) {
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    String result
    = null;
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.getKeyTag(key);
    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Collection<JedisShardInfo> getAllShardInfo() {
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    Collection
    <JedisShardInfo> result = null;
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.getAllShardInfo();

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    public Collection<Jedis> getAllShards() {
    ShardedJedis shardedJedis
    = redisDataSource.getRedisClient();
    Collection
    <Jedis> result = null;
    if (shardedJedis == null) {
    return result;
    }
    boolean broken = false;
    try {
    result
    = shardedJedis.getAllShards();

    }
    catch (Exception e) {
    log.error(e.getMessage(), e);
    broken
    = true;
    }
    finally {
    redisDataSource.returnResource(shardedJedis, broken);
    }
    return result;
    }

    }


    View Code




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


    感激一路有你~

    原来,再大的房子,再大的床,没有相爱的人陪伴,都只是冰冷的物质。而如果身边有爱人陪伴,即使房子小,床小,也觉得无关紧要,因为这些物质上面有了爱的温度,成了家的元素。—— 何珞《婚房》#书摘#
    分享到: