redis的使用

一、环境：

linux操作系统

gcc-c++

ruby脚本运行环境

注：本次的redis测试为单机测试和集群测试，测试运行在windows上，也就是服务器为linux，windows作为客户端，它需要的数据从这个linux取。这与直接用linux做开发不同在于在redis配置上会有些改动，需要注意。

二、搭建过程

1、使用虚拟机安装centos linux操作系统。

2、下载redis3.2.2.tar.gz,下载地址为http://redis.io/download。

2、安装gcc-c++,命令为yum -y install gcc-c++，因为安装redis的时候需要对它编译。

3、安装ruby环境，yum -y install ruby，yum -y install rubygems，这里的rubygems是gem文件的管理工具，安装gem需要用到它，如gem install xxx.gem，之所以安装这个是因为，redis集群管理工具redis-trib.rb依赖ruby环境，ruby是一种面向对象的语言。redis-trib.rb在redis-3.2.3.tar.gz源码包中。

4、下载gem文件https://rubygems.org/gems/redis/versions/3.3.1，点击右边的下载链接

5、安装redis，解压命令tar -zxvf redis-3.2.3.tar.gz，解压后进入解压后的文件夹redis-3.2.3，执行make命令，编译完后执行make install PREFIX=/usr/local/redis命令,prefix表示安装到/usr/local/redis，如果/usr/local/下没有redis文件夹，可先创建mkdir reids。

6、安装gem文件，gem install redis.3.3.1.gem

三、单机版

　　redis的安装已经完成了，怎么启动呢？

　　redis的启动分为前端启动和后端启动。

　　前端启动：

　　直接运行bin/redis-server将以前端模式启动，前端模式启动的缺点是ssh命令窗口关闭则redis-server程序结束，不推荐使用此方法。如下图：

　　

　　后端模式：

　　将解压后的源码包中的redis.conf复制到安装目录/usr/local/redis，使用vim redis.conf修改daemize 为yes，使用./redis-server ./redis.conf运行，它就不会占用命令行了。它的默认端口为6379,如果你是使用linux本身操作，那么默认bind的ip是127.0.0.1，如果你想要通过windows来访问redis，那么bind的ip更改成你linux的ip，使用ifconfig来查看linux的ip。

如果你用命令行的话，在这顺便告诉一下vim的基本的用法，在非插入模式时shift g也就是大G，直接跳到文档的末尾，两个小g跳到文档头，/后面写你要查找的关键词，按确定向后查找，？后面写你要查找到的关键字，向前查找。如/bind查找这个绑定的ip让后修改成你的linux的ip。

四、操作redis，转到安装目录cd /usr/local/redis/bin

输入./redis-cli -h 192.168.243.128 -p 6379

这里的-h表示redis的bind的ip地址，-p指端口

 五、redis的集群

1、在/usr/local/下创建redis-cluster文件夹，使用cp -r /usr/local/redis/bin /usr/local/redis-cluster/redis01,注意redis-cluster下没有redis01文件夹，这样拷贝的好处就是直接把bin文件夹重命名为redis01，就无需再手动创建redis01，按此中操作再复制5个，在把下载的安装包中找到redis-trib.rb，转到解压后的安装包，使用find ./ -name *.rb找到它。然后复制到redis-cluster下

2、进入redis-cluster 文件夹，当前目录下的结构

3、写个修改每个redis0*下的redis.conf，将cluster-enabled 改为yes

 4、进行集群，在这之前，先要启动所有的redis，可以将所有的命令写在脚本文件中

startall.sh

5、查看是否启动成功netstat -anp | grep redis

6、开始集群使用以下命令，可将它写在一个shell脚本中 

./redis-trib.rb create --replicas 1 192.168.243.128:7001 192.168.243.128:7002 192.168.243.128:7003 192.168.243.128:7004 192.168.243.128:7005  192.168.243.128:7006

写在一个叫cluster.sh的脚本中，执行当然你直接将上面的命令输入也可以，这里的ip地址是你在redis.conf绑定的ip

 7、执行后的结果，中间那个输入yes即可

