如何解决缓存的热 key、大 key、雪崩、击穿、穿透问题？

public static byte[] compress(Serializable value) {
    
    try (ByteArrayOutputStream buf = new ByteArrayOutputStream(512);
         ObjectOutputStream output = new ObjectOutputStream(buf);
         // 压缩后的数据
         ByteArrayOutputStream gzipBuf = new ByteArrayOutputStream();
         GZIPOutputStream gzip = new GZIPOutputStream(gzipBuf)) {
        output.writeObject(value);
        // 序列化之后的数据
        byte[] ba = buf.toByteArray();
        gzip.write(ba);
        return gzipBuf.toByteArray();
    } catch (Exception e) {
        log.error("compress error", e);
        throw new UnsupportedOperationException(e);
    }
}

public static void main(String[] args) {
    
    StringBuilder sb = new StringBuilder();
    for(int i = 0; i < 10000; i++) {
        sb.append(UUID.randomUUID().toString());
    }
    String value = sb.toString();
    byte[] base = value.getBytes();
    System.out.println("压缩前 " + base.length);
    byte[] compress = compress(value);
    System.out.println("压缩后 " + compress.length);
}

/**
 * 将集合按照 size 分片
 */
public static <T> List<List<T>> partition(List<T> list, int size) {
    
    List<List<T>> res;
    // 如果待分片集合元素数量大于size则进行分片
    if(list.size() > size) {
        int len = list.size()  size + 1;
        res = new ArrayList<>(len);
        for(int i = 0; i < list.size(); i += size) {
            int limit = i + size;
            res.add(list.subList(i, limit > list.size() ?
                    list.size() : limit));
        }
    } else {
        res = new ArrayList<>(1);
        res.add(list);
    }
    return res;
}

// setList 方法为将集合设置进缓存
public <T> void shardingSet(String key, List<T> list, long seconds, Jedis jedis) {
    // 将集合按照 size 分片
    List<List<T>> partitions = partition(list, 1000);
    // 收集分片 key
    List<String> subKeys = new ArrayList<>(partitions.size());
    for(int i = 0; i < partitions.size(); i++) {
        String subKey = key + i;
        subKeys.add(subKey);
        // 设置分片 List 缓存
        setList(subKey, partitions.get(i), seconds, jedis);
    }
    // 设置分片 key 集合缓存
    setList(key, subKeys, seconds, jedis);
}

// getList 方法为从缓存获取集合
public <T> List<T> shardingGet(String key, Jedis jedis) {
    // 获取分片 key 集合
    List<String> subKeys = getList(key, jedis);
    List<T> res = new ArrayList<>();
    if (CollectionUtils.isEmpty(subKeys)) {
       return res;
    }
    // 组装各个分片缓存集合
    for(String subKey: subKeys) {
        res.addAll(getList(subKey, jedis));
    }
    return res;
}

private static final long RANDOM_EXPIRE_SECONDS = 60 * 6;


public boolean setex(String key, String value, long seconds, Jedis jedis) {
    
    try {
        jedis.setex(key, seconds + ThreadLocalRandom.current()
                .nextLong(RANDOM_EXPIRE_SECONDS), value);
        return true;
    } catch (Throwable t) {
        log.error("setex error, key={}", key, t);
        return false;   
    }
}

public String doubleCheckLock(String key) {
    // 一检
    String value = getCache(key);
    if(!Strings.isNullOrEmpty(value)) {
        return value;
    }
    synchronized (key.intern()) {
        // 二检
        value = getCache(key);
        if(!Strings.isNullOrEmpty(value)) {
            return value;
        }
        // 从数据库中查并写回缓存
        value = getDB(key);
        setCache(key, value);
    }
    return value;
}

// 从缓存中查
String value = getCache(key);
if(value != null) {
    return value;
}
// 从数据库中查
value = getByDB(key);
if(value == null) {
    // 数据库中也为空就将空值写回缓存
    setCache(key, "NULL", 120);
} else {
    setCache(key, value, 1200);
}
return value;