redis管道代码

 1 总结

1：如果将redis的key，在redis删除或者过期，返回数据会是null

2：返回的list是所有key的合集 ，如果key不存在，则返回null

3:  存的key和value是否是二进制跟你的配置文件有关，

1.1 实例：key不存情况

[null, [User(name=aa, age=17), User(name=bb, age=20), User(name=cc, age=17)]]

   准备的数据

    private List<User> initList(){
        List<User> userList = Lists.newArrayList();
        userList.add(new User("小明",17));
        userList.add(new User("红红",20));
        userList.add(new User("黄黄",17));
        return userList;
    }
    private HashMap<String, List<User>> initHash(){
        List<User> userList = Lists.newArrayList();
        userList.add(new User("小明",17));
        userList.add(new User("红红",20));
        userList.add(new User("黄黄",17));

        List<User> userList1 = Lists.newArrayList();
        userList1.add(new User("aa",17));
        userList1.add(new User("bb",20));
        userList1.add(new User("cc",17));

        HashMap<String, List<User>> hashMap = new HashMap<>();
        hashMap.put("aa",userList);
        hashMap.put("bb",userList1);
        return hashMap;
    }

1.1 RedisCallback

    /**
     * 管道测试
     */
    @Test
    void test9() {
      //这里获取String类型的序列化
        RedisSerializer stringSerializer = redisTemplate.getStringSerializer();
        List<User> userList = initList();
        HashMap<String, List<User>> collect = initHash();

        //key 不是字节，值是字节
        redisTemplate.executePipelined(new RedisCallback<Object>() {
            @Override
            public String doInRedis(RedisConnection connection) throws DataAccessException {
                connection.openPipeline();
                for (String key : collect.keySet()) {
                    //hash方式
                    connection.hSet(redisKey.getBytes(), key.getBytes(),
                        redisTemplate.getValueSerializer().serialize(collect.get(key).toString()));
   //hash方式
   connection.hSet(redisKey.getBytes(), key.getBytes(),
                        JSON.toJSONString(collect.get(key)).getBytes());

                    //正常方式
                  //  connection.set("key1".getBytes(), "value1".getBytes());
                }
                //设置过期时间 不能单独设置失效时间
                connection.pExpire(redisKey.getBytes(), 1000 * 60 * 60 * 6);
                return null;
            }
        });

        RedisCallback<HashMap<String, Object>> redisCallback = new RedisCallback<HashMap<String, Object>>() {
            @Override public HashMap<String, Object> doInRedis(RedisConnection connection) throws DataAccessException {
                connection.openPipeline();
                for (String key : collect.keySet()) {
                    //hash方式获取
                    connection.hGet(redisKey.getBytes(), key.getBytes());
                   // connection.get(redisKey.getBytes());
                }
                return null;
            }
        };

        //key
        List list = redisTemplate.executePipelined(redisCallback);
        //返回是所有key的值得集合 [null, [User(name=aa, age=17), User(name=bb, age=20), User(name=cc, age=17)]]
        System.out.println(list);

    }

1.2 SessionCallback

    @Test
    void test10() {

        SessionCallback<HashMap<String, Object>> sessionCallback = new SessionCallback<HashMap<String, Object>>() {
            @Override public <K, V> HashMap<String, Object> execute(RedisOperations<K, V> redisOperations)
                throws DataAccessException {
                HashOperations hashOperations = redisOperations.opsForHash();
                hashOperations.get("redis_executePipelined", "aa");
                hashOperations.get("redis_executePipelined", "bb");

              /*  redisOperations.opsForValue().set("key2", "value2");
                redisOperations.opsForHash().put("hash2", "field", "test");
                operations.delete("redistest:"+"k"+i);*/
                return null;
            }
        };

        List list = redisTemplate.executePipelined(sessionCallback);
        [[User(name=小明, age=17), User(name=红红, age=20), User(name=黄黄, age=17)], [User(name=aa, age=17), User(name=bb, age=20), User(name=cc, age=17)]]
        System.out.println(list);
        for (JSONArray str : list) {
            List<User> userList = JSONArray.parseArray(JSON.toJSONString(str), User.class);
            System.out.println(userList);
        }

    }

2 execute 和 executePipelined 区别

execute ：方法是串行的，命令请求发出后，必须得到响应数据，才能发送下一条命令请求。所以在一次 Redis 会话中，一次会话可能包含多次请求，即多次 RTT

executePipelined： 是穿插的，批量发送命令到服务器，批量获取响应数据。即可能使用一次 RTT 就能完成批量操作。

对比	execute	executePipelined
执行方式	逐个执行 Redis 命令	将多个 Redis 命令封装在管道内，一次性提交
返回结果	根据具体 Redis 命令返回不同类型的结果	返回多个 Redis 命令的执行结果列表
效率	较慢，需要频繁的连接获取和释放	快，将多个 Redis 命令封装在一个管道内，减少连接数