Redis客戶端API操作 Jedis詳解

本文轉載自查看原文 2016-07-12 10:48 9881 Redis

redis是一個著名的key-value存儲系統，也是nosql中的最常見的一種。其實，個人認為，redis最強大的地方不在於其存儲，而在於其強大的緩存作用。

我們可以把它想象成一個巨大的(多借點集群，聚合多借點的內存)的Map，也就是Key-Value。

所以，我們可以把它做成緩存組件。

官方推薦的java版客戶端是jedis，非常強大和穩定，支持事務、管道及有jedis自身實現。我們對redis數據的操作，都可以通過jedis來完成。

更多redis的概念，請參考：Redis集群(Redis3.0)

那我們就來看一看，jedis不同的調用方式：

(1)普通同步方式

這是一種最簡單和最基礎的調用方式，對於簡單的數據存取需求，我們可以通過這種方式調用。

public void jedisNormal() {
    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之后都可以返回結果，標記是否成功。

(2)事務方式(Transactions)

所謂事務，即一個連續操作，是否執行是一個事務，要么完成，要么失敗，沒有中間狀態。

而redis的事務很簡單，他主要目的是保障，一個client發起的事務中的命令可以連續的執行，而中間不會插入其他client的命令，也就是事務的連貫性。

public void jedisTrans() {
    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()方法來取消事務。

(3)管道(Pipelining)

管道是一種兩個進程之間單向通信的機制。

那再redis中，為何要使用管道呢？有時候，我們需要采用異步的方式，一次發送多個指令，並且，不同步等待其返回結果。這樣可以取得非常好的執行效率。

public void jedisPipelined() {
    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();
}

(4)管道中調用事務

對於，事務以及管道，這兩個概念我們都清楚了。

在某種需求下，我們需要異步執行命令，但是，又希望多個命令是有連續的，所以，我們就采用管道加事務的調用方式。jedis是支持在管道中調用事務的。

public void jedisCombPipelineTrans() {
    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();
}
//效率上可能會有所欠缺

(5)分布式直連同步調用

這個是分布式直接連接，並且是同步調用，每步執行都返回執行結果。類似地，還有異步管道調用。

其實就是分片。

public void jedisShardNormal() {
    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();
}

(6)分布式直連異步調用

public void jedisShardpipelined() {
    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();
}

(7)分布式連接池同步調用

如果，你的分布式調用代碼是運行在線程中，那么上面兩個直連調用方式就不合適了，因為直連方式是非線程安全的，這個時候，你就必須選擇連接池調用。

連接池的調用方式，適合大規模的redis集群，並且多客戶端的操作。

public void jedisShardSimplePool() {
    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();
}

(8)分布式連接池異步調用

public void jedisShardPipelinedPool() {
    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();
}

(9)需要注意的地方

事務和管道都是異步模式。在事務和管道中不能同步查詢結果。比如下面兩個調用，都是不允許的：

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

事務和管道都是異步的，個人感覺，在管道中再進行事務調用，沒有必要，不如直接進行事務模式。

分布式中，連接池的性能比直連的性能略好(見后續測試部分)。

分布式調用中不支持事務。

因為事務是在服務器端實現，而在分布式中，每批次的調用對象都可能訪問不同的機器，所以，沒法進行事務。

(10)總結

分布式中，連接池方式調用不但線程安全外，根據上面的測試數據，也可以看出連接池比直連的效率更好。

經測試分布式中用到的機器越多，調用會越慢。

(11)完整的測試代碼

package com.blogchong.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;

/**
* @Description: jedis的8種調用方式
*/

@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("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 jedisNormal() {
        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 jedisTrans() {
        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 jedisPipelined() {
        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 jedisCombPipelineTrans() {
        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 jedisShardNormal() {
        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 jedisShardpipelined() {
        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 jedisShardSimplePool() {
        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 jedisShardPipelinedPool() {
        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");
    }
}

參考修改自:http://www.blogways.net/blog/2013/06/02/jedis-demo.html

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 redis客戶端--jedis Java操作redis客戶端Jedis連接集群(Cluster) Jedis客戶端以及redis中的pipeline批量操作 Redis --Java客戶端 Jedis Redis Java客戶端Jedis入門 Redis之Java客戶端Jedis 使用Jedis操作Redis-使用Java語言在客戶端操作---對key的操作使用Jedis操作Redis-使用Java語言在客戶端操作---對Sorted-Sets的操作 Redis學習記錄（六）redis客戶端jedis多線程操作時報異常使用Jedis操作Redis-使用Java語言在客戶端操作---set類型