package com.xiaomi.weather.vote.webservices.util.redisCache;

import com.google.common.base.Strings;
import org.apache.log4j.Logger;
import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.JedisPoolConfig;

import java.io.InputStream;
import java.util.*;

/**
 * Created by mi on 16-12-22.
 */
public class RedisClusterClient {
    private static final Logger logger = Logger.getLogger(RedisClusterClient.class);
    private static String isOn = "true"; // 是否启用缓存
    private static JedisPoolConfig jedisPoolConfig = new JedisPoolConfig(); // 配置信息
    public JedisCluster jedisCluster = null;
    Set<HostAndPort> jedisClusterNodes = new HashSet<HostAndPort>();

    public static RedisClusterClient redisClusterClient = new RedisClusterClient();

    public RedisClusterClient() {
        init();
    }

    public static RedisClusterClient getInsance() {
        if (redisClusterClient != null) {
            return redisClusterClient;
        } else {
            redisClusterClient = new RedisClusterClient();
            return redisClusterClient;
        }
    }

    public boolean init() {
        try {
            // 读取配置文件
            InputStream path = RedisClusterClient.class.getClassLoader().getResourceAsStream("cache.properties");
            Properties pros = new Properties();
            pros.load(path);
            this.isOn = pros.getProperty("redis.onoff", "true");// 默认开启缓存
            if (this.isOn.equals("false")) {// 未开启缓存
                return false;
            }

            //
            String servers = pros.getProperty("redisMultiCluster.clusters", null);
            if (Strings.isNullOrEmpty(servers)) {
                logger.error("RedisJavaClient.servers 配置错误; in file:cache.properties");
                this.isOn = "false";
                return false;
            }
            String[] hostAndPorts = servers.split("\\|");
            for (int i = 0; i < hostAndPorts.length; i++) {
                String hostAndPort = hostAndPorts[i];
                if (!hostAndPort.contains(":")) {
                    return false;
                }
                jedisClusterNodes.add(new HostAndPort(hostAndPort.split(":")[0], Integer.parseInt(hostAndPort.split(":")[1])));
            }
            try {
                jedisPoolConfig.setMaxTotal(Integer.parseInt(pros.getProperty("redisMultiCluster.maxTotal", "8")));
                jedisPoolConfig.setMaxIdle(Integer.parseInt(pros.getProperty("redisMultiCluster.maxIdle", "8")));
                jedisPoolConfig.setMinIdle(Integer.parseInt(pros.getProperty("redisMultiCluster.minIdle", "0")));
                jedisPoolConfig
                        .setBlockWhenExhausted(Boolean.parseBoolean(pros.getProperty("redisMultiCluster.blockWhenExhausted", "true")));
                jedisPoolConfig.setMaxWaitMillis(Integer.parseInt(pros.getProperty("redisMultiCluster.maxWaitMillis", "true")));
                jedisPoolConfig.setTestOnBorrow(Boolean.parseBoolean(pros.getProperty("redisMultiCluster.testOnBorrow", "true")));
                jedisPoolConfig.setTestOnCreate(Boolean.parseBoolean(pros.getProperty("redisMultiCluster.testOnCreate", "true")));
                jedisPoolConfig.setTestOnReturn(Boolean.parseBoolean(pros.getProperty("redisMultiCluster.testOnReturn", "true")));
                jedisPoolConfig.setTestWhileIdle(Boolean.parseBoolean(pros.getProperty("redisMultiCluster.testWhileIdle", "false")));

            } catch (Exception e) {
                logger.error("{未知异常}", e);
            }
            jedisCluster = new JedisCluster(jedisClusterNodes, jedisPoolConfig);
            logger.info("缓存初始化成功");
            path.close();
            return true;
        } catch (Exception e) {
            logger.error("{缓存初始化错误}", e);
            this.isOn = "false";
        }
        return false;
    }

    public boolean setnx(String key, String value, int expireTime) {
        if (!isOn.equals("true")) {
            logger.info("缓存未开启");
            return false;
        }
        try {
            Long setSuccess = jedisCluster.setnx(key, value);
            if (setSuccess == 1) {
                if (1 == jedisCluster.expire(key, expireTime)) {
                    return true;
                } else {
                    this.deleteKey(key);
                    return false;
                }
            } else {
                return false;
            }
        } catch (Exception e) {
            logger.error("{}", e);
        }
        return false;
    }

