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