一、从缓存张获取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);
        }
    }
}```