超越昨天的自己系列(7)

扯淡:

   最近一直在慢慢多学习各个组件,自己搭建出一些想法。是一个涉猎的过程,慢慢意识到知识是可以融汇贯通,举一反三的,不过前提好像是研究的比较深,有了自己的见解。自认为学习能力不咋地,速度慢不说,还容易放弃,大多数时候都是回头捡起来补的那种情况。

  所以,我想:自我监督的能力是否决定了一个人学习的高度,也限制了见识的高度呢?

  随着年纪的增长,越来越觉得学习知识的那种迫切性,专业方面的,自我修养方面的,都需要急切的得到满足。我知道很多人其实已经放弃看书了,基本刷刷微博,看看新闻,就满足自己的阅读欲望了。但有时候,静下心来的时候,很自己的心田上什么也没有,后悔自己没种棵树,或掘口井什么的。

  不知道你们是否有这样的感觉?


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

  redis的知识:官网

  1,利用spring-data-redis整合

  项目使用的pom.xml:

  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  3. <modelVersion>4.0.0</modelVersion>
  4.  
  5. <groupId>com.x.redis</groupId>
  6. <artifactId>Spring_redis</artifactId>
  7. <version>1.0-SNAPSHOT</version>
  8. <packaging>jar</packaging>
  9.  
  10. <name>Spring_redis</name>
  11. <url>http://maven.apache.org</url>
  12.  
  13. <properties>
  14. <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  15. </properties>
  16.  
  17. <dependencies>
  18. <dependency>
  19. <groupId>org.springframework.data</groupId>
  20. <artifactId>spring-data-redis</artifactId>
  21. <version>1.0.2.RELEASE</version>
  22. </dependency>
  23. <dependency>
  24. <groupId>org.springframework</groupId>
  25. <artifactId>spring-core</artifactId>
  26. <version>3.1.2.RELEASE</version>
  27. </dependency>
  28.  
  29. <dependency>
  30. <groupId>redis.clients</groupId>
  31. <artifactId>jedis</artifactId>
  32. <version>2.1.0</version>
  33. </dependency>
  34.  
  35. <dependency>
  36. <groupId>junit</groupId>
  37. <artifactId>junit</artifactId>
  38. <version>4.8.2</version>
  39. <scope>test</scope>
  40. </dependency>
  41. <dependency>
  42. <groupId>org.slf4j</groupId>
  43. <artifactId>slf4j-api</artifactId>
  44. <version>1.6.1</version>
  45. </dependency>
  46. <!-- 将现有的jakarta commons logging的调用转换成lsf4j的调用。 -->
  47. <dependency>
  48. <groupId>org.slf4j</groupId>
  49. <artifactId>jcl-over-slf4j</artifactId>
  50. <version>1.6.1</version>
  51. </dependency>
  52. <!-- Hack:确保commons-logging的jar包不被引入,否则将和jcl-over-slf4j冲突 -->
  53. <dependency>
  54. <groupId>commons-logging</groupId>
  55. <artifactId>commons-logging</artifactId>
  56. <version>1.1.1</version>
  57. <scope>provided</scope>
  58. </dependency>
  59. <!-- slf4j的实现:logback,用来取代log4j。更快、更强! -->
  60. <dependency>
  61. <groupId>ch.qos.logback</groupId>
  62. <artifactId>logback-classic</artifactId>
  63. <version>0.9.24</version>
  64. <scope>runtime</scope>
  65. </dependency>
  66. </dependencies>
  67. </project>

  除了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的实现就明白了。

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
  4. xmlns:context="http://www.springframework.org/schema/context"
  5. xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
  6. xmlns:aop="http://www.springframework.org/schema/aop"
  7. xsi:schemaLocation="
  8. http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
  9. http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
  10.  
  11. <context:property-placeholder location="classpath:redis.properties" />
  12. <context:component-scan base-package="com.x.redis.dao">
  13. </context:component-scan>
  14. <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
  15. <property name="maxIdle" value="${redis.maxIdle}" />
  16. <property name="maxActive" value="${redis.maxActive}" />
  17. <property name="maxWait" value="${redis.maxWait}" />
  18. <property name="testOnBorrow" value="${redis.testOnBorrow}" />
  19. </bean>
  20.  
  21. <bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
  22. p:host-name="${redis.host}" p:port="${redis.port}" p:password="${redis.pass}" p:pool-config-ref="poolConfig"/>
  23.  
  24. <bean id="redisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">
  25. <property name="connectionFactory" ref="connectionFactory" />
  26. </bean>
  27.  
  28. <bean id="userDAO" class="com.x.redis.dao.impl.UserDAOImpl" />
  29. </beans>

  redis.properties:

  1. # Redis settings
  2. #redis.host=192.168.20.101
  3. #redis.port=6380
  4. #redis.pass=foobared
  5. redis.host=127.0.0.1
  6. redis.port=6379
  7. redis.pass=
  8.  
  9. redis.maxIdle=300
  10. redis.maxActive=600
  11. redis.maxWait=1000
  12. redis.testOnBorrow=true

  UserDAOImpl:

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

  2,RedisTemplate就是spring对redis的一个封装而已。

  1. public class UserDAOImpl implements UserDAO {
  2.  
  3. @Autowired
  4. protected RedisTemplate<Serializable, Serializable> redisTemplate;
  5.  
  6. public void saveUser(final User user) {
  7. redisTemplate.execute(new RedisCallback<Object>() {
  8.  
  9. @Override
  10. public Object doInRedis(RedisConnection connection) throws DataAccessException {
  11. connection.set(redisTemplate.getStringSerializer().serialize("user.uid." + user.getId()),
  12. redisTemplate.getStringSerializer().serialize(user.getName()));
  13. return null;
  14. }
  15. });
  16. }
  17.  
  18. @Override
  19. public User getUser(final long id) {
  20. return redisTemplate.execute(new RedisCallback<User>() {
  21. @Override
  22. public User doInRedis(RedisConnection connection) throws DataAccessException {
  23. byte[] key = redisTemplate.getStringSerializer().serialize("user.uid." + id);
  24. if (connection.exists(key)) {
  25. byte[] value = connection.get(key);
  26. String name = redisTemplate.getStringSerializer().deserialize(value);
  27. User user = new User();
  28. user.setName(name);
  29. user.setId(id);
  30. return user;
  31. }
  32. return null;
  33. }
  34. });
  35. }
  36.  
  37. }

  其他:

  User:

  1. public class User {
  2.  
  3. private long id;
  4. private String name;
  5.  
  6. public long getId() {
  7. return id;
  8. }
  9.  
  10. public void setId(long id) {
  11. this.id = id;
  12. }
  13.  
  14. public String getName() {
  15. return name;
  16. }
  17.  
  18. public void setName(String name) {
  19. this.name = name;
  20. }
  21. }

  测试代码:

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

  2,不利用spring-data-redis整合

  个人觉得这样整合灵活度更大,能够更加明了的完成任务。

  pom.xml:

  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  3. <modelVersion>4.0.0</modelVersion>
  4.  
  5. <groupId>com.d.work</groupId>
  6. <artifactId>Redis_Templete</artifactId>
  7. <version>1.0-SNAPSHOT</version>
  8. <packaging>jar</packaging>
  9.  
  10. <name>Redis_Templete</name>
  11. <url>http://maven.apache.org</url>
  12.  
  13. <properties>
  14. <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  15. </properties>
  16.  
  17. <dependencies>
  18. <dependency>
  19. <groupId>junit</groupId>
  20. <artifactId>junit</artifactId>
  21. <version>3.8.1</version>
  22. <scope>test</scope>
  23. </dependency>
  24. <dependency>
  25. <groupId>redis.clients</groupId>
  26. <artifactId>jedis</artifactId>
  27. <version>2.1.0</version>
  28. </dependency>
  29. <dependency>
  30. <groupId>org.springframework</groupId>
  31. <artifactId>spring-core</artifactId>
  32. <version>3.1.2.RELEASE</version>
  33. </dependency>
  34. <dependency>
  35. <groupId>org.springframework</groupId>
  36. <artifactId>spring-beans</artifactId>
  37. <version>3.1.2.RELEASE</version>
  38. </dependency>
  39. <dependency>
  40. <groupId>org.springframework</groupId>
  41. <artifactId>spring-context</artifactId>
  42. <version>3.1.2.RELEASE</version>
  43. </dependency>
  44. <dependency>
  45. <groupId>org.slf4j</groupId>
  46. <artifactId>slf4j-api</artifactId>
  47. <version>1.6.1</version>
  48. </dependency>
  49. <!-- 将现有的jakarta commons logging的调用转换成lsf4j的调用。 -->
  50. <dependency>
  51. <groupId>org.slf4j</groupId>
  52. <artifactId>jcl-over-slf4j</artifactId>
  53. <version>1.6.1</version>
  54. </dependency>
  55. <!-- Hack:确保commons-logging的jar包不被引入,否则将和jcl-over-slf4j冲突 -->
  56. <dependency>
  57. <groupId>commons-logging</groupId>
  58. <artifactId>commons-logging</artifactId>
  59. <version>1.1.1</version>
  60. <scope>provided</scope>
  61. </dependency>
  62. <!-- slf4j的实现:logback,用来取代log4j。更快、更强! -->
  63. <dependency>
  64. <groupId>ch.qos.logback</groupId>
  65. <artifactId>logback-classic</artifactId>
  66. <version>0.9.24</version>
  67. <scope>runtime</scope>
  68. </dependency>
  69. </dependencies>
  70. </project>

  目录结构:

  

  data-source.xml

  1,context:property-placeholder 和 context:component-scan 前面解释过啦。

  2,配置了一个ShardedJedisPool,在jdeis里 还有个JedisPool。这两个的区别:

    一个是分片形式,可以连接有主备的redis服务端,一个是单个的。详细后续学习
 
  3,因为不使用spring-data-redis的封装,所以自己要自己封装一个
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
  4. xmlns:context="http://www.springframework.org/schema/context"
  5. xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
  6. xmlns:aop="http://www.springframework.org/schema/aop"
  7. xsi:schemaLocation="
  8. http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
  9. http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
  10.  
  11. <context:property-placeholder location="classpath:redis.properties" />
  12. <context:component-scan base-package="com.d.work.main">
  13. </context:component-scan>
  14. <context:component-scan base-package="com.d.work.redis">
  15. </context:component-scan>
  16. <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
  17. <property name="maxActive" value="50" />
  18. <property name="maxIdle" value="8" />
  19. <property name="maxWait" value="1000" />
  20. <property name="testOnBorrow" value="true"/>
  21. <property name="testOnReturn" value="true"/>
  22. <!-- <property name="testWhileIdle" value="true"/> -->
  23. </bean>
  24.  
  25. <bean id="shardedJedisPool" class="redis.clients.jedis.ShardedJedisPool" scope="singleton">
  26. <constructor-arg index="0" ref="jedisPoolConfig" />
  27. <constructor-arg index="1">
  28. <list>
  29. <bean class="redis.clients.jedis.JedisShardInfo">
  30. <constructor-arg name="host" value="${redis.host}" />
  31. <constructor-arg name="port" value="${redis.port}" />
  32. <constructor-arg name="timeout" value="${redis.timeout}" />
  33. <constructor-arg name="weight" value="1" />
  34. </bean>
  35. </list>
  36. </constructor-arg>
  37. </bean>
  38. </beans>

RedisDataSource:定义三个方法

  1. public interface RedisDataSource {
  2. public abstract ShardedJedis getRedisClient();
  3. public void returnResource(ShardedJedis shardedJedis);
  4. public void returnResource(ShardedJedis shardedJedis,boolean broken);
  5. }

实现redisDataSource:

1, 注入配置好的ShardedJedisPool,这三个方法的作用:

  1. getRedisClient() 取得redis的客户端,可以执行命令了。
  1. returnResource(ShardedJedis shardedJedis) 将资源返还给pool
  1. returnResource(ShardedJedis shardedJedis, boolean broken) : 出现异常后,将资源返还给pool (其实不需要第二个方法)
  1. @Repository("redisDataSource")
  2. public class RedisDataSourceImpl implements RedisDataSource {
  3.  
  4. private static final Logger log = LoggerFactory.getLogger(RedisDataSourceImpl.class);
  5.  
  6. @Autowired
  7. private ShardedJedisPool shardedJedisPool;
  8.  
  9. public ShardedJedis getRedisClient() {
  10. try {
  11. ShardedJedis shardJedis = shardedJedisPool.getResource();
  12. return shardJedis;
  13. } catch (Exception e) {
  14. log.error("getRedisClent error", e);
  15. }
  16. return null;
  17. }
  18.  
  19. public void returnResource(ShardedJedis shardedJedis) {
  20. shardedJedisPool.returnResource(shardedJedis);
  21. }
  22.  
  23. public void returnResource(ShardedJedis shardedJedis, boolean broken) {
  24. if (broken) {
  25. shardedJedisPool.returnBrokenResource(shardedJedis);
  26. } else {
  27. shardedJedisPool.returnResource(shardedJedis);
  28. }
  29. }
  30. }

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

  代码就是映射性质的又一次调用jedis的方法而已,用了个broken来做标示符,决定返还资源的方式。

  这一层的目的主要也是让再上层的调用不需要关心pool中链接的取得和返还问题了。

  1. @Repository("redisClientTemplate")
  2. public class RedisClientTemplate {
  3.  
  4. private static final Logger log = LoggerFactory.getLogger(RedisClientTemplate.class);
  5.  
  6. @Autowired
  7. private RedisDataSource redisDataSource;
  8.  
  9. public void disconnect() {
  10. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  11. shardedJedis.disconnect();
  12. }
  13.  
  14. /**
  15. * 设置单个值
  16. *
  17. * @param key
  18. * @param value
  19. * @return
  20. */
  21. public String set(String key, String value) {
  22. String result = null;
  23.  
  24. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  25. if (shardedJedis == null) {
  26. return result;
  27. }
  28. boolean broken = false;
  29. try {
  30. result = shardedJedis.set(key, value);
  31. } catch (Exception e) {
  32. log.error(e.getMessage(), e);
  33. broken = true;
  34. } finally {
  35. redisDataSource.returnResource(shardedJedis, broken);
  36. }
  37. return result;
  38. }
  39.  
  40. /**
  41. * 获取单个值
  42. *
  43. * @param key
  44. * @return
  45. */
  46. public String get(String key) {
  47. String result = null;
  48. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  49. if (shardedJedis == null) {
  50. return result;
  51. }
  52.  
  53. boolean broken = false;
  54. try {
  55. result = shardedJedis.get(key);
  56.  
  57. } catch (Exception e) {
  58. log.error(e.getMessage(), e);
  59. broken = true;
  60. } finally {
  61. redisDataSource.returnResource(shardedJedis, broken);
  62. }
  63. return result;
  64. }
  65. }

