java调用redis方式_Redis的Java客户端Jedis的八种调用方式(事务、管道、分布式)介绍...

最新推荐文章于 2024-09-09 11:40:26 发布
最新推荐文章于 2024-09-09 11:40:26 发布
阅读量104 收藏
点赞数
文章标签： java调用redis方式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39822147/article/details/114771570
版权

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

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

一、普通同步方式

最简单和基础的调用方式，

1

2

3

4

5

6

7

8

9

10

11@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的命令。

看下面例子：

1

2

3

4

5

6

7

8

9

10

11

12

13@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 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)

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

1

2

3

4

5

6

7

8

9

10

11

12

13@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 results = pipeline.syncAndReturnAll();

long end = System.currentTimeMillis();

System.out.println("Pipelined SET: " + ((end - start)/1000.0) +" seconds");

jedis.disconnect();

}

四、管道中调用事务

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

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15@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 results = pipeline.syncAndReturnAll();

long end = System.currentTimeMillis();

System.out.println("Pipelined transaction: " + ((end - start)/1000.0) +" seconds");

jedis.disconnect();

}

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

五、分布式直连同步调用

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17@Test

public void test5shardNormal() {

List 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();

}

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

六、分布式直连异步调用

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19@Test

public void test6shardpipelined() {

List 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 results = pipeline.syncAndReturnAll();

long end = System.currentTimeMillis();

System.out.println("Pipelined@Sharing SET: " + ((end - start)/1000.0) +" seconds");

sharding.disconnect();

}

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

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

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20@Test

public void test7shardSimplePool() {

List 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();

}

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

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

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22@Test

public void test8shardPipelinedPool() {

List 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 results = pipeline.syncAndReturnAll();

long end = System.currentTimeMillis();

pool.returnResource(one);

System.out.println("Pipelined@Pool SET: " + ((end - start)/1000.0) +" seconds");

pool.destroy();

}

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

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19Transaction tx = jedis.multi();

for (int i =0; i <100000; i++) {

tx.set("t" + i,"t" + i);

}

System.out.println(tx.get("t1000").get());//不允许

List 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 results = pipeline.syncAndReturnAll();

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

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

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

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

十、测试

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

1

2

3

4

5

6

7

8

9

10

11Simple 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片：

1

2

3

4Simple@Sharing SET:5.494 seconds

Pipelined@Sharing SET:0.51 seconds

Simple@Pool SET:5.223 seconds

Pipelined@Pool SET:0.518 seconds

下面是10片：

1

2

3

4Simple@Sharing SET:5.9 seconds

Pipelined@Sharing SET:0.794 seconds

Simple@Pool SET:5.624 seconds

Pipelined@Pool SET:0.762 seconds

下面是100片：

1

2

3

4Simple@Sharing SET:14.055 seconds

Pipelined@Sharing SET:8.185 seconds

Simple@Pool SET:13.29 seconds

Pipelined@Pool SET:7.767 seconds

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

十一、完整的测试代码

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150package com.example.nosqlclient;

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;

@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 shards = Arrays.asList(

new JedisShardInfo("localhost",6379),

new JedisShardInfo("localhost",6379));//使用相同的ip:port,仅作测试

jedis =new Jedis("localhost");

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 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 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 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 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 results = pipeline.syncAndReturnAll();

long end = System.currentTimeMillis();

pool.returnResource(one);

System.out.println("Pipelined@Pool SET: " + ((end - start)/1000.0) +" seconds");

}

}

posted on 2015-04-03 13:28 Mr.lu 阅读(149) 评论(0)  编辑  收藏

