Redis客户端Jedis的几种调用方式---事务、管道、分布式

最新推荐文章于 2025-05-26 17:06:58 发布
原创 最新推荐文章于 2025-05-26 17:06:58 发布 · 3.6k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#redis #事务 #jedis #分布式

本文介绍了Redis客户端Jedis的三种调用方式：事务、管道和分布式。强调了事务和管道的异步特性，指出在这些模式下无法同步查询结果。分布式调用不支持事务，且连接池在性能上优于直接连接。测试结果显示，分布式调用的机器数量越多，速度越慢，而使用连接池的方式更优。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Redis是key-value存储系统，而作为其官方推荐的java版客户端jedis也非常强大和稳定，支持事务、管道及有jedis自身实现的分布式。
在这里对jedis关于事务、管道和分布式的调用方式做一个简单的介绍和对比：

package com.ws.Redis;

import java.util.Arrays;
import java.util.List;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.JedisShardInfo;
import redis.clients.jedis.Pipeline;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPipeline;
import redis.clients.jedis.ShardedJedisPool;
import redis.clients.jedis.Transaction;

public class RedisConnection {

    public static void main(String[] args) {
        normalFunction();
//      transactionsFunction();
//      pipeline();
//      combPipelineTranscationFunction();
//      shardNormalFunction();
//      shardpipelinedFunction();
//      shardPipelinedPoolFunction();
//      shardSimplePoolFunction();
    }

