前幾天剛剛粗略看了一下spring-data-redis的原始碼 (1.0.1-RELEASE)

又針對這部分分析了下原始碼，總結整理如下

spring-data-redis的各種Operations實現類，如RedisTemplate，DefaultSetOperations，DefaultListOperations等，對Redis命令的封閉都是通過如下結構呼叫的

RedisTemplate中的hasKey

1. public Boolean hasKey(K key) {  
2.     final byte[] rawKey = rawKey(key);  
3.     return execute(new RedisCallback<Boolean>() {  
4.         public Boolean doInRedis(RedisConnection connection) {  
5.             return connection.exists(rawKey);  
6.         }  
7.     }, true);  
8. }  

要實現一個指定返回型別的RedisCallback介面，這個介面只有一個函式doInRedis

doInRedis的引數是RedisConnection介面，spring-data-redis針對不的Redis Java Client都有對應的 RedisConnection實現：

JedisConnection

JredisConnection

RjcConnection

SrpConnection

目的就是將不同Client的API統一了一下，可以看成是Adapter吧 。

execute這個是模板函式，主是處理連線的問題。

spring-data-redis 針對不的 Redis Java Client 也都實現了相應的 RedisConnectionFactory，來獲取連線。  

比如 JedisConnectionFactory 內部是通過 JedisPool 來實現連線工廠。

execute模板函式原始碼：

1. public
    <T> T execute(RedisCallback<T> action, boolean exposeConnection, boolean pipeline) {  
2.     Assert.notNull(action, "Callback object must not be null");  
3.     RedisConnectionFactory factory = getConnectionFactory();  
4.     RedisConnection conn = RedisConnectionUtils.getConnection(factory);  
5.     boolean existingConnection = TransactionSynchronizationManager.hasResource(factory);  
6.     preProcessConnection(conn, existingConnection);  
7.     boolean pipelineStatus = conn.isPipelined();  
8.     if (pipeline && !pipelineStatus) {  
9.         conn.openPipeline();  
10.     }  
11.     try {  
12.         RedisConnection connToExpose = (exposeConnection ? conn : createRedisConnectionProxy(conn));  
13.         T result = action.doInRedis(connToExpose);  
14.         // close pipeline  
15.         if (pipeline && !pipelineStatus) {  
16.             conn.closePipeline();  
17.         }  
18.         // TODO: any other connection processing?  
19.         return postProcessResult(result, conn, existingConnection);  
20.     } finally {  
21.         RedisConnectionUtils.releaseConnection(conn, factory);  
22.     }  
23. }  

正常情況下RedisCallback中doInRedis獲取的RedisConnection每次都是新的

這也就出現了前面帖子中說的問題了“這時候肯定會有個疑問，既然這個template每次都會生成新連線，那這個multi和exec命令還有個蛋用？？”

使用RedisTemplate確實會有這個問題，但是作者對官方回答的理解有些出入。

The methods are exposed in case the connection is shared across methods. Currently we don't provide any out of the box support for connection binding but the RedisTemplate supports it - just like with the rest of the templates, one connection could be bound to the running thread and the RT will use it without creating new ones. 

回答中確實承認RedisTemplate 不支援連線繫結，但後半段說的是“在其它的模板類中，連線是可以繫結到當前執行緒，這樣RedisTemplate 就會使用這個連線，而不會重新建立了”。

OK！ 下面分析原始碼，看一下這個繫結是怎麼實現的。

org.springframework.data.redis.support.collections.AbstractRedisCollection 是 spring-data-redis 對redis的幾個集合型別的資料結構封裝類的抽象類

其中有 rename 這個函式

1. public void rename(final String newKey) {  
2.     CollectionUtils.rename(key, newKey, operations);  
3.     key = newKey;  
4. }  

但它的實現並沒有使用內部持有的RedisOperations，而是CollectionUtils.rename，那我們就來看一個這個CollectionUtils.rename

這個rename是通過事務來保證進行rename操作時，原key一定存在

1. static <K> void rename(final K key, final K newKey, RedisOperations<K, ?> operations) {  
2.     operations.execute(new SessionCallback<Object>() {  
3.         @SuppressWarnings("unchecked")  
4.         public Object execute(RedisOperations operations) throws DataAccessException {  
5.             do {  
6.                 operations.watch(key);  
7.                 if (operations.hasKey(key)) {  
8.                     operations.multi();  
9.                     operations.rename(key, newKey);  
10.                 }  
11.                 else {  
12.                     operations.multi();  
13.                 }  
14.             } while (operations.exec() == null);  
15.             return null;  
16.         }  
17.     });  
18. }  

 這是一個靜態函式，對Redis的操作是通過傳入的RedisOperations來完成的

rename呼叫了RedisOperations的execute，傳入了一個匿名的回撥介面，實現具體操作，這和前面說的execute模板看起來是一樣的。但這裡的RedisOperations為什麼可以使用watch 和 multi 能？ 前面不是說 RedisTemplate 不能直接watch 和 multi 嗎？  (RedisOperations是RedisTemplate的介面，針對不同資料結構的操作類和集合都是從RedisTemplate生成的，也就是說都是通過RedisTemplate操作Redis的)

其實這個execute模板和前面的是不一樣的，這裡的引數是SessionCallback 而前面的是 RedisCallback，從名字應該能看出，這個裡的 execute 呼叫是會保持會話，也就是連線。

看一下這裡的execute原始碼

1. public <T> T execute(SessionCallback<T> session) {  
2.     RedisConnectionFactory factory = getConnectionFactory();  
3.     // bind connection  
4.     RedisConnectionUtils.bindConnection(factory);  
5.     try {  
6.         return session.execute(this);  
7.     } finally {  
8.         RedisConnectionUtils.unbindConnection(factory);  
9.     }  
10. }  

不用多解釋了吧，在呼叫 SessionCallback 的實現進行具體操作前後，對連線進行了繫結和解綁。

然後在session.execute中，會呼叫operations.watch(key); 等著操作，這些操作和前面分析的RedisTemplate中的hasKey的流程是一樣的，會呼叫前面分析的execute進行操作。

回到前面看下原始碼，那裡的RedisConnection 是通過RedisConnectionUtils取到的

1. RedisConnection conn = RedisConnectionUtils.getConnection(factory);  

連線繫結和解綁也是通過 RedisConnectionUtils 完成的，裡面是通過TransactionSynchronizationManager將連線繫結到當前執行緒的，和spring的DB事務管理是一樣的，這裡就不詳細分析了(主要是使用ThreadLocal)。

這樣一分析，spring-data-redis 是可以使用watch 和 multi 的，關鍵是怎麼使用的問題。 

總結：

RedisTemplate和其它特定型別的操作類，主要是實現了基本的操作功能，也有部分高階功能（如上面的rename和RedisAtomicInteger等高階操作）。

通過 SessionCallback 是可以獲取到繫結連線的操作類的，它上面的操作都是在一個連線上的，這樣可以實現高階功能。

在spring-data-redis中使用watch和multi，可以參照原始碼中的CollectionUtils.rename