redis的安裝和使用

Redis
Redis命令參考網址：http://doc.redisfans.com/

Redis 簡介
Redis 是完全開源免費的，遵守BSD協議，是一個高性能的key-value數據庫。
Redis 與其他 key - value 緩存產品有以下三個特點：

Redis支持數據的持久化，可以將內存中的數據保存在磁盤中，重啓的時候可以再次加載進行使用。
Redis不僅僅支持簡單的key-value類型的數據，同時還提供list，set，zset，hash等數據結構的存儲。
Redis支持數據的備份，即master-slave模式的數據備份。
2.Redis安裝
1）Window 下安裝
64位下載地址：https://github.com/MSOpenTech/redis/releases。
32位下載地址：http://vdisk.weibo.com/s/dbUhxKrgqodB
（如果使用32位，請採用單機模式）
Redis 支持 32 位和 64 位。這個需要根據你係統平臺的實際情況選擇，這裏我們下載 Redis-x64-xxx.zip壓縮包到 C 盤，解壓後，將文件夾重新命名爲 redis。

圖片.png

下載解壓，在解壓後的目錄下有以下這些文件

圖片.png

打開一個 cmd 窗口使用cd命令切換目錄到 C:\redis 運行 redis-server.exe redis.windows.conf 。
如果想方便的話，可以把 redis 的路徑加到系統的環境變量裏，這樣就省得再輸路徑了，後面的那個 redis.windows.conf 可以省略，如果省略，會啓用默認的。輸入之後，會顯示如下界面：

圖片.png

這時候另啓一個cmd窗口，原來的不要關閉，不然就無法訪問服務端了。
切換到redis目錄下運行 redis-cli.exe -h <ip> -p <端口(默認6379)>
例如：redis-cli.exe -h 127.0.0.1 -p 6379。
設置鍵值對 set myKey abc
取出鍵值對 get myKey

圖片.png

2）Linux 下安裝
下載地址：http://redis.io/download，下載最新文檔版本。

$ wget http://download.redis.io/releases/redis-2.8.17.tar.gz
$ tar xzf redis-2.8.17.tar.gz
$ cd redis-2.8.17
$ make

make完後 redis-2.8.17目錄下會出現編譯後的redis服務程序redis-server,還有用於測試的客戶端程序redis-cli,兩個程序位於安裝目錄 src 目錄下：
下面啓動redis服務.

$ cd src
$ ./redis-server

注意這種方式啓動redis 使用的是默認配置。也可以通過啓動參數告訴redis使用指定配置文件使用下面命令啓動。

$ cd src
$ ./redis-server redis.conf

redis.conf是一個默認的配置文件。我們可以根據需要使用自己的配置文件。
啓動redis服務進程後，就可以使用測試客戶端程序redis-cli和redis服務交互了。比如：

$ cd src
$ ./redis-cli
redis> set foo bar
OK
redis> get foo
"bar"

3）window下redis集羣搭建
ruby環境準備
下載 64位的 RubyInstaller並安裝地址http://rubyinstaller.org/downloads/
勾選下面三個不用配置環境變量

圖片.png

安裝RubyGems
下載下來是一個壓縮包，解壓運行裏面的 setup.rb 安裝 rubyGems
由於牆的原因ruby自帶的源有時候很慢，我們換成淘寶的源，不然下面安裝redis依賴會失敗＼（－－）／
在cmd下運行
gem sources --remove https://rubygems.org/ 刪掉原來的源
gem sources -a http://ruby.taobao.org 添加淘寶源(如果添加失敗，試試https://ruby.taobao.org或http://gems.ruby-china.org)
gem sources -l 查看現有的源
gem install redis 安裝redis依賴
二、使用redis cluster
按照文檔的說明步驟來做就行了，詳情在這http://doc.redisfans.com/topic/cluster-tutorial.html#id5
要讓集羣正常運作至少需要三個主節點，因此我們創建6個節點，三個主節點三個從節點，詳細請查看文檔，我簡化一下文檔的步驟即：
1.創建 6個文件夾分別爲 7000-7005
這裏就是做集羣時各個機器所安裝的redis，在每個文件夾放一份下載下來的redis，例如

圖片.png