    //简单调用方式，每次set值之后都会返回结果，标记该次set是否成功。
    public static void normalFunction() {
        Jedis jedis = new Jedis("localhost", 6379);
        jedis.auth("123456");
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            String result = jedis.set("normal" + i, "normal" + i);
        }
        long end = System.currentTimeMillis();
        System.out.println("Normal SET: " + ((end - start)/1000.0) + " seconds");
        jedis.disconnect();
    }

    //redis事务，一个client发起的事务中的命令可以连续执行，中间不会插入其他指令。
    //可以调用jedis.watch()方法来监控key,如果调用后的key值发生变化，则事务执行失败。使用tx.discard()方法取消事务。
    //注：事务中某个操作执行失败，并不会回滚其他操作。
    public static void transactionsFunction() {
        Jedis jedis = new Jedis("localhost", 6379);
        jedis.auth("123456");
        long start = System.currentTimeMillis();
        Transaction tx = jedis.multi();
        for (int i = 0; i < 10000; i++) {
            tx.set("transaction" + i, "transaction" + i);
        }
        List<Object> results = tx.exec();
        long end = System.currentTimeMillis();
        System.out.println("Transaction SET: " + ((end - start)/1000.0) + " seconds");
        jedis.disconnect();

    }

    //采用异步方式，一次发送多个set，不同步等待其返回的结果，可以极大的提升执行效率。
    public static void pipeline() {
        Jedis jedis = new Jedis("localhost", 6379);
        jedis.auth("123456");
        Pipeline pipeline = jedis.pipelined();
        long start = System.currentTimeMillis();
        for(int i=0; i<10000; i++){
            pipeline.set("pipeline" + i, "pipeline" + i);
        }
        List<Object> results = pipeline.syncAndReturnAll();
        long end = System.currentTimeMillis();
        System.out.println("Pipeline SET : " +((end-start)/1000.0) + " seconds");
        jedis.disconnect();
    }

    //在管道中使用事务，但是效率并不比但多使用事务效率高很多。
    public static void combPipelineTranscationFunction() {
        Jedis jedis = new Jedis("localhost", 6379);
        jedis.auth("123456");
        long start = System.currentTimeMillis();
        Pipeline pipeline = jedis.pipelined();
        pipeline.multi();
        for (int i = 0; i < 100000; i++) {
            pipeline.set("" + i, "" + i);
        }
        pipeline.exec();
        List<Object> results = pipeline.syncAndReturnAll();
        long end = System.currentTimeMillis();
        System.out.println("Pipelined transaction: " + ((end - start)/1000.0) + " seconds");
        jedis.disconnect();
    }

    //分布式直接连接，并且是同步调用，每步执行都返回执行结果。
    public static void shardNormalFunction() {
        List<JedisShardInfo> shards = Arrays.asList(
                new JedisShardInfo("localhost",6379),
                new JedisShardInfo("localhost",6380));
        ShardedJedis sharding = new ShardedJedis(shards);
        long start = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            String result = sharding.set("shardNormal" + i, "shardNormal" + i);
        }
        long end = System.currentTimeMillis();
        System.out.println("Simple@Sharing SET: " + ((end - start)/1000.0) + " seconds");
        sharding.disconnect();
    }

    //分布式直接连接，并且是异步调用，不是每步执行都返回执行结果
    public static void shardpipelinedFunction() {
        List<JedisShardInfo> shards = Arrays.asList(
                new JedisShardInfo("localhost",6379),
                new JedisShardInfo("localhost",6380));
        ShardedJedis sharding = new ShardedJedis(shards);
        ShardedJedisPipeline pipeline = sharding.pipelined();
        long start = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            pipeline.set("shardpipelined" + i, "shardpipelined" + i);
        }
        List<Object> results = pipeline.syncAndReturnAll();
        long end = System.currentTimeMillis();
        System.out.println("Pipelined@Sharing SET: " + ((end - start)/1000.0) + " seconds");
        sharding.disconnect();
    }

    //多线程方式，直接连接不安全，需要使用连接池方式，分布式连接池同步调用。
    public static void shardSimplePoolFunction() {
        List<JedisShardInfo> shards = Arrays.asList(
                new JedisShardInfo("localhost",6379),
                new JedisShardInfo("localhost",6380));
        ShardedJedisPool pool = new ShardedJedisPool(new JedisPoolConfig(), shards);
        ShardedJedis one = pool.getResource();
        long start = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            String result = one.set("shardSimplePool" + i, "shardSimplePool" + i);
        }
        long end = System.currentTimeMillis();
        pool.returnResource(one);
        System.out.println("Simple@Pool SET: " + ((end - start)/1000.0) + " seconds");
        pool.destroy();
    }

    //分布式连接池异步调用
    public static void shardPipelinedPoolFunction() {
        List<JedisShardInfo> shards = Arrays.asList(
                new JedisShardInfo("localhost",6379),
                new JedisShardInfo("localhost",6380));
        ShardedJedisPool pool = new ShardedJedisPool(new JedisPoolConfig(), shards);
        ShardedJedis one = pool.getResource();
        ShardedJedisPipeline pipeline = one.pipelined();
        long start = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            pipeline.set("shardPipelinedPool" + i, "shardPipelinedPool" + i);
        }
        List<Object> results = pipeline.syncAndReturnAll();
        long end = System.currentTimeMillis();
        pool.returnResource(one);
        System.out.println("Pipelined@Pool SET: " + ((end - start)/1000.0) + " seconds");
        pool.destroy();
    }
}

一些注意点：

  • 事务和管道都是异步模式。在事务和管道中不能同步查询结果。比如下面两个调用，都是不允许的；
  • 事务和管道都是异步的，在管道中再进行事务调用，没有必要，不如直接进行事务模式；
  • 分布式中，连接池的性能比直连的性能略好；
  • 分布式调用中不支持事务，因为事务是在服务器端实现，而在分布式中，每批次的调用对象都可能访问不同的机器，故没法使用事务；

测试：

Simple SET: 5.227 seconds

Transaction SET: 0.5 seconds

Pipelined SET: 0.353 seconds

Pipelined transaction: 0.509 seconds

Simple@Sharing SET: 5.289 seconds

Pipelined@Sharing SET: 0.348 seconds

Simple@Pool SET: 5.039 seconds

Pipelined@Pool SET: 0.401 seconds

另外，经测试分布式中用到的机器越多，调用会越慢。分布式中，连接池方式调用不但线程安全外，根据上面的测试数据，也可以看出连接池比直连的效率更好。

