redis封装和监控

1. CacheManager

public class CacheManager {

    private static Logger LOGGER = LoggerFactory.getLogger(CacheManager.class);

    private static RedisSupport REDIS_SUPPORT = DispatcherRedisEnum.DISPATCHER_REDIS.get();


    private CacheManager() {
    }

    /**
     * 设置缓存对象，永久有效
     */
    public static String set(String key, Object value) {
        return REDIS_SUPPORT.set(key, value);
    }

    /**
     * 设置缓存对象
     */
    public static String set(final String key, final int expTime, final Object value) {
        try {
            return REDIS_SUPPORT.set(key, expTime, value);
        } catch (Exception e) {
            LOGGER.error("set Object value cache error", e);
            ErrorMonitorManager.putError(ErrorTypeEnum.REDIS, e);
        }

        return null;
    }
    ...........................此处省略500字
}

2.DispatcherRedisEnum

public enum DispatcherRedisEnum implements IJedis{
    /**
     *
     */
    DISPATCHER_REDIS("redis-cluster");

    private String configName;

    DispatcherRedisEnum(String configName) {
        this. configName = configName;
    }

    @Override
    public String configKey() {
        if (configName.contains(",")){
            throw new UnsupportedOperationException("please use configKeys method");
        }
        return configName;
    }
}

3.IJedis

@FunctionalInterface
public interface IJedis {
    ConcurrentHashMap<IJedis, RedisSupport> valueCache = new ConcurrentHashMap<>();

    String configKey();

    default List<String> configKeys() {
        return null;
    }

    default RedisSupport get() {
        if (this.configKeys() == null) {
            return valueCache.computeIfAbsent(this, JedisWrap::new);
        }
        if (this.configKeys().size() == 1) {
            return valueCache.computeIfAbsent(this, k -> new JedisWrap(k.configKeys().get(0)));
        }
        return valueCache.computeIfAbsent(this, JedisTransferSupport::new);
    }
}

4.JedisWrap

这个类重点关注下 public JedisWrap(String configKey) 和 private JedisAdvanceCluster initJedis(String content)方法

public class JedisWrap implements RedisSupport {

    private static final Logger logger = LoggerFactory.getLogger(JedisWrap.class);

    private Serializer serializer;

    private final String configKey;

    private final BaseNodeResource<JedisAdvanceCluster> jcNode;

    private volatile byte[] prefix;

    private volatile String name;

    public JedisWrap(IJedis iJedis) {
        this(iJedis.configKey());
    }

    public JedisWrap(String configKey) {
        this.configKey = configKey;
        this.jcNode = BaseNodeResource.<JedisAdvanceCluster>newBuilder()
                .withKey(configKey)
                .withFactory(this::initJedis)
                .withCleanupConsumer(this::cleanup)
                .withWaitStopPeriod(1000) //鍏抽棴鑰佺殑jedis鍓嶏紝鍏堢瓑1000ms锛岀瓑寰呮棫鏁版嵁鎿嶄綔瀹屾垚銆�
                .addFactoryFailedListener(this::factoryFailListener)
                .build();
    }

    private JedisAdvanceCluster initJedis(String content) {
        JedisConfig config = JedisConfig.from(content);
        checkParam(config);
        String[] hostAndPort = config.getCluster().split(",");
        Set<HostAndPort> jedisClusterNodesSet = new HashSet<>();
        for (String hp : hostAndPort) {
            String[] hap = hp.split(":");
            jedisClusterNodesSet.add(new HostAndPort(hap[0], Integer.parseInt(hap[1])));
        }
        GenericObjectPoolConfig genericObjectPoolConfig = new GenericObjectPoolConfig();
        genericObjectPoolConfig.setMaxIdle(config.getMaxIdle());
        genericObjectPoolConfig.setMaxTotal(config.getMaxTotal());
        genericObjectPoolConfig.setMinIdle(config.getMinIdle());
        genericObjectPoolConfig.setMinEvictableIdleTimeMillis(config.getMinEvictableIdleTimeMillis());
        genericObjectPoolConfig.setTimeBetweenEvictionRunsMillis(config.getTimeBetweenEvictionRunsMillis());
        genericObjectPoolConfig.setEvictionPolicyClassName(config.getEvictionPolicyClassName());
        JedisAdvanceCluster jc = new JedisAdvanceCluster(jedisClusterNodesSet, config.getConnectionTimeout(),
                config.getSoTimeout(), config.getMaxAttempts(), config.getPassword(), genericObjectPoolConfig);
        this.prefix = SerializationUtils.encode(config.getPrefix());
        this.name = config.getName();
        if (!Strings.isNullOrEmpty(config.getSerializerClassName())) {
            try {
                Class<?> clz = ClassUtils.forName(config.getSerializerClassName(), null);
                if (!Serializer.class.isAssignableFrom(clz)) {
                    throw new IllegalArgumentException(config.getSerializerClassName() + " not implements com.sq.jedis.serializer.Serializer");
                }
                this.serializer = (Serializer) clz.newInstance();
            } catch (ClassNotFoundException | IllegalAccessException | InstantiationException e) {
                throw new IllegalArgumentException(e);
            }
        } else if ("json".equals(config.getSerializerType())) {
            this.serializer = new FastJsonImpl();
        } else if ("jdk".equals(config.getSerializerType())) {
            this.serializer = new JdkSerializerImpl();
        } else if ("jackson".equals(config.getSerializerType())) {
            this.serializer = new Jackson2JsonSerializerImpl();
        } else if ("string".equals(config.getSerializerType())) {
            this.serializer = new StringSerializerImpl();
        } else if ("gson".equals(config.getSerializerType())) {
            this.serializer = new GsonImpl();
        } else {
            this.serializer = new FastJsonImpl();
        }
        return jc;
    }