2.創建配置文件 redis.conf
其他幾個7000-7004文件夾以此類推，注意修改對應的端口號
bind <ip> 例：192.168.1.202
port 7005
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes
文件中的
cluster-enabled 選項用於開實例的集羣模式，
cluster-conf-file 選項則設定了保存節點配置文件的路徑，默認值爲nodes.conf 。
nodes.conf 節點配置文件無須人爲修改，它由 Redis 集羣在啓動時創建，並在有需要時自動進行更新。
3.創建啓動腳本7005.bat
這樣不用總是敲命令 ,名字隨意改，其他幾個文件夾同理
@echo off
redis-server.exe redis.conf
@pause
4.創建集羣
1.按照上面所說的配置好各個實例，主要是改端口號，運行 7000.bat- 7005.bat腳本啓動六個redis實例
2.cd到 redis-trib.rb 所在的目錄下運行命令
redis-trib.rb create --replicas 1 <ip>:<端口> <ip>:<端口> <ip>:<端口>…
例：redis-trib.rb create --replicas 1 127.0.0.1:7000 127.0.0.1:7001 127.0.0.1:7002 127.0.0.1:7003 127.0.0.1:7004 127.0.0.1:7005

圖片.png

打印出配置信息，現在的master是 7000 7001 7002這三臺機，redis會對key 做 CRC16 校驗和後分別存儲這三臺機上。沒問題就輸入yes
5、查看配置的集羣的信息
查看集羣的配置信息可執行以下命令：
redis-cli.exe -c -h 127.0.0.1 -p 7003 cluster nodes
連接任意一臺Redis集羣節點即可，會看到以下信息就是成功了：

E:\redis-3.0.501>redis-cli.exe -c -h 127.0.0.1 -p 7002 cluster nodes
aa618ef5e865851d33b71d18eb709766fc18a277 127.0.0.1:7005 slave f673e19b77818c431e61dfb6eb5f3ba321e661c8 0 1468662482348 5 connected
9d9e45376bfc47f816734dadd7f0668f5c713470 127.0.0.1:7003 master - 0 14686624793233 connected 10923-16383
f673e19b77818c431e61dfb6eb5f3ba321e661c8 127.0.0.1:7002 myself,master - 0 0 2 connected 5461-10922
60c544fe2f6e6ea11dfeacd3c778c586bc977b1f 127.0.0.1:7001 master - 0 14686624813441 connected 0-5460
e27dae6b7bac30c7795d3f198ba2324c0c1fa65b 127.0.0.1:7006 slave 9d9e45376bfc47f816734dadd7f0668f5c713470 0 1468662477240 6 connected
773c908e6312b21d938e1185e1cb30dd8b9d9823 127.0.0.1:7004 slave 60c544fe2f6e6ea11dfeacd3c778c586bc977b1f 0 1468662476511 4 connected

6、動態的向集羣是添加一個節點
redis-trib.rb add-node 127.0.0.1:7008（要添加的節點） 127.0.0.1:7002（任意一臺正在運行的節點）

3.springMVC集成redis
依賴jar包：

圖片.png

，

圖片.png

spring-redis.xml

<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">

<property name="maxTotal" value="${redis.maxTotal}" />

<property name="maxIdle" value="${redis.maxIdle}" />

<property name="numTestsPerEvictionRun"value="${redis.numTestsPerEvictionRun}"/>

<property name="timeBetweenEvictionRunsMillis" value="${redis.timeBetweenEvictionRunsMillis}" />

<property name="minEvictableIdleTimeMillis" value="${redis.minEvictableIdleTimeMillis}" />

<property name="softMinEvictableIdleTimeMillis" value="${redis.softMinEvictableIdleTimeMillis}" />

<property name="maxWaitMillis" value="${redis.maxWaitMillis}" />

<property name="testOnBorrow" value="true" />

<property name="testWhileIdle" value="true" />

<property name="blockWhenExhausted" value="false" />
</bean>

<bean id="redisClient" class="redis.clients.jedis.JedisPool">
<constructor-arg name="host" value="${redis.host}"></constructor-arg>
<constructor-arg name="port" value="${redis.port}"></constructor-arg>
<constructor-arg name="poolConfig" ref="jedisPoolConfig"></constructor-arg>
</bean>