Redis系列学习文章分享---第六篇（Redis实战篇--Redis分布式锁+实现思路+误删问题+原子性+lua脚本+Redisson功能介绍+可重入锁+WatchDog机制+multiLock）
私聊前往站内信：https://i.youkuaiyun.com/#/msg/chat/weixin_44976692
03-18 2万+
Redisson是一个基于Redis的Java驻内存数据网格（In-Memory Data Grid）和分布式锁服务的框架，提供了丰富的分布式对象和服务支持。它封装了Redis的分布式对象和服务，简化了Java应用程序对Redis的操作。Redisson是一个基于Redis的Java驻内存数据网格（In-Memory Data Grid）和分布式锁服务的框架，提供了丰富的分布式对象和服务支持。它封装了Redis的分布式对象和服务，简化了Java应用程序对Redis的操作。
redis.clients.jedis_REDIS_API
12-19
Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。从2010年3月15日起，Redis的开发工作由VMware主持。
redis事务执行
hello_IT_的博客
08-11 403
事务提供了一种将多个命令打包，一次性按顺序执行的机制，并且事务在执行期间不会主动中断（服务段在执行完事务中的所有命令之后才会执行其他客户端的其他命令），redis通过MUTIL、DISCARD、EXEC和WATCH四个命令实现事务操作。 事务执行： 开启事务 multi，这个命令唯一做的是将客户端的REDIS_MUTIL选项打开，让客户端从非事务状态进入事务状态 写入命令 当客户端进入事...
Redis 当中 Jedis 的详细刨析与使用
最新发布
kfashfasf的博客
05-26 886
Jedis 是 Java程序操作 Redis 的工具，就像Java操作MySQL时的JDBC一样的功能 。Jedis 工作示意图：Jedis 的API 文档： https://www.javadoc.io/doc/redis.clients/jedis/latest/index.html下面是来自一位网上网友总结的 Jedis中文文档：这里搬运了一下： https://blog.youkuaiyun.com/CYY941027/article/details/109110455创建 Jedis 对象，使用对应的构造器：
Redis入门 – Jave客户端 Jedis 使用
iwangchengyi的专栏
07-19 156
  Redis入门 – Jave客户端 Jedis 使用     原文地址：http://alanland.iteye.com/admin/blogs/1600434（转载请注明）   07/19/12 12:42:52 PM   Redis 的Java客户端有很多个，官网上标星星的是Jedis，项目地址是：https://github.com/xetorthio/jedi...
