com.dxy.library.cache.redis.executor.JedisExecutor Maven / Gradle / Ivy
Show all versions of cache-redis Show documentation
package com.dxy.library.cache.redis.executor;
import com.google.common.collect.Maps;
import com.dxy.library.cache.redis.properties.RedisProperties;
import com.dxy.library.cache.redis.util.BitHashUtil;
import com.dxy.library.cache.redis.util.Serializer;
import org.apache.commons.lang3.BooleanUtils;
import redis.clients.jedis.*;
import redis.clients.jedis.params.GeoRadiusParam;
import redis.clients.jedis.params.SetParams;
import redis.clients.jedis.params.ZAddParams;
import redis.clients.jedis.params.ZIncrByParams;
import java.util.*;
import java.util.concurrent.TimeUnit;
/**
* @author duanxinyuan
* 2020/4/18 17:07
*/
public abstract class JedisExecutor extends AbstractExecutor {
public JedisExecutor(RedisProperties redisProperties) {
super(redisProperties);
}
@Override
public Set keys(String pattern) {
checkNotNull(pattern);
return execute(j -> j.keys(pattern));
}
@Override
public ScanResult scan(String cursor, ScanParams params) {
checkNotNull(cursor, params);
return execute(j -> j.scan(cursor, params));
}
@Override
public String type(String key) {
checkNotNull(key);
return execute(j -> j.type(key));
}
@Override
public Long ttl(String key) {
checkNotNull(key);
return execute(j -> j.ttl(key));
}
@Override
public Long pttl(String key) {
checkNotNull(key);
return execute(j -> j.pttl(key));
}
@Override
public Long expire(String key, int seconds) {
checkNotNull(key);
return execute(j -> j.expire(key, seconds));
}
@Override
public Long expireAt(String key, long unixTime) {
checkNotNull(key);
return execute(j -> j.expireAt(key, unixTime));
}
@Override
public Long persist(String key) {
checkNotNull(key);
return execute(j -> j.persist(key));
}
@Override
public boolean exists(String key) {
checkNotNull(key);
return execute(j -> BooleanUtils.toBoolean(j.exists(key)));
}
@Override
public Long del(String key) {
checkNotNull(key);
return execute(j -> j.del(key));
}
@Override
public Long del(String... keys) {
checkNotNull(keys);
return execute(j -> j.del(keys));
}
@Override
public Long del(List keys) {
checkNotNull(keys);
return execute(j -> j.del(keys.toArray(new String[0])));
}
@Override
public Long unlink(String key) {
checkNotNull(key);
return execute(j -> j.unlink(key));
}
@Override
public String rename(String oldkey, String newkey) {
checkNotNull(oldkey, oldkey);
return execute(j -> j.rename(oldkey, newkey));
}
@Override
public Long renamenx(String oldkey, String newkey) {
checkNotNull(oldkey, oldkey);
return execute(j -> j.renamenx(oldkey, newkey));
}
@Override
public String set(String key, T value) {
checkNotNull(key, value);
return execute(j -> j.set(key, Serializer.serialize(value)));
}
@Override
public String set(String key, T value, SetParams setParams) {
checkNotNull(key, value, setParams);
return execute(j -> j.set(key, Serializer.serialize(value), setParams));
}
@Override
public Long setnx(String key, T value) {
checkNotNull(key, value);
return execute(j -> j.setnx(key, Serializer.serialize(value)));
}
@Override
public String setex(String key, int seconds, T value) {
checkNotNull(key, value);
return execute(j -> j.setex(key, seconds, Serializer.serialize(value)));
}
@Override
public String setex(String key, long time, TimeUnit timeUnit, T value) {
checkNotNull(key, value);
return execute(j -> j.psetex(key, timeUnit.toMillis(time), Serializer.serialize(value)));
}
@Override
public String psetex(String key, long milliseconds, T value) {
checkNotNull(key, value);
return execute(j -> j.psetex(key, milliseconds, Serializer.serialize(value)));
}
@Override
public String mset(Map map) {
checkNotNull(map);
return execute(j -> j.mset(Serializer.serialize(map).toArray(new String[0])));
}
@Override
public String get(String key) {
checkNotNull(key);
return execute(j -> j.get(key));
}
@Override
public T get(String key, Class type) {
return execute(j -> Serializer.deserialize(j.get(key), type));
}
@Override
public List mget(String... keys) {
checkNotNull(keys);
return execute(j -> j.mget(keys));
}
@Override
public List mget(List keys) {
checkNotNull(keys);
return execute(j -> j.mget(keys.toArray(new String[0])));
}
@Override
public List mget(List keys, Class type) {
checkNotNull(keys);
return execute(j -> Serializer.deserialize(j.mget(keys.toArray(new String[0])), type));
}
@Override
public Long incr(String key) {
checkNotNull(key);
return execute(j -> j.incr(key));
}
@Override
public Long incrBy(String key, long increment) {
checkNotNull(key);
return execute(j -> j.incrBy(key, increment));
}
@Override
public Double incrByFloat(String key, double increment) {
checkNotNull(key);
return execute(j -> j.incrByFloat(key, increment));
}
@Override
public Long decr(String key) {
checkNotNull(key);
return execute(j -> j.decr(key));
}
@Override
public Long decrBy(String key, long decrement) {
checkNotNull(key);
return execute(j -> j.decrBy(key, decrement));
}
@Override
public Long append(String key, String value) {
checkNotNull(key, value);
return execute(j -> j.append(key, value));
}
@Override
public Long strlen(String key) {
checkNotNull(key);
return execute(j -> j.strlen(key));
}
@Override
public Long hset(String key, P field, T value) {
checkNotNull(key, field, value);
return execute(j -> j.hset(key, Serializer.serialize(field), Serializer.serialize(value)));
}
@Override
public String hmset(String key, Map hash) {
checkNotNull(key, hash);
Map valueMap = Maps.newHashMap();
hash.forEach((field, value) -> valueMap.put(Serializer.serialize(field), Serializer.serialize(value)));
return execute(j -> j.hmset(key, valueMap));
}
@Override
public Long hsetnx(String key, P field, T value) {
checkNotNull(key, field, value);
return execute(j -> j.hsetnx(key, Serializer.serialize(field), Serializer.serialize(value)));
}
@Override
public String hget(String key, P field) {
checkNotNull(key, field);
return execute(j -> j.hget(key, Serializer.serialize(field)));
}
@Override
public T hget(String key, P field, Class type) {
checkNotNull(key, field);
return execute(j -> Serializer.deserialize(j.hget(key, Serializer.serialize(field)), type));
}
@Override
public List hmget(String key, P... fields) {
checkNotNull(key, fields);
return execute(j -> j.hmget(key, Serializer.serialize(fields)));
}
@Override
public List hmget(String key, List fields) {
checkNotNull(key, fields);
return execute(j -> j.hmget(key, Serializer.serialize(fields).toArray(new String[0])));
}
@Override
public List hmget(String key, List fields, Class type) {
checkNotNull(key, fields);
return execute(j -> {
List hmget = j.hmget(key, Serializer.serialize(fields).toArray(new String[0]));
List ts = new ArrayList<>(hmget.size());
hmget.forEach(s -> ts.add(Serializer.deserialize(s, type)));
return ts;
});
}
@Override
public Long hincrBy(String key, P field, long value) {
checkNotNull(key, field);
return execute(j -> j.hincrBy(key, Serializer.serialize(field), value));
}
@Override
public
Double hincrByFloat(String key, P field, double value) {
checkNotNull(key, field);
return execute(j -> j.hincrByFloat(key.getBytes(), Serializer.serialize(field).getBytes(), value));
}
@Override
public Set hkeys(String key) {
checkNotNull(key);
return execute(j -> j.hkeys(key));
}
@Override
public List hvals(String key) {
checkNotNull(key);
return execute(j -> j.hvals(key));
}
@Override
public List hvals(String key, Class type) {
checkNotNull(key);
List strings = execute(j -> j.hvals(key));
return Serializer.deserialize(strings, type);
}
@Override
public Map hgetAll(String key) {
checkNotNull(key);
return execute(j -> j.hgetAll(key));
}
@Override
public Map hgetAll(String key, Class type) {
checkNotNull(key);
Map stringMap = execute(j -> j.hgetAll(key));
Map result = new LinkedHashMap<>(stringMap.size());
stringMap.forEach((k, v) -> result.put(k, Serializer.deserialize(v, type)));
return result;
}
@Override
public ScanResult> hscan(String key, String cursor) {
checkNotNull(key, cursor);
return execute(j -> j.hscan(key, cursor));
}
@Override
public ScanResult> hscan(String key, String cursor, ScanParams params) {
checkNotNull(key, cursor, params);
return execute(j -> j.hscan(key, cursor, params));
}
@Override
public boolean hexists(String key, P field) {
checkNotNull(key, field);
return execute(j -> j.hexists(key, Serializer.serialize(field)));
}
@Override
public
Long hdel(String key, P... fields) {
checkNotNull(key, fields);
return execute(j -> j.hdel(key, Serializer.serialize(fields)));
}
@Override
public
Long hdel(String key, List
fields) {
checkNotNull(key, fields);
return execute(j -> j.hdel(key, fields.toArray(new String[0])));
}
@Override
public
Long hstrlen(String key, P field) {
checkNotNull(key, field);
return execute(j -> j.hstrlen(key, Serializer.serialize(field)));
}
@Override
public Long lpush(String key, T... values) {
checkNotNull(key, values);
return execute(j -> j.lpush(key, Serializer.serialize(values)));
}
@Override
public Long lpush(String key, List values) {
checkNotNull(key, values);
List strings = Serializer.serialize(values);
return execute(j -> j.lpush(key, strings.toArray(new String[0])));
}
@Override
public Long rpush(String key, T... values) {
checkNotNull(key, values);
return execute(j -> j.rpush(key, Serializer.serialize(values)));
}
@Override
public Long rpush(String key, List values) {
checkNotNull(key, values);
List strings = Serializer.serialize(values);
return execute(j -> j.rpush(key, strings.toArray(new String[0])));
}
@Override
public Long lpushx(String key, T... values) {
checkNotNull(key, values);
return execute(j -> j.lpushx(key, Serializer.serialize(values)));
}
@Override
public Long lpushx(String key, List values) {
checkNotNull(key, values);
List strings = Serializer.serialize(values);
return execute(j -> j.lpushx(key, strings.toArray(new String[0])));
}
@Override
public Long rpushx(String key, T... values) {
checkNotNull(key, values);
return execute(j -> j.rpushx(key, Serializer.serialize(values)));
}
@Override
public Long rpushx(String key, List values) {
checkNotNull(key, values);
List strings = Serializer.serialize(values);
return execute(j -> j.rpushx(key, strings.toArray(new String[0])));
}
@Override
public String lset(String key, long index, T value) {
checkNotNull(key, value);
return execute(j -> j.lset(key, index, Serializer.serialize(value)));
}
@Override
public Long linsert(String key, ListPosition where, String pivot, T value) {
checkNotNull(key, value);
return execute(j -> j.linsert(key, where, pivot, Serializer.serialize(value)));
}
@Override
public String rpoplpush(String srckey, String dstkey) {
checkNotNull(srckey, dstkey);
return execute(j -> j.rpoplpush(srckey, dstkey));
}
@Override
public String brpoplpush(String source, String destination, int timeout) {
checkNotNull(source, destination);
return execute(j -> j.brpoplpush(source, destination, timeout));
}
@Override
public List lrange(String key, long start, long end) {
checkNotNull(key);
return execute(j -> j.lrange(key, start, end));
}
@Override
public List lrange(String key, long start, long end, Class type) {
checkNotNull(key);
List strings = execute(j -> j.lrange(key, start, end));
return Serializer.deserialize(strings, type);
}
@Override
public List lrangePage(String key, int pageNo, int pageSize) {
checkNotNull(key);
return execute(j -> j.lrange(key, pageNo * pageSize, (pageNo + 1) * pageSize));
}
@Override
public List lrangePage(String key, int pageNo, int pageSize, Class type) {
checkNotNull(key);
List strings = execute(j -> j.lrange(key, pageNo * pageSize, (pageNo + 1) * pageSize));
return Serializer.deserialize(strings, type);
}
@Override
public List lrangeAll(String key) {
checkNotNull(key);
return execute(j -> j.lrange(key, 0, -1));
}
@Override
public List lrangeAll(String key, Class type) {
checkNotNull(key);
List strings = execute(j -> j.lrange(key, 0, -1));
return Serializer.deserialize(strings, type);
}
@Override
public String lindex(String key, int index) {
checkNotNull(key);
return execute(j -> j.lindex(key, index));
}
@Override
public T lindex(String key, int index, Class type) {
checkNotNull(key);
String s = execute(j -> j.lindex(key, index));
return Serializer.deserialize(s, type);
}
@Override
public Long llen(String key) {
checkNotNull(key);
return execute(j -> j.llen(key));
}
@Override
public String lpop(String key) {
checkNotNull(key);
return execute(j -> j.lpop(key));
}
@Override
public T lpop(String key, Class type) {
checkNotNull(key);
String s = execute(j -> j.lpop(key));
return Serializer.deserialize(s, type);
}
@Override
public String rpop(String key) {
checkNotNull(key);
return execute(j -> j.rpop(key));
}
@Override
public T rpop(String key, Class type) {
checkNotNull(key);
String s = execute(j -> j.rpop(key));
return Serializer.deserialize(s, type);
}
@Override
public List blpop(int timeout, String key) {
checkNotNull(key);
return execute(j -> j.blpop(timeout, key));
}
@Override
public List brpop(int timeout, String key) {
checkNotNull(key);
return execute(j -> j.brpop(timeout, key));
}
@Override
public Long lrem(String key, long count, T value) {
checkNotNull(key);
return execute(j -> j.lrem(key, count, Serializer.serialize(value)));
}
@Override
public String ltrim(String key, long start, long end) {
checkNotNull(key);
return execute(j -> j.ltrim(key, start, end));
}
@Override
public Long sadd(String key, T... values) {
checkNotNull(key, values);
return execute(j -> j.sadd(key, Serializer.serialize(values)));
}
@Override
public Long sadd(String key, List values) {
checkNotNull(key, values);
List strings = Serializer.serialize(values);
return execute(j -> j.sadd(key, strings.toArray(new String[0])));
}
@Override
public Set smembers(String key) {
checkNotNull(key);
return execute(j -> j.smembers(key));
}
@Override
public Set smembers(String key, Class type) {
checkNotNull(key);
Set strings = execute(j -> j.smembers(key));
return Serializer.deserialize(strings, type);
}
@Override
public ScanResult sscan(String key, String cursor) {
checkNotNull(key, cursor);
return execute(j -> j.sscan(key, cursor));
}
@Override
public ScanResult sscan(String key, String cursor, Class type) {
checkNotNull(key, cursor);
ScanResult strings = execute(j -> j.sscan(key, cursor));
return new ScanResult<>(cursor, Serializer.deserialize(strings.getResult(), type));
}
@Override
public ScanResult sscan(String key, String cursor, ScanParams params) {
checkNotNull(key, cursor, params);
return execute(j -> j.sscan(key, cursor, params));
}
@Override
public ScanResult sscan(String key, String cursor, ScanParams params, Class type) {
checkNotNull(key, cursor, params);
ScanResult strings = sscan(key, cursor, params);
return new ScanResult<>(cursor, Serializer.deserialize(strings.getResult(), type));
}
@Override
public Long srem(String key, T... values) {
checkNotNull(key, values);
return execute(j -> j.srem(key, Serializer.serialize(values)));
}
@Override
public Long srem(String key, List values) {
checkNotNull(key, values);
List strings = Serializer.serialize(values);
return execute(j -> j.srem(key, strings.toArray(new String[0])));
}
@Override
public String spop(String key) {
checkNotNull(key);
return execute(j -> j.spop(key));
}
@Override
public T spop(String key, Class type) {
checkNotNull(key);
String s = execute(j -> j.spop(key));
return Serializer.deserialize(s, type);
}
@Override
public Long scard(String key) {
checkNotNull(key);
return execute(j -> j.scard(key));
}
@Override
public boolean sismember(String key, T value) {
checkNotNull(key, value);
return execute(j -> j.sismember(key, Serializer.serialize(value)));
}
@Override
public String srandmember(String key) {
checkNotNull(key);
return execute(j -> j.srandmember(key));
}
@Override
public List srandmember(String key, int count) {
checkNotNull(key);
return execute(j -> j.srandmember(key, count));
}
@Override
public List srandmember(String key, int count, Class type) {
checkNotNull(key);
return execute(j -> Serializer.deserialize(j.srandmember(key, count), type));
}
@Override
public Long zadd(String key, double score, T member) {
checkNotNull(key, member);
return execute(j -> j.zadd(key, score, Serializer.serialize(member)));
}
@Override
public Long zadd(String key, double score, T member, ZAddParams params) {
checkNotNull(key, member, params);
return execute(j -> j.zadd(key, score, Serializer.serialize(member), params));
}
@Override
public Long zadd(String key, Map scoreMembers) {
checkNotNull(key, scoreMembers);
return execute(j -> j.zadd(key, scoreMembers));
}
@Override
public Long zadd(String key, Map scoreMembers, ZAddParams params) {
checkNotNull(key, scoreMembers, params);
return execute(j -> j.zadd(key, scoreMembers, params));
}
@Override
public Set zrange(String key, long start, long stop) {
checkNotNull(key);
return execute(j -> j.zrange(key, start, stop));
}
@Override
public Set zrange(String key, long start, long stop, Class type) {
checkNotNull(key);
Set strings = execute(j -> j.zrange(key, start, stop));
return Serializer.deserialize(strings, type);
}
@Override
public Set zrevrange(String key, long start, long stop) {
checkNotNull(key);
return execute(j -> j.zrevrange(key, start, stop));
}
@Override
public Set zrevrange(String key, long start, long stop, Class type) {
checkNotNull(key);
Set strings = execute(j -> j.zrevrange(key, start, stop));
return Serializer.deserialize(strings, type);
}
@Override
public Long zrem(String key, T... members) {
checkNotNull(key, members);
return execute(j -> j.zrem(key, Serializer.serialize(members)));
}
@Override
public Long zrem(String key, List members) {
checkNotNull(key, members);
return execute(j -> j.zrem(key, Serializer.serialize(members).toArray(new String[0])));
}
@Override
public Double zincrby(String key, double increment, T member) {
checkNotNull(key, member);
return execute(j -> j.zincrby(key, increment, Serializer.serialize(member)));
}
@Override
public Double zincrby(String key, double increment, T member, ZIncrByParams params) {
checkNotNull(key, member, params);
return execute(j -> j.zincrby(key, increment, Serializer.serialize(member), params));
}
@Override
public Set zrangeByScore(String key, double min, double max) {
checkNotNull(key);
return execute(j -> j.zrangeByScore(key, min, max));
}
@Override
public Set zrangeByScore(String key, double min, double max, Class type) {
checkNotNull(key);
Set strings = execute(j -> j.zrangeByScore(key, min, max));
return Serializer.deserialize(strings, type);
}
@Override
public Set zrangeByScore(String key, String min, String max) {
checkNotNull(key);
return execute(j -> j.zrangeByScore(key, min, max));
}
@Override
public Set zrangeByScore(String key, String min, String max, Class type) {
checkNotNull(key);
Set strings = execute(j -> j.zrangeByScore(key, min, max));
return Serializer.deserialize(strings, type);
}
@Override
public Set zrangeByScoreWithScores(String key, double min, double max) {
checkNotNull(key);
return execute(j -> j.zrangeByScoreWithScores(key, min, max));
}
@Override
public Set zrangeByScoreWithScores(String key, double min, double max, int offset, int count) {
checkNotNull(key);
return execute(j -> j.zrangeByScoreWithScores(key, min, max, offset, count));
}
@Override
public Set zrevrangeByScore(String key, double max, double min) {
checkNotNull(key);
return execute(j -> j.zrevrangeByScore(key, min, max));
}
@Override
public Set zrevrangeByScore(String key, double max, double min, Class type) {
checkNotNull(key);
Set strings = execute(j -> j.zrevrangeByScore(key, min, max));
return Serializer.deserialize(strings, type);
}
@Override
public Set zrevrangeByScore(String key, String max, String min) {
checkNotNull(key);
return execute(j -> j.zrevrangeByScore(key, min, max));
}
@Override
public Set zrevrangeByScore(String key, String max, String min, Class type) {
checkNotNull(key);
Set strings = execute(j -> j.zrevrangeByScore(key, min, max));
return Serializer.deserialize(strings, type);
}
@Override
public Set zrangeByLex(String key, String min, String max) {
checkNotNull(key);
return execute(j -> j.zrangeByLex(key, min, max));
}
@Override
public Set zrangeByLex(String key, String min, String max, Class type) {
checkNotNull(key);
Set strings = execute(j -> j.zrangeByLex(key, min, max));
return Serializer.deserialize(strings, type);
}
@Override
public Set zrevrangeByLex(String key, String max, String min) {
checkNotNull(key);
return execute(j -> j.zrevrangeByLex(key, min, max));
}
@Override
public Set zrevrangeByLex(String key, String max, String min, Class type) {
checkNotNull(key);
Set strings = execute(j -> j.zrevrangeByLex(key, min, max));
return Serializer.deserialize(strings, type);
}
@Override
public ScanResult zscan(String key, String cursor) {
checkNotNull(key, cursor);
return execute(j -> j.zscan(key, cursor));
}
@Override
public ScanResult zscan(String key, String cursor, ScanParams params) {
checkNotNull(key, cursor, params);
return execute(j -> j.zscan(key.getBytes(), cursor.getBytes(), params));
}
@Override
public Long zremrangeByRank(String key, long start, long stop) {
checkNotNull(key);
return execute(j -> j.zremrangeByRank(key, start, stop));
}
@Override
public Long zremrangeByScore(String key, double min, double max) {
checkNotNull(key);
return execute(j -> j.zremrangeByScore(key, min, max));
}
@Override
public Long zremrangeByScore(String key, String min, String max) {
checkNotNull(key);
return execute(j -> j.zremrangeByScore(key, min, max));
}
@Override
public Long zremrangeByLex(String key, String min, String max) {
checkNotNull(key);
return execute(j -> j.zremrangeByLex(key, min, max));
}
@Override
public Long zrank(String key, T member) {
checkNotNull(key, member);
return execute(j -> j.zrank(key, Serializer.serialize(member)));
}
@Override
public Long zrevrank(String key, T member) {
checkNotNull(key, member);
return execute(j -> j.zrevrank(key, Serializer.serialize(member)));
}
@Override
public Long zcard(String key) {
checkNotNull(key);
return execute(j -> j.zcard(key));
}
@Override
public Double zscore(String key, T member) {
checkNotNull(key, member);
return execute(j -> j.zscore(key, Serializer.serialize(member)));
}
@Override
public Long zcount(String key, double min, double max) {
checkNotNull(key);
return execute(j -> j.zcount(key, min, max));
}
@Override
public Long zcount(String key, String min, String max) {
checkNotNull(key);
return execute(j -> j.zcount(key, min, max));
}
@Override
public Long zlexcount(String key, String min, String max) {
checkNotNull(key);
return execute(j -> j.zlexcount(key, min, max));
}
@Override
public Long pfadd(String key, T... elements) {
checkNotNull(key, elements);
return execute(j -> j.pfadd(key, Serializer.serialize(elements)));
}
@Override
public Long pfadd(String key, List elements) {
checkNotNull(key, elements);
return execute(j -> j.pfadd(key, Serializer.serialize(elements).toArray(new String[0])));
}
@Override
public Long pfcount(String key) {
checkNotNull(key);
return execute(j -> j.pfcount(key));
}
@Override
public boolean setbit(String key, long offset, boolean value) {
checkNotNull(key);
return execute(j -> j.setbit(key, offset, value));
}
@Override
public boolean setbit(String key, long offset, String value) {
checkNotNull(key);
return execute(j -> j.setbit(key, offset, value));
}
@Override
public boolean getbit(String key, long offset) {
checkNotNull(key);
return execute(j -> j.getbit(key, offset));
}
@Override
public Long bitcount(String key) {
checkNotNull(key);
return execute(j -> j.bitcount(key));
}
@Override
public Long bitcount(String key, long start, long end) {
checkNotNull(key);
return execute(j -> j.bitcount(key, start, end));
}
@Override
public Long bitpos(String key, boolean value) {
checkNotNull(key);
return execute(j -> j.bitpos(key, value));
}
@Override
public Long bitpos(String key, boolean value, long start, long end) {
checkNotNull(key);
return execute(j -> j.bitpos(key, value, new BitPosParams(start, end)));
}
@Override
public Long bitop(BitOP op, String destKey, String... srcKeys) {
checkNotNull(op, destKey, srcKeys);
return execute(j -> j.bitop(op, destKey, srcKeys));
}
@Override
public Long bitop(BitOP op, String destKey, List srcKeys) {
checkNotNull(op, destKey, srcKeys);
return bitop(op, destKey, srcKeys.toArray(new String[0]));
}
@Override
public List bitfield(String key, String... arguments) {
checkNotNull(key, arguments);
return execute(j -> j.bitfield(key, arguments));
}
@Override
public List bitfield(String key, List arguments) {
checkNotNull(key, arguments);
return execute(j -> j.bitfield(key, arguments.toArray(new String[0])));
}
@Override
public Long geoadd(String key, double longitude, double latitude, T member) {
checkNotNull(key, member);
return execute(j -> j.geoadd(key, longitude, latitude, Serializer.serialize(member)));
}
@Override
public Long geoadd(String key, Map memberCoordinateMap) {
checkNotNull(key, memberCoordinateMap);
return execute(j -> j.geoadd(key, memberCoordinateMap));
}
@Override
public Double geodist(String key, T member1, T member2) {
checkNotNull(key, member1, member2);
return execute(j -> j.geodist(key, Serializer.serialize(member1), Serializer.serialize(member2)));
}
@Override
public Double geodist(String key, T member1, T member2, GeoUnit unit) {
checkNotNull(key, member1, member2);
return execute(j -> j.geodist(key, Serializer.serialize(member1), Serializer.serialize(member2), unit));
}
@Override
public List geohash(String key, T... members) {
checkNotNull(key, members);
return execute(j -> j.geohash(key, Serializer.serialize(members)));
}
@Override
public List geohash(String key, List members) {
checkNotNull(key, members);
return execute(j -> j.geohash(key, Serializer.serialize(members).toArray(new String[0])));
}
@Override
public List geopos(String key, T... members) {
checkNotNull(key, members);
return execute(j -> j.geopos(key, Serializer.serialize(members)));
}
@Override
public List geopos(String key, List members) {
checkNotNull(key, members);
return execute(j -> j.geopos(key, Serializer.serialize(members).toArray(new String[0])));
}
@Override
public List georadius(String key, double longitude, double latitude, double radius, GeoUnit unit) {
checkNotNull(key);
return execute(j -> j.georadius(key, longitude, latitude, radius, unit));
}
@Override
public List georadius(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param) {
checkNotNull(key);
return execute(j -> j.georadius(key, longitude, latitude, radius, unit, param));
}
@Override
public List georadiusByMember(String key, T member, double radius, GeoUnit unit) {
checkNotNull(key);
return execute(j -> j.georadiusByMember(key, Serializer.serialize(member), radius, unit));
}
@Override
public List georadiusByMember(String key, T member, double radius, GeoUnit unit, GeoRadiusParam param) {
checkNotNull(key);
return execute(j -> j.georadiusByMember(key, Serializer.serialize(member), radius, unit, param));
}
@Override
public boolean bloomadd(String key, T value) {
checkNotNull(key, value);
boolean bloomconstains = bloomcons(key, value);
if (bloomconstains) {
return false;
}
long[] offsets = BitHashUtil.getBitOffsets(value);
for (long offset : offsets) {
execute(j -> j.setbit(key, offset, true));
}
return true;
}
@Override
public boolean bloomcons(String key, T value) {
checkNotNull(key, value);
long[] offsets = BitHashUtil.getBitOffsets(value);
for (long offset : offsets) {
Boolean execute = execute(j -> j.getbit(key, offset));
if (BooleanUtils.isFalse(execute)) {
return false;
}
}
return true;
}
@Override
public boolean getDistributedLock(String lockKey, String requestId, int expireTime) {
checkNotNull(lockKey, requestId);
SetParams setParams = SetParams.setParams();
setParams.nx();
setParams.px(expireTime);
String result = execute(j -> j.set(lockKey, requestId, setParams));
return "OK".equals(result);
}
@Override
public boolean releaseDistributedLock(String lockKey, String requestId) {
checkNotNull(lockKey, requestId);
String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
Object result = execute(j -> j.eval(script, Collections.singletonList(lockKey), Collections.singletonList(requestId)));
Long success = 1L;
return success.equals(result);
}
@Override
public T eval(String script, int keyCount, List params, Class type) {
if (keyCount != 0) {
checkNotNull(params);
}
String[] strings = Serializer.serialize(params).toArray(new String[0]);
Object result = execute(j -> j.eval(script, keyCount, strings));
return Serializer.deserialize(result, type);
}
@Override
public T eval(String script, int keyCount, Class type, P... params) {
if (keyCount != 0) {
checkNotNull(params);
}
Object result = execute(j -> j.eval(script, keyCount, Serializer.serialize(params)));
return Serializer.deserialize(result, type);
}
@Override
public R eval(String script, List keys, List args, Class type) {
checkNotNull(keys, args);
Object result = execute(j -> j.eval(script, Serializer.serialize(keys), Serializer.serialize(args)));
return Serializer.deserialize(result, type);
}
}