redis 指令：

原始碼地址：

maven依賴：

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>2.8.1</version>
</dependency>

• 原理：

jedis底層主要有兩個類：
redis.clients.jedis.Protocol
redis.clients.jedis.Connection
Connection負責client與server之間通訊，Protocol是client與server之間通訊協議。

• 主要方法：

public class Connection implements Closeable {
private static final byte[][] EMPTY_ARGS = new byte[0][];
    private String host = "localhost"; //redis伺服器地址（預設"localhost"）
    private int port = 6379;//port:服務端號（預設6379）
    private Socket socket;
    private RedisOutputStream outputStream;//redis-client傳送給redis-server的內容
 

    private RedisInputStream inputStream;//redis-server返回給redis-client的內容
    private int pipelinedCommands = 0;//管道命令數
    private int connectionTimeout = 2000;//連線超時時間（預設2000ms）
    private int soTimeout = 2000;//響應超時時間（預設2000ms）
    private boolean broken = false;

...

/**主要方法*/

//連線
 public void connect() {
        if
 
(!this.isConnected()) {
            try {
                this.socket = new Socket();
                this.socket.setReuseAddress(true);
                this.socket.setKeepAlive(true);
                this.socket.setTcpNoDelay(true);
                this.socket.setSoLinger(true, 0);
                this.socket.connect(new InetSocketAddress(this.host, this.port), this.connectionTimeout);
                this.socket.setSoTimeout(this.soTimeout);
                this.outputStream = new RedisOutputStream(this.socket.getOutputStream());
                this.inputStream = new RedisInputStream(this.socket.getInputStream());
            } catch (IOException var2) {
                this.broken = true;
                throw new JedisConnectionException(var2);
            }
        }

    }

//傳送命令內容
protected Connection sendCommand(Command cmd, byte[]... args) {
        try {
            this.connect();
            Protocol.sendCommand(this.outputStream, cmd, args);
            ++this.pipelinedCommands;
            return this;
        } catch (JedisConnectionException var6) {
            JedisConnectionException ex = var6;

            try {
                String errorMessage = Protocol.readErrorLineIfPossible(this.inputStream);
                if(errorMessage != null && errorMessage.length() > 0) {
                    ex = new JedisConnectionException(errorMessage, ex.getCause());
                }
            } catch (Exception var5) {
                ;
            }

            this.broken = true;
            throw ex;
        }
    }
}    
//協議
public final class Protocol {

//命令的傳送都是通過redis.clients.jedis.Protocol的sendCommand來完成的，就是對RedisOutputStream寫入位元組流 
/**
*[*號][訊息元素個數]\r\n ( 訊息元素個數 = 引數個數 + 1個命令)
*[$號][命令位元組個數]\r\n
*[命令內容]\r\n
*[$號][引數位元組個數]\r\n
*[引數內容]\r\n
*[$號][引數位元組個數]\r\n
*[引數內容]\r\n 
*/
private static void sendCommand(RedisOutputStream os, byte[] command, byte[]... args) {
        try {
            os.write((byte)42);
            os.writeIntCrLf(args.length + 1);
            os.write((byte)36);
            os.writeIntCrLf(command.length);
            os.write(command);
            os.writeCrLf();
            byte[][] e = args;
            int var4 = args.length;

            for(int var5 = 0; var5 < var4; ++var5) {
                byte[] arg = e[var5];
                os.write((byte)36);
                os.writeIntCrLf(arg.length);
                os.write(arg);
                os.writeCrLf();
            }

        } catch (IOException var7) {
            throw new JedisConnectionException(var7);
        }
    }
}

