SpringBoot使用Redis同时执行多条命令的实现方法_Java

在 spring boot 项目中高效、合理地使用 redis 同时执行多条命令，可以显著提升应用性能。下面我将为你介绍几种主要方式、它们的典型应用场景，以及如何在 spring boot 中实现。

首先，我们来通过一个表格快速了解这几种方式的特点和适用场景：

方式	原子性	主要优势	spring boot 中的典型应用场景
pipeline (管道)	否	大幅提升批量操作效率，减少网络往返次数	缓存预热、批量数据导入导出、无依赖关系的批量查询
事务 (transaction)	部分	命令队列化，保证连续执行（但不支持回滚）	简单的原子操作序列，如库存扣减、更新多个相关键
lua 脚本	是	复杂逻辑原子执行，避免中间状态，性能高	分布式锁、秒杀、需要原子性的复杂业务逻辑

1. pipeline (管道)

pipeline 允许客户端将多个命令打包后一次性发送给 redis 服务器，服务器依次执行后再次将所有结果一次性返回给客户端。这能显著减少网络往返次数（rtt），从而大幅提升吞吐量，尤其在高延迟网络环境下效果明显。

spring boot 实现示例：

import org.springframework.data.redis.core.stringredistemplate;
import org.springframework.data.redis.core.rediscallback;
import org.springframework.stereotype.service;
import java.util.list;

@service
public class redispipelineservice {

    private final stringredistemplate stringredistemplate;

    // 构造器注入
    public redispipelineservice(stringredistemplate stringredistemplate) {
        this.stringredistemplate = stringredistemplate;
    }

    public void batchsetkeys(list<string> keys, list<string> values) {
        // 使用 executepipelined 方法执行管道操作
        list<object> results = stringredistemplate.executepipelined((rediscallback<object>) connection -> {
            for (int i = 0; i < keys.size(); i++) {
                connection.set(keys.get(i).getbytes(), values.get(i).getbytes());
            }
            return null; // 回调中返回 null
        });
        // results 包含每个命令的执行结果
    }
}

使用场景：

缓存预热：应用启动时批量加载热点数据到 redis。
批量数据导入/导出：例如从数据库批量导入数据到 redis，或从 redis 批量获取数据进行处理。
批量查询无关联数据：一次性获取多个不相关键的值，减少网络开销。

注意事项：

pipeline 中的命令不具备原子性。
建议单次 pipeline 命令数控制在合理范围内（如几千条），避免服务器内存压力或客户端长时间阻塞。
错误处理：某个命令失败不会影响 pipeline 中其他命令的执行，需要在客户端解析结果列表时逐一检查。

2. 事务 (transaction)

redis 事务通过 multi, exec, discard, watch等命令实现。它允许将多个命令放入一个队列，然后通过 exec命令原子性地顺序执行这些命令。

spring boot 实现示例：

spring data redis 提供了 sessioncallback接口来支持在同一个连接中执行多个操作，这对于事务至关重要。

import org.springframework.data.redis.core.redistemplate;
import org.springframework.data.redis.core.sessioncallback;
import org.springframework.stereotype.service;
import java.util.list;

@service
public class redistransactionservice {

    private final redistemplate<string, object> redistemplate;

    public redistransactionservice(redistemplate<string, object> redistemplate) {
        this.redistemplate = redistemplate;
    }

    public list<object> executeintransaction() {
        // 使用 execute 方法并传递 sessioncallback 来执行事务
        sessioncallback<list<object>> sessioncallback = new sessioncallback<>() {
            @override
            public list<object> execute(org.springframework.data.redis.core.redisoperations operations) {
                operations.multi(); // 开启事务
                operations.opsforvalue().set("key1", "value1");
                operations.opsforvalue().increment("counter");
                operations.opsforset().add("setkey", "member1");
                return operations.exec(); // 执行事务并返回结果
            }
        };
        return redistemplate.execute(sessioncallback);
    }
}

使用场景：

简单的原子操作序列：需要确保一系列命令连续执行，不被其他命令打断，但不要求所有命令必须全部成功（例如，扣减库存后增加销量）。
结合 watch实现乐观锁：监控特定键，如秒杀场景中监控库存键，防止超卖。

// 结合 watch 的乐观锁示例
public boolean watchandexecute(string key, string expectedvalue, string newvalue) {
    return redistemplate.execute(new sessioncallback<boolean>() {
        @override
        public boolean execute(redisoperations operations) {
            operations.watch(key); // 监视 key
            string currentvalue = (string) operations.opsforvalue().get(key);
            if (expectedvalue.equals(currentvalue)) {
                operations.multi();
                operations.opsforvalue().set(key, newvalue);
                list<object> execresult = operations.exec(); // 如果 execresult 为空，表示事务执行失败（键被修改）
                return execresult != null && !execresult.isempty();
            }
            operations.unwatch();
            return false;
        }
    });
}

注意事项：

redis 事务不支持回滚 (rollback)。如果在执行过程中某个命令失败，已执行的命令不会回滚，后续命令仍会继续执行。
错误类型：
- 入队错误（如命令语法错误）：在执行 exec前，redis 可能会检查出错误并放弃整个事务。
- 运行时错误（如数据类型操作错误）：在 exec后执行中发生的错误，redis 会记录错误信息但不会中断事务执行。

3. lua 脚本

redis 支持执行 lua 脚本。脚本中的所有命令会作为一个整体原子性地执行，期间不会被其他命令打断，是原子性最强的方案，同时还能减少网络往返。

spring boot 实现示例：

redistemplate提供了 execute方法用于执行 lua 脚本。

import org.springframework.data.redis.core.redistemplate;
import org.springframework.data.redis.core.script.defaultredisscript;
import org.springframework.stereotype.service;
import java.util.arrays;

@service
public class redisluaservice {

    private final redistemplate<string, object> redistemplate;

    public redisluaservice(redistemplate<string, object> redistemplate) {
        this.redistemplate = redistemplate;
    }

    public string useluascript() {
        // 定义 lua 脚本字符串
        string luascript = """
                local key1 = keys[1]
                local value1 = argv[1]
                redis.call('set', key1, value1)
                local value = redis.call('get', key1)
                redis.call('incr', 'counter')
                return value
                """;
        
        defaultredisscript<string> script = new defaultredisscript<>();
        script.setscripttext(luascript);
        script.setresulttype(string.class); // 设置返回值类型

        // 执行脚本，传入 keys 和 args 数组
        string result = redistemplate.execute(script, arrays.aslist("mykey"), "myvalue");
        return result; // 返回脚本执行结果
    }
}

使用场景：

释放分布式锁：确保判断锁标识和删除锁是一个原子操作。

-- keys[1] 是锁的key，argv[1]是当前持有者的标识
if redis.call("get", keys[1]) == argv[1] then
    return redis.call("del", keys[1])
else
    return 0
end

秒杀/抢购：判断库存和扣减库存需要原子性。

复杂业务逻辑：需要多个命令的中间结果进行逻辑判断。

注意事项：

脚本应尽量简单快速：执行 lua 脚本会阻塞 redis，长时间运行的脚本会影响性能。
注意脚本的复用：redis 会缓存编译过的脚本，可以使用 evalsha通过脚本摘要来执行，减少带宽。defaultredisscript对象通常会被配置为单例，spring 会智能地处理 eval和 evalsha。