    private void factoryFailListener(String config, Throwable t) {
        ConfigUtils.perfConfigFactoryFail(configKey, config, t);
    }

    private void checkParam(JedisConfig config) {
        if (Strings.isNullOrEmpty(config.getCluster())) {
            throw new JedisClusterException("cluster str is null.");
        }

        if (Strings.isNullOrEmpty(config.getName())) {
            throw new JedisClusterException("name is null.");
        }

        if (config.getConnectionTimeout() == 0) {
            config.setConnectionTimeout(DEFAULT_CONNECTION_TIMEOUT);
        }

        if (config.getMaxAttempts() == 0) {
            config.setMaxAttempts(DEFAULT_MAX_ATTEMPTS);
        }

        if (config.getMaxIdle() == 0) {
            config.setMaxIdle(DEFAULT_MAX_IDLE);
        }

        if (config.getMaxTotal() == 0) {
            config.setMaxTotal(DEFAULT_MAX_TOTAL);
        }

        if (config.getMinIdle() == 0) {
            config.setMinIdle(DEFAULT_MIN_IDLE);
        }

        if (config.getSoTimeout() == 0) {
            config.setSoTimeout(DEFAULT_SO_TIMEOUT);
        }

        if (config.getMinEvictableIdleTimeMillis() == 0) {
            config.setMinEvictableIdleTimeMillis(DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS);
        }

        if (config.getTimeBetweenEvictionRunsMillis() == 0) {
            config.setTimeBetweenEvictionRunsMillis(DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS);
        }

        if (Strings.isNullOrEmpty(config.getEvictionPolicyClassName())) {
            config.setEvictionPolicyClassName(DEFAULT_EVICTION_POLICY_CLASS_NAME);
        }

    }

    private void cleanup(JedisAdvanceCluster old) {
        logger.info("Cleanup old jedis {}", old.toString());
        try {
            old.close();
        } catch (IOException e) {
            logger.error("close old jedis error", e);
        }
    }

    @Deprecated
    @Override
    public String set(final String key, final Object value) {
        return runWithPerf(jc -> jc.set(getKey(key), serializer.serialize(value)), "set");
    }

    @Override
    public String set(final String key, int expTime, final Object value) {
        return runWithPerf(jc -> jc.setex(getKey(key), expTime, serializer.serialize(value)), "set");
    }

    @Override
    public String set(String key, int expTime, String value) {
        return runWithPerf(jc -> jc.setex(getKey(key), expTime, serializer.serialize(value)), "set");
    }

    @Override
    public String setnxxx(final String key, final Object value, final String nxxx, final long time) {
        return runWithPerf(jc -> jc.set(getKey(key), serializer.serialize(value), nxxx.getBytes(), "EX".getBytes(), time), "setnxxx");
    }

    @Override
    public <T> T getSet(final String key, final Object value, Class<T> javaType) {
        return runWithPerf(jc -> {
            byte[] data = jc.getSet(getKey(key), serializer.serialize(value));
            return serializer.deserialize(data, javaType);
        }, "getSet");
    }

    @Override
    public boolean set(final String key, final Object value, final String nxxx, final String expx, final long time) {
        return runWithPerf(jc -> jc.set(getKey(key), serializer.serialize(value), nxxx.getBytes(), expx.getBytes(), time) != null, "set");
    }

    @Override
    public boolean setBit(String key, int[] offset, boolean flag) {
        byte[] rawKey = getKey(key);
        return runWithPerf(jc -> {
            Arrays.stream(offset).forEachOrdered(i -> jc.setbit(rawKey, i, true));
            return true;
        }, "setBit");
    }

    @Override
    public boolean getBit(String key, int[] offset) {
        byte[] rawKey = getKey(key);
        return runWithPerf(jc -> Arrays.stream(offset).allMatch(i -> jc.getbit(rawKey, i)), "getBit");
    }

    @Override
    public <T> T get(final String key, Class<T> javaType) {
        return runWithPerf(jc -> serializer.deserialize(jc.get(getKey(key)), javaType), "get");
    }

    /**
     * 褰搒erializerType涓嶇瓑浜嶥EFAULT_SERIALIZER鏃�,
     * 浣跨敤璇ユ柟娉曚細鎶涘嚭寮傚父
     */
    @Override
    public <T> T get(final String key, TypeReference<T> tr) {
        return runWithPerf(jc -> {
            if (!FastJsonImpl.class.isInstance(this.serializer)) {
                throw new SerializationException("姝ゆ柟娉曞彧鏈夊湪浣跨敤fast json搴忓垪鍖栨柟娉曚笅鏈夋晥锛侊紒");
            }
            byte[] value = jc.get(getKey(key));
            if (value == null) {
                return null;
            }
            return JSON.parseObject(new String(value), tr);
        }, "get");
    }

    @Override
    public String get(final String key) {
        return runWithPerf(jc -> serializer.deserialize(jc.get(getKey(key)), String.class), "get");
    }

    @Override
    public long delete(final String key) {
        return runWithPerf(jc -> jc.del(getKey(key)), "delete");
    }

    private byte[] getKey(String key) {
        byte[] rawKey = SerializationUtils.encode(key);
        if (!this.hasPrefix()) {
            return rawKey;
        }
        byte[] pre