redis的安装和使用

逃离我推掉我的手 2021-11-10 08:10 293阅读 0赞

Redis  
Redis命令参考网址：[http://doc.redisfans.com/][http_doc.redisfans.com]

1.  Redis 简介  
    Redis 是完全开源免费的，遵守BSD协议，是一个高性能的key-value数据库。  
    Redis 与其他 key - value 缓存产品有以下三个特点：

1.  Redis支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用。
2.  Redis不仅仅支持简单的key-value类型的数据，同时还提供list，set，zset，hash等数据结构的存储。
3.  Redis支持数据的备份，即master-slave模式的数据备份。  
    2.Redis安装  
    1）Window 下安装  
    64位下载地址：[https://github.com/MSOpenTech/redis/releases][https_github.com_MSOpenTech_redis_releases]。  
    32位下载地址：[http://vdisk.weibo.com/s/dbUhxKrgqodB][http_vdisk.weibo.com_s_dbUhxKrgqodB]  
    （如果使用32位，请采用单机模式）  
    Redis 支持 32 位和 64 位。这个需要根据你系统平台的实际情况选择，这里我们下载 Redis-x64-xxx.zip压缩包到 C 盘，解压后，将文件夹重新命名为 redis。

![aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy81Njg3MTc3LWE2NGQ0YTc5MTUwZmZhY2EucG5nP2ltYWdlTW9ncjIvYXV0by1vcmllbnQvc3RyaXAlN0NpbWFnZVZpZXcyLzIvdy81NTMvZm9ybWF0L3dlYnA][]

图片.png

下载解压，在解压后的目录下有以下这些文件

![aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy81Njg3MTc3LTk3ZmJiMDNjODM2YzY0ZWMucG5nP2ltYWdlTW9ncjIvYXV0by1vcmllbnQvc3RyaXAlN0NpbWFnZVZpZXcyLzIvdy81NTQvZm9ybWF0L3dlYnA][]

图片.png

打开一个 cmd 窗口 使用cd命令切换目录到 C:\\redis 运行 redis-server.exe redis.windows.conf 。  
如果想方便的话，可以把 redis 的路径加到系统的环境变量里，这样就省得再输路径了，后面的那个 redis.windows.conf 可以省略，如果省略，会启用默认的。输入之后，会显示如下界面：

![aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy81Njg3MTc3LWU4NTM1MWE4ZmU5YTg5Y2MucG5nP2ltYWdlTW9ncjIvYXV0by1vcmllbnQvc3RyaXAlN0NpbWFnZVZpZXcyLzIvdy80NjcvZm9ybWF0L3dlYnA][]

图片.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

![aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy81Njg3MTc3LTRkZjE0NmE5YTI0ZWM2MGUucG5nP2ltYWdlTW9ncjIvYXV0by1vcmllbnQvc3RyaXAlN0NpbWFnZVZpZXcyLzIvdy80NjkvZm9ybWF0L3dlYnA][]

图片.png

2）Linux 下安装  
下载地址：[http://redis.io/download][http_redis.io_download]，下载最新文档版本。

$ wget [http://download.redis.io/releases/redis-2.8.17.tar.gz][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/][http_rubyinstaller.org_downloads]  
勾选下面三个不用配置环境变量

![aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy81Njg3MTc3LWQ5YTMwZGNhMGI4ZDBmYzMucG5nP2ltYWdlTW9ncjIvYXV0by1vcmllbnQvc3RyaXAlN0NpbWFnZVZpZXcyLzIvdy81MDMvZm9ybWF0L3dlYnA][]

图片.png

安装RubyGems  
下载下来是一个压缩包，解压运行里面的 setup.rb 安装 rubyGems  
由于墙的原因ruby自带的源有时候很慢，我们换成淘宝的源，不然下面安装redis依赖会失败＼（－－）／  
在cmd下运行  
gem sources --remove [https://rubygems.org/][https_rubygems.org] 删掉原来的源  
gem sources -a [http://ruby.taobao.org][http_ruby.taobao.org] 添加淘宝源(如果添加失败，试试[https://ruby.taobao.org][https_ruby.taobao.org]或[http://gems.ruby-china.org][http_gems.ruby-china.org])  
gem sources -l 查看现有的源  
gem install redis 安装redis依赖  
二 、使用redis cluster  
按照文档的说明步骤来做就行了，详情在这[http://doc.redisfans.com/topic/cluster-tutorial.html\#id5][http_doc.redisfans.com_topic_cluster-tutorial.html_id5]  
要让集群正常运作至少需要三个主节点，因此我们创建6个节点，三个主节点三个从节点，详细请查看文档，我简化一下文档的步骤即：  
1.创建 6个文件夹分别为 7000-7005  
这里就是做集群时各个机器所安装的redis，在每个文件夹放一份下载下来的redis，例如

![aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy81Njg3MTc3LTk4YjE1MDA2YWZkN2JlZDQucG5nP2ltYWdlTW9ncjIvYXV0by1vcmllbnQvc3RyaXAlN0NpbWFnZVZpZXcyLzIvdy81MDMvZm9ybWF0L3dlYnA][]

图片.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

![aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy81Njg3MTc3LWNkODI4NjRmYzA4MGVmNjMucG5nP2ltYWdlTW9ncjIvYXV0by1vcmllbnQvc3RyaXAlN0NpbWFnZVZpZXcyLzIvdy80NjMvZm9ybWF0L3dlYnA][]

图片.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包：

![aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy81Njg3MTc3LWU3MjA5NzI2MGJmZDg5MzEucG5nP2ltYWdlTW9ncjIvYXV0by1vcmllbnQvc3RyaXAlN0NpbWFnZVZpZXcyLzIvdy8xODUvZm9ybWF0L3dlYnA][]

图片.png

，

![aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy81Njg3MTc3LWRkYmY3NTVmYWE3MDBlNjYucG5nP2ltYWdlTW9ncjIvYXV0by1vcmllbnQvc3RyaXAlN0NpbWFnZVZpZXcyLzIvdy85OS9mb3JtYXQvd2VicA][]

图片.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>

![aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy81Njg3MTc3LWFmYzNhMDhjMDA0NjQyNjkucG5nP2ltYWdlTW9ncjIvYXV0by1vcmllbnQvc3RyaXAlN0NpbWFnZVZpZXcyLzIvdy8zNjEvZm9ybWF0L3dlYnA][]

图片.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，也可以进群一起交流，比如遇到技术瓶颈、面试不过的，大家一些交流学习！

[http_doc.redisfans.com]: https://link.jianshu.com?t=http://doc.redisfans.com/
[https_github.com_MSOpenTech_redis_releases]: https://link.jianshu.com?t=https://github.com/MSOpenTech/redis/releases
[http_vdisk.weibo.com_s_dbUhxKrgqodB]: https://link.jianshu.com?t=http://vdisk.weibo.com/s/dbUhxKrgqodB
[aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy81Njg3MTc3LWE2NGQ0YTc5MTUwZmZhY2EucG5nP2ltYWdlTW9ncjIvYXV0by1vcmllbnQvc3RyaXAlN0NpbWFnZVZpZXcyLzIvdy81NTMvZm9ybWF0L3dlYnA]: /images/20211109/dc22816497dd49068df3c1257dfefd00.png
[aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy81Njg3MTc3LTk3ZmJiMDNjODM2YzY0ZWMucG5nP2ltYWdlTW9ncjIvYXV0by1vcmllbnQvc3RyaXAlN0NpbWFnZVZpZXcyLzIvdy81NTQvZm9ybWF0L3dlYnA]: /images/20211109/e1d9e223e54243e98b7c1420ae9d8e5d.png
[aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy81Njg3MTc3LWU4NTM1MWE4ZmU5YTg5Y2MucG5nP2ltYWdlTW9ncjIvYXV0by1vcmllbnQvc3RyaXAlN0NpbWFnZVZpZXcyLzIvdy80NjcvZm9ybWF0L3dlYnA]: /images/20211109/0821b18a8b684e1dbc296dd0c746c099.png
[aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy81Njg3MTc3LTRkZjE0NmE5YTI0ZWM2MGUucG5nP2ltYWdlTW9ncjIvYXV0by1vcmllbnQvc3RyaXAlN0NpbWFnZVZpZXcyLzIvdy80NjkvZm9ybWF0L3dlYnA]: /images/20211109/98c2a0df58d841a99e86ba9bb8555c8a.png
[http_redis.io_download]: https://link.jianshu.com?t=http://redis.io/download
[http_download.redis.io_releases_redis-2.8.17.tar.gz]: https://link.jianshu.com?t=http://download.redis.io/releases/redis-2.8.17.tar.gz
[http_rubyinstaller.org_downloads]: https://link.jianshu.com?t=http://rubyinstaller.org/downloads/
[aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy81Njg3MTc3LWQ5YTMwZGNhMGI4ZDBmYzMucG5nP2ltYWdlTW9ncjIvYXV0by1vcmllbnQvc3RyaXAlN0NpbWFnZVZpZXcyLzIvdy81MDMvZm9ybWF0L3dlYnA]: /images/20211109/e5880cbac07a4e19b8d20102f2b2339c.png
[https_rubygems.org]: https://link.jianshu.com?t=https://rubygems.org/
[http_ruby.taobao.org]: https://link.jianshu.com?t=http://ruby.taobao.org
[https_ruby.taobao.org]: https://link.jianshu.com?t=https://ruby.taobao.org
[http_gems.ruby-china.org]: https://link.jianshu.com?t=http://gems.ruby-china.org
[http_doc.redisfans.com_topic_cluster-tutorial.html_id5]: https://link.jianshu.com?t=http://doc.redisfans.com/topic/cluster-tutorial.html#id5
[aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy81Njg3MTc3LTk4YjE1MDA2YWZkN2JlZDQucG5nP2ltYWdlTW9ncjIvYXV0by1vcmllbnQvc3RyaXAlN0NpbWFnZVZpZXcyLzIvdy81MDMvZm9ybWF0L3dlYnA]: /images/20211109/63595af2a8d749a2942b1dd437b55fe0.png
[aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy81Njg3MTc3LWNkODI4NjRmYzA4MGVmNjMucG5nP2ltYWdlTW9ncjIvYXV0by1vcmllbnQvc3RyaXAlN0NpbWFnZVZpZXcyLzIvdy80NjMvZm9ybWF0L3dlYnA]: /images/20211109/3f6b5d2a0b3049bab52463148c777247.png
[aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy81Njg3MTc3LWU3MjA5NzI2MGJmZDg5MzEucG5nP2ltYWdlTW9ncjIvYXV0by1vcmllbnQvc3RyaXAlN0NpbWFnZVZpZXcyLzIvdy8xODUvZm9ybWF0L3dlYnA]: /images/20211109/a109166f76df4d15b77c5be284a6f9c7.png
[aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy81Njg3MTc3LWRkYmY3NTVmYWE3MDBlNjYucG5nP2ltYWdlTW9ncjIvYXV0by1vcmllbnQvc3RyaXAlN0NpbWFnZVZpZXcyLzIvdy85OS9mb3JtYXQvd2VicA]: /images/20211109/7cf8418f159441689e4a997859c545fd.png
[aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy81Njg3MTc3LWFmYzNhMDhjMDA0NjQyNjkucG5nP2ltYWdlTW9ncjIvYXV0by1vcmllbnQvc3RyaXAlN0NpbWFnZVZpZXcyLzIvdy8zNjEvZm9ybWF0L3dlYnA]: /images/20211109/53170de3cd1c4ca5b06c2548370f0e75.png