圖片.png

RedisModel實體類
package com.sinog2c.model.redis;

import java.io.Serializable;

public class RedisModel implements Serializable {

/**
 * 
 */
private static final long serialVersionUID = -6762060250356126904L;
public static final String OBJECT_KEY = "USER";

private String key;
private Object obj;
private Integer seconds;//過期時間(單位：毫秒)

public RedisModel(){}

public RedisModel(String key, Object obj){
    this.key = key;
    this.obj = obj;
}

public RedisModel(String key, Object obj, Integer seconds){
    this.key = key;
    this.obj = obj;
    this.seconds = seconds;
}

public String getKey() {
    return key;
}
public void setKey(String key) {
    this.key = key;
}
public Object getObj() {
    return obj;
}
public void setObj(Object obj) {
    this.obj = obj;
}
public Integer getSeconds() {
    return seconds;
}
public void setSeconds(Integer seconds) {
    this.seconds = seconds;
}

public String getObjectKey() {
return OBJECT_KEY;
}
}

Service層
JedisClientService.java
package com.sinog2c.service.api.redis;

import com.sinog2c.model.redis.RedisModel;

public interface JedisClientService {
/**
* 往redis緩存中添加數據(Key-Value)
* @param redis
* @return
/
String set(RedisModel redis);
/*
* 往redis緩存中添加數據(hash)
* @param redis
* @return
/
long hset(RedisModel redis);
/*
* 從redis緩存中獲取數據(Key-Value)
* @param key
* @return
/
Object get(String key);
/*
* 從redis緩存中獲取數據(hash)
* @param redis
* @return
/
public Object hget(RedisModel redis);
/*
* 從redis緩存中刪除數據
* @param key
* @return
/
long del(String key);
/*
* 從redis緩存中刪除數據(hash)
* @param key
* @return
/
long hdel(RedisModel redis);
/*
* 設置key的過期時間
* @param key
* @param second
* @return
/
long expire(String key, int second);
/*
* 確認一個key是否存在
* @param key
* @return
/
Boolean exists(String key);
/*
* 確認map中key是否存在
* @param key
* @return
/
Boolean hexists(RedisModel redis);
/*
* 刪除當前DB數據
* @return
/
String flushDB();
/*
* 清空所以數據
* @return
/
String flushAll();
/*
* 對名稱爲key的string增加操作（RedisModel中obj值爲long類型）
* @param redis
* @return
/
long incrBy(RedisModel redis);
/*
* 對名稱爲key的string減少操作（RedisModel中obj值爲long類型）
* @param redis
* @return
/
long decrBy(RedisModel redis);
/*
* 在名稱爲key的list尾添加一個值爲value的元素
* @param redis
* @return
/
long rpush(RedisModel redis);
/*
* 在名稱爲key的list頭添加一個值爲value的元素
* @param redis
* @return
/
long lpush(RedisModel redis);
/*
* 查找名稱爲key的list的長度
* @param key
* @return
/
long llen(String key);
/*
* 查找名稱爲key的list中start至end之間的元素
* @param key
* @param start
* @param end
* @return
/
Object lrange(String key, long start, long end);
/*
* 截取名稱爲key的list
* @param key
* @param start
* @param end
* @return
*/
Object ltrim(String key, long start, long end);

}

單機版實現類（如果採用集羣版不用此實現類）
package com.sinog2c.service.impl.redis;

import java.util.ArrayList;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

import com.sinog2c.model.redis.RedisModel;
import com.sinog2c.service.api.redis.JedisClientService;
import com.sinog2c.util.common.redis.ObjectsTranscoder;

