1.
<?xml version="1.0" encoding="utf-8"?>
<redis>
<cluster auth="xxxxxxxxxxxxxxxx" prefix="dispatcher_test:" maxIdle="100" maxTotal="1024" minIdle="20" connectionTimeout="2000" soTimeout="2000" maxAttempts="2">
<host ip="redis-cluster-c4-car-all-test-db.01zhuanche.com" port="6380"/>
<host ip="redis-cluster-c1-car-all-test-db.01zhuanche.com" port="6381"/>
<host ip="redis-cluster-c5-car-all-test-db.01zhuanche.com" port="6380"/>
<host ip="redis-cluster-c2-car-all-test-db.01zhuanche.com" port="6381"/>
<host ip="redis-cluster-c6-car-all-test-db.01zhuanche.com" port="6380"/>
<host ip="redis-cluster-c3-car-all-test-db.01zhuanche.com" port="6381"/>
</cluster>
</redis>
2.
@Data
@Root(name = "redis")
public class RedisConfig {
@Element(name = "cluster")
private ClusterConfig clusterConfig;
}
3.
@Data
public class ClusterConfig {
@Attribute(name = "auth")
private String auth;
@Attribute(name = "prefix")
private String prefix;
@Attribute(name = "maxIdle")
private Integer maxIdle;
@Attribute(name = "maxTotal")
private Integer maxTotal;
@Attribute(name = "minIdle")
private Integer minIdle;
@Attribute(name = "connectionTimeout")
private Integer connectionTimeout;
@Attribute(name = "soTimeout")
private Integer soTimeout;
@Attribute(name = "maxAttempts")
private Integer maxAttempts;
@ElementList(entry = "host", inline = true)
private List<RedisHostConfig> redisHostConfigs;
public String getHostAndPort() {
if (redisHostConfigs == null || redisHostConfigs.size() == 0) {
return null;
}
StringBuilder hosts = new StringBuilder();
redisHostConfigs.forEach(redisHostConfig -> hosts.append(redisHostConfig.getIp()).append(":").append(redisHostConfig.getPort()).append(","));
return hosts.deleteCharAt(hosts.length() - 1).toString();
}
}
3.
public class RedisClient implements RedisSupport {
private static final Logger logger = LoggerFactory.getLogger(RedisClient.class);
private static final int DEFAULT_MAX_TOTAL = 1024;
private static final int DEFAULT_MAX_IDLE = 50;
private static final int DEFAULT_MIN_IDLE = 20;
private static final int CONNECTION_TIMEOUT = 1500;
private static final int SO_TIMEOUT = 2000;
private static final int MAX_REDIRECTIONS = 2;
private static final long MIN_EVICTABLE_IDLE_TIME_MILLIS = 1000L * 60L * 30L;
private static final long TIME_BETWEEN_EVICTION_RUNS_MILLIS = 1000L * 60L * 10;
private static final String DEFAULT_SERIALIZER = "jackson";
private JedisCluster jc;
private byte[] prefix;
private Serializer<Object> serializer;
public RedisClient(RedisProperties param) {
this(param.getNodes(), param.getPrefix(), param.getPassword(),
param.getMaxIdle(), param.getMaxTotal(), param.getMinIdle(),
param.getConnectionTimeout(), param.getSoTimeout(), param.getMaxAttempts(),
param.getMinEvictableIdleTimeMillis(), param.getTimeBetweenEvictionRunsMillis(), param.getEvictionPolicyClassName(), param.getSerializer());
}
/**
* 閲嶈浇鏋勯�犲嚱鏁�,鎻愪緵榛樿鍙傛暟
*/
public RedisClient(String cluster, String prefix, String password) {
this(cluster, prefix, password, DEFAULT_MAX_IDLE, DEFAULT_MAX_TOTAL, DEFAULT_MIN_IDLE,
CONNECTION_TIMEOUT, SO_TIMEOUT, MAX_REDIRECTIONS, MIN_EVICTABLE_IDLE_TIME_MILLIS, TIME_BETWEEN_EVICTION_RUNS_MILLIS, BaseObjectPoolConfig.DEFAULT_EVICTION_POLICY_CLASS_NAME, DEFAULT_SERIALIZER);
}
/**
* @param cluster 鏍煎紡涓篿p:port,ip:port
* @param prefix redis-cluster鍏ㄥ眬KEY鍓嶇紑
* @param password 瀵嗙爜
* @param maxIdle 鏈�澶氳兘淇濈暀澶氬皯涓┖闂插璞�
* @param maxTotal 鏈�澶氳兘淇濈暀澶氬皯瀵硅薄
* @param minIdle 鏈�灏戞湁澶氬皯涓┖闂插璞�
* @param connectionTimeout 杩炴帴瓒呮椂
* @param soTimeout 杩斿洖鍊肩殑瓒呮椂鏃堕棿
* @param maxAttempts 鍑虹幇寮傚父鏈�澶ч噸璇曟鏁�
*/
public RedisClient(String cluster, String prefix, String password,
int maxIdle, int maxTotal, int minIdle,
int connectionTimeout, int soTimeout, int maxAttempts,
long minEvictableIdleTimeMillis, long timeBetweenEvictionRunsMillis, String evictionPolicyClassName, String serializer) {
try {
if (cluster == null || cluster.trim().length() == 0) {
throw new JedisClusterException("cluster str is null.");
}
if (prefix == null || prefix.trim().length() == 0) {
throw new JedisClusterException("prefix is null.");
}
String[] hostAndPort = cluster.split(",");
Set<HostAndPort> jedisClusterNodesSet = new HashSet<HostAndPort>();
for (String hp : hostAndPort) {
String[] hap = hp.split(":");
jedisClusterNodesSet.add(new HostAndPort(hap[0], Integer.parseInt(hap[1])));
}
GenericObjectPoolConfig genericObjectPoolConfig = new GenericObjectPoolConfig();
genericObjectPoolConfig.setMaxIdle(maxIdle);
genericObjectPoolConfig.setMaxTotal(maxTotal);
genericObjectPoolConfig.setMinIdle(minIdle);
genericObjectPoolConfig.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
genericObjectPoolConfig.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
genericObjectPoolConfig.setEvictionPolicyClassName(evictionPolicyClassName);
jc = new JedisCluster(jedisClusterNodesSet, connectionTimeout, soTimeout, maxAttempts, password, genericObjectPoolConfig);
this.prefix = SerializationUtils.encode(prefix);
this.serializer = SeriaLizerFactory.create(serializer);
} catch (Exception e) {
logger.error("redis client init error", e);
}
}
@Deprecated
@Override
public String set(final String key, final Object value) {
return jc.set(getKey(key), serializer.serialize(value));
}
@Override
public String set(final String key, int expTime, final Object value) {
return jc.setex(getKey(key), expTime, serializer.serialize(value));
}
@Override
public String set(String key, int expTime, String value) {
return jc.setex(getKey(key), expTime, serializer.serialize(value));
}
@Override
public String setnxxx(final String key, final Object value, final String nxxx, final long time) {
return jc.set(getKey(key), serializer.serialize(value), nxxx.getBytes(), "EX".getBytes(), time);
}
@Override
public <T> T getSet(final String key, final Object value, Class<T> javaType) {
byte[] data = jc.getSet(getKey(key), serializer.serialize(value));
return serializer.deserialize(data, javaType);
}
@Override
public boolean set(final String key, final Object value, final String nxxx, final String expx, final long time) {
return jc.set(getKey(key), serializer.serialize(value), nxxx.getBytes(), expx.getBytes(), time) != null;
}
@Override
public <T> T get(final String key, Class<T> javaType) {
return serializer.deserialize(jc.get(getKey(key)), javaType);
}
/**
* 褰搒erializerType涓嶇瓑浜嶥EFAULT_SERIALIZER鏃�,
* 浣跨敤璇ユ柟娉曚細鎶涘嚭寮傚父
*/
@Override
public <T> T get(final String key, TypeReference<T> tr) {
byte[] value = jc.get(getKey(key));
if (serializer instanceof Jackson2JsonSerializer) {
return ((Jackson2JsonSerializer) serializer).deserialize(value, tr);
} else {
// This method does not belong to this type of serialization
throw new SerializationException("serializer type error");
}
}
@Override
public String get(final String key) {
return serializer.deserialize(jc.get(getKey(key)), String.class);
}
@Override
public long delete(final String key) {
return jc.del(getKey(key));
}
private byte[] getKey(String key) {
byte[] rawKey = SerializationUtils.encode(key);
if (!this.hasPrefix()) {
return rawKey;
} else {
byte[] prefixedKey = Arrays.copyOf(this.prefix, this.prefix.length + rawKey.length);
System.arraycopy(rawKey, 0, prefixedKey, this.prefix.length, rawKey.length);
return prefixedKey;
}
}
/**
* getKey鐨勯�嗘搷浣� 鑾峰彇鍘熷key鍊�
*/
private String getOriginalKey(byte[] key) {
if (!this.hasPrefix()) {
return new String(key);
} else {
int keyLen = key.length - this.prefix.length;
byte[] originalKey = new byte[keyLen];
System.arraycopy(key, this.prefix.length, originalKey, 0, keyLen);
return new String(originalKey);
}
}
@Override
public byte[] hget(final String key, final String field) {
return jc.hget(getKey(key), getKey(field));
}
@Override
public long hincrBy(final String key, final String field, final long value) {
return jc.hincrBy(getKey(key), getKey(field), value);
}
@Override
public long incrBy(final String key, final long delta) {
return jc.incrBy(getKey(key), delta);
}
@Override
public long expire(final String key, final int seconds) {
return jc.expire(getKey(key), seconds);
}
@Override
public long lpush(final String key, final Object... value) {
byte[][] args = new byte[value.length][];
for (int i = 0; i < value.length; i++) {
args[i] = serializer.serialize(value[i]);
}
return jc.lpush(getKey(key), args);
}
@Override
public long rpush(final String key, final Object... value) {
byte[][] args = new byte[value.length][];
for (int i = 0; i < value.length; i++) {
args[i] = serializer.serialize(value[i]);
}
return jc.rpush(getKey(key), args);
}
@Override
public <T> T lpop(final String key, Class<T> javaType) {
return serializer.deserialize(jc.lpop(getKey(key)), javaType);
}
@Override
public <T> T blpop(final String key, final int timeout, Class<T> javaType) {
List<byte[]> list = jc.blpop(timeout, getKey(key));
if (list == null || list.isEmpty()) {
return null;
} else {
return serializer.deserialize(list.get(1), javaType);
}
}
@Override
public <T> List<T> lrange(final String key, int start, int end) {
return (List<T>) lrange(key, start, end, Object.class);
}
@Override
public <T> List<T> lrange(final String key, int start, int end, Class<T> javaType) {
List<byte[]> list = jc.lrange(getKey(key), start, end);
List<T> res = new ArrayList<>(list.size());
for (byte[] data : list) {
res.add(serializer.deserialize(data, javaType));
}
return res;
}
@Override
public Long sadd4Sets(final String key, final Object... values) {
if (values == null) {
return -1L;
}
byte[][] valBytes = new byte[values.length][];
for (int i = 0; i < values.length; i++) {
valBytes[i] = serializer.serialize(values[i]);
}
return jc.sadd(getKey(key), valBytes);
}
@Override
public <T> Set<T> smembers4Sets(final String key, Class<T> javaType) {
Set<byte[]> resultSet = jc.smembers(getKey(key));
Set<T> result = new HashSet<T>();
if (resultSet == null) {
return result;
} else {
for (byte[] b : resultSet) {
result.add(serializer.deserialize(b, javaType));
}
}
return result;
}
@Override
public Long srem4Sets(final String key, final Object... values) {
if (values == null) {
return -1L;
}
byte[][] valBytes = new byte[values.length][];
for (int i = 0; i < values.length; i++) {
valBytes[i] = serializer.serialize(values[i]);
}
return jc.srem(getKey(key), valBytes);
}
private <T extends Collection<?>> T deserializeValues(Collection<byte[]> rawValues, Class<T> type) {
if (rawValues == null) {
return null;
} else {
Object values = List.class.isAssignableFrom(type) ? new ArrayList(rawValues.size()) : new LinkedHashSet(rawValues.size());
Iterator i$ = rawValues.iterator();
while (i$.hasNext()) {
byte[] bs = (byte[]) i$.next();
((Collection) values).add(serializer.deserialize(bs, Object.class));
}
return (T) values;
}
}
private boolean hasPrefix() {
return this.prefix != null && this.prefix.length > 0;
}
@Override
public Boolean exists(String key) {
return jc.exists(getKey(key));
}
public void shutdown() {
try {
jc.close();
} catch (IOException e) {
logger.error("jedis pool shutdown error = {}", e);
}
}
@Override
public long hdel(String key) {
return jc.hlen(getKey(key));
}
@Override
public long hdel(String key, String... field) {
if (field.length > 0) {
byte[][] fieldArray = new byte[field.length][];
for (int i = 0; i < field.length; i++) {
fieldArray[i] = getKey(field[i]);
}
return jc.hdel(getKey(key), fieldArray);
} else {
throw new SerializationException("ERR wrong number of arguments for 'hdel' command");
}
}
/**
* 杩斿洖鍝堝笇琛� key 涓紝鎵�鏈夌殑鍩熷拰鍊�
*/
@Override
public Map<String, Object> hgetAll(String key) {
return hgetAll(key, Object.class);
}
/**
* 鍚屾椂灏嗗涓� field-value (鍩�-鍊�)瀵硅缃埌鍝堝笇琛� key 涓�
*/
@Override
public String hmset(String key, Map<String, Object> map) {
return jc.hmset(getKey(key), serializerMap(map));
}
/**
* 杩斿洖鍝堝笇琛� key 涓紝涓�涓垨澶氫釜缁欏畾鍩熺殑鍊�
*/
@Override
public List<Object> hmget(String key, String... field) {
return hmget(key, Object.class, field);
}
/**
* 杩斿洖鍝堝笇琛� key 涓墍鏈夊煙鐨勫��
*/
@Override
public <T> List<T> hvals(String key) {
Collection<byte[]> hvals = jc.hvals(getKey(key));
return (List) deserializeValues(hvals, List.class);
}
/**
* 杩斿洖鍝堝笇琛� key 涓殑鎵�鏈夊煙
*/
@Override
public Set<String> hkeys(String key) {
Set<byte[]> hkeys = jc.hkeys(getKey(key));
Set<String> res = new HashSet<>(hkeys.size());
for (byte[] k : hkeys) {
res.add(getOriginalKey(k));
}
return res;
}
private Map<byte[], byte[]> serializerMap(Map<String, Object> map) {
if (map == null) {
return SerializationUtils.EMPTY_MAP;
}
Map<byte[], byte[]> res = new HashMap<>(map.size());
try {
Set<Map.Entry<String, Object>> entries = map.entrySet();
for (Map.Entry<String, Object> e : entries) {
res.put(getKey(e.getKey()), serializer.serialize(e.getValue()));
}
} catch (Exception e) {
throw new SerializationException("Could not encode map: " + e.getMessage(), e);
}
return res;
}
@Override
public Long setnx(String key, Object value) {
return jc.setnx(getKey(key), serializer.serialize(value));
}
@Override
public Long llen(String key) {
return jc.llen(getKey(key));
}
@Override
public Long lrem(String key, long count, Object value) {
return jc.lrem(getKey(key), count, serializer.serialize(value));
}
@Override
public Long sadd(String key, Object... values) {
return sadd4Sets(key, values);
}
@Override
public Long scard(String key) {
return jc.scard(getKey(key));
}
@Override
public Boolean sismember(String key, Object member) {
return jc.sismember(getKey(key), serializer.serialize(member));
}
@Override
public <T> Set<T> smembers(String key, Class<T> javaType) {
return smembers4Sets(key, javaType);
}
@Override
public Long srem(String key, Object... values) {
return srem4Sets(key, values);
}
@Override
public Long zadd(String key, Object member, double score) {
return jc.zadd(getKey(key), score, serializer.serialize(member));
}
@Override
public Long zadd(String key, Map<Object, Double> scoreMembers) {
if (scoreMembers == null) {
return -1L;
}
Map<byte[], Double> sm = new HashMap<>(scoreMembers.size());
Set<Map.Entry<Object, Double>> entries = scoreMembers.entrySet();
for (Map.Entry<Object, Double> entry : entries) {
sm.put(serializer.serialize(entry.getKey()), entry.getValue());
}
return jc.zadd(getKey(key), sm);
}
@Override
public Long zcard(String key) {
return jc.zcard(getKey(key));
}
@Override
public Long zcount(String key, Double min, Double max) {
return jc.zcount(getKey(key), min, max);
}
@Override
public Long zrem(String key, Object... member) {
if (member == null) {
return -1L;
}
byte[][] valBytes = new byte[member.length][];
for (int i = 0; i < member.length; i++) {
valBytes[i] = serializer.serialize(member[i]);
}
return jc.zrem(getKey(key), valBytes);
}
@Override
public Long hset(String key, String field, Object value) {
return jc.hset(getKey(key), getKey(field), serializer.serialize(value));
}
@Override
public <T> T hget(String key, String field, Class<T> valueType) {
return serializer.deserialize(this.hget(key, field), valueType);
}
@Override
public <T> Map<String, T> hgetAll(String key, Class<T> valueType) {
Map<byte[], byte[]> map = jc.hgetAll(getKey(key));
Map<String, T> res = new HashMap<>(map.size());
Set<Map.Entry<byte[], byte[]>> entries = map.entrySet();
for (Map.Entry<byte[], byte[]> e : entries) {
res.put(getOriginalKey(e.getKey()), serializer.deserialize(e.getValue(), valueType));
}
return res;
}
@Override
public Long hlen(String key) {
return jc.hlen(getKey(key));
}
@Override
public <T> List<T> hmget(String key, Class<T> valueType, String... field) {
if (field.length > 0) {
byte[][] fieldArray = new byte[field.length][];
for (int i = 0; i < field.length; i++) {
fieldArray[i] = getKey(field[i]);
}
List<T> res = new ArrayList<>(field.length);
List<byte[]> values = jc.hmget(getKey(key), fieldArray);
for (byte[] v : values) {
res.add(serializer.deserialize(v, valueType));
}
return res;
} else {
throw new SerializationException("ERR wrong number of arguments for 'hmget' command");
}
}
@Override
public Long hsetnx(String key, String field, Object value) {
return jc.hsetnx(getKey(key), getKey(field), serializer.serialize(value));
}
@Override
public Long expireat(String key, long timestamp) {
return jc.expireAt(getKey(key), timestamp);
}
@Override
public List<Object> zrange(String key, long start, long end) {
return zrange(key, start, end, Object.class);
}
@Override
public <T> List<T> zrange(String key, long start, long end, Class<T> valueType) {
Set<byte[]> set = jc.zrange(getKey(key), start, end);
List<T> result = new ArrayList<>(set.size());
for (byte[] data : set) {
result.add(serializer.deserialize(data, valueType));
}
return result;
}
@Override
public List<Object> zrevrange(String key, long start, long end) {
return zrevrange(key, start, end, Object.class);
}
@Override
public <T> List<T> zrevrange(String key, long start, long end, Class<T> valueType) {
Set<byte[]> set = jc.zrevrange(getKey(key), start, end);
List<T> result = new ArrayList<>(set.size());
for (byte[] data : set) {
T deserialize = serializer.deserialize(data, valueType);
result.add(deserialize);
}
return result;
}
@Override
public Long zrevrank(String key, Object member) {
return jc.zrevrank(getKey(key), serializer.serialize(member));
}
@Override
public Long zrank(String key, Object member) {
return jc.zrank(getKey(key), serializer.serialize(member));
}
}
4.
public class CacheManager {
private static Logger LOGGER = LoggerFactory.getLogger(CacheManager.class);
private static RedisClient REDIS_CLIENT = null;
static {
RedisConfig redisConfig = null;
try {
redisConfig = ConfigManager.get(RedisConfig.class);
ClusterConfig clusterConfig = redisConfig.getClusterConfig();
RedisProperties param = new RedisProperties();
param.setNodes(clusterConfig.getHostAndPort());
param.setPrefix(clusterConfig.getPrefix());
param.setPassword(clusterConfig.getAuth());
param.setSerializer(GsonSerializer.class.getName());
REDIS_CLIENT = new RedisClient(param);
} catch (Throwable e) {
LOGGER.error("初始化redis客户端异常 redisConfig:[{}]", JSON.toJSONString(redisConfig), e);
}
}
private CacheManager() {
}
/**
* 设置缓存对象,永久有效
*
* @param key
* @param value
* @return
*/
public static String set(String key, Object value) {
return REDIS_CLIENT.set(key, value);
}
/**
* 设置缓存对象
*
* @param key
* @param value
* @param expTime
* @return
*/
public static String set(final String key, final int expTime, final Object value) {
try {
return REDIS_CLIENT.set(key, expTime, value);
} catch (Exception e) {
LOGGER.error("set Object value cache error", e);
ErrorMonitorManager.putError(ErrorTypeEnum.REDIS, e);
}
return null;
}
/**
* 设置缓存对象并返回旧的值
*
* @param key
* @param value
* @param javaType
* @return
*/
public static <T> T getSet(String key, Object value, Class<T> javaType) {
try {
return REDIS_CLIENT.getSet(key, value, javaType);
} catch (Exception e) {
LOGGER.error("set Object value cache error", e);
ErrorMonitorManager.putError(ErrorTypeEnum.REDIS, e);
}
return null;
}
/**
* 设置缓存对象
*
* @param key
* @param expTime 单位:秒
* @param value
* @return
*/
public static String set(final String key, final int expTime, final String value) {
try {
return REDIS_CLIENT.set(key, expTime, value);
} catch (Exception e) {
LOGGER.error("set String value cache error", e);
ErrorMonitorManager.putError(ErrorTypeEnum.REDIS, e);
}
return null;
}
/**
* 存储数据到缓存中,并制定过期时间和当Key存在时是否覆盖。
*
* @param key
* @param value
* @param nxxx
* nxxx的值只能取NX或者XX,如果取NX,则只有当key不存在是才进行set,如果取XX,则只有当key已经存在时才进行set
* @param expx
* expx expx的值只能取EX或者PX,代表数据过期时间的单位,EX代表秒,PX代表毫秒。
* @param time
* time 过期时间,单位是expx所代表的单位。
* @return
*/
public static boolean set(final String key, final Object value, final String nxxx, final String expx, final long time) {
try {
return REDIS_CLIENT.set(key, value, nxxx, expx, time);
} catch (Exception e) {
LOGGER.error("set nxxx value error", e);
ErrorMonitorManager.putError(ErrorTypeEnum.REDIS, e);
}
return false;
}
/**
* 获取缓存对象,不支持list,map
*
* @param key
* @param classType
* @param <T>
* @return
*/
public static <T> T get(String key, Class<T> classType) {
try {
return REDIS_CLIENT.get(key, classType);
} catch (Exception e) {
LOGGER.error("get object cache error", e);
ErrorMonitorManager.putError(ErrorTypeEnum.REDIS, e);
}
return null;
}
/**
* 获取缓存对象,支持list,map
*
* @param key
* @param tr
* @param <T>
* @return
*/
public static <T> T get(final String key, TypeReference<T> tr) {
try {
return REDIS_CLIENT.get(key, tr);
} catch (Exception e) {
LOGGER.error("get list cache error", e);
ErrorMonitorManager.putError(ErrorTypeEnum.REDIS, e);
}
return null;
}
/**
* 获取缓存对象
*
* @param key
* @return
*/
public static String get(final String key) {
try {
return REDIS_CLIENT.get(key);
} catch (Exception e) {
LOGGER.error("get list cache error", e);
ErrorMonitorManager.putError(ErrorTypeEnum.REDIS, e);
}
return null;
}
/**
* 删除缓存对象
*
* @param key
* @return
*/
public static long delete(final String key) {
try {
return REDIS_CLIENT.delete(key);
} catch (Exception e) {
LOGGER.error("delete [{}] error", key, e);
ErrorMonitorManager.putError(ErrorTypeEnum.REDIS, e);
}
return 0;
}
private static long hincrBy(final String key, final String field, final long value) {
try {
return REDIS_CLIENT.hincrBy(key, field, value);
} catch (Exception e) {
LOGGER.error("hincrBy cache error", e);
ErrorMonitorManager.putError(ErrorTypeEnum.REDIS, e);
}
return 0;
}
private static byte[] hget(final String key, final String field) {
try {
return REDIS_CLIENT.hget(key, field);
} catch (Exception e) {
LOGGER.error("hget cache error", e);
ErrorMonitorManager.putError(ErrorTypeEnum.REDIS, e);
}
return SerializationUtils.EMPTY_ARRAY;
}
/**
* @param key
* @param delta 累加值,非负值
* @return
*/
public static long incrBy(final String key, final long delta) {
try {
return REDIS_CLIENT.incrBy(key, delta);
} catch (Exception e) {
LOGGER.error("incrBy cache error", e);
ErrorMonitorManager.putError(ErrorTypeEnum.REDIS, e);
}
return 0;
}
public static long rpush(final String key, final Object value) {
try {
return REDIS_CLIENT.rpush(key, value);
} catch (Exception e) {
LOGGER.error("rpush cache error", e);
ErrorMonitorManager.putError(ErrorTypeEnum.REDIS, e);
}
return 0;
}
public static long lpush(final String key, final Object value) {
try {
return REDIS_CLIENT.lpush(key, value);
} catch (Exception e) {
LOGGER.error("lpush cache error", e);
ErrorMonitorManager.putError(ErrorTypeEnum.REDIS, e);
}
return 0;
}
public static <T> T lpop(final String key, Class<T> javaType) {
try {
return REDIS_CLIENT.lpop(key, javaType);
} catch (Exception e) {
LOGGER.error("lpop cache error", e);
ErrorMonitorManager.putError(ErrorTypeEnum.REDIS, e);
}
return null;
}
public static long sadd4Sets(String key, Object... values) {
try {
return REDIS_CLIENT.sadd4Sets(key, values);
} catch (Exception e) {
LOGGER.error("sadd4Sets cache error", e);
ErrorMonitorManager.putError(ErrorTypeEnum.REDIS, e);
}
return 0;
}
public static <T> Set<T> smembers4Sets(String key, Class<T> javaType) {
try {
return REDIS_CLIENT.smembers4Sets(key, javaType);
} catch (Exception e) {
LOGGER.error("smembers4Sets cache error", e);
ErrorMonitorManager.putError(ErrorTypeEnum.REDIS, e);
}
return Collections.emptySet();
}
public static long srem4Sets(String key, Object... values) {
try {
return REDIS_CLIENT.srem4Sets(key, values);
} catch (Exception e) {
LOGGER.error("srem4Sets cache error", e);
ErrorMonitorManager.putError(ErrorTypeEnum.REDIS, e);
}
return 0;
}
public static <T> T blpop(final String key, final int timeout, Class<T> javaType) {
try {
return REDIS_CLIENT.blpop(key, timeout, javaType);
} catch (Exception e) {
LOGGER.error("blpop cache error", e);
ErrorMonitorManager.putError(ErrorTypeEnum.REDIS, e);
}
return null;
}
public static <T> List<T> lrange(final String key, int start, int end) {
try {
return REDIS_CLIENT.lrange(key, start, end);
} catch (Exception e) {
LOGGER.error("lrange cache error", e);
ErrorMonitorManager.putError(ErrorTypeEnum.REDIS, e);
}
return null;
}
public static <T> List<T> lrange(String key, int start, int end, Class<T> javaType) {
try {
return REDIS_CLIENT.lrange(key, start, end, javaType);
} catch (Exception e) {
LOGGER.error("lrange cache error ", e);
}
return null;
}
public static long llen(final String key) {
try {
return REDIS_CLIENT.llen(key);
} catch (Exception e) {
LOGGER.error("llen cache error", e);
ErrorMonitorManager.putError(ErrorTypeEnum.REDIS, e);
}
return 0;
}
public static long expire(final String key, final int seconds) {
try {
return REDIS_CLIENT.expire(key, seconds);
} catch (Exception e) {
LOGGER.error("expire cache error", e);
ErrorMonitorManager.putError(ErrorTypeEnum.REDIS, e);
}
return 0;
}
/**
* @param key
* @author duchao
* @description exists
* @date 2017-06-26 09:44:05
*/
public static Boolean exists(final String key) {
try {
return REDIS_CLIENT.exists(key);
} catch (Exception e) {
LOGGER.error("exists cache error", e);
ErrorMonitorManager.putError(ErrorTypeEnum.REDIS, e);
}
return false;
}
public static long lrem(String key, long count, Object value) {
try {
return REDIS_CLIENT.lrem(key,count,value);
} catch (Exception e) {
LOGGER.error("lrem cache error", e);
ErrorMonitorManager.putError(ErrorTypeEnum.REDIS, e);
}
return 0;
}
}