Redis 最佳实践

Redis键值设计

优雅的key的结构

 Redis的版本低于4.0则长度为embstr的上限为39

 拒绝BigKey

 String的key可以使用以下指令查看key所占的内存大小，但是不推荐使用对cpu的使用率比较高，所以String类型可以通过strlen key来查看长度大概估算大小，集合-拿list举例可以使用llen key来查看集合长度，大概估算大小

memory usage key

 

 Scan扫描的简单实现

    final static int STR_MAX_LEN = 10 * 1024;
    final static int HASH_MAX_LEN = 500;
 
    @Test
    void testScan() {
        int maxLen = 0;
        long len = 0;
 
        String cursor = "0";
        do {
            // 扫描并获取一部分key
            ScanResult result = jedis.scan(cursor);
            // 记录cursor
            cursor = result.getCursor();
            List list = result.getResult();
            if (list == null || list.isEmpty()) {
                break;
            }
            // 遍历
            for (String key : list) {
                // 判断key的类型
                String type = jedis.type(key);
                switch (type) {
                    case "string":
                        len = jedis.strlen(key);
                        maxLen = STR_MAX_LEN;
                        break;
                    case "hash":
                        len = jedis.hlen(key);
                        maxLen = HASH_MAX_LEN;
                        break;
                    case "list":
                        len = jedis.llen(key);
                        maxLen = HASH_MAX_LEN;
                        break;
                    case "set":
                        len = jedis.scard(key);
                        maxLen = HASH_MAX_LEN;
                        break;
                    case "zset":
                        len = jedis.zcard(key);
                        maxLen = HASH_MAX_LEN;
                        break;
                    default:
                        break;
                }
                if (len >= maxLen) {
                    System.out.printf("Found big key : %s, type: %s, length or size: %d %n", key, type, len);
                }
            }
        } while (!cursor.equals("0"));
    }

恰当的数据类型

 

 

 

 

 总结

 批处理优化

Pipeline

 

 总结

 集群下的批处理

 并行slot - jedis实现

public class JedisClusterTest {
 
    private JedisCluster jedisCluster;
 
    @BeforeEach
    void setUp() {
        // 配置连接池
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxTotal(8);
        poolConfig.setMaxIdle(8);
        poolConfig.setMinIdle(0);
        poolConfig.setMaxWaitMillis(1000);
        HashSet nodes = new HashSet<>();
        nodes.add(new HostAndPort("192.168.150.101", 7001));
        nodes.add(new HostAndPort("192.168.150.101", 7002));
        nodes.add(new HostAndPort("192.168.150.101", 7003));
        nodes.add(new HostAndPort("192.168.150.101", 8001));
        nodes.add(new HostAndPort("192.168.150.101", 8002));
        nodes.add(new HostAndPort("192.168.150.101", 8003));
        jedisCluster = new JedisCluster(nodes, poolConfig);
    }
 
    @Test
    void testMSet() {
        jedisCluster.mset("name", "Jack", "age", "21", "sex", "male");
 
    }
 
    @Test
    void testMSet2() {
        Map map = new HashMap<>(3);
        map.put("name", "Jack");
        map.put("age", "21");
        map.put("sex", "Male");
 
        Map>> result = map.entrySet()
                .stream()
                .collect(Collectors.groupingBy(
                        entry -> ClusterSlotHashUtil.calculateSlot(entry.getKey()))
                );
        for (List> list : result.values()) {
            String[] arr = new String[list.size() * 2];
            int j = 0;
            for (int i = 0; i < list.size(); i++) {
                j = i<<2;
                Map.Entry e = list.get(0);
                arr[j] = e.getKey();
                arr[j + 1] = e.getValue();
            }
            jedisCluster.mset(arr);
        }
    }
 
    @AfterEach
    void tearDown() {
        if (jedisCluster != null) {
            jedisCluster.close();
        }
    }
}

并行slot - spring实现

#配置分片集群
spring:
  redis:
    cluster:
      nodes: #配置分片集群的每一个节点信息
        - 192.168.99.100:7001
        - 192.168.99.100:7002
        - 192.168.99.100:7003
        - 192.168.99.100:8001
        - 192.168.99.100:8002
        - 192.168.99.100:8003

    @Test
    void testMSetInCluster() {
        Map map = new HashMap<>(3);
        map.put("name", "Rose");
        map.put("age", "21");
        map.put("sex", "Female");
        stringRedisTemplate.opsForValue().multiSet(map);
 
 
        List strings = stringRedisTemplate.opsForValue().multiGet(Arrays.asList("name", "age", "sex"));
        strings.forEach(System.out::println);
 
    }

服务端优化

持久化配置

 慢查询

 

 上述修改都是一次性的，如果想要永久生效，修改redis.conf

或者在客户端软件中也可以查看到慢查询

 命令及安全配置

 

 rename-command

bind

不要配置bind 为0.0.0.0全部都可以访问，配置成局域网ip

内存配置

 

 

 可以使用client list，查看每一个客户端的信息，其中就包含缓冲区的信息

 集群最佳实践

 集群完整性问题

 当配置为yes时，假设集群3主3从，如果一个master节点和它的slaver节点同时down了.则表明一部分插槽不可用，这时在往这个集群插入数据时，无论它的插槽值是否是在正常运行的节点上还是down的节点上，整个集群都不可用。

当配置为no时，假设集群3主3从，如果一个master节点和它的slaver节点同时down了..则表明一部分插槽不可用，这时在往这个集群插入数据时，如果它的插槽值是在正常运行的节点上则可以正常存储以及获取，但如果插槽值在down的节点上，则对该key的指令执行失败。

集群带宽问题

 数据倾斜问题

如果存在bigkey，并且存储时使用了相同的值hash“{hashkey}”时，会导致存储这些bigkey存储到同一台的集群节点上，导致这个节点相对于其他节点数据过大。

客户端性能问题

客户端在访问集群时，都会对插槽判断，对读写分离服务器的判断，会对客户端的性能带来影响

集群的兼容性问题

Lua和事务问题

因为lua和事务都是对操作的原子性，但是在集群的情况下，lua脚本中每一行命令的操作的key，可能插槽值，读写分离都不能保证在同一个节点上，所以在集群下没有办法执行Lua和事务

总结