8、登录到redis集群，这与平时的不同，多了一个-c参数，表示以集群的方式登陆，简单的测试了一下，set a 10，它把a的值根据hash值放到了7003这个redis。

Redis 集群中内置了 16384 个哈希槽，当需要在 Redis 集群中放置一个 key-value 时，redis 先对 key 使用 crc16 算法算出一个结果，然后把结果对 16384 求余数，这样每个 key 都会对应一个编号在 0-16383 之间的哈希槽，redis 会根据节点数量大致均等的将哈希槽映射到不同的节点

9、假如你集群时出现node 192.168.xxx.xxx is not empty。。。。，请你删除每个redis d的nodes.conf，重试，如果还不行，把appendonly.aof、dump.rdb删除，登录到每个redis，不要以集群方式登陆，对每个redis进行flushdb，清楚数据，再然后全部重启，如下图：

 10、如果你想深入的学习redis，可到这个网站学习http://www.runoob.com/redis/redis-tutorial.html。

 

11、添加主节点，到redis-cluster目录下，再复制一个redis07，然后使用以下命令

./redis-trib.rb add-node  192.168.243.128:7007 192.168.243.128:7001

12、登录到redis 集群查看一下信息，已经加进去了，但是没有分配hash槽，其他的后面都有hash槽的范围。

 先退出集群，然后使用以下命令

./redis-trib.rb reshard 192.168.243.128:7001

、

输入yes，确认这个分配方案。

 

13、删除节点，在删除之前先转移分配在你要删除的那个节点上的槽点，依然使用./redis-trib.rb reshard 192.168.243.128:7001

不同的是source node这里写你要删除的那个节点的id，按确认，然后再输入done，表示完成。槽点完成后，输入命令./redis-trib.rb del-node 192.168.243.128:7007 节点id

15、如果添加节点时出现 Node 192.168.243.128:7007 is not empty. Either the node already knows other nodes (check with CLUSTER NODES) or contains some key in database 0.这个错误，那么按照之前介绍的方法删除nodes.config,*.rdb,*.sof文件，登陆使用flushdb清空数据库，重新启动。

 14、添加从节点

./redis-trib.rb add-node --slave --master-id 主节点id 添加节点的ip和端口 集群中已存在节点ip和端口

./redis-trib.rb add-node --slave --master-id cad9f7413ec6842c971dbcc2c48b4ca959eb5db4

192.168.243.128:7008 192.168.243.128:7001

这就给7001这个redis添加了从节点。

六、使用java代码访问redis，这里使用maven来创建，jedis客户端访问redis。

1、访问单机版的java代码和集群的代码

import java.io.IOException;
import java.util.HashSet;
import java.util.Set;

import org.junit.Test;

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

public class JedisTest {
 
    @Test
    public void jedis() {
        Jedis jedis = new Jedis("192.168.243.128", 6379);
//        jedis.auth("root");//如果你设置了密码，输入进行认证，在linux上的客户端访问，./redis-cli -h 192.168.243.128 -p 6379 -a root
        jedis.set("hello", "world");
        System.out.println(jedis.get("hello"));
        jedis.close();
    }
     
    @Test
    public void jedisPool() { 
        JedisPool jedisPool = new JedisPool("192.168.243.128", 6379);
        Jedis jedis = jedisPool.getResource();
//        jedis.auth("root");
        jedis.set("youth", "hong");
        System.out.println(jedis.get("youth"));
        jedis.close();
        jedisPool.close();
    }
    
