Redis实践（三）基于jedis开发java应用：redis的8种方式设置key，value

前面已经进行了redis的部署实践，下面要进行redis的java开发实践

一、目标

  搭建java开发环境，采用eclipse开发工具

  验证redis的写数据的8种方式的效率

二、环境准备

开始在 Java 中使用 Redis 前， 我们需要确保已经安装了 redis 服务及 Java redis 驱动，且你的机器上能正常使用 Java。 Java的安装配置可以参考我们的 Java开发环境配置 接下来让我们安装 Java redis 驱动：
        首先你需要下载驱动包，下载 jedis.jar，我在本次实践中用的jedis的jar包是2.8.0 版本的。同时，要保证java工程可以正常运行，还需要下载commons-pool2-2.3.jar以及 hamcrest-core-1.3.jar。

        然后，在redis服务上，配置好6379，6380 两个端口的配置文件，启动redis（因为后面需要用分布式的调用，所以需要启动两个redis实例）

三、java工程

在elipse中创建工程，并且将上面三个jar包放到lib目录中，并且添加到buildpath

 

    下面，对jedis关于事务、管道和分布式的调用方式做一个简单的介绍和对比，代码如下：（主要从网上获取，少量改动）

package com.cwqsolo.redis.test;

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; 


//RedisDemo  用来测试redis的使用接口
public class RedisDemo { 

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

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


        jedis = new Jedis("192.168.136.144"); 
        sharding = new ShardedJedis(shards); 
        JedisPoolConfig config =new JedisPoolConfig();//Jedis池配置
        pool = new ShardedJedisPool(config, shards); 
    } 


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


    //测试普通同步方式， 设置10w个key，value，看用时多少。
    public void test1Normal() { 
        long start = System.currentTimeMillis(); 
        for (int i = 0; i < 100000; i++) { 
            String result = jedis.set("1n" + i, "1n" + i); 
        } 
        long end = System.currentTimeMillis(); 
        System.out.println("普通同步方式::Simple SET: " + ((end - start)/1000.0) + " seconds"); 
    } 

  //测试事务方式Transactions， 设置10w个key，value，看用时多少。
    public void test2Trans() { 
        long start = System.currentTimeMillis(); 
        Transaction tx = jedis.multi(); 
        for (int i = 0; i < 100000; i++) { 
            tx.set("1t" + i, "1t" + 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"); 
    } 


    //采用管道方式，异步方式，一次发送多个指令，
    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"); 
    } 

    //管道中调用事务, 
    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"); 
    } 

    //分布式直连同步调用,用到了分片
    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"); 
    } 

    //分布式直连异步调用
    public void test6shardpipelined() { 
	//采用sharding 对象
        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"); 
    } 

    //分布式连接池同步调用, 线程安全
    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"); 
    } 

    //分布式连接池异步调用
    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"); 
    } 
    
    
  
    public static void main(String[] args) {
         
	RedisDemo testDemo = new RedisDemo();
	try {
	testDemo.init();
	}catch (Exception Exc) {
		
		Exc.printStackTrace();
		System.exit(0);
	}
	
	System.out.println("init complete sucessfully!!!"); 

	//测试普通同步方式
	testDemo.test1Normal();
	//测试事务方式Transactions
	testDemo.test2Trans();
	//采用管道方式，异步方式
	testDemo.test3Pipelined();
	//管道中调用事务,
	testDemo.test4combPipelineTrans();
	//分布式直连同步调用,用到了分片
	testDemo.test5shardNormal();
	//分布式直连异步调用
	testDemo.test6shardpipelined();
	//分布式连接池同步调用, 线程安全
	testDemo.test7shardSimplePool();
	//分布式连接池异步调用, 线程安全
	testDemo.test8shardPipelinedPool();
	

	try {
	    testDemo.CleanUp();
		}catch (Exception Exc) {
			
			Exc.printStackTrace();
			System.exit(0);
		}
       
    }
    
    
} 

整个代码，都是对redis进行key，value的设定，数据大小为10w，通过8种不同的接口进行测试，比较一下调用的效率

下面是运行的结果。

从图中可以看出，异步调用的效率非常高。