java經過redisTemplate封裝redis3.2.9工具類

時間 2020-01-10
標籤 java 經過 redistemplate 封裝 redis3.2.9 redis 工具欄目 Java 简体版
原文原文鏈接
前幾天結合mongotemplate封裝了下mongodb的工具類「http://ylcodes01.blog.51cto.com/5607366/1934662」，如今結合redistemplate封裝了下經常使用命令工具類，我的發現兩者的數據類型操做區別仍是挺大的。java
mongodb是出於關係型數據庫和非關係型數據庫中間的DB，在操做中你會發現其更傾向於關係型數據庫的使用，是文檔型數據庫，咱們項目如今利用這一特性處理了系統日誌中的相關操做，mongo的總體數據以列表的形式存於mongo，每條數據以JSON的形式存於列表中，利用mongoTemplate的封裝方法，能夠很自由的把從列表中查詢出的數據轉換成各類數據類型，入庫也同理。由於數據是落地性質的，因此不怕丟數據。redis
redis查詢速度快，適用於高訪問負載的使用，我的喜歡用它處理一些value值小且被常常訪問的數據。關於NOSQL的相關對比可參考個人另外一篇博文「自學總結redis第一部分」spring
「http://ylcodes01.blog.51cto.com/5607366/1881651」中的NOSQL簡介部分。
mongodb
下面是結合spring4.3.7配置redisTmeplate的方式封裝的一些經常使用的命令:
數據庫
package com.stbr.common.redis.base;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;
import javax.annotation.Resource;
import java.util.*;
public class BaseRedisDao implements IBaseRedisDao{
    @Resource(name = "redisMasterTemplate")
    private RedisTemplate<String,Object> redisMasterTemplate;
    @Resource(name = "redisSlaveTemplate")
    private RedisTemplate<String,Object> redisSlaveTemplate;
    /**
     * 字符串類型:經過key值獲取對應的value對象
     * @param key
     * @return
     */
    @Override
    public String get(final String key) {
        return redisSlaveTemplate.execute(new RedisCallback<String>() {
            @Override
            public String doInRedis(RedisConnection redisConnection) throws DataAccessException {
                RedisSerializer<String> serializer = getRedisSlaveSerializer();
                byte keys[] = serializer.serialize(key);
                byte values[] = redisConnection.get(keys);
                if(values == null){
                    return null;
                }
                String value = serializer.deserialize(values);
                //System.out.println("key:"+key+",value:"+value);
                return value;
            }
        });
    }
    /**
     * 字符串類型:存入key-value對象，若是key存在，那麼默認更新value
     * @param key
     * @param value
     * @return
     */
    @Override
    public Boolean set(final String key, final String value) {
        return redisMasterTemplate.execute(new RedisCallback<Boolean>() {
            @Override
            public Boolean doInRedis(RedisConnection redisConnection) throws DataAccessException {
                RedisSerializer<String> serializer = getRedisMasterSerializer();
                byte keys[] = serializer.serialize(key);
                byte values[] = serializer.serialize(value);
                redisConnection.set(keys,values);
                return true;
            }
        });
    }
    /**
     * 字符串類型:經過key刪除對應的key和value
     * @param key
     * @return
     */
    @Override
    public Long delete(final String key) {
        return redisMasterTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection redisConnection) throws DataAccessException {
                RedisSerializer<String> redisSerializer = getRedisMasterSerializer();
                byte keys[] = redisSerializer.serialize(key);
                return redisConnection.del(keys);
            }
        });
    }
    /**
     * 字符串類型:經過key判斷對象是否存在
     * @param key
     * @return
     */
    @Override
    public Boolean exists(final String key) {
        return redisSlaveTemplate.execute(new RedisCallback<Boolean>() {
            @Override
            public Boolean doInRedis(RedisConnection redisConnection) throws DataAccessException {
                byte keys[] = getRedisSlaveSerializer().serialize(key);
                return redisConnection.exists(keys);
            }
        });
    }
    /**
     * 字符串類型:設置key對應的超時時間
     * @param key
     * @param expireTime
     * @return
     */
    @Override
    public Boolean expire(final String key, final Long expireTime) {
        return redisMasterTemplate.execute(new RedisCallback<Boolean>() {
            @Override
            public Boolean doInRedis(RedisConnection redisConnection) throws DataAccessException {
                byte keys[] = getRedisMasterSerializer().serialize(key);
                return redisConnection.expire(keys,expireTime);
            }
        });
    }
    /**
     * 字符串類型:根據key設置value值,若是key中的value存在,那麼返回false
     * @param key
     * @param value
     * @return
     */
    @Override
    public Boolean setnx(final String key, final String value) {
        return redisMasterTemplate.execute(new RedisCallback<Boolean>() {
            @Override
            public Boolean doInRedis(RedisConnection redisConnection) throws DataAccessException {
                byte keys[] = getRedisMasterSerializer().serialize(key);
                byte values[] = getRedisMasterSerializer().serialize(value);
                return redisConnection.setNX(keys,values);
            }
        });
    }
    /**
     * 字符串類型:設置key和value的超時時間(設置成String返回類型,否則要設置成Void)
     * @param key
     * @param timeout
     * @param value
     * @return
     */
    @Override
    public Void setex(final String key,final Long timeout,final String value) {
        return redisMasterTemplate.execute(new RedisCallback<Void>() {
            @Override
            public Void doInRedis(RedisConnection redisConnection) throws DataAccessException {
                byte keys[] = getRedisMasterSerializer().serialize(key);
                byte values[] = getRedisMasterSerializer().serialize(value);
                redisConnection.setEx(keys,timeout,values);
                return null;
            }
        });
    }
    /**
     * 字符串類型:
     * 覆蓋key對應的string的一部分，從指定的offset開始，覆蓋value的長度。
     * 若是offset比當前key對應string還長，那麼這個string後面就補0以達到offset。
     * 不存在的keys被認爲是空字符串，因此這個命令能夠確保key有一個足夠大的字符串，能在offset處設置value。
     * @param key
     * @param value
     * @param offset
     * @return
     */
    @Override
    public Void setrange(final String key,final String value, final Long offset) {
        return redisMasterTemplate.execute(new RedisCallback<Void>() {
            @Override
            public Void doInRedis(RedisConnection redisConnection) throws DataAccessException {
                byte keys[] = getRedisMasterSerializer().serialize(key);
                byte values[] = getRedisMasterSerializer().serialize(value);
                redisConnection.setRange(keys,values,offset);
                return null;
            }
        });
    }
    /**
     * 字符串類型:
     * 返回key對應的字符串value的子串，自個子串是由start和end位移決定的（二者都在string內）。
     * 能夠用負的位移來表示從string尾部開始數的下標。因此-1就是最後一個字符，-2就是倒數第二個，以此類推。
     * 這個函數超出範圍的請求時，都把結果限制在string內。
     * @param key
     * @param start
     * @param end
     * @return
     */
    @Override
    public byte[] getrange(final String key,final Long start,final Long end) {
        return redisMasterTemplate.execute(new RedisCallback<byte[]>() {
            @Override
            public byte[] doInRedis(RedisConnection redisConnection) throws DataAccessException {
                byte keys[] = getRedisMasterSerializer().serialize(key);
                return redisConnection.getRange(keys,start,end);
            }
        });
    }
    /**
     * 字符串類型:
     * 對存儲在指定key的數值執行原子的加1操做。
     * 若是指定的key不存在，那麼在執行incr操做以前，會先把它的值設定爲0.
     * 若是指定的key中存儲的值不是字符串類型或者存儲的字符串類型不能表示爲一個整數，那麼執行這個命令時服務器會返回一個錯誤。
     * 注意：因爲redis並無一個明確的類型來表示整型數據，因此這個操做是一個字符串操做。
     * 執行這個操做的時候，key對應存儲的字符串被解析爲10進制的64位有符號整型數據。
     * 這個操做僅限於64位的有符號整型數據。
     * 事實上，redis內部採用整數形式來存儲對應的整數值，因此對該類字符串值其實是用整數保存，也就不存在存儲整數的字符串表示所帶來的額外消耗。
     * incr的原子操做是說即便多個客戶端對同一個key發出incr命令，也決不會致使競爭的狀況，
     * 例如以下狀況永遠不可能發生：客戶端1和客戶端2同時讀出10，他們倆都對其加到11，而後將新值設置爲11，最終值必定爲12
     * @param key
     * @return
     */
    @Override
    public Long incr(final String key) {
        return redisMasterTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection redisConnection) throws DataAccessException {
                byte keys[] = getRedisMasterSerializer().serialize(key);
                return redisConnection.incr(keys);
            }
        });
    }
    /**
     * 字符串類型:
     * 對key對應的數字作減一操做。若是key不存在，那麼在操做以前，這個key對應的值會被設定爲0。
     * 若是key有一個錯誤類型的value或者是一個不能表示成數字的字符串，就返回錯誤。這個操做最大支持在64位有符號的整型數字。
     * @param key
     * @return
     */
    @Override
    public Long decr(final String key) {
        return redisMasterTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection redisConnection) throws DataAccessException {
                byte keys[] = getRedisMasterSerializer().serialize(key);
                return redisConnection.decr(keys);
            }
        });
    }
    /**
     * 字符串類型:
     * 將key進行遞增。若是key不存在，操做以前，key就會被置爲0.若是key的value類型錯誤或者是個不能表示成數字的字符串，就返回錯誤。
     * 這個操做最多支持64位有符號的×××數字。
     * @param key
     * @param offset
     * @return
     */
    @Override
    public Long incrby(final String key, final Long offset) {
        return redisMasterTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection redisConnection) throws DataAccessException {
                byte keys[] = getRedisMasterSerializer().serialize(key);
                return redisConnection.incrBy(keys,offset);
            }
        });
    }
    /**
     * 字符串類型:
     * 將key對應的數字遞減。若是key不存在，操做以前，key就會被置爲0.若是key的value類型錯誤或者是個不能表示成數字的字符串，就返回錯誤。
     * 這個操做最多支持64位有符號的×××數字。
     * @param key
     * @param offset
     * @return
     */
    @Override
    public Long decrby(final String key, final Long offset) {
        return redisMasterTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection redisConnection) throws DataAccessException {
                byte keys[] = getRedisMasterSerializer().serialize(key);
                return redisConnection.decrBy(keys,offset);
            }
        });
    }
    /**
     * 字符串類型:設置多個key和value
     * 對應給定的keys到他們對應的values上。Mset會用新的value替代已經存在的value，就像普通的set命令同樣。
     * 若是你不想覆蓋已經存在的values，那麼須要參考msetnx.
     * mset是原子性的，因此全部給定的keys是一次性set的。
     * 客戶端不可能看到這種一部分keys被更新而另外的沒有改變的狀況。
     * @param map
     * @return
     */
    @Override
    public Void mset(final Map<byte[],byte[]> map) {
        return redisMasterTemplate.execute(new RedisCallback<Void>() {
            @Override
            public Void doInRedis(RedisConnection redisConnection) throws DataAccessException {
                redisConnection.mSet(map);
                return null;
            }
        });
    }
    /**
     * 字符串類型:一次性獲取多個key對應的value列表
     * @param bytes
     * @return
     */
    @Override
    public List<byte[]> mget(final byte[]... bytes) {
        return redisSlaveTemplate.execute(new RedisCallback<List<byte[]>>() {
            @Override
            public List<byte[]> doInRedis(RedisConnection redisConnection) throws DataAccessException {
                return redisConnection.mGet(bytes);
            }
        });
    }
    /**
     * 字符串類型:
     * 對應給定的keys到他們相應的values上。只要有一個values已經存在，MSETNX一個操做都不會執行。
     * 因爲這種特性，MSETNX能夠實現要麼全部的操做都成功，
     * 要麼一個都不執行，這個能夠用來設置不一樣的key，來表示一個惟一的對象的不一樣字段。
     * MSETNX是原子的，因此全部給定的keys是一次性set的。客戶端不可能看到這種一部分keys被更新而另外的沒有改變的狀況。
     * @param map
     * @return
     */
    @Override
    public Boolean msetnx(final Map<byte[], byte[]> map) {
        return redisMasterTemplate.execute(new RedisCallback<Boolean>() {
            @Override
            public Boolean doInRedis(RedisConnection redisConnection) throws DataAccessException {
                return redisConnection.mSetNX(map);
            }
        });
    }
    /**
     * list列表類型:先進後出棧形式,單個值插入
     * @param key
     * @param value
     * @return
     */
    @Override
    public Long lpush(final String key,final String value) {
        return redisMasterTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection redisConnection) throws DataAccessException {
                byte keys[] = getRedisMasterSerializer().serialize(key);
                byte values[] = getRedisMasterSerializer().serialize(value);
                return redisConnection.lPush(keys,values);
            }
        });
    }
    /**
     * list列表類型:先進先出隊列形式,單個值插入
     * @param key
     * @param value
     * @return
     */
    @Override
    public Long rpush(final String key, final String value) {
        return redisMasterTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection redisConnection) throws DataAccessException {
                byte keys[] = getRedisMasterSerializer().serialize(key);
                byte values[] = getRedisMasterSerializer().serialize(value);
                return redisConnection.rPush(keys,values);
            }
        });
    }
    /**
     * list列表類型:
     * 返回存儲在key的列表裏指定範圍內的元素。Start和end偏移量都是基於0的下標，
     * 即list的第一個元素下標是0(list的開頭)，第二個元素是下標1，以此類推。
     * 偏移量也能夠是負數，表示偏移量是從list尾部開始計數。例如，-1表示列表的最後一個元素，-2是倒數第二個，以此類推。
     * @param key
     * @param start
     * @param end
     * @return
     */
    @Override
    public List<byte[]> lrange(final String key, final Long start, final Long end) {
        return redisMasterTemplate.execute(new RedisCallback<List<byte[]>>() {
            @Override
            public List<byte[]> doInRedis(RedisConnection redisConnection) throws DataAccessException {
                byte keys[] = getRedisMasterSerializer().serialize(key);
                return redisConnection.lRange(keys,start,end);
            }
        });
    }
    /**
     * list列表類型:返回名稱爲key的list中index位置的元素
     * @param key
     * @param offset
     * @return
     */
    @Override
    public byte[] lindex(final String key, final Long offset) {
        return redisSlaveTemplate.execute(new RedisCallback<byte[]>() {
            @Override
            public byte[] doInRedis(RedisConnection redisConnection) throws DataAccessException {
                byte keys[] = getRedisSlaveSerializer().serialize(key);
                return redisConnection.lIndex(keys,offset);
            }
        });
    }
    /**
     * list列表類型:返回list中的元素個數
     * @param key
     * @return
     */
    @Override
    public Long llen(final String key) {
        return redisSlaveTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection redisConnection) throws DataAccessException {
                byte keys[] = getRedisSlaveSerializer().serialize(key);
                return redisConnection.lLen(keys);
            }
        });
    }
    /**
     * set無序集合類型:
     * 添加一個或多個指定的member元素到集合的key中
     * @param key
     * @param bytes
     * @return
     */
    @Override
    public Long sadd(final String key, final byte[]... bytes) {
        return redisMasterTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection redisConnection) throws DataAccessException {
                byte keys[] = getRedisMasterSerializer().serialize(key);
                return redisConnection.sAdd(keys,bytes);
            }
        });
    }
    /**
     * set無序集合類型:
     * 返回key集合全部的元素
     * @param key
     * @return
     */
    @Override
    public Set<byte[]> smembers(final String key) {
        return redisSlaveTemplate.execute(new RedisCallback<Set<byte[]>>() {
            @Override
            public Set<byte[]> doInRedis(RedisConnection redisConnection) throws DataAccessException {
                byte keys[] = getRedisSlaveSerializer().serialize(key);
                return redisConnection.sMembers(keys);
            }
        });
    }
    /**
     * set無序集合類型:刪除key中的指定元素
     * @param key
     * @param bytes
     * @return
     */
    @Override
    public Long srem(final String key, final byte[]... bytes) {
        return redisMasterTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection redisConnection) throws DataAccessException {
                byte keys[] = getRedisMasterSerializer().serialize(key);
                return redisConnection.sRem(keys,bytes);
            }
        });
    }
    /**
     * set無序集合類型:
     * 返回指定的全部集合的成員的交集。若是key不存在則被認爲是一個空的集合，當給定的集合爲空的時候，結果也爲空(一個集合爲空，結果一直爲空)
     * @param bytes
     * @return
     */
    @Override
    public Set<byte[]> sinter(final byte[]... bytes) {
        return redisMasterTemplate.execute(new RedisCallback<Set<byte[]>>() {
            @Override
            public Set<byte[]> doInRedis(RedisConnection redisConnection) throws DataAccessException {
                return redisConnection.sInter(bytes);
            }
        });
    }
    /**
     * set無序集合類型:
     * 把兩個集合的交集結果集結果保存到一個新的集合中。若是這個新的集合是已經存在的，那麼這個新的集合則會被重寫。
     * 返回值爲結果集中成員的個數。
     * @param key
     * @param bytes
     * @return
     */
    @Override
    public Long sinterstore(final String key, final byte[]... bytes) {
        return redisMasterTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection redisConnection) throws DataAccessException {
                byte keys[] = getRedisMasterSerializer().serialize(key);
                return redisConnection.sInterStore(keys,bytes);
            }
        });
    }
    /**
     * set無序集合類型:
     * 返回給定的多個集合的並集中的全部成員，不存在的key能夠認爲是空的集合。
     * 返回值爲並集的成員列表。
     * @param bytes
     * @return
     */
    @Override
    public Set<byte[]> sunion(final byte[]... bytes) {
        return redisMasterTemplate.execute(new RedisCallback<Set<byte[]>>() {
            @Override
            public Set<byte[]> doInRedis(RedisConnection redisConnection) throws DataAccessException {
                return redisConnection.sUnion(bytes);
            }
        });
    }
    /**
     * set無序集合類型:
     * 將集合結果並集存儲在新的集合中，若是新的集合已經存在，那麼會覆蓋這個新的集合。
     * 返回值爲結果集中元素的個數。
     * @param key
     * @param bytes
     * @return
     */
    @Override
    public Long sunionstore(final String key, final byte[]... bytes) {
        return redisMasterTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection redisConnection) throws DataAccessException {
                byte keys[] = getRedisMasterSerializer().serialize(key);
                return redisConnection.sUnionStore(keys,bytes);
            }
        });
    }
    /**
     * set無序集合類型:
     * @param key1    被移除的集合
     * @param key2    接收移除元素的集合
     * @param field   要移除的元素
     * @return
     */
    @Override
    public Boolean smove(final String key1, final String key2, final String field) {
        return redisMasterTemplate.execute(new RedisCallback<Boolean>() {
            @Override
            public Boolean doInRedis(RedisConnection redisConnection) throws DataAccessException {
                return redisConnection.sMove(
                        getRedisMasterSerializer().serialize(key1),
                        getRedisMasterSerializer().serialize(key2),
                        getRedisMasterSerializer().serialize(field)
                );
            }
        });
    }
    /**
     * set無序集合類型:返回集合中的元素個數
     * @param key
     * @return
     */
    @Override
    public Long scard(final String key) {
        return redisSlaveTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection redisConnection) throws DataAccessException {
                byte[] keys = getRedisSlaveSerializer().serialize(key);
                return redisConnection.sCard(keys);
            }
        });
    }
    /**
     * set無序集合類型:判斷bytes2是不是bytes1中的元素
     * @param key
     * @param value
     * @return
     */
    @Override
    public Boolean sismember(final String key, final String value) {
        return redisSlaveTemplate.execute(new RedisCallback<Boolean>() {
            @Override
            public Boolean doInRedis(RedisConnection redisConnection) throws DataAccessException {
                return redisConnection.sIsMember(
                        getRedisSlaveSerializer().serialize(key),
                        getRedisSlaveSerializer().serialize(value)
                );
            }
        });
    }
    /**
     * zset有序集合類型:
     * @param     key
     * @param offset    分數值是一個雙精度的浮點型數字字符串
     * @param bytes2    value
     * @return
     */
    @Override
    public Boolean zadd(final String key, final Double offset, final byte[] bytes2) {
        return redisMasterTemplate.execute(new RedisCallback<Boolean>() {
            @Override
            public Boolean doInRedis(RedisConnection redisConnection) throws DataAccessException {
                return redisConnection.zAdd(getRedisMasterSerializer().serialize(key),offset,bytes2);
            }
        });
    }
    /**
     * zset有序集合類型:根據集合中指定的index返回成員列表
     * @param key
     * @param start
     * @param end
     * @return
     */
    @Override
    public Set<byte[]> zrange(final String key, final Long start, final Long end) {
        return redisSlaveTemplate.execute(new RedisCallback<Set<byte[]>>() {
            @Override
            public Set<byte[]> doInRedis(RedisConnection redisConnection) throws DataAccessException {
                return redisConnection.zRange(getRedisSlaveSerializer().serialize(key),start,end);
            }
        });
    }
    /**
     * zset有序集合類型:
     * 從排序的集合中刪除一個或多個成員
     * 返回值爲從有序集合中刪除的成員個數，不包括不存在的成員
     * @param key
     * @param bytes
     * @return
     */
    @Override
    public Long zrem(final String key, final byte[]... bytes) {
        return redisMasterTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection redisConnection) throws DataAccessException {
                byte[] keys = getRedisSlaveSerializer().serialize(key);
                return redisConnection.zRem(keys,bytes);
            }
        });
    }
    /**
     * zset有序集合類型:爲有序集key的成員member的offset值加上增量increment
     * @param key    key
     * @param offset    增量increment
     * @param field    集合成員
     * @return  member成員的新offset值
     */
    @Override
    public Double zincrby(final String key, final Double offset, final String field) {
        return redisMasterTemplate.execute(new RedisCallback<Double>() {
            @Override
            public Double doInRedis(RedisConnection redisConnection) throws DataAccessException {
                return redisConnection.zIncrBy(
                        getRedisMasterSerializer().serialize(key),
                        offset,
                        getRedisMasterSerializer().serialize(field));
            }
        });
    }
    /**
     * zset有序集合類型:找到指定區間範圍的數據進行返回
     * @param key
     * @param start
     * @param end
     * @return
     */
    @Override
    public Set<byte[]> zrangebyscore(final String key, final Double start, final Double end) {
        return redisSlaveTemplate.execute(new RedisCallback<Set<byte[]>>() {
            @Override
            public Set<byte[]> doInRedis(RedisConnection redisConnection) throws DataAccessException {
                return redisConnection.zRangeByScore(getRedisSlaveSerializer().serialize(key),start,end);
            }
        });
    }
    /**
     * zset有序集合類型:移除有序集key中，指定排名(rank)區間內的全部成員。
     * @param key
     * @param start
     * @param end
     * @return
     */
    @Override
    public Long zremrangebyrank(final String key, final Double start, final Double end) {
        return redisMasterTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection redisConnection) throws DataAccessException {
                byte[] keys = getRedisMasterSerializer().serialize(key);
                return redisConnection.zRemRangeByScore(keys,start,end);
            }
        });
    }
    /**
     * zset有序集合類型:返回有序集key中，score值在min和max之間(默認包括score值等於min或max)的成員。
     * @param key
     * @param start
     * @param end
     * @return
     */
    @Override
    public Long zcount(final String key, final Double start, final Double end) {
        return redisSlaveTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection redisConnection) throws DataAccessException {
                byte[] keys = getRedisSlaveSerializer().serialize(key);
                return redisConnection.zCount(keys,start,end);
            }
        });
    }
    /**
     * hash類型:
     * 設置 key 指定的哈希集中指定字段的值
     * 若是 key 指定的哈希集不存在，會建立一個新的哈希集並與 key 關聯
     * 若是字段在哈希集中存在，它將被重寫
     * @param     key
     * @param     field
     * @param     value
     * @return
     */
    @Override
    public Boolean hset(final String key, final String field, final String value) {
        return redisMasterTemplate.execute(new RedisCallback<Boolean>() {
            @Override
            public Boolean doInRedis(RedisConnection redisConnection) throws DataAccessException {
                return redisConnection.hSet(
                        getRedisMasterSerializer().serialize(key),
                        getRedisMasterSerializer().serialize(field),
                        getRedisMasterSerializer().serialize(value)
                );
            }
        });
    }
    /**
     * hash類型:返回 key 指定的哈希集中該字段所關聯的值
     * @param    key
     * @param    field
     * @return
     */
    @Override
    public byte[] hget(final String key, final String field) {
        return redisSlaveTemplate.execute(new RedisCallback<byte[]>() {
            @Override
            public byte[] doInRedis(RedisConnection redisConnection) throws DataAccessException {
                return redisConnection.hGet(getRedisSlaveSerializer().serialize(key),
                        getRedisSlaveSerializer().serialize(field));
            }
        });
    }
    /**
     * hash類型:返回 key 指定的哈希集中全部字段的名字
     * @param key
     * @return
     */
    @Override
    public Set<byte[]> hkeys(final String key) {
        return redisSlaveTemplate.execute(new RedisCallback<Set<byte[]>>() {
            @Override
            public Set<byte[]> doInRedis(RedisConnection redisConnection) throws DataAccessException {
                return redisConnection.hKeys(getRedisSlaveSerializer().serialize(key));
            }
        });
    }
    /**
     * hash類型:從 key 指定的哈希集中移除指定的域。
     * @param key
     * @param fields
     * @return
     */
    @Override
    public Long hdel(final String key, final byte[]... fields) {
        return redisMasterTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection redisConnection) throws DataAccessException {
                return redisConnection.hDel(getRedisMasterSerializer().serialize(key),fields);
            }
        });
    }
    /**
     * hash類型:返回 key 指定的哈希集包含的字段的數量
     * @param key
     * @return
     */
    @Override
    public Long hlen(final String key) {
        return redisSlaveTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection redisConnection) throws DataAccessException {
                return redisConnection.hLen(getRedisSlaveSerializer().serialize(key));
            }
        });
    }
    /**
     * hash類型:可同時對key設置多個值，hset只能一次設置一個
     * @param key
     * @param map
     * @return
     */
    @Override
    public Void hmset(final String key, final Map<byte[], byte[]> map) {
        return redisMasterTemplate.execute(new RedisCallback<Void>() {
            @Override
            public Void doInRedis(RedisConnection redisConnection) throws DataAccessException {
                redisConnection.hMSet(getRedisMasterSerializer().serialize(key),map);
                return null;
            }
        });
    }
    /**
     * hash類型:返回 key 指定的哈希集中指定多個字段的值。
     * @param key
     * @param fields
     * @return
     */
    @Override
    public List<byte[]> hmget(final String key, final byte[]... fields) {
        return redisSlaveTemplate.execute(new RedisCallback<List<byte[]>>() {
            @Override
            public List<byte[]> doInRedis(RedisConnection redisConnection) throws DataAccessException {
                return redisConnection.hMGet(getRedisSlaveSerializer().serialize(key),fields);
            }
        });
    }
    /**
     * hash類型:
     * 增長 key 指定的哈希集中指定字段的數值。
     * 若是 key 不存在，會建立一個新的哈希集並與 key 關聯。若是字段不存在，則字段的值在該操做執行前被設置爲 0
     * HINCRBY 支持的值的範圍限定在 64位 有符號整數
     * @param key
     * @param field
     * @param val
     * @return
     */
    @Override
    public Double hincrby(final String key, final String field, final Double val) {
        return redisMasterTemplate.execute(new RedisCallback<Double>() {
            @Override
            public Double doInRedis(RedisConnection redisConnection) throws DataAccessException {
                return redisConnection.hIncrBy(
                        getRedisMasterSerializer().serialize(key),
                        getRedisMasterSerializer().serialize(field),
                        val
                );
            }
        });
    }
    /**
     * hash類型:返回hash裏面key是否存在的標誌
     * @param key
     * @param field
     * @return
     */
    @Override
    public Boolean hexists(final String key, final String field) {
        return redisSlaveTemplate.execute(new RedisCallback<Boolean>() {
            @Override
            public Boolean doInRedis(RedisConnection redisConnection) throws DataAccessException {
                return redisConnection.hExists(
                        getRedisSlaveSerializer().serialize(key),
                        getRedisSlaveSerializer().serialize(field)
                );
            }
        });
    }
    /**
     * hash類型:返回 key 指定的哈希集中全部字段的值。
     * @param key
     * @return
     */
    @Override
    public List<byte[]> hvals(final String key) {
        return redisSlaveTemplate.execute(new RedisCallback<List<byte[]>>() {
            @Override
            public List<byte[]> doInRedis(RedisConnection redisConnection) throws DataAccessException {
                return redisConnection.hVals(getRedisSlaveSerializer().serialize(key));
            }
        });
    }
    /**
     * hash類型:
     * 只在 key 指定的哈希集中不存在指定的字段時，設置字段的值。
     * 若是 key 指定的哈希集不存在，會建立一個新的哈希集並與 key 關聯。
     * 若是字段已存在，該操做無效果。
     * @param key
     * @param field
     * @param value
     * @return
     */
    @Override
    public Boolean hsetnx(final String key, final String field, final String value) {
        return redisMasterTemplate.execute(new RedisCallback<Boolean>() {
            @Override
            public Boolean doInRedis(RedisConnection redisConnection) throws DataAccessException {
                return redisConnection.hSetNX(getRedisMasterSerializer().serialize(key),
                        getRedisMasterSerializer().serialize(field),
                        getRedisMasterSerializer().serialize(value));
            }
        });
    }
    /**
     * hash類型:
     * 返回 key 指定的哈希集中全部的字段和值。返回值中，每一個字段名的下一個是它的值，因此返回值的長度是哈希集大小的兩倍
     * @param key
     * @return
     */
    @Override
    public Map<byte[], byte[]> hgetall(final String key) {
        return redisSlaveTemplate.execute(new RedisCallback<Map<byte[], byte[]>>() {
            @Override
            public Map<byte[], byte[]> doInRedis(RedisConnection redisConnection) throws DataAccessException {
                return redisConnection.hGetAll(getRedisSlaveSerializer().serialize(key));
            }
        });
    }
    /**
     * 獲取主庫的redis模板
     * @return
     */
    protected RedisTemplate<String, Object> getRedisMasterTemplate() {
        return redisMasterTemplate;
    }
    /**
     * 獲取從庫的redis模板
     * @return
     */
    protected RedisTemplate<String, Object> getRedisSlaveTemplate() {
        return redisSlaveTemplate;
    }
    /**
     * 獲取主庫的字符串序列化對象
     * @return
     */
    protected RedisSerializer<String> getRedisMasterSerializer() {
        RedisSerializer<String> redisSerializer = getRedisMasterTemplate().getStringSerializer();
        return redisSerializer;
    }
    /**
     * 獲取從庫的字符串序列化對象
     * @return
     */
    protected RedisSerializer<String> getRedisSlaveSerializer() {
        RedisSerializer<String> redisSerializer = getRedisSlaveTemplate().getStringSerializer();
        return redisSerializer;
    }
}
像上面的Map<byte[],byte[]>等一些相關數據類型的轉換，能夠手工注入一個bean來進行調用處理。服務器