redis的java客户端之jedis
nuist_NJUPT的博客
08-26 1427
Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。从2010年3月15日起，Redis的开发工作由VMware主持。从2013年5月开始，Redis的开发由Pivotal赞助。Redis是 NoSQL技术阵营中的一员，它通过多种键值数据类型来适应不同场景下的存储需求，借助一些高层级的接口使用其可以胜任，如缓存、队列系统的不同角色。通过jedis可以在java客户端对redis进行一些操作。...
如果你无法导入`redis.clients.jedis.Jedis`类，可能是因为没有添加Jedis的依赖库。
Java&Develop的博客
05-03 2882
如果你无法导入`redis.clients.jedis.Jedis`类，可能是因为没有添加Jedis的依赖库。
redis开发与运维-redis04-redis客户端Jedis与连接池及客户端异常模拟
PacosonSWJTU的博客
12-28 975
原因1-客户端： 高并发下连接池设置过小，供不应求；原因2-客户端：没有正确使用连接池，jedis连接没有释放；原因3-客户端：存在慢查询，慢查询会导致业务线程归还Jedis连接速度变慢，最终导致连接池被顶满；原因4-服务端：redis服务器执行客户端命令时存在阻塞，与慢查询类似，会导致业务线程归还Jedis连接速度变慢，最终导致连接池被顶满；
Redis客户端Jedis 3.1.0-rc版本发布
10. 分布式锁：Jedis可以利用Redis实现分布式锁，这是分布式系统中常用的一种同步机制，用于在多个进程或服务之间对共享资源进行互斥访问。 11. 脚本支持：Jedis支持Redis的脚本功能，允许用户编写Lua脚本并在Redis...
Redis客户端Jedis 3.7.0-RC1版本发布
Jedis是Redis官方推荐的Java客户端，它提供了连接池管理、管道、事务以及发布/订阅等功能。Jedis通常被用于实现缓存层，也广泛用于处理分布式缓存、会话存储、消息队列等场景。由于其轻量级和简单的API设计，Jedis...
jedisRedis的Java客户端
08-08
通过`jedis.pipelined()`开启管道，调用相应方法，最后调用`pipeline.execute()`发送命令。 - Batch操作与Pipeline类似，但使用`Transaction`对象，适用于需要事务处理的批量操作。 6. **复制与Sentinel支持** - ...
Redis Java客户端Jedis 2.9.0 jar包（含common-pool2）
11-17
Redis的官方推荐Java客户端——Jedis 此Jar包为Jedis 2.9.0版（2016年7月22日发布） 支持Redis 3.0 （亲测有效） 使用方法： import redis.clients.jedis.Jedis; Jedis jedis = new Jedis("localhost"); jedis.set("foo", "bar"); String value = jedis.get("foo"); jedis.close(); System.out.println(value);
Redis客户端操作之Jedis
chengxiesuan0485的博客
05-09 121
本文主要来和大家讲一下Java程序是如何去操作redis里的数据的 在Redis官网中提供了各种语言的客户端，使用起来很方便，本文主要简介Java中常用的Jedis Jedis Jedis Client是Redis官网推荐的一个面向Java客户端，库文件实现了对redis各类API进行封装调...
【Redis】已解决：redis.clients.jedis.exceptions.JedisDataException: NOAUTH Authentication required
屿小夏.的知识博客
08-30 1801
在使用Redis进行缓存或数据存储时，开发者通常会用到Jedis客户端库与Redis服务器进行通信。为了正确解决该报错问题，我们需要在连接Redis服务器后，提供正确的密码进行身份认证。场景：一个Java应用程序尝试连接到启用了密码保护的Redis服务器，却没有提供或提供了错误的密码。该错误通常发生在Redis服务器开启了密码保护，而客户端未提供正确的认证信息的情况下。当我们运行该代码时，如果Redis服务器启用了密码保护而代码未进行认证，将会遇到。报错问题，确保Redis客户端与服务器的正常通信和操作。
【Redis】已解决：redis.clients.jedis.exceptions.JedisNoScriptException
屿小夏.的知识博客
08-30 3266
在使用Redis进行缓存或数据处理时，Lua脚本是一种常用的扩展手段，用于保证操作的原子性和高效性。Jedis是Java中使用Redis的一个常用客户端库，但在执行Lua脚本时，开发者可能会遇到。为了解决该报错问题，可以在执行脚本之前先加载脚本并获取其SHA值，然后使用该SHA值进行脚本调用。场景：在一个Spring Boot项目中，开发者使用Jedis来执行Redis Lua脚本进行分布式锁的实现。在上述代码中，开发者希望通过Lua脚本在Redis中设置一个分布式锁，但在执行时可能会遇到。
Redis 系列03--Redis Jedis 客户端
fengxianaa的博客
04-23 875
redis 客户端 Jedis
Redis -- Jedis
qq_52025208的博客
10-05 2068
jedis
jQuery获取带点的id元素
weixin_34179762的博客
11-23 481
一般jQuery获取某个id为elem元素，只需用$('#elem')就行了，但是如果id中不小心包括了'.' ，那么我吗就会发现这时候jQuery就不能获取到这个元素了。但是使用dom原生的getElementById的方法就可以获取到。 一开始遇见这种情况还是有点蒙的，后面看下jQuery的源码就能发现使用css选择器来获取元素的时候首先调用的是dom的querySelector方法，我们试...
redis 客户端 jedis的使用
Jingqingmo的博客
12-05 365
版本：                 redis.clients           jedis           2.9.0       直接上源码，jedis工具类 import redis.clients.jedis.Jedis; public class RedisUtil { public static void setKey(String k
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值