Redis的Java客户端Jedis的八种调用方式(事务、管道、分布式等)介绍

最新推荐文章于 2024-05-16 14:01:56 发布
最新推荐文章于 2024-05-16 14:01:56 发布
阅读量159 收藏
点赞数
分类专栏： redis数据库 文章标签： redis jedis 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wjxbj/article/details/84623563
版权

        redis是一个著名的key-value存储系统，而作为其官方推荐的java版客户端jedis也非常强大和稳定，支持事务、管道及有jedis自身实现的分布式。

        在这里对jedis关于事务、管道和分布式的调用方式做一个简单的介绍和对比：

一.普通同步方式

        最简单和基础的调用方式

@Test
public void test1Normal() {
    Jedis jedis = new Jedis("localhost");
    long start = System.currentTimeMillis();
    for (int i = 0; i < 100000; i++) {
        String result = jedis.set("n" + i, "n" + i);
    }
    long end = System.currentTimeMillis();
    System.out.println("Simple SET: " + ((end - start)/1000.0) + " seconds");
    jedis.disconnect();
}

        很简单吧，每次set之后都可以返回结果，标记是否成功。

 

二.事务方式(Transactions)

        redis的事务很简单，他主要目的是保障，一个client发起的事务中的命令可以连续的执行，而中间不会插入其他client的命令。

        看下面例子：

@Test
public void test2Trans() {
    Jedis jedis = new Jedis("localhost");
    long start = System.currentTimeMillis();
    Transaction tx = jedis.multi();
    for (int i = 0; i < 100000; i++) {
        tx.set("t" + i, "t" + i);
    }
    List<Object> results = tx.exec();
    long end = System.currentTimeMillis();
    System.out.println("Transaction SET: " + ((end - start)/1000.0) + " seconds");
    jedis.disconnect();
}

        我们调用jedis.watch(…)方法来监控key，如果调用后key值发生变化，则整个事务会执行失败。另外，事务中某个操作失败，并不会回滚其他操作。这一点需要注意。还有，我们可以使用discard()方法来取消事务。

 

三.管道(Pipelining)

        有时，我们需要采用异步方式，一次发送多个指令，不同步等待其返回结果。这样可以取得非常好的执行效率。这就是管道，调用方法如下：

@Test
public void test3Pipelined() {
    Jedis jedis = new Jedis("localhost");
    Pipeline pipeline = jedis.pipelined();
    long start = System.currentTimeMillis();
    for (int i = 0; i < 100000; i++) {
        pipeline.set("p" + i, "p" + i);
    }
    List<Object> results = pipeline.syncAndReturnAll();
    long end = System.currentTimeMillis();
    System.out.println("Pipelined SET: " + ((end - start)/1000.0) + " seconds");
    jedis.disconnect();
}

 

四.管道中调用事务

        就Jedis提供的方法而言，是可以做到在管道中使用事务，其代码如下：

@Test
public void test4combPipelineTrans() {
    jedis = new Jedis("localhost"); 
    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();
}

        但是经测试（见本文后续部分），发现其效率和单独使用事务差不多，甚至还略微差点。

 

五.分布式直连同步调用

@Test
public void test5shardNormal() {
    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("sn" + i, "n" + i);
    }
    long end = System.currentTimeMillis();
    System.out.println("Simple@Sharing SET: " + ((end - start)/1000.0) + " seconds");

    sharding.disconnect();
}

        这个是分布式直接连接，并且是同步调用，每步执行都返回执行结果。类似地，还有异步管道调用。

 

六.分布式直连异步调用

@Test
public void test6shardpipelined() {
    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("sp" + i, "p" + i);
    }
    List<Object> results = pipeline.syncAndReturnAll();
    long end = System.currentTimeMillis();
    System.out.println("Pipelined@Sharing SET: " + ((end - start)/1000.0) + " seconds");

    sharding.disconnect();
}

 

七.分布式连接池同步调用

        如果，你的分布式调用代码是运行在线程中，那么上面两个直连调用方式就不合适了，因为直连方式是非线程安全的，这个时候，你就必须选择连接池调用。

@Test
public void test7shardSimplePool() {
    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("spn" + i, "n" + i);
    }
    long end = System.currentTimeMillis();
    pool.returnResource(one);
    System.out.println("Simple@Pool SET: " + ((end - start)/1000.0) + " seconds");

    pool.destroy();
}

        上面是同步方式，当然还有异步方式。

 

八.分布式连接池异步调用