//返回的資料是通過讀取RedisInputStream  進行解析處理後得到的
  /** 
   * public static final byte PLUS_BYTE = 43;
   * public static final byte DOLLAR_BYTE = 36;
   * public static final byte ASTERISK_BYTE = 42;
   * public static final byte COLON_BYTE = 58;

   * "+": 狀態回覆（status reply）         PLUS_BYTE 
   *    * <pre> 
   * 狀態回覆通常由那些不需要返回資料的命令返回，這種回覆不能包含新行。 
   * eg: 
   *    cli: set name zhangsan 
   *    server: +OK 
   * </pre> 
   * 
   * "$": 批量回復（bulk reply）           DOLLAR_BYTE 
   *   伺服器使用批量回復來返回二進位制安全的字串，字串的最大長度為 512 MB。 
   *  eg: 
   *      cli: get name 
   *      server: $8\r\nzhangsan\r\n 
   *  空批量回復： 
   *  如果被請求的值不存在， 那麼批量回復會將特殊值 -1 用作回覆的長度值。當請求物件不存在時，客戶端應該返回空物件，而不是空字串。 
   * 
   * "*": 多條批量回復（multi bulk reply）  ASTERISK_BYTE  
   *    * 多條批量回復是由多個回覆組成的陣列， 陣列中的每個元素都可以是任意型別的回覆， 包括多條批量回複本身。 
   * eg: 
   *    cli: lrange mylist 0 3 
   *    server: *4\r\n 
   *            :1\r\n 
   *            :2\r\n 
   *            :3\r\n 
   *            $3\r\n 
   *            foo\r\n 
   * 多條批量回復也可以是空白的, 
   * eg: 
   *    cli: lrange mylist 7 8 
   *    server: *0\r\n 
   * 無內容的多條批量回復（null multi bulk reply）也是存在的， 比如當 BLPOP 命令的阻塞時間超過最大時限時， 它就返回一個無內容的多條批量回復， 這個回覆的計數值為 -1 ： 
   * eg: 
   *    cli: blpop key 1 
   *    server: *-1\r\n 
   * 多條批量回復中的元素可以將自身的長度設定為 -1 ， 從而表示該元素不存在， 並且也不是一個空白字串（empty string）。 
   * 
   * ":": 整數回覆（integer reply）        COLON_BYTE
   *    *  整數回覆就是一個以 ":" 開頭， CRLF 結尾的字串表示的整數。 
   *    eg: 
   *    cli: exists name 
   *    server: :1 
   * 
   * "-": 錯誤回覆（error reply）          MINUS_BYTE
   */ 
private static Object process(RedisInputStream is) {
        byte b = is.readByte();
        if(b == 43) {
            return processStatusCodeReply(is);
        } else if(b == 36) {
            return processBulkReply(is);
        } else if(b == 42) {
            return processMultiBulkReply(is);
        } else if(b == 58) {
            return processInteger(is);
        } else if(b == 45) {
            processError(is);
            return null;
        } else {
            throw new JedisConnectionException("Unknown reply: " + (char)b);
        }
    }

}

• 示例：

以Jedis的get方法為例：

public String get(String key) {
        this.checkIsInMultiOrPipeline();
        this.client.sendCommand(Command.GET, new String[]{key});
        return this.client.getBulkReply();
    }

1：this.checkIsInMultiOrPipeline();
進行無事務檢查 Jedis不能進行有事務的操作 帶事務的連線要用redis.clients.jedis.Transaction類。
2：this.client.sendCommand(Command.GET, new String[]{key});
2.1：redis.clients.jedis.Connection connect()方法建立連線
2.2：public final class Protocol sendCommand()方法向RedisOutputStream寫入命令
2.3：在命令寫入成功之後，會將Connection的piplinedCommands 屬性自增一，表示在管道中已經有一個命令了
3：return this.client.getBulkReply();
get方法使用getBulkReply()獲取返回結果，其他見上文redis.clients.jedis.Protocol process()方法

• pipeline

redis是一個cs模式的tcp server，使用和http類似的請求響應協議。一個client可以通過一個socket連線發起多個請求命令。每個請求命令發出後client通常會阻塞並等待redis服務處理，redis處理完後請求命令後會將結果通過響應報文返回給client。
所以在多條命令需要處理時，使用pipeline效率會快得多。
通過pipeline方式當有大批量的操作時候。我們可以節省很多原來浪費在網路延遲的時間。pipeline方式將client端命令一起發出，redis server會處理完多條命令後，將結果一起打包返回client,從而節省大量的網路延遲開銷。需要注意到是用 pipeline方式打包命令傳送，redis必須在處理完所有命令前先快取起所有命令的處理結果。打包的命令越多，快取消耗記憶體也越多。所以並是不是打包的命令越多越好。具體多少合適需要根據具體情況測試。

• pipeline 示例

 Pipeline pipeline = jedis.pipelined();
        pipeline.set("a","a");
        pipeline.get("a");
        pipeline.set("b","b");
        pipeline.get("b");
        pipeline.del("a");
        pipeline.get("a");
        List<Object> list = pipeline.syncAndReturnAll();
        for (Object o : list){
            System.out.println(o);
        }

結果如下：

OK
a
OK
b
1
null

• 參考連結