@Service("jedisClientSingleService")
public class JedisClientSingleServiceImpl implements JedisClientService {

@Autowired  
private JedisPool jedisPool;   
/**
 * 往redis緩存中添加數據
 */
@Override
public String set(RedisModel redis) {
    Jedis jedis = jedisPool.getResource();
    String string = "faile"; 
    try {
        if (redis != null) {
            String key = redis.getKey();
            Integer seconds = redis.getSeconds();
            string = jedis.set(key.getBytes(), ObjectsTranscoder.getInstance().serialize(redis.getObj()));
            if (seconds != null) {
                jedis.expire(key.getBytes(), seconds);
            }
        }
    } catch (Exception e) {

    } finally {
        jedis.close();
    }
    return string;
}
/**
 * 往redis緩存中添加數據(Hash)
 */

@Override
public long hset(RedisModel redis){
    Jedis jedis = jedisPool.getResource();
    long flag = 0; 
    try {
        if (redis != null) {
            String key = redis.getKey();
            Integer seconds = redis.getSeconds();
            flag = jedis.hset(redis.getObjectKey().getBytes(),key.getBytes(), ObjectsTranscoder.getInstance().serialize(redis.getObj()));
            if (seconds != null) {
                jedis.expire(key.getBytes(), seconds);
            }
        }
    } catch (Exception e) {

    } finally {
        jedis.close();
    }
    return flag;
}

/**
 * 從redis緩存中獲取數據
 */
@Override
public Object get(String key) {
    Jedis jedis = jedisPool.getResource(); 
    try {
        if(key != null && !"".equals(key)){
            byte[] bytes = jedis.get(key.getBytes());
            return ObjectsTranscoder.getInstance().deserialize(bytes);
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        jedis.close();
    }
    return null;
} 
/**
 * 從redis緩存中獲取數據(hash)
 */
@Override
public Object hget(RedisModel redis) {
    Jedis jedis = jedisPool.getResource(); 
    try {
        String key = redis.getKey();
        if(key != null && !"".equals(key)){
            byte[] bytes = jedis.hget(redis.getObjectKey().getBytes(),key.getBytes());
            return ObjectsTranscoder.getInstance().deserialize(bytes);
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        jedis.close();
    }
    return null;
}
/**
 * 從redis緩存中刪除數據
 */
@Override  
public long del(String key) {
    if(key != null && !"".equals(key)){
        Jedis jedis = jedisPool.getResource();  
        Long result = jedis.del(key.getBytes());  
        jedis.close();  
        return result;  
    }
    return 0;
}
/**
 * 從redis緩存中刪除數據
 */
@Override  
public long hdel(RedisModel redis) {
    if(redis != null){
        String key = redis.getKey(); 
        if(key != null && !"".equals(key)){
            Jedis jedis = jedisPool.getResource();  
            Long result = jedis.hdel(key.getBytes());  
            jedis.close();  
            return result; 
        } 
    }
    return 0;
}

/**
 * 設置key的過期時間
 */
@Override  
public long expire(String key, int second) {
    if(key != null && !"".equals(key)){
        Jedis jedis = jedisPool.getResource();  
        Long result = jedis.expire(key.getBytes(), second);  
        jedis.close();  
        return result;  
    }
    return 0;
}
/**
 * 對名稱爲key的string增加操作（RedisModel中obj值爲long類型）
 */
@Override  
public long incrBy(RedisModel redis) {  
    if(redis != null){
        Jedis jedis = jedisPool.getResource(); 
        long result = jedis.incrBy(redis.getKey().getBytes(), Long.parseLong(redis.getObj()+""));
        jedis.close();  
        return result; 
    }  
    return 0;  
}
/**
 * 對名稱爲key的string減少操作（RedisModel中obj值爲long類型）
 */
@Override
public long decrBy(RedisModel redis) {
    if(redis != null){
        Jedis jedis = jedisPool.getResource();
        long result = jedis.decrBy(redis.getKey().getBytes(), Long.parseLong(redis.getObj()+""));
        jedis.close();
        return result;
    }
    return 0;
}
/**
 * 在名稱爲key的list尾添加一個值爲value的元素
 */
@Override
public long rpush(RedisModel redis) {
    if(redis != null){
        Jedis jedis = jedisPool.getResource(); 
        long result = jedis.rpush(redis.getKey().getBytes(), ObjectsTranscoder.getInstance().serialize(redis.getObj()));
        jedis.close();
        return result;
    }
    return 0;
}
/**
 * 在名稱爲key的list頭添加一個值爲value的元素
 */
@Override
public long lpush(RedisModel redis) {
    if(redis != null){
        Jedis jedis = jedisPool.getResource();
        long result = jedis.lpush(redis.getKey().getBytes(), ObjectsTranscoder.getInstance().serialize(redis.getObj()));
        jedis.close();
        return result;
    }
    return 0;
}
/**
 * 查找名稱爲key的list的長度
 */
@Override
public long llen(String key) {
    if(key != null && !"".equals(key)){
        Jedis jedis = jedisPool.getResource(); 
        long result =  jedis.llen(key.getBytes());
        jedis.close();
        return result;
    }
    return 0;
}
/**
 * 查找名稱爲key的list中start至end之間的元素
 */
@Override
public Object lrange(String key, long start, long end) {
    if(key != null && !"".equals(key)){
        Jedis jedis = jedisPool.getResource(); 
        List<byte[]> list = jedis.lrange(key.getBytes(), start, end);
        jedis.close();
        return listByteArrayToObject(list);
    } 
    return null;

}
/**
 * 截取名稱爲key的list
 */
@Override
public Object ltrim(String key, long start, long end) {
    if(key != null && !"".equals(key)){
        Jedis jedis = jedisPool.getResource(); 
        String result = jedis.ltrim(key.getBytes(), start, end);
        jedis.close();
        return result;
    }
    return null;
}
/**
 * 確認一個key是否存在
 * @param key
 * @return
 */
@Override
public Boolean exists(String key) {
    Jedis jedis = jedisPool.getResource();
    Boolean flag = jedis.exists(key);
    jedis.close();
    return flag;
}
/**
 * 確認map中key是否存在
 * @param key
 * @return
 */
@Override
public Boolean hexists(RedisModel redis) {
    Boolean flag = false;
    if(redis != null){
        String key = redis.getKey();
        if(key != null && !"".equals(key)){
            Jedis jedis = jedisPool.getResource();
            flag = jedis.hexists(redis.getObjectKey().getBytes(), key.getBytes());
            jedis.close();
        }
    }

    return flag;
}
/**
 * 刪除當前DB數據
 * @return
 */
@Override 
public String flushDB(){
    Jedis jedis = jedisPool.getResource();  
    String result = jedis.flushDB();  
    jedis.close();  
    return result; 
}
/**
 * 清空所以數據
 * @return
 */
@Override 
public String flushAll(){
    Jedis jedis = jedisPool.getResource();  
    String result = jedis.flushAll();  
    jedis.close();  
    return result;
}
/**
 * 將List<byte[]>轉化爲List<Object>
 * @param list
 * @return
 */
private Object listByteArrayToObject(List<byte[]> list){
    List<Object> result = new ArrayList<Object>();
    if(list != null && list.size() > 0){
        for(int i=0; i<list.size(); i++){
            result.add(ObjectsTranscoder.getInstance().deserialize(list.get(i)));
        }
        return result;
    } else {
        return "";
    }
}

}
集羣實現類（單機版不用此時實現類）

package com.sinog2c.service.impl.redis;

import java.util.ArrayList;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisCluster;

import com.sinog2c.model.redis.RedisModel;
import com.sinog2c.service.api.redis.JedisClientService;
import com.sinog2c.util.common.redis.ObjectsTranscoder;
/**

類描述:集羣版實現
@author 許傑

*/
@Service("jedisClientClusterServcie")
public class JedisClientClusterServcieImpl implements JedisClientService {
@Autowired
private JedisCluster jedisCluster;

/**
 * 往redis緩存中添加數據(Key-Value)
 */
@Override
public String set(RedisModel redis) {
    String string = "faile"; 
    try {
        if (redis != null) {
            String key = redis.getKey();
            Integer seconds = redis.getSeconds();
            string = jedisCluster.set(key.getBytes(), ObjectsTranscoder.getInstance().serialize(redis.getObj()));
            if (seconds != null) {
                jedisCluster.expire(key.getBytes(), seconds);
            }
        }
    } catch (Exception e) {
        
    } 
    return string;
}

/**
 * 往redis緩存中添加數據(Hash)
 */
@Override
public long hset(RedisModel redis) {
    long log = 0; 
    try {
        if (redis != null) {
            String key = redis.getKey();
            Integer seconds = redis.getSeconds();
            log = jedisCluster.hset(redis.getObjectKey().getBytes(),key.getBytes(), ObjectsTranscoder.getInstance().serialize(redis.getObj()));
            if (seconds != null) {
                jedisCluster.expire(key.getBytes(), seconds);
            }
        }
    } catch (Exception e) {
        
    } 
    return log;
}
/**
 * 從redis緩存中獲取數據(Key-Value)
 */
@Override
public Object get(String key) {
    try {
        if(key != null && !"".equals(key)){
            byte[] bytes = jedisCluster.get(key.getBytes());
            return ObjectsTranscoder.getInstance().deserialize(bytes);
        }
    } catch (Exception e) {
        e.printStackTrace();
    } 
    return null;
} 

/**
 * 從redis緩存中獲取數據(hash)
 */
@Override
public Object hget(RedisModel redis) {
    try {
        if(redis != null){
            String key = redis.getKey();
            if(key != null && !"".equals(key)){
                byte[] bytes = jedisCluster.hget(redis.getObjectKey().getBytes(),key.getBytes());
                return ObjectsTranscoder.getInstance().deserialize(bytes);
            }
        }
        
    } catch (Exception e) {
        e.printStackTrace();
    } 
    return null;
} 
/**
 * 從redis緩存中刪除數據
 */
@Override  
public long del(String key) {
    if(key != null && !"".equals(key)){
        Long result = jedisCluster.del(key.getBytes());  
        return result;  
    }
    return 0;
}
/**
 * 從redis緩存中刪除數據(hash)
 * @param key
 * @return
 */
@Override
public long hdel(RedisModel redis) {
    if(redis != null){
        String key = redis.getKey();
        if(key != null && !"".equals(key)){
            Long result = jedisCluster.hdel(redis.getObjectKey().getBytes(), key.getBytes());  
            return result;  
        }
    }
    return 0;
}
/**
 * 設置key的過期時間
 */
@Override  
public long expire(String key, int second) {
    if(key != null && !"".equals(key)){
        Long result = jedisCluster.expire(key.getBytes(), second);  
        return result;  
    }
    return 0;
}
/**
 * 確認一個key是否存在
 * @param key
 * @return
 */
@Override
public Boolean exists(String key) {
    Boolean flag = jedisCluster.exists(key);
    return flag;
}
/**
 * 確認map中key是否存在
 * @param key
 * @return
 */
@Override
public Boolean hexists(RedisModel redis) {
    Boolean flag = false;
    if(redis != null){
        String key = redis.getKey();
        if(key != null && !"".equals(key)){
            flag = jedisCluster.hexists(redis.getObjectKey().getBytes(), key.getBytes());
        }
    }
    return flag;
}
/**
 * 刪除當前DB數據
 * @return
 */
@SuppressWarnings("deprecation")
@Override 
public String flushDB(){
    String result = jedisCluster.flushDB();  
    return result; 
}
/**
 * 清空所以數據
 * @return
 */
@SuppressWarnings("deprecation")
@Override 
public String flushAll(){
    String result = jedisCluster.flushAll();  
    return result;
}
/**
 * 對名稱爲key的string增加操作（RedisModel中obj值爲long類型）
 */
@Override  
public long incrBy(RedisModel redis) {  
    if(redis != null){
        long result = jedisCluster.incrBy(redis.getKey().getBytes(), Long.parseLong(redis.getObj()+""));
        return result; 
    }  
    return 0;  
}
/**
 * 對名稱爲key的string減少操作（RedisModel中obj值爲long類型）
 */
@Override
public long decrBy(RedisModel redis) {
    if(redis != null){
        long result = jedisCluster.decrBy(redis.getKey().getBytes(), Long.parseLong(redis.getObj()+""));
        return result;
    }
    return 0;
}
/**
 * 在名稱爲key的list尾添加一個值爲value的元素
 */
@Override
public long rpush(RedisModel redis) {
    if(redis != null){
        long result = jedisCluster.rpush(redis.getKey().getBytes(), ObjectsTranscoder.getInstance().serialize(redis.getObj()));
        return result;
    }
    return 0;
}
/**
 * 在名稱爲key的list頭添加一個值爲value的元素
 */
@Override
public long lpush(RedisModel redis) {
    if(redis != null){
        long result = jedisCluster.lpush(redis.getKey().getBytes(), ObjectsTranscoder.getInstance().serialize(redis.getObj()));
        return result;
    }
    return 0;
}
/**
 * 查找名稱爲key的list的長度
 */
@Override
public long llen(String key) {
    if(key != null && !"".equals(key)){
        long result =  jedisCluster.llen(key.getBytes());
        return result;
    }
    return 0;
}
/**
 * 查找名稱爲key的list中start至end之間的元素
 */
@Override
public Object lrange(String key, long start, long end) {
    if(key != null && !"".equals(key)){
        List<byte[]> list = jedisCluster.lrange(key.getBytes(), start, end);
        return listByteArrayToObject(list);
    } 
    return null;
    
}
/**
 * 截取名稱爲key的list
 */
@Override
public Object ltrim(String key, long start, long end) {
    if(key != null && !"".equals(key)){
        String result = jedisCluster.ltrim(key.getBytes(), start, end);
        return result;
    }
    return null;
}
/**
 * 將List<byte[]>轉化爲List<Object>
 * @param list
 * @return
 */
private Object listByteArrayToObject(List<byte[]> list){
    List<Object> result = new ArrayList<Object>();
    if(list != null && list.size() > 0){
        for(int i=0; i<list.size(); i++){
            result.add(ObjectsTranscoder.getInstance().deserialize(list.get(i)));
        }
        return result;
    } else {
        return "";
    }
}

}

ObjectsTranscoder類(將對象序列化反序列化)

package com.sinog2c.util.common.redis;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
/**

將對象序列化，反序列化
@author 許傑
@param <M> 對象
*/
public class ObjectsTranscoder<M extends Serializable> extends SerializeTranscoder {

private ObjectsTranscoder(){}
private static ObjectsTranscoder single=null;
//靜態工廠方法
public static ObjectsTranscoder getInstance() {
if (single == null) {
single = new ObjectsTranscoder();
}
return single;
}

public byte[] serialize(Object value) {
if (value == null) {
throw new NullPointerException("Can't serialize null");
}
byte[] result = null;
ByteArrayOutputStream bos = null;
ObjectOutputStream os = null;
try {
bos = new ByteArrayOutputStream();
os = new ObjectOutputStream(bos);
M m = (M) value;
os.writeObject(m);
os.close();
bos.close();
result = bos.toByteArray();
} catch (IOException e) {
throw new IllegalArgumentException("Non-serializable object", e);
} finally {
close(os);
close(bos);
}
return result;
}

public M deserialize(byte[] in) {
M result = null;
ByteArrayInputStream bis = null;
ObjectInputStream is = null;
try {
if (in != null) {
bis = new ByteArrayInputStream(in);
is = new ObjectInputStream(bis);
result = (M) is.readObject();
is.close();
bis.close();
}
} catch (IOException e) {
```
 } catch (ClassNotFoundException e) {  

 } finally {  
     close(is);  
     close(bis);  
 }  
 return result;  
```
}
}

SerializeTranscoder類

package com.sinog2c.util.common.redis;

import java.io.Closeable;

import org.apache.log4j.Logger;

public abstract class SerializeTranscoder {

protected static Logger logger = Logger.getLogger(SerializeTranscoder.class);

public abstract byte[] serialize(Object value);

public abstract Object deserialize(byte[] in);

public void close(Closeable closeable) {
    if (closeable != null) {
        try {
            closeable.close();
        } catch (Exception e) {
             logger.info("Unable to close " + closeable, e); 
        }
    }
}

以上是我的分享，感謝大佬們耐心看完文章，最後再分享一個我自己的後端技術羣，羣裏自己收集了很多Java架構資料，大家可以進羣免費領取資料，羣號：680075317，也可以進羣一起交流，比如遇到技術瓶頸、面試不過的，大家一些交流學習！

redis的安裝和使用

你真的瞭解String類的intern()方法嗎

分佈式網站架構：緩存在分佈式系統中的應用

詳解Proxy代理模式的場景分析

這些分佈式知識，BAT的架構師都在用！一，通信二，伸縮性三，穩定性四，可維護性

Java分佈式架構的演進過程

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結