    public boolean set(String key, String value, int expireTime) {
        if (!isOn.equals("true")) {
            logger.info("缓存未开启");
            return false;
        }
        try {
            jedisCluster.setex(key, expireTime, value);
            return true;
        } catch (Exception e) {
            logger.error("{}", e);
        }
        return false;
    }

    public String get(String key) {
        if (!isOn.equals("true")) {
            logger.info("缓存未开启");
            return "";
        }
        try {
            return jedisCluster.get(key);
        } catch (Exception e) {
            logger.error("{}", e);
        }
        return null;
    }

    public <T> boolean setList(String key, List<T> list, Class<T> tClass, int expireTime) {
        if (!isOn.equals("true")) {
            logger.info("缓存未开启");
            return false;
        }
        try {
            if (this.setnx(key + "Lock", "true", expireTime)) {
                this.deleteKey(key);
                for (T t : list) {
                    jedisCluster.rpush(key, SerializationDefine.Object2String(t));
                }
                if (1 == jedisCluster.expire(key, expireTime)) {
                    return true;
                } else {
                    this.deleteKey(key);
                    return false;
                }
            }
            return true;
        } catch (Exception e) {
            logger.error("{}", e);
        }
        return false;
    }

    public <T> List<T> getList(String key, Class<T> tClass) {
        if (!isOn.equals("true")) {
            logger.info("缓存未开启");
            return null;
        }
        try {
            List<T> tList = new ArrayList<T>();
            List<String> strList = jedisCluster.lrange(key, 0L, -1L);
            for (String str : strList) {
                tList.add(SerializationDefine.String2Object(str, tClass));
            }

            return tList.size() == 0 ? null : tList;
        } catch (Exception e) {
            logger.error("{}", e);
            return null;
        }
    }

    public <T> boolean setMap(String key, Map<String, T> map, Class<T> tClass, int expireTime) {
        if (!isOn.equals("true")) {
            logger.info("缓存未开启");
            return false;
        }
        Map<String, String> catchMap = new HashMap<String, String>();
        if (this.setnx(key + "Lock", "true", expireTime)) {
            this.deleteKey(key);
            for (Map.Entry<String, T> entry : map.entrySet()) {
                catchMap.put(entry.getKey(), SerializationDefine.Object2String(entry.getValue()));
            }
            jedisCluster.hmset(key, catchMap);
            if (1 == jedisCluster.expire(key, expireTime)) {
                return true;
            } else {
                this.deleteKey(key);
                return false;
            }

        }
        return true;
    }

    public <T> Map<String, T> getMap(String key, Class<T> tClass) {
        if (!isOn.equals("true")) {
            logger.info("缓存未开启");
            return null;
        }
        try {
            Map<String, String> catchMap = jedisCluster.hgetAll(key);
            Map<String, T> retMap = new HashMap<String, T>();
            for (Map.Entry<String, String> entry : catchMap.entrySet()) {
                retMap.put(entry.getKey(), SerializationDefine.String2Object(entry.getValue(), tClass));
            }
            return retMap;
        } catch (Exception e) {
            logger.error("{}", e);
            return null;
        }

    }

    public boolean deleteKey(String key) {
        if (!isOn.equals("true")) {
            logger.info("缓存未开启");
            return false;
        }
        try {
            if (1 == jedisCluster.del(key)) {
                return true;
            } else {
                throw new Exception("redis异常,删除key失败:method = deleteKey; key = " + key);
            }
        } catch (Exception e) {
            logger.error("{严重异常}", e);
        }

        return false;
    }

    /**
     * 加1操作
     *
     * @param key
     * @return
     */
    public boolean incr(String key) {
        if (!isOn.equals("true")) {
            logger.info("缓存未开启");
            return false;
        }
        try {
            jedisCluster.incr(key);
            return true;
        } catch (Exception e) {
            logger.error("{}", e);
            return false;
        }
    }

    /**
     * 减1操作
     *
     * @param key
     * @return
     */
    public boolean decr(String key) {
        if (!isOn.equals("true")) {
            logger.info("缓存未开启");
            return false;
        }
        try {
            jedisCluster.decr(key);
            return true;
        } catch (Exception e) {
            logger.error("{}", e);
            return false;
        }
    }

    /**
     * 判断是否已缓存
     *
     * @param key
     * @return
     */
    public boolean isExist(String key) {
        if (!isOn.equals("true")) {
            logger.info("缓存未开启");
            return false;
        }
        try {
            return jedisCluster.exists(key);
        } catch (Exception e) {
            return false;
        }
    }
}
RedisClusterClient

相关文章: