redis的安装和使用

最新推荐文章于 2024-01-25 17:06:37 发布
最新推荐文章于 2024-01-25 17:06:37 发布
阅读量342 收藏
点赞数
分类专栏： 程序员 架构 Java. 文章标签： Java  Java程序员 程序员 架构 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhuguang10/article/details/98199043
版权
Java. 同时被 3 个专栏收录
148 篇文章 0 订阅
订阅专栏
架构
114 篇文章 2 订阅
订阅专栏
程序员
113 篇文章 1 订阅
订阅专栏

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); 
        }
    }
}

以上是我的分享，感谢大佬们耐心看完文章，最后再分享一个我自己的后端技术群，群里自己收集了很多Java架构资料，大家可以进群免费领取资料，群号：680075317，也可以进群一起交流，比如遇到技术瓶颈、面试不过的，大家一些交流学习！

zhuguang10
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
mac系统下Redis安装和使用步骤详解
09-09
主要介绍了mac下Redis安装和使用步骤详解，并将python如何操作Redis做了简单介绍,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Redis安装和使用教程
10-21
小白学习redis的必备文档，认识redis,安装reids,redis语法等等教程
Redis配置参数详解
梁吉林的博客
05-30 3万+
本文将按照不同的功能模块的方式，依次对各个功能模块的配置参数进行详细介绍。
Redis安装教程（超详细）
热门推荐
X_lsod的博客
03-03 17万+
Redis 一、Redis安装 1、windows下安装 默认端口：6379 下载连接 https://github.com/tporadowski/redis/releases 解压 双击redis-server.exe启动服务端 双击redis-cli.exe启动客户端连接服务端 在客户端输入 “ping”，出现“PONG”，即证明连接成功 2、Linux下安装 2.1、下载linux压缩包 【redis-5.0.5.tar.gz】 2.2、通过FlashFXP把压缩包
Redis安装教程
最新发布
weixin_49628108的博客
01-25 998
（这个步骤的前提是redis已经开启）新建连接，地址填服务器的地址，然后点击测试连接，成功后点击右下角的确定即可。执行shutdown和exit即可推出redis服务，再次查看也发现redis的服务端和客户端进程都消失了。2、将 protected-mode yes 改为 protected-mode no。2.4、进入redis-5.0.5可以看到redis的配置文件redis.conf。2.7、将redis的配置文件拷贝到新建的目录myredis-config下。
超级详细 的 Redis 安装教程
IT小郭的技术博客
12-04 3万+
1、双击 启动 Redis2、打开cmd，进入到刚才解压到的目录，启动临时服务：默认端口：6379 有的机器双击 redis-server.exe 执行失败，找不到配置文件，可以采用以下执行方式： 在命令行（cmd）中按如下方式执行： 打开另一个cmd窗口，客户端调用：1、进入Redis安装包目录，安装服务： 2、,可以看到服务安装成功 将d盘下新建一个文件夹叫redis2，把redis文件夹的东西拷贝到redis2文件夹下，将redis-windows.conf配置文件中的ip 和端口号改一下，然后按照
Redis的详细安装步骤
m0_67094505的博客
10-30 8182
一、Redis简介一、Redis简介Redis是一个开源（BSD许可），内存存储的数据结构服务器，可用作数据库，高速缓存和消息队列代理。它支持字符串（string）、哈希表（hash）、列表（list）、集合（set）、有序集合（zset / sort zset），位图，hyperloglogs等数据类型。内置复制、Lua脚本、LRU收回、事务以及不同级别磁盘持久化功能，同时通过Redis Sentinel提供高可用，通过Redis Cluster提供自动分区。
Redis 安装详细过程（redis基本使用（服务端和客户端）、修改密码）
IT之一小佬的博客
02-14 4982
Redis 安装详细过程（redis基本使用（服务端和客户端）、修改密码）
C# Redis 安装与使用
09-03
C# Redis 安装与使用，有服务器端安装包和客户端查看工具。及net调用例子
【redis篇】超详细的redis安装教程，学不会你找我
BinvinCode技术分享
02-22 7363
Linux安装redis最详细教程，实现守护线程方式启动redis、redis开机自启动、gcc升级
如何实现Redis安装与使用的详细教程
简的博客
06-08 8828
Redis是一种高性能键值存储数据库，被广泛应用于Web应用程序中。本教程中将详细讲解如何从源代码编译并安装Redis，以及如何在Windows系统上与Linux系统上配置和使用Redis。
Redis基础篇
Wolf__king的博客
05-07 9201
Hash表，List可重复有序的，set不可重复无序的。下面三种是基于基本类型的基础上进行了特殊的处理用来实现特殊功能。5种基本类型，3中复杂类型。
redis的安装步骤
sujt0726的博客
05-29 2355
1 Redis是一个开源的key-value存储系统。2 和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。3 这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。4 在此基础上，Redis支持各种不同方式的排序。5 与memcached一样，为了保证效率，数据都是缓存在内存中。
Redis安装教程(详细)
H_sm666的博客
04-03 2919
官网：中文：2，将redis文件传输到Linux服务器将从官网下载的redis文件传入Linux服务器，home目录下去home目录下查看有没有此文件。
redis安装教程（简明扼要，一看就懂）
qq_44104879的博客
08-19 1万+
简明扼要，一看就懂--- redis 安装教程
【Redis】Redis 的安装与配置（Redis 的安装、启动和停止、相关配置、客户端、配置文件配置项详解）
emmmm.....
07-26 4263
Redis 的安装与配置（Redis 的安装、启动和停止、相关配置、客户端、配置文件配置项详解）
Redis 的安装
2301_77783312的博客
06-11 2899
执行 ./install_server.sh 文件后，会相应的配置很多文件，比如端口号、配置文件的目录、日志文件的目录、数据文件的目录、Redis 服务的文件。这些文件我都将其放在了 Redis 的安装目录下，即 /usr/local/redis/ 路径下。既然 ./install_server 已经帮我们完成了服务的启动，那么我们就需要查看一下。这样，在任何目录当中都可以使用 redis 项目的文件了。以上就是完整的使用源码安装 Redis 的方法！配置完成后，会自动启动 Redis 服务。
Redis安装(保姆级教程)
不惧困难 顽强拼搏
06-30 1052
redis它是一个开源的数据库，缓存的服务器，它里面可以存放字符串，hash，列表，集合数据类型的数据，它的计算基于内存进行计算的。而且数据也可以持久化到磁盘中。 而且它也提高了哨兵模式以及集群模式来提高redis的可用性。
redis安装与使用
08-23
- *1* *2* [Redis安装及用法介绍](https://blog.csdn.net/qq_56687451/article/details/118538966)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值