redis3 集群封装

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;
    }
}