redis的安装和使用

Redis
Redis命令参考网址：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。
    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); 
        }
    }
}

}

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 206,482评论 6赞 481
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 88,377评论 2赞 382
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 152,762评论 0赞 342
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 55,273评论 1赞 279
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 64,289评论 5赞 373
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 49,046评论 1赞 285
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,351评论 3赞 400
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,988评论 0赞 259
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 43,476评论 1赞 300
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,948评论 2赞 324
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,064评论 1赞 333
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,712评论 4赞 323
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,261评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,264评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,486评论 1赞 262
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 45,511评论 2赞 354
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,802评论 2赞 345

推荐阅读更多精彩内容