测试代码:

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

附上RedisClientTemplate全部实现:

  1. @Repository("redisClientTemplate")
  2. public class RedisClientTemplate {
  3.  
  4. private static final Logger log = LoggerFactory.getLogger(RedisClientTemplate.class);
  5.  
  6. @Autowired
  7. private RedisDataSource redisDataSource;
  8.  
  9. public void disconnect() {
  10. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  11. shardedJedis.disconnect();
  12. }
  13.  
  14. /**
  15. * 设置单个值
  16. *
  17. * @param key
  18. * @param value
  19. * @return
  20. */
  21. public String set(String key, String value) {
  22. String result = null;
  23.  
  24. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  25. if (shardedJedis == null) {
  26. return result;
  27. }
  28. boolean broken = false;
  29. try {
  30. result = shardedJedis.set(key, value);
  31. } catch (Exception e) {
  32. log.error(e.getMessage(), e);
  33. broken = true;
  34. } finally {
  35. redisDataSource.returnResource(shardedJedis, broken);
  36. }
  37. return result;
  38. }
  39.  
  40. /**
  41. * 获取单个值
  42. *
  43. * @param key
  44. * @return
  45. */
  46. public String get(String key) {
  47. String result = null;
  48. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  49. if (shardedJedis == null) {
  50. return result;
  51. }
  52.  
  53. boolean broken = false;
  54. try {
  55. result = shardedJedis.get(key);
  56.  
  57. } catch (Exception e) {
  58. log.error(e.getMessage(), e);
  59. broken = true;
  60. } finally {
  61. redisDataSource.returnResource(shardedJedis, broken);
  62. }
  63. return result;
  64. }
  65.  
  66. public Boolean exists(String key) {
  67. Boolean result = false;
  68. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  69. if (shardedJedis == null) {
  70. return result;
  71. }
  72. boolean broken = false;
  73. try {
  74. result = shardedJedis.exists(key);
  75. } catch (Exception e) {
  76. log.error(e.getMessage(), e);
  77. broken = true;
  78. } finally {
  79. redisDataSource.returnResource(shardedJedis, broken);
  80. }
  81. return result;
  82. }
  83.  
  84. public String type(String key) {
  85. String result = null;
  86. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  87. if (shardedJedis == null) {
  88. return result;
  89. }
  90. boolean broken = false;
  91. try {
  92. result = shardedJedis.type(key);
  93.  
  94. } catch (Exception e) {
  95. log.error(e.getMessage(), e);
  96. broken = true;
  97. } finally {
  98. redisDataSource.returnResource(shardedJedis, broken);
  99. }
  100. return result;
  101. }
  102.  
  103. /**
  104. * 在某段时间后实现
  105. *
  106. * @param key
  107. * @param unixTime
  108. * @return
  109. */
  110. public Long expire(String key, int seconds) {
  111. Long result = null;
  112. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  113. if (shardedJedis == null) {
  114. return result;
  115. }
  116. boolean broken = false;
  117. try {
  118. result = shardedJedis.expire(key, seconds);
  119.  
  120. } catch (Exception e) {
  121. log.error(e.getMessage(), e);
  122. broken = true;
  123. } finally {
  124. redisDataSource.returnResource(shardedJedis, broken);
  125. }
  126. return result;
  127. }
  128.  
  129. /**
  130. * 在某个时间点失效
  131. *
  132. * @param key
  133. * @param unixTime
  134. * @return
  135. */
  136. public Long expireAt(String key, long unixTime) {
  137. Long result = null;
  138. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  139. if (shardedJedis == null) {
  140. return result;
  141. }
  142. boolean broken = false;
  143. try {
  144. result = shardedJedis.expireAt(key, unixTime);
  145.  
  146. } catch (Exception e) {
  147. log.error(e.getMessage(), e);
  148. broken = true;
  149. } finally {
  150. redisDataSource.returnResource(shardedJedis, broken);
  151. }
  152. return result;
  153. }
  154.  
  155. public Long ttl(String key) {
  156. Long result = null;
  157. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  158. if (shardedJedis == null) {
  159. return result;
  160. }
  161. boolean broken = false;
  162. try {
  163. result = shardedJedis.ttl(key);
  164.  
  165. } catch (Exception e) {
  166. log.error(e.getMessage(), e);
  167. broken = true;
  168. } finally {
  169. redisDataSource.returnResource(shardedJedis, broken);
  170. }
  171. return result;
  172. }
  173.  
  174. public boolean setbit(String key, long offset, boolean value) {
  175.  
  176. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  177. boolean result = false;
  178. if (shardedJedis == null) {
  179. return result;
  180. }
  181. boolean broken = false;
  182. try {
  183. result = shardedJedis.setbit(key, offset, value);
  184. } catch (Exception e) {
  185. log.error(e.getMessage(), e);
  186. broken = true;
  187. } finally {
  188. redisDataSource.returnResource(shardedJedis, broken);
  189. }
  190. return result;
  191. }
  192.  
  193. public boolean getbit(String key, long offset) {
  194. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  195. boolean result = false;
  196. if (shardedJedis == null) {
  197. return result;
  198. }
  199. boolean broken = false;
  200.  
  201. try {
  202. result = shardedJedis.getbit(key, offset);
  203. } catch (Exception e) {
  204. log.error(e.getMessage(), e);
  205. broken = true;
  206. } finally {
  207. redisDataSource.returnResource(shardedJedis, broken);
  208. }
  209. return result;
  210. }
  211.  
  212. public long setrange(String key, long offset, String value) {
  213. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  214. long result = 0;
  215. if (shardedJedis == null) {
  216. return result;
  217. }
  218. boolean broken = false;
  219. try {
  220. result = shardedJedis.setrange(key, offset, value);
  221. } catch (Exception e) {
  222. log.error(e.getMessage(), e);
  223. broken = true;
  224. } finally {
  225. redisDataSource.returnResource(shardedJedis, broken);
  226. }
  227. return result;
  228. }
  229.  
  230. public String getrange(String key, long startOffset, long endOffset) {
  231. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  232. String result = null;
  233. if (shardedJedis == null) {
  234. return result;
  235. }
  236. boolean broken = false;
  237. try {
  238. result = shardedJedis.getrange(key, startOffset, endOffset);
  239.  
  240. } catch (Exception e) {
  241. log.error(e.getMessage(), e);
  242. broken = true;
  243. } finally {
  244. redisDataSource.returnResource(shardedJedis, broken);
  245. }
  246. return result;
  247. }
  248.  
  249. public String getSet(String key, String value) {
  250. String result = null;
  251. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  252. if (shardedJedis == null) {
  253. return result;
  254. }
  255. boolean broken = false;
  256. try {
  257. result = shardedJedis.getSet(key, value);
  258. } catch (Exception e) {
  259. log.error(e.getMessage(), e);
  260. broken = true;
  261. } finally {
  262. redisDataSource.returnResource(shardedJedis, broken);
  263. }
  264. return result;
  265. }
  266.  
  267. public Long setnx(String key, String value) {
  268. Long result = null;
  269. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  270. if (shardedJedis == null) {
  271. return result;
  272. }
  273. boolean broken = false;
  274. try {
  275. result = shardedJedis.setnx(key, value);
  276. } catch (Exception e) {
  277. log.error(e.getMessage(), e);
  278. broken = true;
  279. } finally {
  280. redisDataSource.returnResource(shardedJedis, broken);
  281. }
  282. return result;
  283. }
  284.  
  285. public String setex(String key, int seconds, String value) {
  286. String result = null;
  287. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  288. if (shardedJedis == null) {
  289. return result;
  290. }
  291. boolean broken = false;
  292. try {
  293. result = shardedJedis.setex(key, seconds, value);
  294.  
  295. } catch (Exception e) {
  296. log.error(e.getMessage(), e);
  297. broken = true;
  298. } finally {
  299. redisDataSource.returnResource(shardedJedis, broken);
  300. }
  301. return result;
  302. }
  303.  
  304. public Long decrBy(String key, long integer) {
  305. Long result = null;
  306. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  307. if (shardedJedis == null) {
  308. return result;
  309. }
  310. boolean broken = false;
  311. try {
  312. result = shardedJedis.decrBy(key, integer);
  313.  
  314. } catch (Exception e) {
  315. log.error(e.getMessage(), e);
  316. broken = true;
  317. } finally {
  318. redisDataSource.returnResource(shardedJedis, broken);
  319. }
  320. return result;
  321. }
  322.  
  323. public Long decr(String key) {
  324. Long result = null;
  325. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  326. if (shardedJedis == null) {
  327. return result;
  328. }
  329. boolean broken = false;
  330. try {
  331. result = shardedJedis.decr(key);
  332.  
  333. } catch (Exception e) {
  334. log.error(e.getMessage(), e);
  335. broken = true;
  336. } finally {
  337. redisDataSource.returnResource(shardedJedis, broken);
  338. }
  339. return result;
  340. }
  341.  
  342. public Long incrBy(String key, long integer) {
  343. Long result = null;
  344. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  345. if (shardedJedis == null) {
  346. return result;
  347. }
  348. boolean broken = false;
  349. try {
  350. result = shardedJedis.incrBy(key, integer);
  351.  
  352. } catch (Exception e) {
  353. log.error(e.getMessage(), e);
  354. broken = true;
  355. } finally {
  356. redisDataSource.returnResource(shardedJedis, broken);
  357. }
  358. return result;
  359. }
  360.  
  361. public Long incr(String key) {
  362. Long result = null;
  363. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  364. if (shardedJedis == null) {
  365. return result;
  366. }
  367. boolean broken = false;
  368. try {
  369. result = shardedJedis.incr(key);
  370.  
  371. } catch (Exception e) {
  372. log.error(e.getMessage(), e);
  373. broken = true;
  374. } finally {
  375. redisDataSource.returnResource(shardedJedis, broken);
  376. }
  377. return result;
  378. }
  379.  
  380. public Long append(String key, String value) {
  381. Long result = null;
  382. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  383. if (shardedJedis == null) {
  384. return result;
  385. }
  386. boolean broken = false;
  387. try {
  388. result = shardedJedis.append(key, value);
  389.  
  390. } catch (Exception e) {
  391. log.error(e.getMessage(), e);
  392. broken = true;
  393. } finally {
  394. redisDataSource.returnResource(shardedJedis, broken);
  395. }
  396. return result;
  397. }
  398.  
  399. public String substr(String key, int start, int end) {
  400. String result = null;
  401. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  402. if (shardedJedis == null) {
  403. return result;
  404. }
  405. boolean broken = false;
  406. try {
  407. result = shardedJedis.substr(key, start, end);
  408.  
  409. } catch (Exception e) {
  410. log.error(e.getMessage(), e);
  411. broken = true;
  412. } finally {
  413. redisDataSource.returnResource(shardedJedis, broken);
  414. }
  415. return result;
  416. }
  417.  
  418. public Long hset(String key, String field, String value) {
  419. Long result = null;
  420. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  421. if (shardedJedis == null) {
  422. return result;
  423. }
  424. boolean broken = false;
  425. try {
  426. result = shardedJedis.hset(key, field, value);
  427.  
  428. } catch (Exception e) {
  429. log.error(e.getMessage(), e);
  430. broken = true;
  431. } finally {
  432. redisDataSource.returnResource(shardedJedis, broken);
  433. }
  434. return result;
  435. }
  436.  
  437. public String hget(String key, String field) {
  438. String result = null;
  439. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  440. if (shardedJedis == null) {
  441. return result;
  442. }
  443. boolean broken = false;
  444. try {
  445. result = shardedJedis.hget(key, field);
  446.  
  447. } catch (Exception e) {
  448. log.error(e.getMessage(), e);
  449. broken = true;
  450. } finally {
  451. redisDataSource.returnResource(shardedJedis, broken);
  452. }
  453. return result;
  454. }
  455.  
  456. public Long hsetnx(String key, String field, String value) {
  457. Long result = null;
  458. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  459. if (shardedJedis == null) {
  460. return result;
  461. }
  462. boolean broken = false;
  463. try {
  464. result = shardedJedis.hsetnx(key, field, value);
  465.  
  466. } catch (Exception e) {
  467. log.error(e.getMessage(), e);
  468. broken = true;
  469. } finally {
  470. redisDataSource.returnResource(shardedJedis, broken);
  471. }
  472. return result;
  473. }
  474.  
  475. public String hmset(String key, Map<String, String> hash) {
  476. String result = null;
  477. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  478. if (shardedJedis == null) {
  479. return result;
  480. }
  481. boolean broken = false;
  482. try {
  483. result = shardedJedis.hmset(key, hash);
  484.  
  485. } catch (Exception e) {
  486. log.error(e.getMessage(), e);
  487. broken = true;
  488. } finally {
  489. redisDataSource.returnResource(shardedJedis, broken);
  490. }
  491. return result;
  492. }
  493.  
  494. public List<String> hmget(String key, String... fields) {
  495. List<String> result = null;
  496. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  497. if (shardedJedis == null) {
  498. return result;
  499. }
  500. boolean broken = false;
  501. try {
  502. result = shardedJedis.hmget(key, fields);
  503.  
  504. } catch (Exception e) {
  505. log.error(e.getMessage(), e);
  506. broken = true;
  507. } finally {
  508. redisDataSource.returnResource(shardedJedis, broken);
  509. }
  510. return result;
  511. }
  512.  
  513. public Long hincrBy(String key, String field, long value) {
  514. Long result = null;
  515. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  516. if (shardedJedis == null) {
  517. return result;
  518. }
  519. boolean broken = false;
  520. try {
  521. result = shardedJedis.hincrBy(key, field, value);
  522.  
  523. } catch (Exception e) {
  524. log.error(e.getMessage(), e);
  525. broken = true;
  526. } finally {
  527. redisDataSource.returnResource(shardedJedis, broken);
  528. }
  529. return result;
  530. }
  531.  
  532. public Boolean hexists(String key, String field) {
  533. Boolean result = false;
  534. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  535. if (shardedJedis == null) {
  536. return result;
  537. }
  538. boolean broken = false;
  539. try {
  540. result = shardedJedis.hexists(key, field);
  541.  
  542. } catch (Exception e) {
  543. log.error(e.getMessage(), e);
  544. broken = true;
  545. } finally {
  546. redisDataSource.returnResource(shardedJedis, broken);
  547. }
  548. return result;
  549. }
  550.  
  551. public Long del(String key) {
  552. Long result = null;
  553. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  554. if (shardedJedis == null) {
  555. return result;
  556. }
  557. boolean broken = false;
  558. try {
  559. result = shardedJedis.del(key);
  560.  
  561. } catch (Exception e) {
  562. log.error(e.getMessage(), e);
  563. broken = true;
  564. } finally {
  565. redisDataSource.returnResource(shardedJedis, broken);
  566. }
  567. return result;
  568. }
  569.  
  570. public Long hdel(String key, String field) {
  571. Long result = null;
  572. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  573. if (shardedJedis == null) {
  574. return result;
  575. }
  576. boolean broken = false;
  577. try {
  578. result = shardedJedis.hdel(key, field);
  579.  
  580. } catch (Exception e) {
  581. log.error(e.getMessage(), e);
  582. broken = true;
  583. } finally {
  584. redisDataSource.returnResource(shardedJedis, broken);
  585. }
  586. return result;
  587. }
  588.  
  589. public Long hlen(String key) {
  590. Long result = null;
  591. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  592. if (shardedJedis == null) {
  593. return result;
  594. }
  595. boolean broken = false;
  596. try {
  597. result = shardedJedis.hlen(key);
  598.  
  599. } catch (Exception e) {
  600. log.error(e.getMessage(), e);
  601. broken = true;
  602. } finally {
  603. redisDataSource.returnResource(shardedJedis, broken);
  604. }
  605. return result;
  606. }
  607.  
  608. public Set<String> hkeys(String key) {
  609. Set<String> result = null;
  610. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  611. if (shardedJedis == null) {
  612. return result;
  613. }
  614. boolean broken = false;
  615. try {
  616. result = shardedJedis.hkeys(key);
  617.  
  618. } catch (Exception e) {
  619. log.error(e.getMessage(), e);
  620. broken = true;
  621. } finally {
  622. redisDataSource.returnResource(shardedJedis, broken);
  623. }
  624. return result;
  625. }
  626.  
  627. public List<String> hvals(String key) {
  628. List<String> result = null;
  629. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  630. if (shardedJedis == null) {
  631. return result;
  632. }
  633. boolean broken = false;
  634. try {
  635. result = shardedJedis.hvals(key);
  636.  
  637. } catch (Exception e) {
  638. log.error(e.getMessage(), e);
  639. broken = true;
  640. } finally {
  641. redisDataSource.returnResource(shardedJedis, broken);
  642. }
  643. return result;
  644. }
  645.  
  646. public Map<String, String> hgetAll(String key) {
  647. Map<String, String> result = null;
  648. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  649. if (shardedJedis == null) {
  650. return result;
  651. }
  652. boolean broken = false;
  653. try {
  654. result = shardedJedis.hgetAll(key);
  655.  
  656. } catch (Exception e) {
  657. log.error(e.getMessage(), e);
  658. broken = true;
  659. } finally {
  660. redisDataSource.returnResource(shardedJedis, broken);
  661. }
  662. return result;
  663. }
  664.  
  665. // ================list ====== l表示 list或 left, r表示right====================
  666. public Long rpush(String key, String string) {
  667. Long result = null;
  668. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  669. if (shardedJedis == null) {
  670. return result;
  671. }
  672. boolean broken = false;
  673. try {
  674. result = shardedJedis.rpush(key, string);
  675.  
  676. } catch (Exception e) {
  677. log.error(e.getMessage(), e);
  678. broken = true;
  679. } finally {
  680. redisDataSource.returnResource(shardedJedis, broken);
  681. }
  682. return result;
  683. }
  684.  
  685. public Long lpush(String key, String string) {
  686. Long result = null;
  687. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  688. if (shardedJedis == null) {
  689. return result;
  690. }
  691. boolean broken = false;
  692. try {
  693. result = shardedJedis.lpush(key, string);
  694.  
  695. } catch (Exception e) {
  696. log.error(e.getMessage(), e);
  697. broken = true;
  698. } finally {
  699. redisDataSource.returnResource(shardedJedis, broken);
  700. }
  701. return result;
  702. }
  703.  
  704. public Long llen(String key) {
  705. Long result = null;
  706. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  707. if (shardedJedis == null) {
  708. return result;
  709. }
  710. boolean broken = false;
  711. try {
  712. result = shardedJedis.llen(key);
  713.  
  714. } catch (Exception e) {
  715. log.error(e.getMessage(), e);
  716. broken = true;
  717. } finally {
  718. redisDataSource.returnResource(shardedJedis, broken);
  719. }
  720. return result;
  721. }
  722.  
  723. public List<String> lrange(String key, long start, long end) {
  724. List<String> result = null;
  725. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  726. if (shardedJedis == null) {
  727. return result;
  728. }
  729. boolean broken = false;
  730. try {
  731. result = shardedJedis.lrange(key, start, end);
  732.  
  733. } catch (Exception e) {
  734. log.error(e.getMessage(), e);
  735. broken = true;
  736. } finally {
  737. redisDataSource.returnResource(shardedJedis, broken);
  738. }
  739. return result;
  740. }
  741.  
  742. public String ltrim(String key, long start, long end) {
  743. String result = null;
  744. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  745. if (shardedJedis == null) {
  746. return result;
  747. }
  748. boolean broken = false;
  749. try {
  750. result = shardedJedis.ltrim(key, start, end);
  751.  
  752. } catch (Exception e) {
  753. log.error(e.getMessage(), e);
  754. broken = true;
  755. } finally {
  756. redisDataSource.returnResource(shardedJedis, broken);
  757. }
  758. return result;
  759. }
  760.  
  761. public String lindex(String key, long index) {
  762. String result = null;
  763. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  764. if (shardedJedis == null) {
  765. return result;
  766. }
  767. boolean broken = false;
  768. try {
  769. result = shardedJedis.lindex(key, index);
  770.  
  771. } catch (Exception e) {
  772. log.error(e.getMessage(), e);
  773. broken = true;
  774. } finally {
  775. redisDataSource.returnResource(shardedJedis, broken);
  776. }
  777. return result;
  778. }
  779.  
  780. public String lset(String key, long index, String value) {
  781. String result = null;
  782. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  783. if (shardedJedis == null) {
  784. return result;
  785. }
  786. boolean broken = false;
  787. try {
  788. result = shardedJedis.lset(key, index, value);
  789.  
  790. } catch (Exception e) {
  791. log.error(e.getMessage(), e);
  792. broken = true;
  793. } finally {
  794. redisDataSource.returnResource(shardedJedis, broken);
  795. }
  796. return result;
  797. }
  798.  
  799. public Long lrem(String key, long count, String value) {
  800. Long result = null;
  801. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  802. if (shardedJedis == null) {
  803. return result;
  804. }
  805. boolean broken = false;
  806. try {
  807. result = shardedJedis.lrem(key, count, value);
  808.  
  809. } catch (Exception e) {
  810. log.error(e.getMessage(), e);
  811. broken = true;
  812. } finally {
  813. redisDataSource.returnResource(shardedJedis, broken);
  814. }
  815. return result;
  816. }
  817.  
  818. public String lpop(String key) {
  819. String result = null;
  820. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  821. if (shardedJedis == null) {
  822. return result;
  823. }
  824. boolean broken = false;
  825. try {
  826. result = shardedJedis.lpop(key);
  827.  
  828. } catch (Exception e) {
  829. log.error(e.getMessage(), e);
  830. broken = true;
  831. } finally {
  832. redisDataSource.returnResource(shardedJedis, broken);
  833. }
  834. return result;
  835. }
  836.  
  837. public String rpop(String key) {
  838. String result = null;
  839. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  840. if (shardedJedis == null) {
  841. return result;
  842. }
  843. boolean broken = false;
  844. try {
  845. result = shardedJedis.rpop(key);
  846.  
  847. } catch (Exception e) {
  848. log.error(e.getMessage(), e);
  849. broken = true;
  850. } finally {
  851. redisDataSource.returnResource(shardedJedis, broken);
  852. }
  853. return result;
  854. }
  855.  
  856. //return 1 add a not exist value ,
  857. //return 0 add a exist value
  858. public Long sadd(String key, String member) {
  859. Long result = null;
  860. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  861. if (shardedJedis == null) {
  862. return result;
  863. }
  864. boolean broken = false;
  865. try {
  866. result = shardedJedis.sadd(key, member);
  867.  
  868. } catch (Exception e) {
  869. log.error(e.getMessage(), e);
  870. broken = true;
  871. } finally {
  872. redisDataSource.returnResource(shardedJedis, broken);
  873. }
  874. return result;
  875. }
  876.  
  877. public Set<String> smembers(String key) {
  878. Set<String> result = null;
  879. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  880. if (shardedJedis == null) {
  881. return result;
  882. }
  883. boolean broken = false;
  884. try {
  885. result = shardedJedis.smembers(key);
  886.  
  887. } catch (Exception e) {
  888. log.error(e.getMessage(), e);
  889. broken = true;
  890. } finally {
  891. redisDataSource.returnResource(shardedJedis, broken);
  892. }
  893. return result;
  894. }
  895.  
  896. public Long srem(String key, String member) {
  897. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  898.  
  899. Long result = null;
  900. if (shardedJedis == null) {
  901. return result;
  902. }
  903. boolean broken = false;
  904. try {
  905. result = shardedJedis.srem(key, member);
  906. } catch (Exception e) {
  907. log.error(e.getMessage(), e);
  908. broken = true;
  909. } finally {
  910. redisDataSource.returnResource(shardedJedis, broken);
  911. }
  912. return result;
  913. }
  914.  
  915. public String spop(String key) {
  916. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  917. String result = null;
  918. if (shardedJedis == null) {
  919. return result;
  920. }
  921. boolean broken = false;
  922. try {
  923. result = shardedJedis.spop(key);
  924. } catch (Exception e) {
  925. log.error(e.getMessage(), e);
  926. broken = true;
  927. } finally {
  928. redisDataSource.returnResource(shardedJedis, broken);
  929. }
  930. return result;
  931. }
  932.  
  933. public Long scard(String key) {
  934. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  935. Long result = null;
  936. if (shardedJedis == null) {
  937. return result;
  938. }
  939. boolean broken = false;
  940. try {
  941. result = shardedJedis.scard(key);
  942.  
  943. } catch (Exception e) {
  944. log.error(e.getMessage(), e);
  945. broken = true;
  946. } finally {
  947. redisDataSource.returnResource(shardedJedis, broken);
  948. }
  949. return result;
  950. }
  951.  
  952. public Boolean sismember(String key, String member) {
  953. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  954. Boolean result = null;
  955. if (shardedJedis == null) {
  956. return result;
  957. }
  958. boolean broken = false;
  959. try {
  960. result = shardedJedis.sismember(key, member);
  961. } catch (Exception e) {
  962. log.error(e.getMessage(), e);
  963. broken = true;
  964. } finally {
  965. redisDataSource.returnResource(shardedJedis, broken);
  966. }
  967. return result;
  968. }
  969.  
  970. public String srandmember(String key) {
  971. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  972. String result = null;
  973. if (shardedJedis == null) {
  974. return result;
  975. }
  976. boolean broken = false;
  977. try {
  978. result = shardedJedis.srandmember(key);
  979. } catch (Exception e) {
  980. log.error(e.getMessage(), e);
  981. broken = true;
  982. } finally {
  983. redisDataSource.returnResource(shardedJedis, broken);
  984. }
  985. return result;
  986. }
  987.  
  988. public Long zadd(String key, double score, String member) {
  989. Long result = null;
  990. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  991. if (shardedJedis == null) {
  992. return result;
  993. }
  994. boolean broken = false;
  995. try {
  996. result = shardedJedis.zadd(key, score, member);
  997. } catch (Exception e) {
  998. log.error(e.getMessage(), e);
  999. broken = true;
  1000. } finally {
  1001. redisDataSource.returnResource(shardedJedis, broken);
  1002. }
  1003. return result;
  1004. }
  1005.  
  1006. public Set<String> zrange(String key, int start, int end) {
  1007. Set<String> result = null;
  1008. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1009. if (shardedJedis == null) {
  1010. return result;
  1011. }
  1012. boolean broken = false;
  1013. try {
  1014. result = shardedJedis.zrange(key, start, end);
  1015. } catch (Exception e) {
  1016. log.error(e.getMessage(), e);
  1017. broken = true;
  1018. } finally {
  1019. redisDataSource.returnResource(shardedJedis, broken);
  1020. }
  1021. return result;
  1022. }
  1023.  
  1024. public Long zrem(String key, String member) {
  1025. Long result = null;
  1026. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1027. if (shardedJedis == null) {
  1028. return result;
  1029. }
  1030. boolean broken = false;
  1031. try {
  1032. result = shardedJedis.zrem(key, member);
  1033. } catch (Exception e) {
  1034. log.error(e.getMessage(), e);
  1035. broken = true;
  1036. } finally {
  1037. redisDataSource.returnResource(shardedJedis, broken);
  1038. }
  1039. return result;
  1040. }
  1041.  
  1042. public Double zincrby(String key, double score, String member) {
  1043. Double result = null;
  1044. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1045. if (shardedJedis == null) {
  1046. return result;
  1047. }
  1048. boolean broken = false;
  1049. try {
  1050.  
  1051. result = shardedJedis.zincrby(key, score, member);
  1052.  
  1053. } catch (Exception e) {
  1054. log.error(e.getMessage(), e);
  1055. broken = true;
  1056. } finally {
  1057. redisDataSource.returnResource(shardedJedis, broken);
  1058. }
  1059. return result;
  1060. }
  1061.  
  1062. public Long zrank(String key, String member) {
  1063. Long result = null;
  1064. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1065. if (shardedJedis == null) {
  1066. return result;
  1067. }
  1068. boolean broken = false;
  1069. try {
  1070.  
  1071. result = shardedJedis.zrank(key, member);
  1072.  
  1073. } catch (Exception e) {
  1074. log.error(e.getMessage(), e);
  1075. broken = true;
  1076. } finally {
  1077. redisDataSource.returnResource(shardedJedis, broken);
  1078. }
  1079. return result;
  1080. }
  1081.  
  1082. public Long zrevrank(String key, String member) {
  1083. Long result = null;
  1084. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1085. if (shardedJedis == null) {
  1086. return result;
  1087. }
  1088. boolean broken = false;
  1089. try {
  1090.  
  1091. result = shardedJedis.zrevrank(key, member);
  1092.  
  1093. } catch (Exception e) {
  1094. log.error(e.getMessage(), e);
  1095. broken = true;
  1096. } finally {
  1097. redisDataSource.returnResource(shardedJedis, broken);
  1098. }
  1099. return result;
  1100. }
  1101.  
  1102. public Set<String> zrevrange(String key, int start, int end) {
  1103. Set<String> result = null;
  1104. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1105. if (shardedJedis == null) {
  1106. return result;
  1107. }
  1108. boolean broken = false;
  1109. try {
  1110.  
  1111. result = shardedJedis.zrevrange(key, start, end);
  1112.  
  1113. } catch (Exception e) {
  1114. log.error(e.getMessage(), e);
  1115. broken = true;
  1116. } finally {
  1117. redisDataSource.returnResource(shardedJedis, broken);
  1118. }
  1119. return result;
  1120. }
  1121.  
  1122. public Set<Tuple> zrangeWithScores(String key, int start, int end) {
  1123. Set<Tuple> result = null;
  1124. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1125. if (shardedJedis == null) {
  1126. return result;
  1127. }
  1128. boolean broken = false;
  1129. try {
  1130.  
  1131. result = shardedJedis.zrangeWithScores(key, start, end);
  1132.  
  1133. } catch (Exception e) {
  1134. log.error(e.getMessage(), e);
  1135. broken = true;
  1136. } finally {
  1137. redisDataSource.returnResource(shardedJedis, broken);
  1138. }
  1139. return result;
  1140. }
  1141.  
  1142. public Set<Tuple> zrevrangeWithScores(String key, int start, int end) {
  1143. Set<Tuple> result = null;
  1144. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1145. if (shardedJedis == null) {
  1146. return result;
  1147. }
  1148. boolean broken = false;
  1149. try {
  1150.  
  1151. result = shardedJedis.zrevrangeWithScores(key, start, end);
  1152.  
  1153. } catch (Exception e) {
  1154. log.error(e.getMessage(), e);
  1155. broken = true;
  1156. } finally {
  1157. redisDataSource.returnResource(shardedJedis, broken);
  1158. }
  1159. return result;
  1160. }
  1161.  
  1162. public Long zcard(String key) {
  1163. Long result = null;
  1164. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1165. if (shardedJedis == null) {
  1166. return result;
  1167. }
  1168. boolean broken = false;
  1169. try {
  1170.  
  1171. result = shardedJedis.zcard(key);
  1172.  
  1173. } catch (Exception e) {
  1174. log.error(e.getMessage(), e);
  1175. broken = true;
  1176. } finally {
  1177. redisDataSource.returnResource(shardedJedis, broken);
  1178. }
  1179. return result;
  1180. }
  1181.  
  1182. public Double zscore(String key, String member) {
  1183. Double result = null;
  1184. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1185. if (shardedJedis == null) {
  1186. return result;
  1187. }
  1188. boolean broken = false;
  1189. try {
  1190.  
  1191. result = shardedJedis.zscore(key, member);
  1192.  
  1193. } catch (Exception e) {
  1194. log.error(e.getMessage(), e);
  1195. broken = true;
  1196. } finally {
  1197. redisDataSource.returnResource(shardedJedis, broken);
  1198. }
  1199. return result;
  1200. }
  1201.  
  1202. public List<String> sort(String key) {
  1203. List<String> result = null;
  1204. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1205. if (shardedJedis == null) {
  1206. return result;
  1207. }
  1208. boolean broken = false;
  1209. try {
  1210.  
  1211. result = shardedJedis.sort(key);
  1212.  
  1213. } catch (Exception e) {
  1214. log.error(e.getMessage(), e);
  1215. broken = true;
  1216. } finally {
  1217. redisDataSource.returnResource(shardedJedis, broken);
  1218. }
  1219. return result;
  1220. }
  1221.  
  1222. public List<String> sort(String key, SortingParams sortingParameters) {
  1223. List<String> result = null;
  1224. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1225. if (shardedJedis == null) {
  1226. return result;
  1227. }
  1228. boolean broken = false;
  1229. try {
  1230.  
  1231. result = shardedJedis.sort(key, sortingParameters);
  1232.  
  1233. } catch (Exception e) {
  1234. log.error(e.getMessage(), e);
  1235. broken = true;
  1236. } finally {
  1237. redisDataSource.returnResource(shardedJedis, broken);
  1238. }
  1239. return result;
  1240. }
  1241.  
  1242. public Long zcount(String key, double min, double max) {
  1243. Long result = null;
  1244. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1245. if (shardedJedis == null) {
  1246. return result;
  1247. }
  1248. boolean broken = false;
  1249. try {
  1250.  
  1251. result = shardedJedis.zcount(key, min, max);
  1252.  
  1253. } catch (Exception e) {
  1254. log.error(e.getMessage(), e);
  1255. broken = true;
  1256. } finally {
  1257. redisDataSource.returnResource(shardedJedis, broken);
  1258. }
  1259. return result;
  1260. }
  1261.  
  1262. public Set<String> zrangeByScore(String key, double min, double max) {
  1263. Set<String> result = null;
  1264. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1265. if (shardedJedis == null) {
  1266. return result;
  1267. }
  1268. boolean broken = false;
  1269. try {
  1270.  
  1271. result = shardedJedis.zrangeByScore(key, min, max);
  1272.  
  1273. } catch (Exception e) {
  1274. log.error(e.getMessage(), e);
  1275. broken = true;
  1276. } finally {
  1277. redisDataSource.returnResource(shardedJedis, broken);
  1278. }
  1279. return result;
  1280. }
  1281.  
  1282. public Set<String> zrevrangeByScore(String key, double max, double min) {
  1283. Set<String> result = null;
  1284. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1285. if (shardedJedis == null) {
  1286. return result;
  1287. }
  1288. boolean broken = false;
  1289. try {
  1290.  
  1291. result = shardedJedis.zrevrangeByScore(key, max, min);
  1292.  
  1293. } catch (Exception e) {
  1294. log.error(e.getMessage(), e);
  1295. broken = true;
  1296. } finally {
  1297. redisDataSource.returnResource(shardedJedis, broken);
  1298. }
  1299. return result;
  1300. }
  1301.  
  1302. public Set<String> zrangeByScore(String key, double min, double max, int offset, int count) {
  1303. Set<String> result = null;
  1304. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1305. if (shardedJedis == null) {
  1306. return result;
  1307. }
  1308. boolean broken = false;
  1309. try {
  1310.  
  1311. result = shardedJedis.zrangeByScore(key, min, max, offset, count);
  1312.  
  1313. } catch (Exception e) {
  1314. log.error(e.getMessage(), e);
  1315. broken = true;
  1316. } finally {
  1317. redisDataSource.returnResource(shardedJedis, broken);
  1318. }
  1319. return result;
  1320. }
  1321.  
  1322. public Set<String> zrevrangeByScore(String key, double max, double min, int offset, int count) {
  1323. Set<String> result = null;
  1324. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1325. if (shardedJedis == null) {
  1326. return result;
  1327. }
  1328. boolean broken = false;
  1329. try {
  1330.  
  1331. result = shardedJedis.zrevrangeByScore(key, max, min, offset, count);
  1332.  
  1333. } catch (Exception e) {
  1334. log.error(e.getMessage(), e);
  1335. broken = true;
  1336. } finally {
  1337. redisDataSource.returnResource(shardedJedis, broken);
  1338. }
  1339. return result;
  1340. }
  1341.  
  1342. public Set<Tuple> zrangeByScoreWithScores(String key, double min, double max) {
  1343. Set<Tuple> result = null;
  1344. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1345. if (shardedJedis == null) {
  1346. return result;
  1347. }
  1348. boolean broken = false;
  1349. try {
  1350.  
  1351. result = shardedJedis.zrangeByScoreWithScores(key, min, max);
  1352.  
  1353. } catch (Exception e) {
  1354. log.error(e.getMessage(), e);
  1355. broken = true;
  1356. } finally {
  1357. redisDataSource.returnResource(shardedJedis, broken);
  1358. }
  1359. return result;
  1360. }
  1361.  
  1362. public Set<Tuple> zrevrangeByScoreWithScores(String key, double max, double min) {
  1363. Set<Tuple> result = null;
  1364. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1365. if (shardedJedis == null) {
  1366. return result;
  1367. }
  1368. boolean broken = false;
  1369. try {
  1370.  
  1371. result = shardedJedis.zrevrangeByScoreWithScores(key, max, min);
  1372.  
  1373. } catch (Exception e) {
  1374. log.error(e.getMessage(), e);
  1375. broken = true;
  1376. } finally {
  1377. redisDataSource.returnResource(shardedJedis, broken);
  1378. }
  1379. return result;
  1380. }
  1381.  
  1382. public Set<Tuple> zrangeByScoreWithScores(String key, double min, double max, int offset, int count) {
  1383. Set<Tuple> result = null;
  1384. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1385. if (shardedJedis == null) {
  1386. return result;
  1387. }
  1388. boolean broken = false;
  1389. try {
  1390.  
  1391. result = shardedJedis.zrangeByScoreWithScores(key, min, max, offset, count);
  1392.  
  1393. } catch (Exception e) {
  1394. log.error(e.getMessage(), e);
  1395. broken = true;
  1396. } finally {
  1397. redisDataSource.returnResource(shardedJedis, broken);
  1398. }
  1399. return result;
  1400. }
  1401.  
  1402. public Set<Tuple> zrevrangeByScoreWithScores(String key, double max, double min, int offset, int count) {
  1403. Set<Tuple> result = null;
  1404. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1405. if (shardedJedis == null) {
  1406. return result;
  1407. }
  1408. boolean broken = false;
  1409. try {
  1410.  
  1411. result = shardedJedis.zrevrangeByScoreWithScores(key, max, min, offset, count);
  1412.  
  1413. } catch (Exception e) {
  1414. log.error(e.getMessage(), e);
  1415. broken = true;
  1416. } finally {
  1417. redisDataSource.returnResource(shardedJedis, broken);
  1418. }
  1419. return result;
  1420. }
  1421.  
  1422. public Long zremrangeByRank(String key, int start, int end) {
  1423. Long result = null;
  1424. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1425. if (shardedJedis == null) {
  1426. return result;
  1427. }
  1428. boolean broken = false;
  1429. try {
  1430.  
  1431. result = shardedJedis.zremrangeByRank(key, start, end);
  1432.  
  1433. } catch (Exception e) {
  1434. log.error(e.getMessage(), e);
  1435. broken = true;
  1436. } finally {
  1437. redisDataSource.returnResource(shardedJedis, broken);
  1438. }
  1439. return result;
  1440. }
  1441.  
  1442. public Long zremrangeByScore(String key, double start, double end) {
  1443. Long result = null;
  1444. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1445. if (shardedJedis == null) {
  1446. return result;
  1447. }
  1448. boolean broken = false;
  1449. try {
  1450.  
  1451. result = shardedJedis.zremrangeByScore(key, start, end);
  1452.  
  1453. } catch (Exception e) {
  1454. log.error(e.getMessage(), e);
  1455. broken = true;
  1456. } finally {
  1457. redisDataSource.returnResource(shardedJedis, broken);
  1458. }
  1459. return result;
  1460. }
  1461.  
  1462. public Long linsert(String key, LIST_POSITION where, String pivot, String value) {
  1463. Long result = null;
  1464. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1465. if (shardedJedis == null) {
  1466. return result;
  1467. }
  1468. boolean broken = false;
  1469. try {
  1470.  
  1471. result = shardedJedis.linsert(key, where, pivot, value);
  1472.  
  1473. } catch (Exception e) {
  1474. log.error(e.getMessage(), e);
  1475. broken = true;
  1476. } finally {
  1477. redisDataSource.returnResource(shardedJedis, broken);
  1478. }
  1479. return result;
  1480. }
  1481.  
  1482. public String set(byte[] key, byte[] value) {
  1483. String result = null;
  1484. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1485. if (shardedJedis == null) {
  1486. return result;
  1487. }
  1488. boolean broken = false;
  1489. try {
  1490.  
  1491. result = shardedJedis.set(key, value);
  1492.  
  1493. } catch (Exception e) {
  1494. log.error(e.getMessage(), e);
  1495. broken = true;
  1496. } finally {
  1497. redisDataSource.returnResource(shardedJedis, broken);
  1498. }
  1499. return result;
  1500. }
  1501.  
  1502. public byte[] get(byte[] key) {
  1503. byte[] result = null;
  1504. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1505. if (shardedJedis == null) {
  1506. return result;
  1507. }
  1508. boolean broken = false;
  1509. try {
  1510.  
  1511. result = shardedJedis.get(key);
  1512.  
  1513. } catch (Exception e) {
  1514. log.error(e.getMessage(), e);
  1515. broken = true;
  1516. } finally {
  1517. redisDataSource.returnResource(shardedJedis, broken);
  1518. }
  1519. return result;
  1520. }
  1521.  
  1522. public Boolean exists(byte[] key) {
  1523. Boolean result = false;
  1524. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1525. if (shardedJedis == null) {
  1526. return result;
  1527. }
  1528. boolean broken = false;
  1529. try {
  1530.  
  1531. result = shardedJedis.exists(key);
  1532.  
  1533. } catch (Exception e) {
  1534. log.error(e.getMessage(), e);
  1535. broken = true;
  1536. } finally {
  1537. redisDataSource.returnResource(shardedJedis, broken);
  1538. }
  1539. return result;
  1540. }
  1541.  
  1542. public String type(byte[] key) {
  1543. String result = null;
  1544. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1545. if (shardedJedis == null) {
  1546. return result;
  1547. }
  1548. boolean broken = false;
  1549. try {
  1550.  
  1551. result = shardedJedis.type(key);
  1552.  
  1553. } catch (Exception e) {
  1554. log.error(e.getMessage(), e);
  1555. broken = true;
  1556. } finally {
  1557. redisDataSource.returnResource(shardedJedis, broken);
  1558. }
  1559. return result;
  1560. }
  1561.  
  1562. public Long expire(byte[] key, int seconds) {
  1563. Long result = null;
  1564. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1565. if (shardedJedis == null) {
  1566. return result;
  1567. }
  1568. boolean broken = false;
  1569. try {
  1570.  
  1571. result = shardedJedis.expire(key, seconds);
  1572.  
  1573. } catch (Exception e) {
  1574. log.error(e.getMessage(), e);
  1575. broken = true;
  1576. } finally {
  1577. redisDataSource.returnResource(shardedJedis, broken);
  1578. }
  1579. return result;
  1580. }
  1581.  
  1582. public Long expireAt(byte[] key, long unixTime) {
  1583. Long result = null;
  1584. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1585. if (shardedJedis == null) {
  1586. return result;
  1587. }
  1588. boolean broken = false;
  1589. try {
  1590.  
  1591. result = shardedJedis.expireAt(key, unixTime);
  1592.  
  1593. } catch (Exception e) {
  1594. log.error(e.getMessage(), e);
  1595. broken = true;
  1596. } finally {
  1597. redisDataSource.returnResource(shardedJedis, broken);
  1598. }
  1599. return result;
  1600. }
  1601.  
  1602. public Long ttl(byte[] key) {
  1603. Long result = null;
  1604. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1605. if (shardedJedis == null) {
  1606. return result;
  1607. }
  1608. boolean broken = false;
  1609. try {
  1610.  
  1611. result = shardedJedis.ttl(key);
  1612.  
  1613. } catch (Exception e) {
  1614. log.error(e.getMessage(), e);
  1615. broken = true;
  1616. } finally {
  1617. redisDataSource.returnResource(shardedJedis, broken);
  1618. }
  1619. return result;
  1620. }
  1621.  
  1622. public byte[] getSet(byte[] key, byte[] value) {
  1623. byte[] result = null;
  1624. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1625. if (shardedJedis == null) {
  1626. return result;
  1627. }
  1628. boolean broken = false;
  1629. try {
  1630.  
  1631. result = shardedJedis.getSet(key, value);
  1632.  
  1633. } catch (Exception e) {
  1634. log.error(e.getMessage(), e);
  1635. broken = true;
  1636. } finally {
  1637. redisDataSource.returnResource(shardedJedis, broken);
  1638. }
  1639. return result;
  1640. }
  1641.  
  1642. public Long setnx(byte[] key, byte[] value) {
  1643. Long result = null;
  1644. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1645. if (shardedJedis == null) {
  1646. return result;
  1647. }
  1648. boolean broken = false;
  1649. try {
  1650.  
  1651. result = shardedJedis.setnx(key, value);
  1652.  
  1653. } catch (Exception e) {
  1654. log.error(e.getMessage(), e);
  1655. broken = true;
  1656. } finally {
  1657. redisDataSource.returnResource(shardedJedis, broken);
  1658. }
  1659. return result;
  1660. }
  1661.  
  1662. public String setex(byte[] key, int seconds, byte[] value) {
  1663. String result = null;
  1664. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1665. if (shardedJedis == null) {
  1666. return result;
  1667. }
  1668. boolean broken = false;
  1669. try {
  1670.  
  1671. result = shardedJedis.setex(key, seconds, value);
  1672.  
  1673. } catch (Exception e) {
  1674. log.error(e.getMessage(), e);
  1675. broken = true;
  1676. } finally {
  1677. redisDataSource.returnResource(shardedJedis, broken);
  1678. }
  1679. return result;
  1680. }
  1681.  
  1682. public Long decrBy(byte[] key, long integer) {
  1683. Long result = null;
  1684. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1685. if (shardedJedis == null) {
  1686. return result;
  1687. }
  1688. boolean broken = false;
  1689. try {
  1690.  
  1691. result = shardedJedis.decrBy(key, integer);
  1692.  
  1693. } catch (Exception e) {
  1694. log.error(e.getMessage(), e);
  1695. broken = true;
  1696. } finally {
  1697. redisDataSource.returnResource(shardedJedis, broken);
  1698. }
  1699. return result;
  1700. }
  1701.  
  1702. public Long decr(byte[] key) {
  1703. Long result = null;
  1704. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1705. if (shardedJedis == null) {
  1706. return result;
  1707. }
  1708. boolean broken = false;
  1709. try {
  1710.  
  1711. result = shardedJedis.decr(key);
  1712.  
  1713. } catch (Exception e) {
  1714. log.error(e.getMessage(), e);
  1715. broken = true;
  1716. } finally {
  1717. redisDataSource.returnResource(shardedJedis, broken);
  1718. }
  1719. return result;
  1720. }
  1721.  
  1722. public Long incrBy(byte[] key, long integer) {
  1723. Long result = null;
  1724. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1725. if (shardedJedis == null) {
  1726. return result;
  1727. }
  1728. boolean broken = false;
  1729. try {
  1730.  
  1731. result = shardedJedis.incrBy(key, integer);
  1732.  
  1733. } catch (Exception e) {
  1734. log.error(e.getMessage(), e);
  1735. broken = true;
  1736. } finally {
  1737. redisDataSource.returnResource(shardedJedis, broken);
  1738. }
  1739. return result;
  1740. }
  1741.  
  1742. public Long incr(byte[] key) {
  1743. Long result = null;
  1744. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1745. if (shardedJedis == null) {
  1746. return result;
  1747. }
  1748. boolean broken = false;
  1749. try {
  1750.  
  1751. result = shardedJedis.incr(key);
  1752.  
  1753. } catch (Exception e) {
  1754. log.error(e.getMessage(), e);
  1755. broken = true;
  1756. } finally {
  1757. redisDataSource.returnResource(shardedJedis, broken);
  1758. }
  1759. return result;
  1760. }
  1761.  
  1762. public Long append(byte[] key, byte[] value) {
  1763. Long result = null;
  1764. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1765. if (shardedJedis == null) {
  1766. return result;
  1767. }
  1768. boolean broken = false;
  1769. try {
  1770.  
  1771. result = shardedJedis.append(key, value);
  1772.  
  1773. } catch (Exception e) {
  1774. log.error(e.getMessage(), e);
  1775. broken = true;
  1776. } finally {
  1777. redisDataSource.returnResource(shardedJedis, broken);
  1778. }
  1779. return result;
  1780. }
  1781.  
  1782. public byte[] substr(byte[] key, int start, int end) {
  1783. byte[] result = null;
  1784. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1785. if (shardedJedis == null) {
  1786. return result;
  1787. }
  1788. boolean broken = false;
  1789. try {
  1790.  
  1791. result = shardedJedis.substr(key, start, end);
  1792.  
  1793. } catch (Exception e) {
  1794. log.error(e.getMessage(), e);
  1795. broken = true;
  1796. } finally {
  1797. redisDataSource.returnResource(shardedJedis, broken);
  1798. }
  1799. return result;
  1800. }
  1801.  
  1802. public Long hset(byte[] key, byte[] field, byte[] value) {
  1803. Long result = null;
  1804. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1805. if (shardedJedis == null) {
  1806. return result;
  1807. }
  1808. boolean broken = false;
  1809. try {
  1810.  
  1811. result = shardedJedis.hset(key, field, value);
  1812.  
  1813. } catch (Exception e) {
  1814. log.error(e.getMessage(), e);
  1815. broken = true;
  1816. } finally {
  1817. redisDataSource.returnResource(shardedJedis, broken);
  1818. }
  1819. return result;
  1820. }
  1821.  
  1822. public byte[] hget(byte[] key, byte[] field) {
  1823. byte[] result = null;
  1824. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1825. if (shardedJedis == null) {
  1826. return result;
  1827. }
  1828. boolean broken = false;
  1829. try {
  1830.  
  1831. result = shardedJedis.hget(key, field);
  1832.  
  1833. } catch (Exception e) {
  1834. log.error(e.getMessage(), e);
  1835. broken = true;
  1836. } finally {
  1837. redisDataSource.returnResource(shardedJedis, broken);
  1838. }
  1839. return result;
  1840. }
  1841.  
  1842. public Long hsetnx(byte[] key, byte[] field, byte[] value) {
  1843. Long result = null;
  1844. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1845. if (shardedJedis == null) {
  1846. return result;
  1847. }
  1848. boolean broken = false;
  1849. try {
  1850.  
  1851. result = shardedJedis.hsetnx(key, field, value);
  1852.  
  1853. } catch (Exception e) {
  1854.  
  1855. log.error(e.getMessage(), e);
  1856. broken = true;
  1857. } finally {
  1858. redisDataSource.returnResource(shardedJedis, broken);
  1859. }
  1860. return result;
  1861. }
  1862.  
  1863. public String hmset(byte[] key, Map<byte[], byte[]> hash) {
  1864. String result = null;
  1865. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1866. if (shardedJedis == null) {
  1867. return result;
  1868. }
  1869. boolean broken = false;
  1870. try {
  1871.  
  1872. result = shardedJedis.hmset(key, hash);
  1873.  
  1874. } catch (Exception e) {
  1875.  
  1876. log.error(e.getMessage(), e);
  1877. broken = true;
  1878. } finally {
  1879. redisDataSource.returnResource(shardedJedis, broken);
  1880. }
  1881. return result;
  1882. }
  1883.  
  1884. public List<byte[]> hmget(byte[] key, byte[]... fields) {
  1885. List<byte[]> result = null;
  1886. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1887. if (shardedJedis == null) {
  1888. return result;
  1889. }
  1890. boolean broken = false;
  1891. try {
  1892.  
  1893. result = shardedJedis.hmget(key, fields);
  1894.  
  1895. } catch (Exception e) {
  1896.  
  1897. log.error(e.getMessage(), e);
  1898. broken = true;
  1899. } finally {
  1900. redisDataSource.returnResource(shardedJedis, broken);
  1901. }
  1902. return result;
  1903. }
  1904.  
  1905. public Long hincrBy(byte[] key, byte[] field, long value) {
  1906. Long result = null;
  1907. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1908. if (shardedJedis == null) {
  1909. return result;
  1910. }
  1911. boolean broken = false;
  1912. try {
  1913.  
  1914. result = shardedJedis.hincrBy(key, field, value);
  1915.  
  1916. } catch (Exception e) {
  1917.  
  1918. log.error(e.getMessage(), e);
  1919. broken = true;
  1920. } finally {
  1921. redisDataSource.returnResource(shardedJedis, broken);
  1922. }
  1923. return result;
  1924. }
  1925.  
  1926. public Boolean hexists(byte[] key, byte[] field) {
  1927. Boolean result = false;
  1928. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1929. if (shardedJedis == null) {
  1930. return result;
  1931. }
  1932. boolean broken = false;
  1933. try {
  1934.  
  1935. result = shardedJedis.hexists(key, field);
  1936.  
  1937. } catch (Exception e) {
  1938.  
  1939. log.error(e.getMessage(), e);
  1940. broken = true;
  1941. } finally {
  1942. redisDataSource.returnResource(shardedJedis, broken);
  1943. }
  1944. return result;
  1945. }
  1946.  
  1947. public Long hdel(byte[] key, byte[] field) {
  1948. Long result = null;
  1949. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1950. if (shardedJedis == null) {
  1951. return result;
  1952. }
  1953. boolean broken = false;
  1954. try {
  1955.  
  1956. result = shardedJedis.hdel(key, field);
  1957.  
  1958. } catch (Exception e) {
  1959.  
  1960. log.error(e.getMessage(), e);
  1961. broken = true;
  1962. } finally {
  1963. redisDataSource.returnResource(shardedJedis, broken);
  1964. }
  1965. return result;
  1966. }
  1967.  
  1968. public Long hlen(byte[] key) {
  1969. Long result = null;
  1970. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1971. if (shardedJedis == null) {
  1972. return result;
  1973. }
  1974. boolean broken = false;
  1975. try {
  1976.  
  1977. result = shardedJedis.hlen(key);
  1978.  
  1979. } catch (Exception e) {
  1980.  
  1981. log.error(e.getMessage(), e);
  1982. broken = true;
  1983. } finally {
  1984. redisDataSource.returnResource(shardedJedis, broken);
  1985. }
  1986. return result;
  1987. }
  1988.  
  1989. public Set<byte[]> hkeys(byte[] key) {
  1990. Set<byte[]> result = null;
  1991. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1992. if (shardedJedis == null) {
  1993. return result;
  1994. }
  1995. boolean broken = false;
  1996. try {
  1997.  
  1998. result = shardedJedis.hkeys(key);
  1999.  
  2000. } catch (Exception e) {
  2001.  
  2002. log.error(e.getMessage(), e);
  2003. broken = true;
  2004. } finally {
  2005. redisDataSource.returnResource(shardedJedis, broken);
  2006. }
  2007. return result;
  2008. }
  2009.  
  2010. public Collection<byte[]> hvals(byte[] key) {
  2011. Collection<byte[]> result = null;
  2012. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2013. if (shardedJedis == null) {
  2014. return result;
  2015. }
  2016. boolean broken = false;
  2017. try {
  2018.  
  2019. result = shardedJedis.hvals(key);
  2020.  
  2021. } catch (Exception e) {
  2022.  
  2023. log.error(e.getMessage(), e);
  2024. broken = true;
  2025. } finally {
  2026. redisDataSource.returnResource(shardedJedis, broken);
  2027. }
  2028. return result;
  2029. }
  2030.  
  2031. public Map<byte[], byte[]> hgetAll(byte[] key) {
  2032. Map<byte[], byte[]> result = null;
  2033. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2034. if (shardedJedis == null) {
  2035. return result;
  2036. }
  2037. boolean broken = false;
  2038. try {
  2039.  
  2040. result = shardedJedis.hgetAll(key);
  2041.  
  2042. } catch (Exception e) {
  2043.  
  2044. log.error(e.getMessage(), e);
  2045. broken = true;
  2046. } finally {
  2047. redisDataSource.returnResource(shardedJedis, broken);
  2048. }
  2049. return result;
  2050. }
  2051.  
  2052. public Long rpush(byte[] key, byte[] string) {
  2053. Long result = null;
  2054. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2055. if (shardedJedis == null) {
  2056. return result;
  2057. }
  2058. boolean broken = false;
  2059. try {
  2060.  
  2061. result = shardedJedis.rpush(key, string);
  2062.  
  2063. } catch (Exception e) {
  2064.  
  2065. log.error(e.getMessage(), e);
  2066. broken = true;
  2067. } finally {
  2068. redisDataSource.returnResource(shardedJedis, broken);
  2069. }
  2070. return result;
  2071. }
  2072.  
  2073. public Long lpush(byte[] key, byte[] string) {
  2074. Long result = null;
  2075. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2076. if (shardedJedis == null) {
  2077. return result;
  2078. }
  2079. boolean broken = false;
  2080. try {
  2081.  
  2082. result = shardedJedis.lpush(key, string);
  2083.  
  2084. } catch (Exception e) {
  2085.  
  2086. log.error(e.getMessage(), e);
  2087. broken = true;
  2088. } finally {
  2089. redisDataSource.returnResource(shardedJedis, broken);
  2090. }
  2091. return result;
  2092. }
  2093.  
  2094. public Long llen(byte[] key) {
  2095. Long result = null;
  2096. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2097. if (shardedJedis == null) {
  2098. return result;
  2099. }
  2100. boolean broken = false;
  2101. try {
  2102.  
  2103. result = shardedJedis.llen(key);
  2104.  
  2105. } catch (Exception e) {
  2106.  
  2107. log.error(e.getMessage(), e);
  2108. broken = true;
  2109. } finally {
  2110. redisDataSource.returnResource(shardedJedis, broken);
  2111. }
  2112. return result;
  2113. }
  2114.  
  2115. public List<byte[]> lrange(byte[] key, int start, int end) {
  2116. List<byte[]> result = null;
  2117. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2118. if (shardedJedis == null) {
  2119. return result;
  2120. }
  2121. boolean broken = false;
  2122. try {
  2123.  
  2124. result = shardedJedis.lrange(key, start, end);
  2125.  
  2126. } catch (Exception e) {
  2127.  
  2128. log.error(e.getMessage(), e);
  2129. broken = true;
  2130. } finally {
  2131. redisDataSource.returnResource(shardedJedis, broken);
  2132. }
  2133. return result;
  2134. }
  2135.  
  2136. public String ltrim(byte[] key, int start, int end) {
  2137. String result = null;
  2138. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2139. if (shardedJedis == null) {
  2140. return result;
  2141. }
  2142. boolean broken = false;
  2143. try {
  2144.  
  2145. result = shardedJedis.ltrim(key, start, end);
  2146.  
  2147. } catch (Exception e) {
  2148. log.error(e.getMessage(), e);
  2149. broken = true;
  2150. } finally {
  2151. redisDataSource.returnResource(shardedJedis, broken);
  2152. }
  2153. return result;
  2154. }
  2155.  
  2156. public byte[] lindex(byte[] key, int index) {
  2157. byte[] result = null;
  2158. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2159. if (shardedJedis == null) {
  2160. return result;
  2161. }
  2162. boolean broken = false;
  2163. try {
  2164.  
  2165. result = shardedJedis.lindex(key, index);
  2166.  
  2167. } catch (Exception e) {
  2168.  
  2169. log.error(e.getMessage(), e);
  2170. broken = true;
  2171. } finally {
  2172. redisDataSource.returnResource(shardedJedis, broken);
  2173. }
  2174. return result;
  2175. }
  2176.  
  2177. public String lset(byte[] key, int index, byte[] value) {
  2178. String result = null;
  2179. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2180. if (shardedJedis == null) {
  2181. return result;
  2182. }
  2183. boolean broken = false;
  2184. try {
  2185.  
  2186. result = shardedJedis.lset(key, index, value);
  2187.  
  2188. } catch (Exception e) {
  2189.  
  2190. log.error(e.getMessage(), e);
  2191. broken = true;
  2192. } finally {
  2193. redisDataSource.returnResource(shardedJedis, broken);
  2194. }
  2195. return result;
  2196. }
  2197.  
  2198. public Long lrem(byte[] key, int count, byte[] value) {
  2199. Long result = null;
  2200. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2201. if (shardedJedis == null) {
  2202. return result;
  2203. }
  2204. boolean broken = false;
  2205. try {
  2206.  
  2207. result = shardedJedis.lrem(key, count, value);
  2208.  
  2209. } catch (Exception e) {
  2210.  
  2211. log.error(e.getMessage(), e);
  2212. broken = true;
  2213. } finally {
  2214. redisDataSource.returnResource(shardedJedis, broken);
  2215. }
  2216. return result;
  2217. }
  2218.  
  2219. public byte[] lpop(byte[] key) {
  2220. byte[] result = null;
  2221. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2222. if (shardedJedis == null) {
  2223. return result;
  2224. }
  2225. boolean broken = false;
  2226. try {
  2227.  
  2228. result = shardedJedis.lpop(key);
  2229.  
  2230. } catch (Exception e) {
  2231.  
  2232. log.error(e.getMessage(), e);
  2233. broken = true;
  2234. } finally {
  2235. redisDataSource.returnResource(shardedJedis, broken);
  2236. }
  2237. return result;
  2238. }
  2239.  
  2240. public byte[] rpop(byte[] key) {
  2241. byte[] result = null;
  2242. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2243. if (shardedJedis == null) {
  2244. return result;
  2245. }
  2246. boolean broken = false;
  2247. try {
  2248.  
  2249. result = shardedJedis.rpop(key);
  2250.  
  2251. } catch (Exception e) {
  2252.  
  2253. log.error(e.getMessage(), e);
  2254. broken = true;
  2255. } finally {
  2256. redisDataSource.returnResource(shardedJedis, broken);
  2257. }
  2258. return result;
  2259. }
  2260.  
  2261. public Long sadd(byte[] key, byte[] member) {
  2262. Long result = null;
  2263. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2264. if (shardedJedis == null) {
  2265. return result;
  2266. }
  2267. boolean broken = false;
  2268. try {
  2269.  
  2270. result = shardedJedis.sadd(key, member);
  2271.  
  2272. } catch (Exception e) {
  2273.  
  2274. log.error(e.getMessage(), e);
  2275. broken = true;
  2276. } finally {
  2277. redisDataSource.returnResource(shardedJedis, broken);
  2278. }
  2279. return result;
  2280. }
  2281.  
  2282. public Set<byte[]> smembers(byte[] key) {
  2283. Set<byte[]> result = null;
  2284. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2285. if (shardedJedis == null) {
  2286. return result;
  2287. }
  2288. boolean broken = false;
  2289. try {
  2290.  
  2291. result = shardedJedis.smembers(key);
  2292.  
  2293. } catch (Exception e) {
  2294.  
  2295. log.error(e.getMessage(), e);
  2296. broken = true;
  2297. } finally {
  2298. redisDataSource.returnResource(shardedJedis, broken);
  2299. }
  2300. return result;
  2301. }
  2302.  
  2303. public Long srem(byte[] key, byte[] member) {
  2304. Long result = null;
  2305. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2306. if (shardedJedis == null) {
  2307. return result;
  2308. }
  2309. boolean broken = false;
  2310. try {
  2311.  
  2312. result = shardedJedis.srem(key, member);
  2313.  
  2314. } catch (Exception e) {
  2315.  
  2316. log.error(e.getMessage(), e);
  2317. broken = true;
  2318. } finally {
  2319. redisDataSource.returnResource(shardedJedis, broken);
  2320. }
  2321. return result;
  2322. }
  2323.  
  2324. public byte[] spop(byte[] key) {
  2325. byte[] result = null;
  2326. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2327. if (shardedJedis == null) {
  2328. return result;
  2329. }
  2330. boolean broken = false;
  2331. try {
  2332.  
  2333. result = shardedJedis.spop(key);
  2334.  
  2335. } catch (Exception e) {
  2336.  
  2337. log.error(e.getMessage(), e);
  2338. broken = true;
  2339. } finally {
  2340. redisDataSource.returnResource(shardedJedis, broken);
  2341. }
  2342. return result;
  2343. }
  2344.  
  2345. public Long scard(byte[] key) {
  2346. Long result = null;
  2347. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2348. if (shardedJedis == null) {
  2349. return result;
  2350. }
  2351. boolean broken = false;
  2352. try {
  2353.  
  2354. result = shardedJedis.scard(key);
  2355.  
  2356. } catch (Exception e) {
  2357.  
  2358. log.error(e.getMessage(), e);
  2359. broken = true;
  2360. } finally {
  2361. redisDataSource.returnResource(shardedJedis, broken);
  2362. }
  2363. return result;
  2364. }
  2365.  
  2366. public Boolean sismember(byte[] key, byte[] member) {
  2367. Boolean result = false;
  2368. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2369. if (shardedJedis == null) {
  2370. return result;
  2371. }
  2372. boolean broken = false;
  2373. try {
  2374.  
  2375. result = shardedJedis.sismember(key, member);
  2376.  
  2377. } catch (Exception e) {
  2378.  
  2379. log.error(e.getMessage(), e);
  2380. broken = true;
  2381. } finally {
  2382. redisDataSource.returnResource(shardedJedis, broken);
  2383. }
  2384. return result;
  2385. }
  2386.  
  2387. public byte[] srandmember(byte[] key) {
  2388. byte[] result = null;
  2389. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2390. if (shardedJedis == null) {
  2391. return result;
  2392. }
  2393. boolean broken = false;
  2394. try {
  2395.  
  2396. result = shardedJedis.srandmember(key);
  2397.  
  2398. } catch (Exception e) {
  2399.  
  2400. log.error(e.getMessage(), e);
  2401. broken = true;
  2402. } finally {
  2403. redisDataSource.returnResource(shardedJedis, broken);
  2404. }
  2405. return result;
  2406. }
  2407.  
  2408. public Long zadd(byte[] key, double score, byte[] member) {
  2409. Long result = null;
  2410. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2411. if (shardedJedis == null) {
  2412. return result;
  2413. }
  2414. boolean broken = false;
  2415. try {
  2416.  
  2417. result = shardedJedis.zadd(key, score, member);
  2418.  
  2419. } catch (Exception e) {
  2420.  
  2421. log.error(e.getMessage(), e);
  2422. broken = true;
  2423. } finally {
  2424. redisDataSource.returnResource(shardedJedis, broken);
  2425. }
  2426. return result;
  2427. }
  2428.  
  2429. public Set<byte[]> zrange(byte[] key, int start, int end) {
  2430. Set<byte[]> result = null;
  2431. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2432. if (shardedJedis == null) {
  2433. return result;
  2434. }
  2435. boolean broken = false;
  2436. try {
  2437.  
  2438. result = shardedJedis.zrange(key, start, end);
  2439.  
  2440. } catch (Exception e) {
  2441.  
  2442. log.error(e.getMessage(), e);
  2443. broken = true;
  2444. } finally {
  2445. redisDataSource.returnResource(shardedJedis, broken);
  2446. }
  2447. return result;
  2448. }
  2449.  
  2450. public Long zrem(byte[] key, byte[] member) {
  2451. Long result = null;
  2452. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2453. if (shardedJedis == null) {
  2454. return result;
  2455. }
  2456. boolean broken = false;
  2457. try {
  2458.  
  2459. result = shardedJedis.zrem(key, member);
  2460.  
  2461. } catch (Exception e) {
  2462.  
  2463. log.error(e.getMessage(), e);
  2464. broken = true;
  2465. } finally {
  2466. redisDataSource.returnResource(shardedJedis, broken);
  2467. }
  2468. return result;
  2469. }
  2470.  
  2471. public Double zincrby(byte[] key, double score, byte[] member) {
  2472. Double result = null;
  2473. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2474. if (shardedJedis == null) {
  2475. return result;
  2476. }
  2477. boolean broken = false;
  2478. try {
  2479.  
  2480. result = shardedJedis.zincrby(key, score, member);
  2481.  
  2482. } catch (Exception e) {
  2483.  
  2484. log.error(e.getMessage(), e);
  2485. broken = true;
  2486. } finally {
  2487. redisDataSource.returnResource(shardedJedis, broken);
  2488. }
  2489. return result;
  2490. }
  2491.  
  2492. public Long zrank(byte[] key, byte[] member) {
  2493. Long result = null;
  2494. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2495. if (shardedJedis == null) {
  2496. return result;
  2497. }
  2498. boolean broken = false;
  2499. try {
  2500.  
  2501. result = shardedJedis.zrank(key, member);
  2502.  
  2503. } catch (Exception e) {
  2504.  
  2505. log.error(e.getMessage(), e);
  2506. broken = true;
  2507. } finally {
  2508. redisDataSource.returnResource(shardedJedis, broken);
  2509. }
  2510. return result;
  2511. }
  2512.  
  2513. public Long zrevrank(byte[] key, byte[] member) {
  2514. Long result = null;
  2515. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2516. if (shardedJedis == null) {
  2517. return result;
  2518. }
  2519. boolean broken = false;
  2520. try {
  2521.  
  2522. result = shardedJedis.zrevrank(key, member);
  2523.  
  2524. } catch (Exception e) {
  2525.  
  2526. log.error(e.getMessage(), e);
  2527. broken = true;
  2528. } finally {
  2529. redisDataSource.returnResource(shardedJedis, broken);
  2530. }
  2531. return result;
  2532. }
  2533.  
  2534. public Set<byte[]> zrevrange(byte[] key, int start, int end) {
  2535. Set<byte[]> result = null;
  2536. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2537. if (shardedJedis == null) {
  2538. return result;
  2539. }
  2540. boolean broken = false;
  2541. try {
  2542.  
  2543. result = shardedJedis.zrevrange(key, start, end);
  2544.  
  2545. } catch (Exception e) {
  2546.  
  2547. log.error(e.getMessage(), e);
  2548. broken = true;
  2549. } finally {
  2550. redisDataSource.returnResource(shardedJedis, broken);
  2551. }
  2552. return result;
  2553. }
  2554.  
  2555. public Set<Tuple> zrangeWithScores(byte[] key, int start, int end) {
  2556. Set<Tuple> result = null;
  2557. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2558. if (shardedJedis == null) {
  2559. return result;
  2560. }
  2561. boolean broken = false;
  2562. try {
  2563.  
  2564. result = shardedJedis.zrangeWithScores(key, start, end);
  2565.  
  2566. } catch (Exception e) {
  2567.  
  2568. log.error(e.getMessage(), e);
  2569. broken = true;
  2570. } finally {
  2571. redisDataSource.returnResource(shardedJedis, broken);
  2572. }
  2573. return result;
  2574. }
  2575.  
  2576. public Set<Tuple> zrevrangeWithScores(byte[] key, int start, int end) {
  2577. Set<Tuple> result = null;
  2578. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2579. if (shardedJedis == null) {
  2580. return result;
  2581. }
  2582. boolean broken = false;
  2583. try {
  2584.  
  2585. result = shardedJedis.zrevrangeWithScores(key, start, end);
  2586.  
  2587. } catch (Exception e) {
  2588.  
  2589. log.error(e.getMessage(), e);
  2590. broken = true;
  2591. } finally {
  2592. redisDataSource.returnResource(shardedJedis, broken);
  2593. }
  2594. return result;
  2595. }
  2596.  
  2597. public Long zcard(byte[] key) {
  2598. Long result = null;
  2599. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2600. if (shardedJedis == null) {
  2601. return result;
  2602. }
  2603. boolean broken = false;
  2604. try {
  2605.  
  2606. result = shardedJedis.zcard(key);
  2607.  
  2608. } catch (Exception e) {
  2609.  
  2610. log.error(e.getMessage(), e);
  2611. broken = true;
  2612. } finally {
  2613. redisDataSource.returnResource(shardedJedis, broken);
  2614. }
  2615. return result;
  2616. }
  2617.  
  2618. public Double zscore(byte[] key, byte[] member) {
  2619. Double result = null;
  2620. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2621. if (shardedJedis == null) {
  2622. return result;
  2623. }
  2624. boolean broken = false;
  2625. try {
  2626.  
  2627. result = shardedJedis.zscore(key, member);
  2628.  
  2629. } catch (Exception e) {
  2630.  
  2631. log.error(e.getMessage(), e);
  2632. broken = true;
  2633. } finally {
  2634. redisDataSource.returnResource(shardedJedis, broken);
  2635. }
  2636. return result;
  2637. }
  2638.  
  2639. public List<byte[]> sort(byte[] key) {
  2640. List<byte[]> result = null;
  2641. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2642. if (shardedJedis == null) {
  2643. return result;
  2644. }
  2645. boolean broken = false;
  2646. try {
  2647.  
  2648. result = shardedJedis.sort(key);
  2649.  
  2650. } catch (Exception e) {
  2651.  
  2652. log.error(e.getMessage(), e);
  2653. broken = true;
  2654. } finally {
  2655. redisDataSource.returnResource(shardedJedis, broken);
  2656. }
  2657. return result;
  2658. }
  2659.  
  2660. public List<byte[]> sort(byte[] key, SortingParams sortingParameters) {
  2661. List<byte[]> result = null;
  2662. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2663. if (shardedJedis == null) {
  2664. return result;
  2665. }
  2666. boolean broken = false;
  2667. try {
  2668.  
  2669. result = shardedJedis.sort(key, sortingParameters);
  2670.  
  2671. } catch (Exception e) {
  2672.  
  2673. log.error(e.getMessage(), e);
  2674. broken = true;
  2675. } finally {
  2676. redisDataSource.returnResource(shardedJedis, broken);
  2677. }
  2678. return result;
  2679. }
  2680.  
  2681. public Long zcount(byte[] key, double min, double max) {
  2682. Long result = null;
  2683. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2684. if (shardedJedis == null) {
  2685. return result;
  2686. }
  2687. boolean broken = false;
  2688. try {
  2689.  
  2690. result = shardedJedis.zcount(key, min, max);
  2691.  
  2692. } catch (Exception e) {
  2693.  
  2694. log.error(e.getMessage(), e);
  2695. broken = true;
  2696. } finally {
  2697. redisDataSource.returnResource(shardedJedis, broken);
  2698. }
  2699. return result;
  2700. }
  2701.  
  2702. public Set<byte[]> zrangeByScore(byte[] key, double min, double max) {
  2703. Set<byte[]> result = null;
  2704. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2705. if (shardedJedis == null) {
  2706. return result;
  2707. }
  2708. boolean broken = false;
  2709. try {
  2710.  
  2711. result = shardedJedis.zrangeByScore(key, min, max);
  2712.  
  2713. } catch (Exception e) {
  2714.  
  2715. log.error(e.getMessage(), e);
  2716. broken = true;
  2717. } finally {
  2718. redisDataSource.returnResource(shardedJedis, broken);
  2719. }
  2720. return result;
  2721. }
  2722.  
  2723. public Set<byte[]> zrangeByScore(byte[] key, double min, double max, int offset, int count) {
  2724. Set<byte[]> result = null;
  2725. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2726. if (shardedJedis == null) {
  2727. return result;
  2728. }
  2729. boolean broken = false;
  2730. try {
  2731.  
  2732. result = shardedJedis.zrangeByScore(key, min, max, offset, count);
  2733.  
  2734. } catch (Exception e) {
  2735.  
  2736. log.error(e.getMessage(), e);
  2737. broken = true;
  2738. } finally {
  2739. redisDataSource.returnResource(shardedJedis, broken);
  2740. }
  2741. return result;
  2742. }
  2743.  
  2744. public Set<Tuple> zrangeByScoreWithScores(byte[] key, double min, double max) {
  2745. Set<Tuple> result = null;
  2746. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2747. if (shardedJedis == null) {
  2748. return result;
  2749. }
  2750. boolean broken = false;
  2751. try {
  2752.  
  2753. result = shardedJedis.zrangeByScoreWithScores(key, min, max);
  2754.  
  2755. } catch (Exception e) {
  2756.  
  2757. log.error(e.getMessage(), e);
  2758. broken = true;
  2759. } finally {
  2760. redisDataSource.returnResource(shardedJedis, broken);
  2761. }
  2762. return result;
  2763. }
  2764.  
  2765. public Set<Tuple> zrangeByScoreWithScores(byte[] key, double min, double max, int offset, int count) {
  2766. Set<Tuple> result = null;
  2767. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2768. if (shardedJedis == null) {
  2769. return result;
  2770. }
  2771. boolean broken = false;
  2772. try {
  2773.  
  2774. result = shardedJedis.zrangeByScoreWithScores(key, min, max, offset, count);
  2775.  
  2776. } catch (Exception e) {
  2777.  
  2778. log.error(e.getMessage(), e);
  2779. broken = true;
  2780. } finally {
  2781. redisDataSource.returnResource(shardedJedis, broken);
  2782. }
  2783. return result;
  2784. }
  2785.  
  2786. public Set<byte[]> zrevrangeByScore(byte[] key, double max, double min) {
  2787. Set<byte[]> result = null;
  2788. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2789. if (shardedJedis == null) {
  2790. return result;
  2791. }
  2792. boolean broken = false;
  2793. try {
  2794.  
  2795. result = shardedJedis.zrevrangeByScore(key, max, min);
  2796.  
  2797. } catch (Exception e) {
  2798.  
  2799. log.error(e.getMessage(), e);
  2800. broken = true;
  2801. } finally {
  2802. redisDataSource.returnResource(shardedJedis, broken);
  2803. }
  2804. return result;
  2805. }
  2806.  
  2807. public Set<byte[]> zrevrangeByScore(byte[] key, double max, double min, int offset, int count) {
  2808. Set<byte[]> result = null;
  2809. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2810. if (shardedJedis == null) {
  2811. return result;
  2812. }
  2813. boolean broken = false;
  2814. try {
  2815.  
  2816. result = shardedJedis.zrevrangeByScore(key, max, min, offset, count);
  2817.  
  2818. } catch (Exception e) {
  2819.  
  2820. log.error(e.getMessage(), e);
  2821. broken = true;
  2822. } finally {
  2823. redisDataSource.returnResource(shardedJedis, broken);
  2824. }
  2825. return result;
  2826. }
  2827.  
  2828. public Set<Tuple> zrevrangeByScoreWithScores(byte[] key, double max, double min) {
  2829. Set<Tuple> result = null;
  2830. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2831. if (shardedJedis == null) {
  2832. return result;
  2833. }
  2834. boolean broken = false;
  2835. try {
  2836.  
  2837. result = shardedJedis.zrevrangeByScoreWithScores(key, max, min);
  2838.  
  2839. } catch (Exception e) {
  2840.  
  2841. log.error(e.getMessage(), e);
  2842. broken = true;
  2843. } finally {
  2844. redisDataSource.returnResource(shardedJedis, broken);
  2845. }
  2846. return result;
  2847. }
  2848.  
  2849. public Set<Tuple> zrevrangeByScoreWithScores(byte[] key, double max, double min, int offset, int count) {
  2850. Set<Tuple> result = null;
  2851. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2852. if (shardedJedis == null) {
  2853. return result;
  2854. }
  2855. boolean broken = false;
  2856. try {
  2857.  
  2858. result = shardedJedis.zrevrangeByScoreWithScores(key, max, min, offset, count);
  2859.  
  2860. } catch (Exception e) {
  2861.  
  2862. log.error(e.getMessage(), e);
  2863. broken = true;
  2864. } finally {
  2865. redisDataSource.returnResource(shardedJedis, broken);
  2866. }
  2867. return result;
  2868. }
  2869.  
  2870. public Long zremrangeByRank(byte[] key, int start, int end) {
  2871. Long result = null;
  2872. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2873. if (shardedJedis == null) {
  2874. return result;
  2875. }
  2876. boolean broken = false;
  2877. try {
  2878.  
  2879. result = shardedJedis.zremrangeByRank(key, start, end);
  2880.  
  2881. } catch (Exception e) {
  2882.  
  2883. log.error(e.getMessage(), e);
  2884. broken = true;
  2885. } finally {
  2886. redisDataSource.returnResource(shardedJedis, broken);
  2887. }
  2888. return result;
  2889. }
  2890.  
  2891. public Long zremrangeByScore(byte[] key, double start, double end) {
  2892. Long result = null;
  2893. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2894. if (shardedJedis == null) {
  2895. return result;
  2896. }
  2897. boolean broken = false;
  2898. try {
  2899.  
  2900. result = shardedJedis.zremrangeByScore(key, start, end);
  2901.  
  2902. } catch (Exception e) {
  2903. log.error(e.getMessage(), e);
  2904. broken = true;
  2905. } finally {
  2906. redisDataSource.returnResource(shardedJedis, broken);
  2907. }
  2908. return result;
  2909. }
  2910.  
  2911. public Long linsert(byte[] key, LIST_POSITION where, byte[] pivot, byte[] value) {
  2912. Long result = null;
  2913. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2914. if (shardedJedis == null) {
  2915. return result;
  2916. }
  2917. boolean broken = false;
  2918. try {
  2919.  
  2920. result = shardedJedis.linsert(key, where, pivot, value);
  2921.  
  2922. } catch (Exception e) {
  2923. log.error(e.getMessage(), e);
  2924. broken = true;
  2925. } finally {
  2926. redisDataSource.returnResource(shardedJedis, broken);
  2927. }
  2928. return result;
  2929. }
  2930.  
  2931. public List<Object> pipelined(ShardedJedisPipeline shardedJedisPipeline) {
  2932. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2933. List<Object> result = null;
  2934. if (shardedJedis == null) {
  2935. return result;
  2936. }
  2937. boolean broken = false;
  2938. try {
  2939. result = shardedJedis.pipelined(shardedJedisPipeline);
  2940. } catch (Exception e) {
  2941. log.error(e.getMessage(), e);
  2942. broken = true;
  2943. } finally {
  2944. redisDataSource.returnResource(shardedJedis, broken);
  2945. }
  2946. return result;
  2947. }
  2948.  
  2949. public Jedis getShard(byte[] key) {
  2950. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2951. Jedis result = null;
  2952. if (shardedJedis == null) {
  2953. return result;
  2954. }
  2955. boolean broken = false;
  2956. try {
  2957. result = shardedJedis.getShard(key);
  2958. } catch (Exception e) {
  2959. log.error(e.getMessage(), e);
  2960. broken = true;
  2961. } finally {
  2962. redisDataSource.returnResource(shardedJedis, broken);
  2963. }
  2964. return result;
  2965. }
  2966.  
  2967. public Jedis getShard(String key) {
  2968. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2969. Jedis result = null;
  2970. if (shardedJedis == null) {
  2971. return result;
  2972. }
  2973. boolean broken = false;
  2974. try {
  2975. result = shardedJedis.getShard(key);
  2976. } catch (Exception e) {
  2977. log.error(e.getMessage(), e);
  2978. broken = true;
  2979. } finally {
  2980. redisDataSource.returnResource(shardedJedis, broken);
  2981. }
  2982. return result;
  2983. }
  2984.  
  2985. public JedisShardInfo getShardInfo(byte[] key) {
  2986. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2987. JedisShardInfo result = null;
  2988. if (shardedJedis == null) {
  2989. return result;
  2990. }
  2991. boolean broken = false;
  2992. try {
  2993. result = shardedJedis.getShardInfo(key);
  2994. } catch (Exception e) {
  2995. log.error(e.getMessage(), e);
  2996. broken = true;
  2997. } finally {
  2998. redisDataSource.returnResource(shardedJedis, broken);
  2999. }
  3000. return result;
  3001. }
  3002.  
  3003. public JedisShardInfo getShardInfo(String key) {
  3004. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  3005. JedisShardInfo result = null;
  3006. if (shardedJedis == null) {
  3007. return result;
  3008. }
  3009. boolean broken = false;
  3010. try {
  3011. result = shardedJedis.getShardInfo(key);
  3012. } catch (Exception e) {
  3013. log.error(e.getMessage(), e);
  3014. broken = true;
  3015. } finally {
  3016. redisDataSource.returnResource(shardedJedis, broken);
  3017. }
  3018. return result;
  3019. }
  3020.  
  3021. public String getKeyTag(String key) {
  3022. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  3023. String result = null;
  3024. if (shardedJedis == null) {
  3025. return result;
  3026. }
  3027. boolean broken = false;
  3028. try {
  3029. result = shardedJedis.getKeyTag(key);
  3030. } catch (Exception e) {
  3031. log.error(e.getMessage(), e);
  3032. broken = true;
  3033. } finally {
  3034. redisDataSource.returnResource(shardedJedis, broken);
  3035. }
  3036. return result;
  3037. }
  3038.  
  3039. public Collection<JedisShardInfo> getAllShardInfo() {
  3040. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  3041. Collection<JedisShardInfo> result = null;
  3042. if (shardedJedis == null) {
  3043. return result;
  3044. }
  3045. boolean broken = false;
  3046. try {
  3047. result = shardedJedis.getAllShardInfo();
  3048.  
  3049. } catch (Exception e) {
  3050. log.error(e.getMessage(), e);
  3051. broken = true;
  3052. } finally {
  3053. redisDataSource.returnResource(shardedJedis, broken);
  3054. }
  3055. return result;
  3056. }
  3057.  
  3058. public Collection<Jedis> getAllShards() {
  3059. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  3060. Collection<Jedis> result = null;
  3061. if (shardedJedis == null) {
  3062. return result;
  3063. }
  3064. boolean broken = false;
  3065. try {
  3066. result = shardedJedis.getAllShards();
  3067.  
  3068. } catch (Exception e) {
  3069. log.error(e.getMessage(), e);
  3070. broken = true;
  3071. } finally {
  3072. redisDataSource.returnResource(shardedJedis, broken);
  3073. }
  3074. return result;
  3075. }
  3076.  
  3077. }

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