    @Test
    public void jedisCluster() {
        
        Set<HostAndPort> nodes = new HashSet<HostAndPort>();
        nodes.add(new HostAndPort("192.168.243.128", 7001));
        nodes.add(new HostAndPort("192.168.243.128", 7002));
        nodes.add(new HostAndPort("192.168.243.128", 7003));
        nodes.add(new HostAndPort("192.168.243.128", 7004));
        nodes.add(new HostAndPort("192.168.243.128", 7005));
        nodes.add(new HostAndPort("192.168.243.128", 7006));
        
        JedisCluster jedisCluster = new JedisCluster(nodes);
        
        jedisCluster.set("isJedisCluster", "yes");
        System.out.println(jedisCluster.get("isJedisCluster"));
        try {
            if(jedisCluster != null) {
                jedisCluster.close();
                jedisCluster = null;
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }
    
    
}

在spring中的配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!-- 连接池配置 -->
    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <!-- 最大连接数 -->
        <property name="maxTotal" value="30" />
        <!-- 最大空闲连接数 -->
        <property name="maxIdle" value="10" />
        <!-- 每次释放连接的最大数目 -->
        <property name="numTestsPerEvictionRun" value="1024" />
        <!-- 释放连接的扫描间隔（毫秒） -->
        <property name="timeBetweenEvictionRunsMillis" value="30000" />
        <!-- 连接最小空闲时间 -->
        <property name="minEvictableIdleTimeMillis" value="1800000" />
        <!-- 连接空闲多久后释放, 当空闲时间>该值 且 空闲连接>最大空闲连接数 时直接释放 -->
        <property name="softMinEvictableIdleTimeMillis" value="10000" />
        <!-- 获取连接时的最大等待毫秒数,小于零:阻塞不确定的时间,默认-1 -->
        <property name="maxWaitMillis" value="1500" />
        <!-- 在获取连接的时候检查有效性, 默认false -->
        <property name="testOnBorrow" value="true" />
        <!-- 在空闲时检查有效性, 默认false -->
        <property name="testWhileIdle" value="true" />
        <!-- 连接耗尽时是否阻塞, false报异常,ture阻塞直到超时, 默认true -->
        <property name="blockWhenExhausted" value="false" />
    </bean>
    <!-- jedis客户端单机版 -->
    <bean id="redisClient" class="redis.clients.jedis.JedisPool">
        <constructor-arg name="host" value="192.168.243.128"></constructor-arg>
        <constructor-arg name="port" value="6379"></constructor-arg>
        <constructor-arg name="poolConfig" ref="jedisPoolConfig"></constructor-arg>
    </bean> 
    <bean id="jedisSingle" class="com.test.rest.dao.impl.JedisSingle" ></bean>
    
    <!-- jedis集群版配置 -->
    <!-- <bean id="redisClient" class="redis.clients.jedis.JedisCluster">
        <constructor-arg name="nodes">
            <set>
                <bean class="redis.clients.jedis.HostAndPort">
                    <constructor-arg name="host" value="192.168.243.128"></constructor-arg>
                    <constructor-arg name="port" value="7001"></constructor-arg>
                </bean>
                <bean class="redis.clients.jedis.HostAndPort">
                    <constructor-arg name="host" value="192.168.243.128"></constructor-arg>
                    <constructor-arg name="port" value="7002"></constructor-arg>
                </bean>
                <bean class="redis.clients.jedis.HostAndPort">
                    <constructor-arg name="host" value="192.168.243.128"></constructor-arg>
                    <constructor-arg name="port" value="7003"></constructor-arg>
                </bean>
                <bean class="redis.clients.jedis.HostAndPort">
                    <constructor-arg name="host" value="192.168.243.128"></constructor-arg>
                    <constructor-arg name="port" value="7004"></constructor-arg>
                </bean>
                <bean class="redis.clients.jedis.HostAndPort">
                    <constructor-arg name="host" value="192.168.243.128"></constructor-arg>
                    <constructor-arg name="port" value="7005"></constructor-arg>
                </bean>
                <bean class="redis.clients.jedis.HostAndPort">
                    <constructor-arg name="host" value="192.168.243.128"></constructor-arg>
                    <constructor-arg name="port" value="7006"></constructor-arg>
                </bean>
            </set>
        </constructor-arg>
        <constructor-arg name="poolConfig" ref="jedisPoolConfig"></constructor-arg>
    </bean>
    <bean id="jedisCluster" class="com.test.rest.dao.impl.JedisCluster" ></bean> -->
</beans>

dao

public interface JedisClient {
    
    String get(String key);
    String set(String key, String value);
    String hget(String hkey, String key);
    long hset(String hkey, String key, String value);
    long incr(String key);
    long expire(String key, int seconds);
    long ttl(String key);
    long del(String key);
    long hdel(String hkey, String key);
        
}

dao impl

jedisSingle.java

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

import com.taotao.rest.dao.JedisClient;

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

public class JedisSingle implements JedisClient {

    @Autowired
    private JedisPool jedisPool;
    private Jedis jedis;

    @Override
    public String get(String key) {
        jedis = jedisPool.getResource();
        String string = jedis.get(key);
        jedis.close();
        return string;
    }

    @Override
    public String set(String key, String value) {
        jedis = jedisPool.getResource();
        String string = jedis.set(key, value);
        jedis.close();
        return string;
    }

    @Override
    public String hget(String hkey, String key) {
        jedis = jedisPool.getResource();
        String string = jedis.hget(hkey, key);
        jedis.close();
        return string;
    }

    @Override
    public long hset(String hkey, String key, String value) {
        jedis = jedisPool.getResource();
        long string = jedis.hset(hkey, key, value);
        jedis.close();
        return string;
    }

    @Override
    public long incr(String key) {
        jedis = jedisPool.getResource();
        long result = jedis.incr(key);
        jedis.close();
        return result;
    }

    @Override
    public long expire(String key, int seconds) {
        jedis = jedisPool.getResource();
        long result = jedis.expire(key, seconds);
        jedis.close();
        return result;
    }

    @Override
    public long ttl(String key) {
        jedis = jedisPool.getResource();
        long result = jedis.ttl(key);
        jedis.close();
        return result;
    }

    @Override
    public long del(String key) {
        jedis = jedisPool.getResource();
        long result = jedis.del(key);
        jedis.close();
        return result;
    }

    @Override
    public long hdel(String hkey, String key) {
        jedis = jedisPool.getResource();
        long result = jedis.hdel(hkey, key);
        jedis.close();
        return result;
    }

}

JedisCluster.java

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

import com.taotao.rest.dao.JedisClient;

public class JedisCluster implements JedisClient {

    @Autowired
    private redis.clients.jedis.JedisCluster jedisCluster;

    @Override
    public String get(String key) {
        return jedisCluster.get(key);
    }

    @Override
    public String set(String key, String value) {
        return jedisCluster.set(key, value);
    }

    @Override
    public String hget(String hkey, String key) {
        return jedisCluster.hget(hkey, key);
    }

    @Override
    public long hset(String hkey, String key, String value) {
        return jedisCluster.hset(hkey, key, value);
    }

    @Override
    public long incr(String key) {
        return jedisCluster.incr(key);
    }

    @Override
    public long expire(String key, int seconds) {
        return jedisCluster.expire(key, seconds);
    }

    @Override
    public long ttl(String key) {
        return jedisCluster.ttl(key);
    }

    @Override
    public long del(String key) {
        return jedisCluster.del(key);
    }

    @Override
    public long hdel(String hkey, String key) {
        return jedisCluster.hdel(hkey, key);
    }

}

redisTest.java

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

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

public class RedisTest {

    @Test
    public void redisTest() { 
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:spring/applicationContext-*.xml");
        JedisPool jedisPool = applicationContext.getBean("redisClient", JedisPool.class);
        Jedis jedis = jedisPool.getResource();
        String str = jedis.get("hello");
        System.out.println(str);
        
    }
    @Test
    public void redisClusterTest() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:spring/applicationContext-*.xml");
        JedisCluster jedisCluster = applicationContext.getBean("redisClient", JedisCluster.class);
        
        String str = jedisCluster.get("isJedisCluster");
        System.out.println(str);
        
    }
    
}