Spring整合redis
Spring整合redis
环境配置
db.properties
redis_TIMEOUT = 100000
redis_REDIS_HOST = 127.0.0.1
redis_REDIS_PORT = 6379
redis_REDIS_PWD = 123456
redis_SSSION_TIMEOUT = 1800
redis_MAX_TOTAL = 500
redis_MAX_IDLE = 100
application-redis.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:jdbc="http://www.springframework.org/schema/jdbc"
xmlns:jee="http://www.springframework.org/schema/jee"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:util="http://www.springframework.org/schema/util"
xmlns:jpa="http://www.springframework.org/schema/data/jpa"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd">
<!-- redis 相关配置 -->
<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
<property name="maxTotal" value="${redis_MAX_TOTAL}" />
<property name="maxIdle" value="${redis_MAX_IDLE}" />
</bean>
<bean id="jedisConnectionFactory"
class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" destroy-method="destroy">
<property name="hostName" value="${redis_REDIS_HOST}"/>
<property name="port" value="${redis_REDIS_PORT}"/>
<property name="password" value="${redis_REDIS_PWD}" />
<property name="timeout" value="${redis_TIMEOUT}"/>
<property name="usePool" value="true"/>
<property name="poolConfig" ref="jedisPoolConfig"/>
</bean>
<bean id="shardedJedisPool" class="redis.clients.jedis.ShardedJedisPool">
<constructor-arg index="0" ref="jedisPoolConfig" />
<constructor-arg index="1">
<list>
<bean name="master" class="redis.clients.jedis.JedisShardInfo">
<constructor-arg index="0" value="${redis_REDIS_HOST}" />
<constructor-arg index="1" value="${redis_REDIS_PORT}" type="int" />
<property name="timeout" value="${redis_TIMEOUT}"/>
<property name="password" value="${redis_REDIS_PWD}"/>
</bean>
</list>
</constructor-arg>
</bean>
</beans>
application-context.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:jdbc="http://www.springframework.org/schema/jdbc"
xmlns:jee="http://www.springframework.org/schema/jee"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:util="http://www.springframework.org/schema/util"
xmlns:jpa="http://www.springframework.org/schema/data/jpa"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd">
<!-- 扫描redis包 -->
<context:component-scan base-package="com.shyb.redis"/>
<!-- 加载其他配置文件 -->
<import resource="application-dao.xml"/><!--dao中读取db.properties-->
<import resource="application-redis.xml"/>
</beans>
redis包和java文件
包和结构
自己项目的包
CallBack.java
package com.shyb.redis;
import redis.clients.jedis.ShardedJedis;
//回调接口
public interface CallBack {
Object doExecute(ShardedJedis shardedJedis);
}
RedisDataSourceImpl
package com.shyb.redis;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;
@Repository
public class RedisDataSourceImpl implements RedisDataSource {
private static Logger logger = LoggerFactory.getLogger(RedisDataSourceImpl.class);
@Autowired
private ShardedJedisPool shardedJedisPool;
public ShardedJedis getRedisClient() {
try {
ShardedJedis shardJedis = shardedJedisPool.getResource();
return shardJedis;
} catch (Exception e) {
logger.error("getRedisClent error", e);
}
return null;
}
public void returnResource(ShardedJedis shardedJedis) {
shardedJedisPool.returnResource(shardedJedis);
}
public void returnResource(ShardedJedis shardedJedis, boolean broken) {
if (broken) {
shardedJedisPool.returnBrokenResource(shardedJedis);
} else {
shardedJedisPool.returnResource(shardedJedis);
}
}
}
RedisDataSource
package com.shyb.redis;
import redis.clients.jedis.ShardedJedis;
public interface RedisDataSource {
public abstract ShardedJedis getRedisClient();
public void returnResource(ShardedJedis shardedJedis);
public void returnResource(ShardedJedis shardedJedis,boolean broken);
}
RedisClientTemplate
package com.shyb.redis;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import redis.clients.jedis.BinaryClient.LIST_POSITION;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisShardInfo;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPipeline;
import redis.clients.jedis.SortingParams;
import redis.clients.jedis.Tuple;
/**
* http://doc.redisfans.com/index.html查看api
*/
@SuppressWarnings("all")
@Repository
public class RedisClientTemplate {
private static Logger log = LoggerFactory.getLogger(RedisClientTemplate.class);
@Autowired
private RedisDataSource redisDataSource;
public void disconnect() {
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
shardedJedis.disconnect();
}
/**
* 获取ShardedJedis并执行的模板方法
* @param back 根据ShardedJedis执行具体的方法
* @return
*/
private Object executeRedis(CallBack back) {
Object result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = back.doExecute(shardedJedis);
} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}
/**
* 根据通配符找到符合条件的key
* @param pattern
* @return
*/
public Set<String> keys(String pattern) {
return (Set<String>) executeRedis(new CallBack() {
public Set<String> doExecute(ShardedJedis shardedJedis) {
Jedis j = shardedJedis.getShard(pattern);
return j.keys(pattern);
}
});
}
/**
* 设置单个key
* @param key
* @param value
* @return
*/
public String set(String key,String value) {
return (String) executeRedis(new CallBack() {
public String doExecute(ShardedJedis shardedJedis) {
return shardedJedis.set(key, value);
}
});
}
/**
* 获取单个key
*
* @param key
* @return
*/
public String get(String key) {
return (String) executeRedis(new CallBack() {
public String doExecute(ShardedJedis shardedJedis) {
return shardedJedis.get(key);
}
});
}
/**
* 判断key是否存在
* @param key
* @return
*/
public Boolean exists(String key) {
return (Boolean) executeRedis(new CallBack() {
@Override
public Boolean doExecute(ShardedJedis shardedJedis) {
return shardedJedis.exists(key);
}
});
}
/**
* 查询key的类型
* 1.不存在 none 2.字符串string 3.列表list 4.集合set 5.有序集zset 6.哈希表hash
* @param key
* @return
*/
public String type(String key) {
return (String) executeRedis(new CallBack() {
@Override
public String doExecute(ShardedJedis shardedJedis) {
return shardedJedis.type(key);
}
});
}
/**
* 在seconds秒后失效
*
* @param key
* @param unixTime
* @return
*/
public Long expire(String key, int seconds) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.expire(key, seconds);
}
});
}
/**
* 在某个时间点失效
* @param key
* @param unixTime unix时间戳
* @return
*/
public Long expireAt(String key, long unixTime) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.expireAt(key, unixTime);
}
});
}
/**
* 查询key还有多少生效时间
* @param key
* @return key不存在返回-2 没有设置生效时间返回-1
*/
public Long ttl(String key) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.ttl(key);
}
});
}
/**
* 二进制设置偏移值 如 a:01100001 变为b:01100010 需要调用setbit(key,7,0);setbit(key,6,1); key的value是a
* @param key
* @param offset 偏移量
* @param value true为1 false为0
* @return 返回值为原有位置的值 如：a变b setbit(key,7,0)返回true setbit(key,6,1)返回false
*/
public boolean setbit(String key, long offset, boolean value) {
return (boolean) executeRedis(new CallBack() {
@Override
public Object doExecute(ShardedJedis shardedJedis) {
return shardedJedis.setbit(key, offset, value);
}
});
}
/**
* 获取key对应的value的二进制所在偏移量的值
* @param key
* @param offset
* @return
*/
public boolean getbit(String key, long offset) {
return (boolean) executeRedis(new CallBack() {
@Override
public Object doExecute(ShardedJedis shardedJedis) {
return shardedJedis.getbit(key, offset);
}
});
}
/**
* 将key对应的value从偏移量位置开始替换为value等长的字符串
* key不存在，会创建key value为""
* @param key
* @param offset
* @param value
* @return
*/
public long setrange(String key, long offset, String value) {
return (long) executeRedis(new CallBack() {
@Override
public Object doExecute(ShardedJedis shardedJedis) {
return shardedJedis.setrange(key, offset, value);
}
});
}
/**
* 等价于substring,但包含头和尾 substring不包含尾
* @param key
* @param startOffset
* @param endOffset
* @return
*/
public String getrange(String key, long startOffset, long endOffset) {
return (String) executeRedis(new CallBack() {
@Override
public String doExecute(ShardedJedis shardedJedis) {
return shardedJedis.getrange(key, startOffset, endOffset);
}
});
}
/**
* 设置并返回旧值 没有返回null
* set方法返回值为"OK"
* @param key
* @param value
* @return
*/
public String getSet(String key, String value) {
return (String) executeRedis(new CallBack() {
@Override
public String doExecute(ShardedJedis shardedJedis) {
return shardedJedis.getSet(key, value);
}
});
}
/**
* 当key不存在时设置值，返回1
* 当key存在时不改动，返回0
* @param key
* @param value
* @return
*/
public Long setnx(String key, String value) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.setnx(key, value);
}
});
}
/**
* 设置或替换值，并设置生存时间
* @param key
* @param seconds
* @param value
* @return
*/
public String setex(String key, int seconds, String value) {
return (String) executeRedis(new CallBack() {
@Override
public String doExecute(ShardedJedis shardedJedis) {
return shardedJedis.setex(key, seconds, value);
}
});
}
/**
* 将key对应的数值减count并返回
* 如果key不存在，创建key，默认值为0
* @param key
* @return
*/
public Long decrBy(String key, long count) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.decrBy(key, count);
}
});
}
/**
* 将key对应的数值减1并返回
* 如果key不存在，创建key，默认值为0，再减一(即返回-1)
* @param key
* @return
*/
public Long decr(String key) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.decr(key);
}
});
}
/**
* 将key对应的数值加count并返回
* 如果key不存在，创建key，默认值为0
* @param key
* @return
*/
public Long incrBy(String key, long count) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.incrBy(key, count);
}
});
}
/**
* 将key对应的数值加1并返回
* 如果key不存在，创建key，默认值为0，再加一(即返回1)
* @param key
* @return
*/
public Long incr(String key) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.incr(key);
}
});
}
/**
* 追加字符串，相当于StringBuilder的append
* key不存在时等价于set方法
* @param key
* @param value
* @return 返回最终字符串的长度
*/
public Long append(String key, String value) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.append(key, value);
}
});
}
/**
* 和getrange作用一样
* @param key
* @param start
* @param end
* @return
*/
public String substr(String key, int start, int end) {
return (String) executeRedis(new CallBack() {
@Override
public String doExecute(ShardedJedis shardedJedis) {
return shardedJedis.substr(key, start, end);
}
});
}
/**
* key不存在，创建新的hash表
* key存在。 field存在，value被覆盖。field不存在，添加新的
* @param key
* @param field
* @param value
* @return 值被覆盖返回0,创建新参数返回1
*/
public Long hset(String key, String field, String value) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.hset(key, field, value);
}
});
}
/**
* key或field不存在时返回null
* @param key
* @param field
* @return
*/
public String hget(String key, String field) {
return (String) executeRedis(new CallBack() {
@Override
public String doExecute(ShardedJedis shardedJedis) {
return shardedJedis.hget(key, field);
}
});
}
/**
* 如果key,field都存在，不执行操作，返回0
* 其他情况执行并返回1
* @param key
* @param field
* @param value
* @return
*/
public Long hsetnx(String key, String field, String value) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.hsetnx(key, field, value);
}
});
}
/**
* 将多个field和value值设置到key中，会覆盖旧值。返回"OK"
* @param key
* @param hash
* @return
*/
public String hmset(String key, Map<String, String> hash) {
return (String) executeRedis(new CallBack() {
@Override
public String doExecute(ShardedJedis shardedJedis) {
return shardedJedis.hmset(key, hash);
}
});
}
/**
* 根据fields返回1个或多个value,并存入list中。如果field不存在，list也会添加一个null
* @param key
* @param fields
* @return
*/
public List<String> hmget(String key, String... fields) {
return (List<String>) executeRedis(new CallBack() {
@Override
public List<String> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.hmget(key, fields);
}
});
}
/**
* 给key下的field属性的值添加value增量，不存在则创建默认值0
* key下的field属性的值是字符串时，报错JedisDataException
* @param key
* @param field
* @param value
* @return
*/
public Long hincrBy(String key, String field, long value) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.hincrBy(key, field, value);
}
});
}
/**
* 判断是否存在key以及对应的field域
* @param key
* @param field
* @return
*/
public Boolean hexists(String key, String field) {
return (Boolean) executeRedis(new CallBack() {
@Override
public Boolean doExecute(ShardedJedis shardedJedis) {
return shardedJedis.hexists(key, field);
}
});
}
/**
* 删除指定的key
* @param key
* @return
*/
public Long del(String key) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.del(key);
}
});
}
/**
* 删除指定的key下的field
* @param key
* @param field
* @return
*/
public Long hdel(String key, String field) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.hdel(key, field);
}
});
}
/**
* 获取key下的filed数量
* @param key
* @return
*/
public Long hlen(String key) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.hlen(key);
}
});
}
/**
* 获取key下所有的field
* @param key
* @return
*/
public Set<String> hkeys(String key) {
return (Set<String>) executeRedis(new CallBack() {
@Override
public Set<String> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.hkeys(key);
}
});
}
/**
* 获取key下所有field对应的value
* @param key
* @return
*/
public List<String> hvals(String key) {
return (List<String>) executeRedis(new CallBack() {
@Override
public List<String> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.hvals(key);
}
});
}
/**
* 获取key下的所有键值对
* @param key
* @return
*/
public Map<String, String> hgetAll(String key) {
return (Map<String, String>) executeRedis(new CallBack() {
@Override
public Map<String, String> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.hgetAll(key);
}
});
}
// ================list ====== l表示 list,l表示left, r表示right====================
/**
* 向列表key的右边添加string元素，key不是列表报错
* @param key
* @param string
* @return 新列表的长度
*/
public Long rpush(String key, String string) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.rpush(key, string);
}
});
}
/**
* 向列表key的左边添加string元素，key不是列表报错
* @param key
* @param string
* @return 新列表的长度
*/
public Long lpush(String key, String string) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.lpush(key, string);
}
});
}
/**
* 返回列表key的长度，key不存在返回0，key不是列表报错
* @param key
* @return
*/
public Long llen(String key) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.llen(key);
}
});
}
/**
* 返回列表key的start到end位置的元素 含头含尾 end为-1标识最后一位
* @param key
* @param start
* @param end
* @return
*/
public List<String> lrange(String key, long start, long end) {
return (List<String>) executeRedis(new CallBack() {
@Override
public List<String> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.lrange(key, start, end);
}
});
}
/**
* 清空不在start和end范围内的列表
* @param key
* @param start
* @param end
* @return "OK"
*/
public String ltrim(String key, long start, long end) {
return (String) executeRedis(new CallBack() {
@Override
public String doExecute(ShardedJedis shardedJedis) {
return shardedJedis.ltrim(key, start, end);
}
});
}
/**
* 根据key和下标获取列表对应位置的值
* @param key
* @param index
* @return
*/
public String lindex(String key, long index) {
return (String) executeRedis(new CallBack() {
@Override
public String doExecute(ShardedJedis shardedJedis) {
return shardedJedis.lindex(key, index);
}
});
}
/**
* 修改列表key对应Index下标的值
* key不存在或Index越界报错，成功返回"OK"
* @param key
* @param index
* @param value
* @return
*/
public String lset(String key, long index, String value) {
return (String) executeRedis(new CallBack() {
@Override
public String doExecute(ShardedJedis shardedJedis) {
return shardedJedis.lset(key, index, value);
}
});
}
/**
* 移除列表key的value元素
* count为要移除的数量 正数：从左开始 负数：从右开始
* @param key
* @param count
* @param value
* @return 实际移除数量
*/
public Long lrem(String key, long count, String value) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.lrem(key, count, value);
}
});
}
/**
* 移除列表第一个(左)元素，没有返回null
* @param key
* @return
*/
public String lpop(String key) {
return (String) executeRedis(new CallBack() {
@Override
public String doExecute(ShardedJedis shardedJedis) {
return shardedJedis.lpop(key);
}
});
}
/**
* 移除列表最后一个(右)元素，没有返回null
* @param key
* @return
*/
public String rpop(String key) {
return (String) executeRedis(new CallBack() {
@Override
public String doExecute(ShardedJedis shardedJedis) {
return shardedJedis.rpop(key);
}
});
}
/**
* 向key对应的集合中添加member成员 已存在不添加，返回0.不存在添加，返回1
* @param key
* @param member
* @return
*/
public Long sadd(String key, String member) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.sadd(key, member);
}
});
}
/**
* 向key对应的集合中添加1或多个member,成功返回添加的个数
* @param key
* @param member
* @return
*/
public Long sadd(String key, String... member) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.sadd(key, member);
}
});
}
/**
* 获取key对应的集合中所有的元素
* @param key
* @return
*/
public Set<String> smembers(String key) {
return (Set<String>) executeRedis(new CallBack() {
@Override
public Set<String> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.smembers(key);
}
});
}
/**
* 移除key对应的集合中的member成员
* @param key
* @param member
* @return 0 未移除 1移除1个
*/
public Long srem(String key, String member) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.srem(key, member);
}
});
}
/**
* 随机移除集合中的一个成员
* @param key
* @return
*/
public String spop(String key) {
return (String) executeRedis(new CallBack() {
@Override
public String doExecute(ShardedJedis shardedJedis) {
return shardedJedis.spop(key);
}
});
}
/**
* 获取集合的基数(成员个数)
* @param key
* @return
*/
public Long scard(String key) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.scard(key);
}
});
}
/**
* 判断member是不是key对应集合的成员
* @param key
* @param member
* @return
*/
public Boolean sismember(String key, String member) {
return (Boolean) executeRedis(new CallBack() {
@Override
public Boolean doExecute(ShardedJedis shardedJedis) {
return shardedJedis.sismember(key, member);
}
});
}
/**
* 随机获取集合中的一个元素
* @param key
* @return
*/
public String srandmember(String key) {
return (String) executeRedis(new CallBack() {
@Override
public String doExecute(ShardedJedis shardedJedis) {
return shardedJedis.srandmember(key);
}
});
}
/**
* 添加或修改key对应的有序集合的member成员的score值
* @param key
* @param score
* @param member
* @return 添加的个数
*/
public Long zadd(String key, double score, String member) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zadd(key, score, member);
}
});
}
/**
* 获取start和end区间的成员，按score递增顺序排
* @param key
* @param start
* @param end
* @return
*/
public Set<String> zrange(String key, int start, int end) {
return (Set<String>) executeRedis(new CallBack() {
@Override
public Set<String> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zrange(key, start, end);
}
});
}
/**
* 获取start和end区间的成员，按score递减顺序排
* @param key
* @param start
* @param end
* @return
*/
public Set<String> zrevrange(String key, int start, int end) {
return (Set<String>) executeRedis(new CallBack() {
@Override
public Set<String> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zrevrange(key, start, end);
}
});
}
/**
* 移除有序集合的member成员
* @param key
* @param member
* @return 移除的数量 返回1或0
*/
public Long zrem(String key, String member) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zrem(key, member);
}
});
}
/**
* 给key对应的member成员添加score分，score可以为负数
* @param key
* @param score
* @param member
* @return member的新score值
*/
public Double zincrby(String key, double score, String member) {
return (Double) executeRedis(new CallBack() {
@Override
public Double doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zincrby(key, score, member);
}
});
}
/**
* key中member成员的排名(score从小到大排 第一score值最小) 第一名返回0 第二返回1 ……
* @param key
* @param member
* @return
*/
public Long zrank(String key, String member) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zrank(key, member);
}
});
}
/**
* key中member成员的排名(score从大到小排) score最大返回0 第二返回1 ……
* @param key
* @param member
* @return
*/
public Long zrevrank(String key, String member) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zrevrank(key, member);
}
});
}
/**
* 获取key的start到end区间的成员和分数,并按照score从低到高排
* Tuple对象的element为成员，score为对应的分数
* @param key
* @param start
* @param end
* @return
*/
public Set<Tuple> zrangeWithScores(String key, int start, int end) {
return (Set<Tuple>) executeRedis(new CallBack() {
@Override
public Set<Tuple> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zrangeWithScores(key, start, end);
}
});
}
/**
* 获取key的start到end区间的成员和分数,并按照score从高到低排
* Tuple对象的element为成员，score为对应的分数
* @param key
* @param start
* @param end
* @return
*/
public Set<Tuple> zrevrangeWithScores(String key, int start, int end) {
return (Set<Tuple>) executeRedis(new CallBack() {
@Override
public Set<Tuple> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zrevrangeWithScores(key, start, end);
}
});
}
/**
* 获取有序集合的长度
* @param key
* @return key不存在返回0
*/
public Long zcard(String key) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zcard(key);
}
});
}
/**
* 获取有序集合key中member的score值，不存在返回null
* @param key
* @param member
* @return
*/
public Double zscore(String key, String member) {
return (Double) executeRedis(new CallBack() {
@Override
public Double doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zscore(key, member);
}
});
}
/**
* 返回或保存key(列表，集合，有序集合)中经过排序的成员
* 默认按照数字排序从小到大
* @param key
* @return
*/
public List<String> sort(String key) {
return (List<String>) executeRedis(new CallBack() {
@Override
public List<String> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.sort(key);
}
});
}
/**
* 返回或保存key(列表，集合，有序集合)中经过排序的成员
* 默认按照数字排序从小到大
* @param key
* @param sortingParameters 排序参数
* @return
*/
public List<String> sort(String key, SortingParams sortingParameters) {
return (List<String>) executeRedis(new CallBack() {
@Override
public List<String> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.sort(key, sortingParameters);
}
});
}
/**
* 获取key对应有序集合中score在min到max之间的成员数量(包含min和max)
* @param key
* @param min
* @param max
* @return
*/
public Long zcount(String key, double min, double max) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zcount(key, min, max);
}
});
}
/**
* 获取key对应有序集合分数在min和max之间的所有成员(包含min和max)
* 成员顺序按score从小到大排序
* @param key
* @param min
* @param max
* @return
*/
public Set<String> zrangeByScore(String key, double min, double max) {
return (Set<String>) executeRedis(new CallBack() {
@Override
public Set<String> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zrangeByScore(key, min, max);
}
});
}
/**
* 获取key对应有序集合分数在min和max之间的所有成员(包含min和max)
* 成员顺序按score从大到小排序
* @param key
* @param min
* @param max
* @return
*/
public Set<String> zrevrangeByScore(String key, double max, double min) {
return (Set<String>) executeRedis(new CallBack() {
@Override
public Set<String> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zrevrangeByScore(key, min, max);
}
});
}
/**
* 获取key对应有序集合分数在min和max之间的所有成员(包含min和max)
* 成员顺序按score从小到大排序
* @param key
* @param min
* @param max
* @param offset 从那个位置取 offset过大会影响速度
* @param count 取的个数 和数据库的limit一样
* @return
*/
public Set<String> zrangeByScore(String key, double min, double max, int offset, int count) {
return (Set<String>) executeRedis(new CallBack() {
@Override
public Set<String> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zrangeByScore(key, min, max, offset, count);
}
});
}
/**
* 获取key对应有序集合分数在min和max之间的所有成员(包含min和max)
* 成员顺序按score从大到小排序
* @param key
* @param min
* @param max
* @param offset 从那个位置取 offset过大会影响速度
* @param count 取的个数 和数据库的limit一样
* @return
*/
public Set<String> zrevrangeByScore(String key, double max, double min, int offset, int count) {
return (Set<String>) executeRedis(new CallBack() {
@Override
public Set<String> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zrevrangeByScore(key, min, max, offset, count);
}
});
}
/**
* 获取key对应有序集合分数在min和max之间的所有成员和score值(包含min和max)
* 成员顺序按score从小到大排序
* @param key
* @param min
* @param max
* @return
*/
public Set<Tuple> zrangeByScoreWithScores(String key, double min, double max) {
return (Set<Tuple>) executeRedis(new CallBack() {
@Override
public Set<Tuple> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zrangeByScoreWithScores(key, min, max);
}
});
}
/**
* 获取key对应有序集合分数在min和max之间的所有成员和score值(包含min和max)
* 成员顺序按score从大到小排序
* @param key
* @param min
* @param max
* @return
*/
public Set<Tuple> zrevrangeByScoreWithScores(String key, double max, double min) {
return (Set<Tuple>) executeRedis(new CallBack() {
@Override
public Set<Tuple> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zrevrangeByScoreWithScores(key, min, max);
}
});
}
/**
* 获取key对应有序集合分数在min和max之间的所有成员带score值(包含min和max)
* 成员顺序按score从小到大排序
* @param key
* @param min
* @param max
* @param offset 从那个位置取 offset过大会影响速度
* @param count 取的个数 和数据库的limit一样
* @return
*/
public Set<Tuple> zrangeByScoreWithScores(String key, double min, double max, int offset, int count) {
return (Set<Tuple>) executeRedis(new CallBack() {
@Override
public Set<Tuple> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zrangeByScoreWithScores(key, min, max, offset, count);
}
});
}
/**
* 获取key对应有序集合分数在min和max之间的所有成员带score值(包含min和max)
* 成员顺序按score从大到小排序
* @param key
* @param min
* @param max
* @param offset 从那个位置取 offset过大会影响速度
* @param count 取的个数 和数据库的limit一样
* @return
*/
public Set<Tuple> zrevrangeByScoreWithScores(String key, double max, double min, int offset, int count) {
return (Set<Tuple>) executeRedis(new CallBack() {
@Override
public Set<Tuple> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zrevrangeByScoreWithScores(key, min, max, offset, count);
}
});
}
/**
* 移除key对应有序集合的顺序在start至end的成员
* 集合按score从小到大排
* @param key
* @param start
* @param end
* @return 移除的数量
*/
public Long zremrangeByRank(String key, int start, int end) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zremrangeByRank(key, start, end);
}
});
}
/**
* 删除key对应有序集合的score在start至end的成员
* 集合按score从小到大排
* @param key
* @param start
* @param end
* @return 移除的数量
*/
public Long zremrangeByScore(String key, double start, double end) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zremrangeByScore(key, start, end);
}
});
}
/**
* 向key对应列表的pivot成员(where设置before或after)插入value
* @param key
* @param where 枚举类
* @param pivot
* @param value
* @return key不存在或列表为空，返回0 成功返回列表长度，pivot不存在返回-1
*/
public Long linsert(String key, LIST_POSITION where, String pivot, String value) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.linsert(key, where, pivot, value);
}
});
}
/**
* 存储key value都为byte数组
* @param key
* @param value
* @return
*/
public String set(byte[] key, byte[] value) {
return (String) executeRedis(new CallBack() {
@Override
public String doExecute(ShardedJedis shardedJedis) {
return shardedJedis.set(key, value);
}
});
}
/**
* 根据byte数组获取值
* @param key
* @return
*/
public byte[] get(byte[] key) {
return (byte[]) executeRedis(new CallBack() {
@Override
public byte[] doExecute(ShardedJedis shardedJedis) {
return shardedJedis.get(key);
}
});
}
/**
* byte数组是否存在
* @param key
* @return
*/
public Boolean exists(byte[] key) {
return (Boolean) executeRedis(new CallBack() {
@Override
public Boolean doExecute(ShardedJedis shardedJedis) {
return shardedJedis.exists(key);
}
});
}
/**
* 获取key类型
* @param key
* @return
*/
public String type(byte[] key) {
return (String) executeRedis(new CallBack() {
@Override
public String doExecute(ShardedJedis shardedJedis) {
return shardedJedis.type(key);
}
});
}
/**
* 设置key生效时间
* @param key
* @param seconds
* @return 成功返回1
*/
public Long expire(byte[] key, int seconds) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.expire(key, seconds);
}
});
}
/**
* 设置在unixTime时失效
* @param key
* @param unixTime
* @return
*/
public Long expireAt(byte[] key, long unixTime) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.expireAt(key, unixTime);
}
});
}
/**
* 查询剩余生效时间
* @param key
* @return
*/
public Long ttl(byte[] key) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.ttl(key);
}
});
}
/**
* 设置并获取原来存在的值
* @param key
* @param value
* @return
*/
public byte[] getSet(byte[] key, byte[] value) {
return (byte[]) executeRedis(new CallBack() {
@Override
public byte[] doExecute(ShardedJedis shardedJedis) {
return shardedJedis.getSet(key, value);
}
});
}
/**
* 不存在时设置
* @param key
* @param value
* @return
*/
public Long setnx(byte[] key, byte[] value) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.setnx(key, value);
}
});
}
/**
* 修改值、生效时间
* @param key
* @param seconds
* @param value
* @return
*/
public String setex(byte[] key, int seconds, byte[] value) {
return (String) executeRedis(new CallBack() {
@Override
public String doExecute(ShardedJedis shardedJedis) {
return shardedJedis.setex(key, seconds, value);
}
});
}
public Long decrBy(byte[] key, long integer) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.decrBy(key, integer);
}
});
}
public Long decr(byte[] key) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.decr(key);
}
});
}
public Long incrBy(byte[] key, long integer) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.incrBy(key, integer);
}
});
}
public Long incr(byte[] key) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.incr(key);
}
});
}
public Long append(byte[] key, byte[] value) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.append(key, value);
}
});
}
public byte[] substr(byte[] key, int start, int end) {
return (byte[]) executeRedis(new CallBack() {
@Override
public byte[] doExecute(ShardedJedis shardedJedis) {
return shardedJedis.substr(key, start, end);
}
});
}
public Long hset(byte[] key, byte[] field, byte[] value) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.hset(key, field, value);
}
});
}
public byte[] hget(byte[] key, byte[] field) {
return (byte[]) executeRedis(new CallBack() {
@Override
public byte[] doExecute(ShardedJedis shardedJedis) {
return shardedJedis.hget(key, field);
}
});
}
public Long hsetnx(byte[] key, byte[] field, byte[] value) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.hsetnx(key, field, value);
}
});
}
public String hmset(byte[] key, Map<byte[], byte[]> hash) {
return (String) executeRedis(new CallBack() {
@Override
public String doExecute(ShardedJedis shardedJedis) {
return shardedJedis.hmset(key, hash);
}
});
}
public List<byte[]> hmget(byte[] key, byte[]... fields) {
return (List<byte[]>) executeRedis(new CallBack() {
@Override
public List<byte[]> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.hmget(key, fields);
}
});
}
public Long hincrBy(byte[] key, byte[] field, long value) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.hincrBy(key, field, value);
}
});
}
public Boolean hexists(byte[] key, byte[] field) {
return (Boolean) executeRedis(new CallBack() {
@Override
public Boolean doExecute(ShardedJedis shardedJedis) {
return shardedJedis.hexists(key, field);
}
});
}
public Long hdel(byte[] key, byte[] field) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.hdel(key, field);
}
});
}
public Long hlen(byte[] key) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.hlen(key);
}
});
}
public Set<byte[]> hkeys(byte[] key) {
return (Set<byte[]>) executeRedis(new CallBack() {
@Override
public Set<byte[]> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.hkeys(key);
}
});
}
public Collection<byte[]> hvals(byte[] key) {
return (Collection<byte[]>) executeRedis(new CallBack() {
@Override
public Collection<byte[]> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.hvals(key);
}
});
}
public Map<byte[], byte[]> hgetAll(byte[] key) {
return (Map<byte[], byte[]>) executeRedis(new CallBack() {
@Override
public Map<byte[], byte[]> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.hgetAll(key);
}
});
}
public Long rpush(byte[] key, byte[] string) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.rpush(key, string);
}
});
}
public Long lpush(byte[] key, byte[] string) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.lpush(key, string);
}
});
}
public Long llen(byte[] key) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.llen(key);
}
});
}
public List<byte[]> lrange(byte[] key, int start, int end) {
return (List<byte[]>) executeRedis(new CallBack() {
@Override
public List<byte[]> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.lrange(key, start, end);
}
});
}
public String ltrim(byte[] key, int start, int end) {
return (String) executeRedis(new CallBack() {
@Override
public String doExecute(ShardedJedis shardedJedis) {
return shardedJedis.ltrim(key, start, end);
}
});
}
public byte[] lindex(byte[] key, int index) {
return (byte[]) executeRedis(new CallBack() {
@Override
public byte[] doExecute(ShardedJedis shardedJedis) {
return shardedJedis.lindex(key, index);
}
});
}
public String lset(byte[] key, int index, byte[] value) {
return (String) executeRedis(new CallBack() {
@Override
public String doExecute(ShardedJedis shardedJedis) {
return shardedJedis.lset(key, index, value);
}
});
}
public Long lrem(byte[] key, int count, byte[] value) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.lrem(key, count, value);
}
});
}
public byte[] lpop(byte[] key) {
return (byte[]) executeRedis(new CallBack() {
@Override
public byte[] doExecute(ShardedJedis shardedJedis) {
return shardedJedis.lpop(key);
}
});
}
public byte[] rpop(byte[] key) {
return (byte[]) executeRedis(new CallBack() {
@Override
public byte[] doExecute(ShardedJedis shardedJedis) {
return shardedJedis.rpop(key);
}
});
}
public Long sadd(byte[] key, byte[] member) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.sadd(key, member);
}
});
}
public Set<byte[]> smembers(byte[] key) {
return (Set<byte[]>) executeRedis(new CallBack() {
@Override
public Set<byte[]> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.smembers(key);
}
});
}
public Long srem(byte[] key, byte[] member) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.srem(key, member);
}
});
}
public byte[] spop(byte[] key) {
return (byte[]) executeRedis(new CallBack() {
@Override
public byte[] doExecute(ShardedJedis shardedJedis) {
return shardedJedis.spop(key);
}
});
}
public Long scard(byte[] key) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.scard(key);
}
});
}
public Boolean sismember(byte[] key, byte[] member) {
return (Boolean) executeRedis(new CallBack() {
@Override
public Boolean doExecute(ShardedJedis shardedJedis) {
return shardedJedis.sismember(key, member);
}
});
}
public byte[] srandmember(byte[] key) {
return (byte[]) executeRedis(new CallBack() {
@Override
public byte[] doExecute(ShardedJedis shardedJedis) {
return shardedJedis.srandmember(key);
}
});
}
public Long zadd(byte[] key, double score, byte[] member) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zadd(key, score, member);
}
});
}
public Set<byte[]> zrange(byte[] key, int start, int end) {
return (Set<byte[]>) executeRedis(new CallBack() {
@Override
public Set<byte[]> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zrange(key, start, end);
}
});
}
public Long zrem(byte[] key, byte[] member) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zrem(key, member);
}
});
}
public Double zincrby(byte[] key, double score, byte[] member) {
return (Double) executeRedis(new CallBack() {
@Override
public Double doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zincrby(key, score, member);
}
});
}
public Long zrank(byte[] key, byte[] member) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zrank(key, member);
}
});
}
public Long zrevrank(byte[] key, byte[] member) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zrevrank(key, member);
}
});
}
public Set<byte[]> zrevrange(byte[] key, int start, int end) {
return (Set<byte[]>) executeRedis(new CallBack() {
@Override
public Set<byte[]> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zrevrange(key, start, end);
}
});
}
public Set<Tuple> zrangeWithScores(byte[] key, int start, int end) {
return (Set<Tuple>) executeRedis(new CallBack() {
@Override
public Set<Tuple> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zrangeWithScores(key, start, end);
}
});
}
public Set<Tuple> zrevrangeWithScores(byte[] key, int start, int end) {
return (Set<Tuple>) executeRedis(new CallBack() {
@Override
public Set<Tuple> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zrevrangeWithScores(key, start, end);
}
});
}
public Long zcard(byte[] key) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zcard(key);
}
});
}
public Double zscore(byte[] key, byte[] member) {
return (Double) executeRedis(new CallBack() {
@Override
public Double doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zscore(key, member);
}
});
}
public List<byte[]> sort(byte[] key) {
return (List<byte[]>) executeRedis(new CallBack() {
@Override
public List<byte[]> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.sort(key);
}
});
}
public List<byte[]> sort(byte[] key, SortingParams sortingParameters) {
return (List<byte[]>) executeRedis(new CallBack() {
@Override
public List<byte[]> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.sort(key, sortingParameters);
}
});
}
public Long zcount(byte[] key, double min, double max) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zcount(key, min, max);
}
});
}
public Set<byte[]> zrangeByScore(byte[] key, double min, double max) {
return (Set<byte[]>) executeRedis(new CallBack() {
@Override
public Set<byte[]> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zrangeByScore(key, min, max);
}
});
}
public Set<byte[]> zrangeByScore(byte[] key, double min, double max, int offset, int count) {
return (Set<byte[]>) executeRedis(new CallBack() {
@Override
public Set<byte[]> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zrangeByScore(key, min, max, offset, count);
}
});
}
public Set<Tuple> zrangeByScoreWithScores(byte[] key, double min, double max) {
return (Set<Tuple>) executeRedis(new CallBack() {
@Override
public Set<Tuple> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zrangeByScoreWithScores(key, min, max);
}
});
}
public Set<Tuple> zrangeByScoreWithScores(byte[] key, double min, double max, int offset, int count) {
return (Set<Tuple>) executeRedis(new CallBack() {
@Override
public Set<Tuple> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zrangeByScoreWithScores(key, min, max, offset, count);
}
});
}
public Set<byte[]> zrevrangeByScore(byte[] key, double max, double min) {
return (Set<byte[]>) executeRedis(new CallBack() {
@Override
public Set<byte[]> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zrevrangeByScore(key, max, min);
}
});
}
public Set<byte[]> zrevrangeByScore(byte[] key, double max, double min, int offset, int count) {
return (Set<byte[]>) executeRedis(new CallBack() {
@Override
public Set<byte[]> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zrevrangeByScore(key, max, min, offset, count);
}
});
}
public Set<Tuple> zrevrangeByScoreWithScores(byte[] key, double max, double min) {
return (Set<Tuple>) executeRedis(new CallBack() {
@Override
public Set<Tuple> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zrevrangeByScoreWithScores(key, max, min);
}
});
}
public Set<Tuple> zrevrangeByScoreWithScores(byte[] key, double max, double min, int offset, int count) {
Set<Tuple> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrevrangeByScoreWithScores(key, max, min, offset, count);
} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}
public Long zremrangeByRank(byte[] key, int start, int end) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zremrangeByRank(key, start, end);
}
});
}
public Long zremrangeByScore(byte[] key, double start, double end) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.zremrangeByScore(key, start, end);
}
});
}
public Long linsert(byte[] key, LIST_POSITION where, byte[] pivot, byte[] value) {
return (Long) executeRedis(new CallBack() {
@Override
public Long doExecute(ShardedJedis shardedJedis) {
return shardedJedis.linsert(key, where, pivot, value);
}
});
}
public List<Object> pipelined(ShardedJedisPipeline shardedJedisPipeline) {
return (List<Object>) executeRedis(new CallBack() {
@Override
public List<Object> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.pipelined(shardedJedisPipeline);
}
});
}
/**
* 根据key，使用hash算法找到对应的jedis对象
* @param key
* @return
*/
public Jedis getShard(byte[] key) {
return (Jedis) executeRedis(new CallBack() {
@Override
public Jedis doExecute(ShardedJedis shardedJedis) {
return shardedJedis.getShard(key);
}
});
}
public Jedis getShard(String key) {
return (Jedis) executeRedis(new CallBack() {
@Override
public Jedis doExecute(ShardedJedis shardedJedis) {
return shardedJedis.getShard(key);
}
});
}
public JedisShardInfo getShardInfo(byte[] key) {
return (JedisShardInfo) executeRedis(new CallBack() {
@Override
public JedisShardInfo doExecute(ShardedJedis shardedJedis) {
return shardedJedis.getShardInfo(key);
}
});
}
public JedisShardInfo getShardInfo(String key) {
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
JedisShardInfo result = null;
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.getShardInfo(key);
} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}
public String getKeyTag(String key) {
return (String) executeRedis(new CallBack() {
@Override
public String doExecute(ShardedJedis shardedJedis) {
return shardedJedis.getKeyTag(key);
}
});
}
public Collection<JedisShardInfo> getAllShardInfo() {
return (Collection<JedisShardInfo>) executeRedis(new CallBack() {
@Override
public Collection<JedisShardInfo> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.getAllShardInfo();
}
});
}
public Collection<Jedis> getAllShards() {
return (Collection<Jedis>) executeRedis(new CallBack() {
@Override
public Collection<Jedis> doExecute(ShardedJedis shardedJedis) {
return shardedJedis.getAllShards();
}
});
}
}