感谢一路有你~

spring和redis的整合-超越昨天的自己系列(7)的更多相关文章

  1. spring和redis的整合

    spring和redis的整合-超越昨天的自己系列(7) 超越昨天的自己系列(7) 扯淡:  最近一直在慢慢多学习各个组件,自己搭建出一些想法.是一个涉猎的过程,慢慢意识到知识是可以融汇贯通,举一反三 ...

  2. 时间作为横轴的图表(morris.js)超越昨天的自己系列(8)

    超越昨天的自己系列(8) morris.js的官网有详细的例子:http://www.oesmith.co.uk/morris.js/ 特别注意它的依赖: <link rel="sty ...

  3. maven为不同环境打包(hibernate)-超越昨天的自己系列(6)

    超越昨天的自己系列(6) 使用ibatis开发中,耗在dao层的开发时间,调试时间,差错时间,以及适应修改需求的时间太长,导致项目看起来就添删改查,却特别费力.   在项目性能要求不高的情况下,开始寻 ...

  4. spring与redis简单整合

    项目结构 整合需要的依赖 <dependencies> <dependency> <groupId>org.springframework</groupId& ...

  5. Redis入门到高可用(十)—— Spring与Redis的整合

    1.pom文件 <!--redis--> <dependency> <groupId>org.springframework.data</groupId> ...

  6. HashMap归档-超越昨天的自己系列

    java HashMap 读一下源码,一个数组存储数据: transient Entry[] table; 内部存key和value的内部类: static class Entry<K,V> ...

  7. Collections.reverse 代码思考-超越昨天的自己系列(13)

    点进Collections.reverse的代码瞄了眼,然后就开始了一些基础知识的收集. 现在发现知道的越多,知道不知道的越多. 列几个记录下: reverse方法源码: /** * Reverses ...

  8. crontab 移动日志-超越昨天的自己系列(12)

    linux上定时执行某些脚本是管理服务器的时候比较常用的场景,比如定时检查进程是否存在,定时启动或关闭进程,定时检查日志删除日志等. 当我打开google百度crontab时长篇大论的一大堆,详细解释 ...

  9. java进程性能分析步骤-超越昨天的自己系列(11)

    java进程load过高分析步骤: top 查看java进程情况     top -Hp 查看某个进程的具体线程情况   printf 0x%x 确认哪一个线程占用cpu比较多,拿出来转成16进制   ...

随机推荐

  1. POJ 3206 最小生成树

    DESCRIPTION:T_T 在下是读不懂题意的.但是捏.现在知道是求把所有的点(是字母的点)连起来的最小的权值.即最小生成树.因为求最小生成树是不计较源点是哪个的.所以可以把A和S看成一样的.首先 ...

  2. Matrix-Tree定理

    感觉又学到了一个利器! 感谢Vfleaking神犇,传送门 http://vfleaking.blog.163.com/blog/static/1748076342013112523651955/   ...

  3. Jmeter java.lang.OutOfMemoryError: GC overhead limit exceeded

    使用这个jmeter工具测试时,遇到这么个gc错误,网上找到了解决方案.原因是jmeter默认分配内存的参数很小,好像是256M吧.故而解决方法,就是增加内存: set HEAP=-Xms4g -Xm ...

  4. Oracle连接出现TNS:no listener或者ORA-12514: TNS:listener does not currently know

    1.Message 850 not found; No message file for product=network, facility=NL 提示框:TNS:no listener 解决办法: ...

  5. K2上海总部技术培训分享笔记

    第一部门 WinDdg 入门指南 1.NGen.exe --> native code 预编译,省去了.NET程序编译器JIT过程,是程序第一次运行也非常快. NGen 参考资料:http:// ...

  6. SQL学习心得(转)

    http://www.cnblogs.com/lyhabc/p/3732942.html

  7. checkbox的全选、反选、删除(MainActivity)

    package com.example.ay; import java.util.ArrayList;import java.util.List; import com.example.adapter ...

  8. UIScrollerView常见属性

    CGSize contentSize :设置UIScrollView的滚动范围 CGPoint contentOffset :UIScrollView当前滚动的位置 UIEdgeInsets cont ...

  9. 码表由来:ascll码-Gbk2312-GBK-Unicode-UTF-8

    码表ascll码-Gbk2312-GBK-Unicode-UTF-8, ascll是基本的标准码表,GB2312是中文码表,GBK是扩展之后的码表,Unicode是国际通用码表,UTF-8是优化后的U ...

  10. Mysql5.0以下 手工注入

    order by 20 www. .com/product/introduction.php?id=-65 UNION SELECT user(),2 www. .com/product/introd ...