源碼梳理——Jedis從緩存池中擷取資源和銷毀資源

一、從緩存張擷取redis執行個體

通過JedisPool的getResource就可以從緩存池中取出一個redis執行個體對象，該方法是從Pool類繼承而來

@SuppressWarnings("unchecked")
    public T getResource() {
        try {
            return (T) internalPool.borrowObject();
        } catch (Exception e) {
            throw new JedisConnectionException(
                    "Could not get a resource from the pool", e);
        }
    }           

在初始化JedisPool執行個體時，如果testOnBorrow為true的話，那麼在borrowObject方法中會調用上文中提到的JedisFactory的validateObject方法來确報從borrowObject方法中擷取到的執行個體對象必然是可用的。

public boolean validateObject(final Object obj) {
            if (obj instanceof Jedis) {
                final Jedis jedis = (Jedis) obj;
                try {
                    return jedis.isConnected() && jedis.ping().equals("PONG");
                } catch (final Exception e) {
                    return false;
                }
            } else {
                return false;
            }
        }
    }```  

在validateObject方法中，Jedis會去看從緩存池中取出的redis執行個體是否和redis伺服器保持連接配接，以及輸入和輸出流是否可用
           

public boolean isConnected() {

return socket != null && socket.isBound() && !socket.isClosed()
            && socket.isConnected() && !socket.isInputShutdown()
            && !socket.isOutputShutdown();
}```  
           

如果socket可用的話，那麼再像redis伺服器發送ping指令，測試與伺服器的連接配接是否仍然生效

public String ping() {
    checkIsInMulti();
    client.ping();
    return client.getStatusCodeReply();
    }```  

方法中首先檢查是否開啟了事務，Jedis類并不支援事務，使用事務可用Transaction類，然後向redis伺服器發送ping指令

# 二、Jedis與redis通信協定格式

1、請求
           

public static void sendCommand(final RedisOutputStream os,

final Command command, final byte[]... args) {
sendCommand(os, command.raw, args);
}

private static void sendCommand(final RedisOutputStream os,
    final byte[] command, final byte[]... args) {
try {
    os.write(ASTERISK_BYTE);
    os.writeIntCrLf(args.length + 1);
    os.write(DOLLAR_BYTE);
    os.writeIntCrLf(command.length);
    os.write(command);
    os.writeCrLf();

    for (final byte[] arg : args) {
    os.write(DOLLAR_BYTE);
    os.writeIntCrLf(arg.length);
    os.write(arg);
    os.writeCrLf();
    }
} catch (IOException e) {
    throw new JedisConnectionException(e);
}
}```  
           

Jedis向伺服器發送指令最終是由Protocol類完成，Jedis将建立時保留下來的輸入流和要發送的指令以及參數傳給Protocol的sendCommand方法，由Protocol類來向redis伺服器發送通信内容。這個地方用到了指令模式這樣的設計思想，Client類發送指令給Connection，Connection将指令傳遞給Protocol，由Protocol來決定指令具體怎麼執行，這樣Client和Protocol消除了耦合。

redis通信協定如下；

*<參數數量> CR LF
$<參數 1 的位元組數量> CR LF
<參數 1 的資料> CR LF
...
$<參數 N 的位元組數量> CR LF
<參數 N 的資料> CR LF```  

注：指令本身也作為協定的其中一個參數來發送。

2、回複

redis回複格式如下

    狀态回複（status reply）的第一個位元組是 "+"

    錯誤回複（error reply）的第一個位元組是 "-"

    整數回複（integer reply）的第一個位元組是 ":"

    批量回複（bulk reply）的第一個位元組是 "$"

    多條批量回複（multi bulk reply）的第一個位元組是 "*"
注：redis通信協定具體可參考http://redis.readthedocs.org/en/latest/topic/protocol.html
           

private static Object process(final RedisInputStream is) {

try {
    byte b = is.readByte();
    if (b == MINUS_BYTE) {
    processError(is);
    } else if (b == ASTERISK_BYTE) {
    return processMultiBulkReply(is);
    } else if (b == COLON_BYTE) {
    return processInteger(is);
    } else if (b == DOLLAR_BYTE) {
    return processBulkReply(is);
    } else if (b == PLUS_BYTE) {
    return processStatusCodeReply(is);
    } else {
    throw new JedisConnectionException("Unknown reply: " + (char) b);
    }
} catch (IOException e) {
    throw new JedisConnectionException(e);
}
return null;
}```  
           

通過Jedis建立時保留下來的輸入流，來讀取第一個位元組，判斷是哪種類型的類型，然後進行相應的解析，以ping指令為例

private static byte[] processStatusCodeReply(final RedisInputStream is) {
    return SafeEncoder.encode(is.readLine());
    }```  

ping指令回複的類型屬于狀态回複。Jedis讀取輸入流中的第一行中除去第一個位元組剩下的位元組進行utf-8編碼轉換成字元串

# 二、釋放緩存池中redis執行個體資源
           

/**
      * 釋放jedis資源
      * @param jedis
      */
     public static void returnResource(final Jedis jedis) {
         if (jedis != null) {
             jedisPool.returnResource(jedis);
         }
     }```             

調用了基類Pool的returnResource方法。該方法會調用初始化JedisPool時傳入的JedisFactory中的destroyObject方法來銷毀資源。

public void destroyObject(final Object obj) throws Exception {
            if (obj instanceof Jedis) {
                final Jedis jedis = (Jedis) obj;
                if (jedis.isConnected()) {
                    try {
                        try {
                            jedis.quit();
                        } catch (Exception e) {
                        }
                        jedis.disconnect();
                    } catch (Exception e) {

                    }
                }
            }
        }```  

該方法首先向redis伺服器發送quit指令，來結束此次會話。然後調用disconnect方法來關閉輸入和輸出流以及關閉socket套接字
           

public void disconnect() {

if (isConnected()) {
        try {
            inputStream.close();
            outputStream.close();
            if (!socket.isClosed()) {
                socket.close();
            }
        } catch (IOException ex) {
            throw new JedisConnectionException(ex);
        }
    }
}```