SpringBoot实战（十七）:Redis Pipeline 轻松实现百倍性能提升（续）

r囧r小猫 2022-12-02 10:51 28阅读 0赞

## 前言 ##

> 最近在做业务的时候，需要批量操作Redis，虽然Redis的速度非常快，但是for循环操作Redis还是会有问题，在之前的基础上又对批量操作Redis进行了汇总；
> 
> 批量操作Redis：
> 
>  *  批量Set
>  *  批量Get
>  *  批量Set且设置过期时间
>  *  批量Delete

## 批量操作效果&技术实现方案 ##

*  之前本地测试操作100个Key值，批量操作是单个操作的快**122倍**（《[SpringBoot实战（六）:Redis Pipeline 轻松实现百倍性能提升][SpringBoot_Redis Pipeline]》）
 *  技术实现方案
    
     *  SpringBoot
     *  Redis

## 代码实现 ##

*  完整代码（GitHub，欢迎大家**Star,Fork,Watch**)
    
    [**https://github.com/dangnianchuntian/springboot**][https_github.com_dangnianchuntian_springboot]
 *  主要代码展示
    
     *  Controller
    
        /* * Copyright (c) 2020. zhanghan_java@163.com All Rights Reserved. * 项目名称：Spring Boot实战:Redis批量操作轻松实现百倍性能提升 * 类名称：BatchRedisController.java * 创建人：张晗 * 联系方式：zhanghan_java@163.com * 开源地址: https://github.com/dangnianchuntian/springboot * 博客地址: https://zhanghan.blog.csdn.net */
        
        package com.zhanghan.zhredisbatch.controller;
        
        import com.zhanghan.zhredisbatch.controller.request.ListMultiGetRequest;
        import com.zhanghan.zhredisbatch.controller.request.PostMultiDeleteRequest;
        import com.zhanghan.zhredisbatch.controller.request.PostMultiSetRequest;
        import com.zhanghan.zhredisbatch.service.BatchRedisService;
        import org.springframework.beans.factory.annotation.Autowired;
        import org.springframework.validation.annotation.Validated;
        import org.springframework.web.bind.annotation.RequestBody;
        import org.springframework.web.bind.annotation.RequestMapping;
        import org.springframework.web.bind.annotation.RequestMethod;
        import org.springframework.web.bind.annotation.RestController;
        
        @RestController
        public class BatchRedisController { 
        
            @Autowired
            private BatchRedisService batchRedisService;
        
            /** * Redis批量Set */
            @RequestMapping(value = "/post/multi/set", method = RequestMethod.POST)
            public Object postMultiSet(@RequestBody @Validated PostMultiSetRequest postMultiSetRequest) { 
                return batchRedisService.postMultiSet(postMultiSetRequest);
            }
        
            /** * Redis批量Get */
            @RequestMapping(value = "/list/multi/get", method = RequestMethod.POST)
            public Object listMultiGet(@RequestBody @Validated ListMultiGetRequest listMultiGetRequest) { 
                return batchRedisService.listMultiGet(listMultiGetRequest);
            }
        
            /** * Redis批量Set且设置失效时间 */
            @RequestMapping(value = "/post/multi/set/expire", method = RequestMethod.POST)
            public Object postMultiSetAndExpire(@RequestBody @Validated PostMultiSetRequest postMultiSetRequest) { 
                return batchRedisService.postMultiSetAndExpire(postMultiSetRequest);
            }
        
            /** * Redis批量Delete */
            @RequestMapping(value = "/post/multi/delete", method = RequestMethod.POST)
            public Object postMultiDelete(@RequestBody @Validated PostMultiDeleteRequest postMultiDeleteRequest) { 
                return batchRedisService.postMultiDelete(postMultiDeleteRequest);
            }
        
        }
 *  service
    
        /* * Copyright (c) 2020. zhanghan_java@163.com All Rights Reserved. * 项目名称：Spring Boot实战:Redis批量操作轻松实现百倍性能提升 * 类名称：BatchRedisServiceImpl.java * 创建人：张晗 * 联系方式：zhanghan_java@163.com * 开源地址: https://github.com/dangnianchuntian/springboot * 博客地址: https://zhanghan.blog.csdn.net */
        
        package com.zhanghan.zhredisbatch.service.impl;
        
        import com.zhanghan.zhredisbatch.controller.request.ListMultiGetRequest;
        import com.zhanghan.zhredisbatch.controller.request.PostMultiDeleteRequest;
        import com.zhanghan.zhredisbatch.controller.request.PostMultiSetRequest;
        import com.zhanghan.zhredisbatch.controller.response.ListMultiGetResponse;
        import com.zhanghan.zhredisbatch.dto.BatchRedisDto;
        import com.zhanghan.zhredisbatch.service.BatchRedisService;
        import com.zhanghan.zhredisbatch.util.wrapper.WrapMapper;
        import org.slf4j.Logger;
        import org.slf4j.LoggerFactory;
        import org.springframework.beans.factory.annotation.Autowired;
        import org.springframework.dao.DataAccessException;
        import org.springframework.data.redis.connection.RedisConnection;
        import org.springframework.data.redis.connection.RedisStringCommands;
        import org.springframework.data.redis.core.RedisCallback;
        import org.springframework.data.redis.core.RedisTemplate;
        import org.springframework.data.redis.core.types.Expiration;
        import org.springframework.stereotype.Service;
        import org.springframework.util.StringUtils;
        
        import java.util.ArrayList;
        import java.util.HashMap;
        import java.util.List;
        import java.util.Map;
        import java.util.concurrent.TimeUnit;
        
        @Service
        public class BatchRedisServiceImpl implements BatchRedisService { 
        
            private static Logger logger = LoggerFactory.getLogger(BatchRedisServiceImpl.class);
        
            @Autowired
            private RedisTemplate<String, String> strRedisTemplate;
        
            /** * Redis批量Set */
            @Override
            public Object postMultiSet(PostMultiSetRequest postMultiSetRequest) { 
                Map<String, String> batchSetMap = new HashMap<>();
                List<BatchRedisDto> batchRedisDtoList = postMultiSetRequest.getBatchRedisDtoList();
                for (BatchRedisDto batchRedisDto : batchRedisDtoList) { 
                    batchSetMap.put(batchRedisDto.getRedisKey(), batchRedisDto.getRedisValue());
                }
        
                strRedisTemplate.opsForValue().multiSet(batchSetMap);
                return WrapMapper.ok();
            }
        
            /** * Redis批量Get */
            @Override
            public Object listMultiGet(ListMultiGetRequest listMultiGetRequest) { 
                List<String> keyList = listMultiGetRequest.getKeyList();
                List<String> valueList = strRedisTemplate.opsForValue().multiGet(keyList);
                List<BatchRedisDto> batchRedisDtoList = new ArrayList<>();
                ListMultiGetResponse listMultiGetResponse = new ListMultiGetResponse();
        
                for (int i = 0; i < valueList.size(); i++) { 
                    String value = valueList.get(i);
                    if (StringUtils.isEmpty(value)) { 
                        continue;
                    }
                    BatchRedisDto batchRedisDto = new BatchRedisDto();
                    batchRedisDto.setRedisKey(keyList.get(i));
                    batchRedisDto.setRedisValue(value);
                    batchRedisDtoList.add(batchRedisDto);
                }
        
                listMultiGetResponse.setBatchRedisDtoList(batchRedisDtoList);
        
                return WrapMapper.ok(listMultiGetResponse);
            }
        
            /** * Redis批量Set且设置失效时间 */
            @Override
            public Object postMultiSetAndExpire(PostMultiSetRequest postMultiSetRequest) { 
                List<BatchRedisDto> batchRedisDtoList = postMultiSetRequest.getBatchRedisDtoList();
                strRedisTemplate.executePipelined(new RedisCallback<String>() { 
                    @Override
                    public String doInRedis(RedisConnection connection) throws DataAccessException { 
                        for (BatchRedisDto batchRedisDto : batchRedisDtoList) { 
                            String key = batchRedisDto.getRedisKey();
                            String value = batchRedisDto.getRedisValue();
                            connection.set(key.getBytes(), value.getBytes(), Expiration.from(1, TimeUnit.DAYS), RedisStringCommands.SetOption.UPSERT);
                        }
                        return null;
                    }
                });
        
                return WrapMapper.ok();
            }
        
            /** * Redis批量Delete */
            @Override
            public Object postMultiDelete(PostMultiDeleteRequest postMultiDeleteRequest) { 
                strRedisTemplate.delete(postMultiDeleteRequest.getKeyList());
                return WrapMapper.ok();
            }
        
        }

## 测试 ##

*  批量Set
    
     *  进行请求  
        ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTI4MjkxMjQ_size_16_color_FFFFFF_t_70_pic_center]
     *  查看Redis结果  
        ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTI4MjkxMjQ_size_16_color_FFFFFF_t_70_pic_center 1]
 *  批量Get
    
     *  进行请求  
        ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTI4MjkxMjQ_size_16_color_FFFFFF_t_70_pic_center 2]
 *  批量Set且设置失效时间
    
     *  进行请求  
        ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTI4MjkxMjQ_size_16_color_FFFFFF_t_70_pic_center 3]
     *  查看结果  
        ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTI4MjkxMjQ_size_16_color_FFFFFF_t_70_pic_center 4]
 *  批量Delete
    
     *  进行请求  
        ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTI4MjkxMjQ_size_16_color_FFFFFF_t_70_pic_center 5]
     *  查看结果  
        ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTI4MjkxMjQ_size_16_color_FFFFFF_t_70_pic_center 6]

## 总结 ##

*  亮点：批量操作Redis，轻松实现百倍性能提升
 *  注意点：批量Set ，redisTemplate的multiSet不支持设置超时时间，需要用executePipelined去实现

[SpringBoot_Redis Pipeline]: https://zhanghan.blog.csdn.net/article/details/90646951
[https_github.com_dangnianchuntian_springboot]: https://github.com/dangnianchuntian/springboot
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTI4MjkxMjQ_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/40af25cc6bf44511b9b4bae0300eb660.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTI4MjkxMjQ_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/de6a8849d3dc47a3bf6f904318c07b44.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTI4MjkxMjQ_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/5e9803c585b044d088aa24dadeeb737a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTI4MjkxMjQ_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221123/0677f816e4e445d4b38a432dc98434be.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTI4MjkxMjQ_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221123/7ca83ae2dc814578933afe85e9f1ded2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTI4MjkxMjQ_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221123/fa50688b51374688b163bb53d02a540c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTI4MjkxMjQ_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221123/9c0136c92824476388a82fd0e3d24cba.png