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

标签: redis java 客户端 | 发表时间:2014-08-07 23:04 | 作者:bijian1013
出处:http://www.iteye.com

        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("[email protected] 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("[email protected] 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("[email protected] 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("[email protected] 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
[email protected] SET: 5.289 seconds
[email protected] SET: 0.348 seconds
[email protected] SET: 5.039 seconds
[email protected] SET: 0.401 seconds

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

[email protected] SET: 5.494 seconds
[email protected] SET: 0.51 seconds
[email protected] SET: 5.223 seconds
[email protected] SET: 0.518 seconds

        下面是10片:

[email protected] SET: 5.9 seconds
[email protected] SET: 0.794 seconds
[email protected] SET: 5.624 seconds
[email protected] SET: 0.762 seconds

        下面是100片:

[email protected] SET: 14.055 seconds
[email protected] SET: 8.185 seconds
[email protected] SET: 13.29 seconds
[email protected] 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("[email protected] 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("[email protected] 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("[email protected] 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("[email protected] 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
[email protected] SET: 29.287 seconds
[email protected] SET: 1.953 seconds
[email protected] SET: 31.537 seconds
[email protected] SET: 1.156 seconds

直接查看redis数据库:

[[email protected] 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





已有 0 人发表留言,猛击->> 这里<<-参与讨论


ITeye推荐



相关 [redis java 客户端] 推荐:

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

- - 数据库 - ITeye博客
        redis是一个著名的key-value存储系统,而作为其官方推荐的java版客户端jedis也非常强大和稳定,支持事务、管道及有jedis自身实现的分布式.         在这里对jedis关于事务、管道和分布式的调用方式做一个简单的介绍和对比:.         最简单和基础的调用方式.

Redis如何处理客户端连接

- - NoSQLFan
本文主要介绍了 Redis 处理 客户端连接的一些内部实现机制,包括连接处理、 超时、缓冲区等一系列内容. 注:本文所述内容基于 Redis2.6 及以上版本. Redis 通过监听一个 TCP 端口或者 Unix socket 的方式来接收来自客户端的连接,当一个连接建立后,Redis 内部会进行以下一些操作:.

Redis客户端之Spring整合Jedis

- - 开源软件 - ITeye博客
1.下载相关jar包,并引入工程:. 2.将以下XML配置引入spring. 3.将shardedJedisPool注入相关的类中即可使用. * 设置一个key的过期时间(单位:秒). * @param key key值. * @param seconds 多少秒后过期. * @return 1:设置了过期时间 0:没有设置过期时间/不能设置过期时间.

Redis客户端Jedis使用示例

- - 移动开发 - ITeye博客
Jedis 是 Redis 官方首选的 Java 客户端开发包. 工作过程总结的一个示例,贴出来,如下:.      * 在不同的线程中使用相同的Jedis实例会发生奇怪的错误. 但是创建太多的实现也不好因为这意味着会建立很多sokcet连接, .      * 也会导致奇怪的错误发生. 单一Jedis实例不是线程安全的.

ElasticSearch的JAVA客户端操作

- - 编程语言 - ITeye博客
一、java操作ES有两种客户端:. 1、TransportClient:轻量级的Client,使用Netty线程池,Socket连接到ES集群. 本身不加入到集群,只作为请求的处理. 2、Node Client:客户端节点本身也是ES节点,加入到集群,和其他ElasticSearch节点一样. 频繁的开启和关闭这类Node Clients会在集群中产生“噪音”.

java对redis的基本操作

- - 编程语言 - ITeye博客
    可看到当前可下载版本:redis2.6.     下载windows平台文件:.      解压后,选择当前64位win7系统对应的版本:.     1)解压后将里面所有文件拷贝至redis安装目录:.      几个exe程序的功能:    .         redis-benchmark.exe:性能测试,用以模拟同时由N个客户端发送M个 SETs/GETs 查询 (类似于 Apache 的ab 工具).

JAVA的Corba客户端 - 服务端 通信实现

- - 博客园_首页
先在Eclipse建立两个Java Project. **这里注意, } 后面的 ";"一定要写上,不然会编译错误. 右键这个HelloApp.idl 文件. 点击,Change to parent folder in Shell. 点击OK , Eclipse会打开Shell视图,是命令行视图,其实和CMD是一个作用..

Windows7+Eclipse环境下Hbase Java客户端的开发

- - zzm
Centos 下Hbase0.98.10-hadoop2 集群的配置. 在Eclipse中创建Maven的工程. 将集群的hbase-site.xml文件放到工程的classes目录下. C:\windows\system32\drivers\etc文件,将Hbase集群的IP以及域名配置到该文件中.

java实现JT809协议数据对接客户端

- - Java - 编程语言 - ITeye博客
最近使用JT809协议进行数据对接,遇到了不少问题,度娘谷歌都不好使,找不到很好的客户端实现代码的例子,只能苦逼的自己闷头弄,现在特意写篇帖子,希望能帮助一些人. 背景:跟某公司做数据对接,将本公司的一些信息推送到接收端. 要求:建立tcp链接,使用接收端提供的用户名密码等信息 先登录,登录成功后推送数据,数据采用JT809标准协议.

用Redis来存储关注关系(java实现)

- - ITeye博客
//一个接口UserService.java //一个接口的实现UserServiceImpl.java //两个采用Jedis的客户端测试类FollowTestMain.java,IsFollowTestMain.java. //UserService.java接口如下 package com.redis.test; import java.util.Set; public interface UserService {.