Easonxxy
关注
java redis分布式事务处理_Redis分布式事务
weixin_34565946的博客
02-16 1141
乐观锁大多数是基于数据版本(version)的记录机制实现的。即为数据增加一个版本标识，在基于数据库表的版本解决方案中，一般是通过为数据库表增加一个”version”字段来实现读取出数据时，将此版本号一同读出，之后更新时，对此版本号加1。此时，将提交数据的版本号与数据库表对应记录的当前版本号进行比对，如果提交的数据版本号大于数据库当前版本号，则予以更新，否则认为是过期数据。redis中可以使用wa...
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
java redis管道存储_Redis的Java客户端Jedis的八种调用方式(事务、管道、分布式)介绍 - 博客频道 - CSDN.NET...
weixin_39650994的博客
02-23 196
1、redis简介 redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash(哈希类型)。这些数据类型都支持push/pop、add/remove及取交集并集和差集及在这里对jedis关于事务、管道和分布式的调用方式做一个简单的介...
使用java客户端调用redis
weixin_34332905的博客
12-12 225
Redis支持很多编程语言的客户端，有C、C#、C++、Clojure、Common Lisp、Erlang、Go、Lua、Objective-C、PHP、Ruby、Scala，甚至更时髦的Node.js，当然，更少不了Java的客户端支持。Redis官方列出的Java客户端也有少，有Jedis、JRedis、JDBC-Redis、RJC等，当然，Jedis是Redis官方首选的Java客户端开发...
Druid连接池在分布式系统中的应用有哪些特点？
最新发布
qq_33240556的博客
09-09 384
在分布式系统中，Druid 连接池因其高性能和丰富的功能集而被广泛应用。
java中jedis使用,Java中使用Jedis操作Redis
weixin_34199161的博客
03-10 406
使用Java操作Redis需要jedis-2.1.0.jar，下载地址：http://files.cnblogs.com/liuling/jedis-2.1.0.jar.zip如果需要使用Redis连接池的话，还需commons-pool-1.5.4.jar，下载地址:http://files.cnblogs.com/liuling/commons-pool-1.5.4.jar.zip1 pack...
java中间件 - redis分布式问题
sinat_36387539的博客
03-31 2532
Redis实现分布式锁？ Redis为单进程单线程模式，采用队列模式将并发访问变成串行访问，且多客户端对Redis的连接 并不存在竞争关系Redis中可以使用setNx命令实现分布式锁。 当且仅当 key 不存在，将 key 的值设为 value。 若给定的 key 已经存在，则 setNx不做任何动作 SETNX 是『SET if Not eXists』(如果不存在，则 SET)的简写。 返回值：设置成功，返回 1 。设置失败，返回 0 。 使用setNx完成同步锁的流程及事项如下： 使用SETNX命令获
java异步读redis数据_java – Jedis是否支持异步操作
weixin_32382353的博客
02-28 402
我正在使用Jedis(java客户端)与Redis服务器进行通信.我在三个不同的节点上运行了3个Redis实例.我想从3个Redis实例中“获取”(读取)一些记录.我想并行发出这些“获取”(读取),然后对接收到的数据进行一些处理并形成最终输出.在java中执行此操作的最佳方法是什么？其中一种方法是创建3个线程并在每个线程中“获取”(读取)(同步).等待所有3个命令完成,然后合并结果.Jedis是否...
jedis.jar java调用Redis及Redis安装使用
09-03
在Java中调用Redis，我们通常会使用Jedis库，这也是标题中提到的`jedis.jar`。Jedis是Redis官方推荐的Java客户端，提供了丰富的API来操作Redis。 1. **引入依赖**：在项目中，需要添加`jedis-2.1.0.jar`作为依赖。...
Java基于redis实现分布式锁代码实例
08-19
Java基于Redis实现分布式锁代码实例 分布式锁的必要性 在多线程环境中，资源竞争是一个常见的问题。例如，在一个简单的用户操作中，一个线程修改用户状态，首先在内存中读取用户状态，然后在内存中进行修改，然后...
Java客户端Redis.zip
05-23
通过学习和使用Jedis，开发者能够轻松地将Java应用程序与Redis集成，利用Redis的强大功能进行数据存储、缓存管理和分布式计算。结合Jedis提供的丰富API，开发者可以实现高效、可靠的Redis操作。
java频繁存储redis_JAVA编程——我们为什么要用Redis
weixin_39897070的博客
02-25 211
定义Redis是一个使用ANSI C编写的开源、支持网络、基于内存、可选持久性的键值对存储数据库Redis可以通过一些键值类型来存储数据。 键值类型： String字符类型 map散列类型 list列表类型 set集合类型 sortedset有序集合类型特性开源多种数据结构基于键值的存储服务系统高性能，功能服务redis的前世今生谁在使用redisgithubtwitter微博Stack Over...
五、Java内存数据库实践之深入浅出Redis - Jedis分布式（Sharding/Sharded)
Josh_Persistence
06-16 219
一、Jedis分布式（Sharding/shared 一致性哈希）     我们知道Memcached是完全基于分布式的集群，而Redis是Master-Slave的模式，如果想把Redis做成集群模式，其实无外乎就是多做几套Master-Slave，每套Master-Slave完成各自的容灾处理，通过Client工具，完成一致性哈希。（PS:Memcached是在Server端完成Shard...
Jredis的使用
weixin_44153921的博客
12-10 3301
JRedis 是一个高性能的 Java 客户端，用来连接到 Redis 分布式哈希键-值数据库。提供同步和异步的连接。本文讲述了从Maven的引到Redis的常用API，事务的开启以及Redis线程池
使用Jedis操作Redis-使用Java语言在客户端操作---String类型
weixin_33729196的博客
08-15 107
前提：需要引入Jedis的jar包。 1 /** 2 * 我的redis在Linux虚拟机Centos7中，192.168.222.129是我虚拟机的ip地址。 3 */ 4 private static Jedis jedis = new Jedis("192.168.222.129"); 1 //测试String类型 ...
Redis的Java客户端——Jedis
weixin_51351637的博客
10-24 991
到现在的小伙伴可能在想，那我们最后执行close方法的时候，不还是销毁了吗？ 答案：不是销毁了 我们看一下close的原码文件，当判断我们又连接池的时候就是进入到第一个if，底层并不会真正的close，而是归还return出去了
【Redis】Java Redis Pipeline(管道) 使用示例
m0_45406092的博客
04-22 2772
文章目录概述 概述 一般情况下，大家使用redis去put/get都是先拿到一个jedis实例，然后操作，然后释放连接，这种模式是 请求-响应，请求-响应 这种模式，下一次请求必须得等第一次请求响应回来之后才可以，因为redis是单线程的，按部就班，一步一步来。 而pipeline管道改变了这种请求模式，客户端可以一次发送多个命令，无须等待服务器的返回，请求，请求，请求，响应，响应，响应 这种模式大大减少了影响性能的关键因素-网络往返时间。 package com.test.jedis; import
Redis的队列如何异步使用？
ConstXiong
02-12 213
Redis 的 list 结构可以作为队列使用，rpush 生产消息，lpop 消费消息，lpop 没有取到消息时，可以让线程休眠一会再获取消息 blpop 指令，在队列没有消息时，会阻塞线程直到消息被生产，获取消息 【Java面试题与答案】整理推荐 基础与语法 集合 网络编程 并发编程 Web 安全 设计模式 框架 算法与数据结构 异常 文件解析与生成...
java redis pipeline_Redis 批量操作之pipeline
weixin_32809369的博客
03-01 1434
业务场景最近项目中场景需要get一批key的value，因为redis的get操作(不单单是get命令)是阻塞的，如果循环取值的话，就算是内网，耗时也是巨大的。所以想到了redis的pipeline命令。pipeline简介非pipeline：client一个请求，redis server一个响应，期间client阻塞Pipeline：redis的管道命令，允许client将多个请求依次发给服务器...
Jedis事务详解：Java连接Redis缓存实战
"本文将详细介绍【Redis缓存机制】在Java环境中的应用，特别是通过Jedis库进行连接和事务处理。Redis作为一款高性能的键值存储系统，其事务机制对于提高数据一致性、减少网络开销具有重要作用。在Java开发中，Jedis...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值