@Test
public void test8shardPipelinedPool() {
    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("sppn" + i, "n" + 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();
}

 

九.需要注意的地方

        事务和管道都是异步模式。在事务和管道中不能同步查询结果。比如下面两个调用，都是不允许的：

Transaction tx = jedis.multi();
for (int i = 0; i < 100000; i++) {
    tx.set("t" + i, "t" + i);
}
System.out.println(tx.get("t1000").get());  //不允许

List<Object> results = tx.exec();
Pipeline pipeline = jedis.pipelined();
long start = System.currentTimeMillis();
for (int i = 0; i < 100000; i++) {
pipeline.set("p" + i, "p" + i);
}
System.out.println(pipeline.get("p1000").get()); //不允许

List<Object> results = pipeline.syncAndReturnAll();

        事务和管道都是异步的，个人感觉，在管道中再进行事务调用，没有必要，不如直接进行事务模式。

        分布式中，连接池的性能比直连的性能略好(见后续测试部分)。

        分布式调用中不支持事务。

        因为事务是在服务器端实现，而在分布式中，每批次的调用对象都可能访问不同的机器，所以，没法进行事务。

 

十.测试

        运行上面的代码，进行测试，其结果如下：

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

        另外，经测试分布式中用到的机器越多，调用会越慢。上面是2片，下面是5片：

Simple@Sharing SET: 5.494 seconds
Pipelined@Sharing SET: 0.51 seconds
Simple@Pool SET: 5.223 seconds
Pipelined@Pool SET: 0.518 seconds

        下面是10片：

Simple@Sharing SET: 5.9 seconds
Pipelined@Sharing SET: 0.794 seconds
Simple@Pool SET: 5.624 seconds
Pipelined@Pool SET: 0.762 seconds

        下面是100片：

Simple@Sharing SET: 14.055 seconds
Pipelined@Sharing SET: 8.185 seconds
Simple@Pool SET: 13.29 seconds
Pipelined@Pool SET: 7.767 seconds

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

 

十一.完整的测试代码

package com.bijian.study;

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

import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;

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;

import org.junit.FixMethodOrder;
import org.junit.runners.MethodSorters;

@SuppressWarnings("unused")
@FixMethodOrder(MethodSorters.NAME_ASCENDING)
public class TestJedis {

	private static Jedis jedis;
	private static ShardedJedis sharding;
	private static ShardedJedisPool pool;

	@BeforeClass
	public static void setUpBeforeClass() throws Exception {
		List<JedisShardInfo> shards = Arrays.asList(new JedisShardInfo("192.168.128.129", 6379), new JedisShardInfo("192.168.128.129",6379)); // 使用相同的ip:port,仅作测试

		jedis = new Jedis("192.168.128.129");
		sharding = new ShardedJedis(shards);

		pool = new ShardedJedisPool(new JedisPoolConfig(), shards);
	}

	@AfterClass
	public static void tearDownAfterClass() throws Exception {
		jedis.disconnect();
		sharding.disconnect();
		pool.destroy();
	}

	@Test
	public void test1Normal() {
		long start = System.currentTimeMillis();
		for (int i = 0; i < 100000; i++) {
			String result = jedis.set("n" + i, "n" + i);
		}
		long end = System.currentTimeMillis();
		System.out.println("Simple SET: " + ((end - start) / 1000.0)
				+ " seconds");
	}

	@Test
	public void test2Trans() {
		long start = System.currentTimeMillis();
		Transaction tx = jedis.multi();
		for (int i = 0; i < 100000; i++) {
			tx.set("t" + i, "t" + i);
		}
		// System.out.println(tx.get("t1000").get());

		List<Object> results = tx.exec();
		long end = System.currentTimeMillis();
		System.out.println("Transaction SET: " + ((end - start) / 1000.0)
				+ " seconds");
	}

	@Test
	public void test3Pipelined() {
		Pipeline pipeline = jedis.pipelined();
		long start = System.currentTimeMillis();
		for (int i = 0; i < 100000; i++) {
			pipeline.set("p" + i, "p" + i);
		}
		// System.out.println(pipeline.get("p1000").get());
		List<Object> results = pipeline.syncAndReturnAll();
		long end = System.currentTimeMillis();
		System.out.println("Pipelined SET: " + ((end - start) / 1000.0)
				+ " seconds");
	}

	@Test
	public void test4combPipelineTrans() {
		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");
	}

	@Test
	public void test5shardNormal() {
		long start = System.currentTimeMillis();
		for (int i = 0; i < 100000; i++) {
			String result = sharding.set("sn" + i, "n" + i);
		}
		long end = System.currentTimeMillis();
		System.out.println("Simple@Sharing SET: " + ((end - start) / 1000.0)
				+ " seconds");
	}

	@Test
	public void test6shardpipelined() {
		ShardedJedisPipeline pipeline = sharding.pipelined();
		long start = System.currentTimeMillis();
		for (int i = 0; i < 100000; i++) {
			pipeline.set("sp" + i, "p" + i);
		}
		List<Object> results = pipeline.syncAndReturnAll();
		long end = System.currentTimeMillis();
		System.out.println("Pipelined@Sharing SET: " + ((end - start) / 1000.0)
				+ " seconds");
	}

	@Test
	public void test7shardSimplePool() {
		ShardedJedis one = pool.getResource();

		long start = System.currentTimeMillis();
		for (int i = 0; i < 100000; i++) {
			String result = one.set("spn" + i, "n" + i);
		}
		long end = System.currentTimeMillis();
		pool.returnResource(one);
		System.out.println("Simple@Pool SET: " + ((end - start) / 1000.0)
				+ " seconds");
	}

	@Test
	public void test8shardPipelinedPool() {
		ShardedJedis one = pool.getResource();

		ShardedJedisPipeline pipeline = one.pipelined();

		long start = System.currentTimeMillis();
		for (int i = 0; i < 100000; i++) {
			pipeline.set("sppn" + i, "n" + i);
		}
		List<Object> results = pipeline.syncAndReturnAll();
		long end = System.currentTimeMillis();
		pool.returnResource(one);
		System.out.println("Pipelined@Pool SET: " + ((end - start) / 1000.0)
				+ " seconds");
	}
}

运行结果：


Simple SET: 24.316 seconds
Transaction SET: 2.641 seconds
Pipelined SET: 1.016 seconds
Pipelined transaction: 1.484 seconds
Simple@Sharing SET: 29.287 seconds
Pipelined@Sharing SET: 1.953 seconds
Simple@Pool SET: 31.537 seconds
Pipelined@Pool SET: 1.156 seconds

直接查看redis数据库：

[root@localhost bin]# /usr/local/redis/bin/redis-cli
127.0.0.1:6379> dbsize
(integer) 800000
127.0.0.1:6379>

 

PS：如上实例是基于jedis-2.1.0.jar、commons-pool-1.6.jar、junit-4.11.jar、hamcrest-core-1.3.jar运行的。

 

文章来源：http://www.blogways.net/blog/2013/06/02/jedis-demo.html

Jedis事务详解
qq_41915921的博客
07-18 776
Jedis事务 1、正常执行的事务 编码测试 package com.haiyang; import com.alibaba.fastjson.JSONObject; import redis.clients.jedis.Jedis; import redis.clients.jedis.Transaction; public class TestTX { public static void main(String[] args) { Jedis jedis = new J
Redis客户端Jedis的几种调用方式---事务、管道、分布式
wangshuang1631的博客
01-06 3648
Redis是key-value存储系统，而作为其官方推荐的java版客户端jedis也非常强大和稳定，支持事务、管道及有jedis自身实现的分布式。 在这里对jedis关于事务、管道和分布式的调用方式做一个简单的介绍和对比：package com.ws.Redis;import java.util.Arrays; import java.util.List;import redis.clients
Redis的Java客户端Jedis的八种调用方式(事务、管道、分布式)介绍
chuteng3602的博客
09-12 262
一、普通同步方式 二、事务方式(Transactions) 三、管道(Pipelining) 四、管道中调用事务 五、分布式直连同步调用 六、分布式直连异步调用 七、分布式连接池同步调用 八、分布式连接池异步调用 九、需要注意的地方 十、测试 十一...
jedis操作事务
weixin_43472934的博客
03-05 567
package org.example; import com.alibaba.fastjson.JSONObject; import redis.clients.jedis.Jedis; import redis.clients.jedis.Transaction; public class TestTX { public static void main(String[] args) { Jedis jedis = new Jedis("192.168.222.200",6
Redis应用学习——Redis事务与实现分布式锁
weixin_34377065的博客
11-13 194
2019独角兽企业重金招聘Python工程师标准>>> ...
java客户端访问redis的两种方式详解
- 只为伊人 博客
11-25 1193
java客户端访问redis Java客户端访问redis的方式： jedis springboot集成的StringRedisTemplate与RedisTemplate (StringRedisTemplate继承了RedisTemplate，两者方法一模一样，不同之处是RedisTemplate使用的是JdkSerializationRedisSerializer 存入数据会将数据先...
jedisRedis的Java客户端
08-08
Jedis是Redis的Java客户端，它提供了一个丰富的API来操作Redis数据存储系统。Redis是一个高性能的键值数据库，常用于缓存、消息中间件以及数据结构服务器等场景。Jedis作为Java开发者与Redis交互的主要工具，使得在...
Redis Java客户端Jedis 3.0.0版本发布
Jedis是Redis的Java实现客户端，用于Java应用程序与Redis服务器之间进行通信。在给定的文件信息中，所提到的'jedis-jedis-3.0.0.tar.gz'是Jedis客户端版本3.0.0的源代码压缩包文件。这个压缩包是通过gzip算法压缩的...
java redis分布式事务处理_Redis分布式事务
weixin_34565946的博客
02-16 1144
乐观锁大多数是基于数据版本(version)的记录机制实现的。即为数据增加一个版本标识，在基于数据库表的版本解决方案中，一般是通过为数据库表增加一个”version”字段来实现读取出数据时，将此版本号一同读出，之后更新时，对此版本号加1。此时，将提交数据的版本号与数据库表对应记录的当前版本号进行比对，如果提交的数据版本号大于数据库当前版本号，则予以更新，否则认为是过期数据。redis中可以使用wa...
redis基础篇——Redis客户端（Jedis，Lettuce，Redisson）
石灰聪的博客
12-01 1257
Redis客户端 通信协议 Redis监听默认6379的端口号，可以通过TCP方式建立连接。 服务端约定了一种特殊的消息格式，每个命令都是以rn（CRLF回车+换行）结尾。这种编码格式我们之前在AOF文件里面见到了，叫做Redis Serialization Protocol（RESP，Redis序列化协议），发消息或者响应消息需要按这种格式编码，接收消息需要按这种格式解码。Redis设计这种格式的原因：容易实现、解析快、可读性强。Redis6.0新特性里面说的RESP协议升级到了3.0版本，其实就是
Jedis-事务
weixin_54097396的博客
04-07 236
Jedis-事务
Redis 分布式事务实现
热门推荐
叱咤少帅的博客
12-22 1万+
开始本文之前，我们先来看什么是分布式事务。 分布式事务是什么？
管道(实现事务)
direnya1260的博客
04-02 153
redis-py默认在执行每次请求都会创建（连接池申请连接）和断开（归还连接池）一次连接操作，如果想要在一次请求中指定多个命令，则可以使用pipline实现一次请求指定多个命令，并且默认情况下一次pipline 是原子性操作。 import redis pool = redis.ConnectionPool(host='10.211.55.4', port=6379) r = r...
Jedis 事务操作
Mason97的博客
07-22 188
package com.mason; import com.alibaba.fastjson.JSONObject; import redis.clients.jedis.Jedis; import redis.clients.jedis.Transaction; /** * @Auther: Mason * @Date: 2020/07/22/17:13 * @Description: */ public class TestTX { public static void main(S
Redis总结三（事务 Jedis）
qq_52840805的博客
07-31 282
Redis事务 Redis中事务可以一次执行多个命令，是一组命令的集合，一个事务中的命令都会被序列化，在事务的执行过程中，会按照顺序串行化执行队列中的命令。 Redis是一次性，顺序性，排他性的执行一个队列中的一系列命令 Redis不保证原子性 Redis中，单条命令的执行是原子性，但事务是不保证原子性，而且没有回滚的换概念， 事务中任意的命令执行失败，其他的命令是可以执行的 Redis中的事务是没有隔离级别的 事务命令 事物的执行过程分为三个步骤：开始事务：multi ———&gt
Jedis事务用法
iteye_19495的博客
11-25 443
[size=small]今天同事问了一个redis的问题，主要就是出现错误之后就把所有的本次操作添加的key删除掉。当时以为nosql数据库都不提供事务方面的机制呢，后来上网搜了一下还是找到解决方案了。代码实例如下。[/size] [code="java"] public static void transactionDemo() { Jedis jedis = new ...
一次讲清楚Redis的分布式事务和分布式锁
最新发布
菜鸟学飞的博客
05-16 1978
一次讲清楚Redis的分布式事务和分布式锁
对 Redis 实现分布式事务的探索与实现
BXA
08-01 1335
Redis是一个高性能的key-value型NoSQL数据库系统，它被广泛应用于缓存、队列、计数器等场景中。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值