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

最新推荐文章于 2025-04-03 11:23:17 发布

转载最新推荐文章于 2025-04-03 11:23:17 发布 · 245 阅读

CC 4.0 BY-SA版权

原文链接：https://blog.youkuaiyun.com/zhanghan18333611647/article/details/108305904?utm_medium=distribute.pc_feed.none-task-blog-personrec_tag-5.nonecase&depth_1-utm_source=distribute.pc_feed.none-task-blog-personrec_tag-5.nonecase&request_id=5f4d9196ad40e5707a463b66

本文介绍如何使用SpringBoot和Redis进行批量操作，包括批量Set、Get、Set并设置过期时间及Delete，实测批量操作速度提升百倍，适用于需要高效处理大量数据的场景。

前言
最近在做业务的时候，需要批量操作Redis，虽然Redis的速度非常快，但是for循环操作Redis还是会有问题，在之前的基础上又对批量操作Redis进行了汇总；

批量操作Redis：

批量Set
批量Get
批量Set且设置过期时间
批量Delete
批量操作效果&技术实现方案
之前本地测试操作100个Key值，批量操作是单个操作的快122倍（《SpringBoot实战（六）:Redis Pipeline 轻松实现百倍性能提升》）

技术实现方案

SpringBoot

Redis

代码实现
完整代码（GitHub，欢迎大家Star,Fork,Watch)

https://github.com/dangnianchuntian/springboot

主要代码展示

Controller
/*

Copyright © 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.youkuaiyun.com
*/

package com.zhanghan.zhredisbatch.controller;

@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

项目名称：Spring Boot实战:Redis批量操作轻松实现百倍性能提升
类名称：BatchRedisServiceImpl.java
创建人：张晗
联系方式：zhanghan_java@163.com
开源地址: https://github.com/dangnianchuntian/springboot
博客地址: https://zhanghan.blog.youkuaiyun.com
*/

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

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