Springboot下使用Redis管道(pipeline)进行批量操作

之前有业务场景需要批量插入数据到Redis中，做的过程中也有一些感悟，因此记录下来，以防忘记。下面的内容会涉及到

分别使用for、管道处理批量操作，比较其所花费时间。
分别使用RedisCallback、SessionCallback进行Redis pipeline 操作
解释RedisCallback、SessionCallback这两种用法的区别

1.网络传输(RTT)开销少
Redis的传输层是基于TCP协议,一次操作请求的完成，存在网络传输来回的开销，即使Redis每秒能接受10万的请求，但也会因为网络传输而浪费很多时间，导致降低整体的性能。所以面对大量的批量处理，可以使用Redis的管道（pipeline），优势在于多次指令操作只会使用一次的网络传输的开销。

PS:像批量插入、批量获取，RedisTemplate提供了multiSet、multiGet的方法可以进行操作，不过像multiSet并不支持批量设置key的过期时间，可以考虑业务场景进行使用

2.提高redis每秒可以执行操作的数量
在进行批量操作的前提下

不使用管道的时候，每一次Redis执行命令，都要涉及到读(read)和写(write)的系统调用，系统会将用户端切换到内核端。上下文切换会有一定的消耗使用管道的话，多条命令只需要一个读(read)，多条响应只需要一个写(write)，可想而知，这其中省下了很多的消耗。

环境配置

JDK8
Spring boot 2.6.13
spring-boot-starter-data-redis
分别使用for、管道处理批量操作，比较其所花费时间

public void testForOrPipeline(){
     //使用for
    StopWatch stopWatch1=new StopWatch();
    stopWatch1.start();
    for(int i=0;i<10000;i++){
        String value = String.valueOf(i);
        String key = "test:" + value;
        redisTemplate.opsForValue().set(key, value, 10, TimeUnit.SECONDS);
    }
    stopWatch1.stop();
    System.out.println("for所需时间："+stopWatch1.getTotalTimeSeconds()+"s");
    //使用管道
    StopWatch stopWatch2=new StopWatch();
    stopWatch2.start();
    List<Boolean> list = redisTemplate.executePipelined(new SessionCallback<Object>() {
        @Override
        public Object execute(RedisOperations operations) throws DataAccessException {
            for (int i = 0; i < 10000; i++) {
                String value = String.valueOf(i);
                String key = "test:" + value;
                operations.opsForValue().set(key, value, 10, TimeUnit.SECONDS);
            }
            return null;
        }
    });
    stopWatch2.stop();
    System.out.println("管道所需时间："+stopWatch2.getTotalTimeSeconds()+"s");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

PS: 本地，且只有一个客户端的情况下测试（做不到严谨性，见谅）

目前只是本地跑（网络传输所带来的开销本身会很小），如果redis服务端是在其他地区的服务器上，这两种方式所需的时间相差还会越来越大。

RedisCallback

private void RedisCallBackHandler() {
    //这里获取String类型的序列化器
    RedisSerializer stringSerializer = redisTemplate.getStringSerializer();
    //第二个参数是指定结果反序列化器，用于反序列化管道中读到的数据，不是必传，
    //如果不传，则使用自定义RedisTemplate的配置，
    //如果没有自定义，则使用RedisTemplate默认的配置（JDK反序列化）
    List list = redisTemplate.executePipelined(new RedisCallback<Object>() {
        @Override
        public Object doInRedis(RedisConnection connection) throws DataAccessException {
            for (int i = 0; i < 10; i++) {
                String value = String.valueOf(i);
                String key="test:"+value;
                connection.setEx(stringSerializer.serialize(key),10,stringSerializer.serialize(value));
            }
            //这里bytes只会获取到null，因为这里get操作只是放在管道里面，并没有
            //真正执行，所以获取不到值
            //byte[] bytes = connection.get("test:1".getBytes());
            connection.get("test:1".getBytes());
            //executePipelined 这个方法需要返回值为null，不然会抛异常，
            //这一点可以查看executePipelined源码
            return null;
        }
    }, stringSerializer);
    list.stream().forEach(result->{
        System.out.println(result);
    });
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

SessionCallback

private void SessionCallBackHandler() {
    //这里获取String类型的序列化
    RedisSerializer stringSerializer = redisTemplate.getStringSerializer();
    //第二个参数是指定结果反序列化器，用于反序列化管道中读到的数据，不是必传，
    //如果不传，则使用自定义RedisTemplate的配置，
    //如果没有自定义，则使用RedisTemplate默认的配置（JDK反序列化）
    List list = redisTemplate.executePipelined(new SessionCallback<Object>() {
        @Override
        public Object execute(RedisOperations operations) throws DataAccessException {
            for (int i = 0; i < 10; i++) {
                String value = String.valueOf(i);
                String key = "test:" + value;
                operations.opsForValue().set(key, value, 10, TimeUnit.SECONDS);
            }
            //这里o只会获取到null，因为这里get操作只是放在管道里面，并没有真正执行，所以获取不到值
            //Object o = operations.opsForValue().get("test:1");
            operations.opsForValue().get("test:1");
            //executePipelined 这个方法需要返回值为null，不然会抛异常，
            //这一点可以查看executePipelined源码
            return null;
        }
    }, stringSerializer);
    list.stream().forEach(result->{
        System.out.println(result);
    });
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

解释RedisCallback、SessionCallback这两种用法的区别
上面代码显示了RedisCallback、SessionCallback这两种都能实现相同的效果，那么这两个又有什么区别呢？

SessionCallback 的使用比RedisCallback要友好一些

SessionCallback的execute方法提供给使用者使用的是RedisOperations接口类，RedisTemplate实现类

RedisCallback的doInRedis方法提供给使用者使用的是RedisConnection接口类，也就是LettuceConnection是实现类

RedisConnection提供了字节数组类型的get和set方法，有关序列化部分的细节还需要我们去关心。（和使用原生jdbc感受差不多），而RedisTemplate负责序列化和连接管理，不需要让使用者关系这一块的部分。总结： 个人感觉从日常使用上应该都倾向于SessionCallback，而个别特殊有关底层的业务，可能就需要RedisCallback。