Linux环境安装redis丶搭建redis集群以及Spring

作者: Cehae | 来源:发表于2018-06-22 13:21 被阅读0次

一丶环境准备

VMware Linux CentOS-6.5。
redis-3.0.0.tar.gz包
上传工具FileZilla Client
Redis是c语言开发的。安装redis需要c语言的编译环境。如果没有gcc需要联网(虚拟机联网请自行百度，稍后我也会写一篇文章介绍虚拟机联网配置)在线安装。Linux命令行执行：

yum install gcc-c++

二丶安装redis

第一步：上传。使用FileZilla Client将redis的源码包上传到linux系统。并解压。

图片.png

第二步：编译。进入redis源码目录。make

图片.png

第四步：安装。make install PREFIX=/usr/local/redis
PREFIX参数指定redis的安装目录。一般软件安装到/usr目录下

图片.png

第五步：启动。

图片.png

第六步前端启动

图片.png

第七步后端启动：需要复制配置文件并修改

图片.png

将redis.conf文件中的 daemonize 改为yes。

图片.png

后端启动

图片.png

查看redis进程

图片.png

三丶使用redis-cli

[root@cehae bin]# ./redis-cli
默认连接localhost运行在6379端口的redis服务。
[root@cehae bin]# ./redis-cli -h 192.168.25.200 -p 6379
-h：连接的服务器的地址
-p：服务的端口号

图片.png

注意存储中文时出现乱码。可以退出后使用
./redis-cli -h 192.168.25.200 -p 6379 --raw 启动

图片.png

关闭redis

方式一

图片.png

方式二：使用Linux杀死进程命令

kill -9 进程号强制退出(如果运行出错，可以使用强制退出)
kill 进程号让进程正常退出(让进程处理完后退出)

四丶搭建redis集群

redis集群原理

redis-cluster架构图

图片.png

redis容错机制:投票

图片.png

架构细节:
(1)所有的redis节点彼此互联(PING-PONG机制),内部使用二进制协议优化传输速度和带宽。

(2)节点的fail是通过集群中超过半数的节点检测失效时才生效。

(3)客户端与redis节点直连,不需要中间proxy层.客户端不需要连接集群所有节点,连接集群中任何一个可用节点即可。

(4)redis-cluster把所有的物理节点映射到[0-16383]slot上,cluster 负责维护node<->slot<->value。

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

图片.png

搭建集群

说明：
由于投票机制redis集群中至少应该有三个节点，同时要保证集群的高可用，需要每个节点有一个备份机。因此redis集群至少需要6台服务器。在这我只搭建伪分布式，使用一台虚拟机运行6个redis实例。对应6个redis实例的端口号为7001-7006。

第一步：使用ruby脚本搭建集群。
需要ruby的运行环境。安装ruby

yum install ruby
yum install rubygems

第二步：安装ruby脚本运行使用的包

[root@cehae ~]# gem install redis-3.0.0.gem 
Successfully installed redis-3.0.0
1 gem installed
Installing ri documentation for redis-3.0.0...
Installing RDoc documentation for redis-3.0.0...
[root@cehae ~]#

redis-trib.rb脚本

[root@cehae ~]# cd redis-3.0.0/src
[root@cehae src]# ll *.rb
-rwxrwxr-x. 1 root root 48141 Apr  1  2015 redis-trib.rb

图片.png

第三步：创建redis-cluster目录。并将/usr/local/redis下的bin目录复制6份至redis-cluster下面。

图片.png

第四步：修改配置文件。每个实例运行在不同的端口，需要修改redis.conf配置文件。配置文件中还需要把cluster-enabled yes前的注释去掉。

图片.png

修改端口

图片.png

去掉# cluster-enabled yes 中的注释

图片.png

第五步：编写启动redis脚本并使用ruby脚本搭建集群。

图片.png

启动脚本

图片.png

cd redis01
./redis-server redis.conf
cd ..
cd redis02
./redis-server redis.conf
cd ..
cd redis03
./redis-server redis.conf
cd ..
cd redis04
./redis-server redis.conf
cd ..
cd redis05
./redis-server redis.conf
cd ..
cd redis06
./redis-server redis.conf

注意创建完毕后并没有执行的权限，因此需要修改脚本权限

图片.png

启动6个redis

图片.png

使用ruby脚本搭建集群

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

图片.png

输入yes

图片.png

搭建成功，槽以及主机备份机也自动设置完毕。

图片.png

[root@cehae redis-cluster]# ./redis-trib.rb create --replicas 1 192.168.25.200:7001 192.168.25.200:7002 192.168.25.200:7003 192.168.25.200:7004 192.168.25.200:7005  192.168.25.200:7006
>>> Creating cluster
Connecting to node 192.168.25.200:7001: OK
Connecting to node 192.168.25.200:7002: OK
Connecting to node 192.168.25.200:7003: OK
Connecting to node 192.168.25.200:7004: OK
Connecting to node 192.168.25.200:7005: OK
Connecting to node 192.168.25.200:7006: OK
>>> Performing hash slots allocation on 6 nodes...
Using 3 masters:
192.168.25.200:7001
192.168.25.200:7002
192.168.25.200:7003
Adding replica 192.168.25.200:7004 to 192.168.25.200:7001
Adding replica 192.168.25.200:7005 to 192.168.25.200:7002
Adding replica 192.168.25.200:7006 to 192.168.25.200:7003
M: 2e48ae301e9c32b04a7d4d92e15e98e78de8c1f3 192.168.25.200:7001
   slots:0-5460 (5461 slots) master
M: 8cd93a9a943b4ef851af6a03edd699a6061ace01 192.168.25.200:7002
   slots:5461-10922 (5462 slots) master
M: 2935007902d83f20b1253d7f43dae32aab9744e6 192.168.25.200:7003
   slots:10923-16383 (5461 slots) master
S: 74f9d9706f848471583929fc8bbde3c8e99e211b 192.168.25.200:7004
   replicates 2e48ae301e9c32b04a7d4d92e15e98e78de8c1f3
S: 42cc9e25ebb19dda92591364c1df4b3a518b795b 192.168.25.200:7005
   replicates 8cd93a9a943b4ef851af6a03edd699a6061ace01
S: 8b1b11d509d29659c2831e7a9f6469c060dfcd39 192.168.25.200:7006
   replicates 2935007902d83f20b1253d7f43dae32aab9744e6
Can I set the above configuration? (type 'yes' to accept): yes
>>> Nodes configuration updated
>>> Assign a different config epoch to each node
>>> Sending CLUSTER MEET messages to join the cluster
Waiting for the cluster to join.....
>>> Performing Cluster Check (using node 192.168.25.200:7001)
M: 2e48ae301e9c32b04a7d4d92e15e98e78de8c1f3 192.168.25.200:7001
   slots:0-5460 (5461 slots) master
M: 8cd93a9a943b4ef851af6a03edd699a6061ace01 192.168.25.200:7002
   slots:5461-10922 (5462 slots) master
M: 2935007902d83f20b1253d7f43dae32aab9744e6 192.168.25.200:7003
   slots:10923-16383 (5461 slots) master
M: 74f9d9706f848471583929fc8bbde3c8e99e211b 192.168.25.200:7004
   slots: (0 slots) master
   replicates 2e48ae301e9c32b04a7d4d92e15e98e78de8c1f3
M: 42cc9e25ebb19dda92591364c1df4b3a518b795b 192.168.25.200:7005
   slots: (0 slots) master
   replicates 8cd93a9a943b4ef851af6a03edd699a6061ace01
M: 8b1b11d509d29659c2831e7a9f6469c060dfcd39 192.168.25.200:7006
   slots: (0 slots) master
   replicates 2935007902d83f20b1253d7f43dae32aab9744e6
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.
[root@cehae redis-cluster]#

第六步：连接和关闭集群

连接任意一个节点就连接到了集群，注意一定要加 -c，-c代表连接的是集群，否则只是连接单个redis。

[root@cehae redis-cluster]# redis01/redis-cli -p 7001 -c

注意下图 set d test 并没有存放在redis01上面，而是通过crc16算法再对16384 取余计算得到结果，将结果与槽对比，分配到了redis03上面，证明集群搭建成功。

图片.png

编写关闭集群脚本

图片.png

redis01/redis-cli -p 7001 shutdown
redis02/redis-cli -p 7002 shutdown
redis03/redis-cli -p 7003 shutdown
redis04/redis-cli -p 7004 shutdown
redis05/redis-cli -p 7005 shutdown
redis06/redis-cli -p 7006 shutdown

同样注意赋予执行权限。

图片.png

关闭集群

图片.png

使用jedis连接集群
创建Maven工程，将jedis和junit的坐标添加到pom文件中然后编写测试代码:

@Test
    public void testJedisCluster() throws Exception {
        // 第一步：使用JedisCluster对象。需要一个Set<HostAndPort>参数。Redis节点的列表。
        Set<HostAndPort> nodes = new HashSet<>();
        nodes.add(new HostAndPort("192.168.25.200", 7001));
        nodes.add(new HostAndPort("192.168.25.200", 7002));
        nodes.add(new HostAndPort("192.168.25.200", 7003));
        nodes.add(new HostAndPort("192.168.25.200", 7004));
        nodes.add(new HostAndPort("192.168.25.200", 7005));
        nodes.add(new HostAndPort("192.168.25.200", 7006));
        JedisCluster jedisCluster = new JedisCluster(nodes);
        // 第二步：直接使用JedisCluster对象操作redis。在系统中单例存在。
        jedisCluster.set("hello", "100");
        String result = jedisCluster.get("hello");
        // 第三步：打印结果
        System.out.println(result);
        // 第四步：系统关闭前，关闭JedisCluster对象。
        jedisCluster.close();
    }

安装所需要的资料可以自行下载，也可以去我GitHub下面下载。欢迎star，转载请私聊，谢谢。

SpringDataRedis的使用

搭建工程引入依赖

    <!-- 集中定义依赖版本号 -->
    <properties>
        <spring.version>4.2.4.RELEASE</spring.version>
        <junit.version>4.12</junit.version>
    </properties>

    <dependencies>
        <!-- Spring -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jms</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- 测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.9</version>
        </dependency>

        <!-- redis -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.8.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>1.7.2.RELEASE</version>
        </dependency>
    </dependencies>

配置文件

在src/main/resources下创建 properties/redis-config.properties 目录以及文件

# Redis settings 
# server IP 
redis.host=192.168.25.200
# server port 
redis.port=6379
# server pass 
redis.pass=
# use dbIndex 
redis.database=0
# 控制一个pool最多有多少个状态为idle(空闲的)的jedis实例 
redis.maxIdle=300
# 表示当borrow(引入)一个jedis实例时，最大的等待时间，如果超过等待时间(毫秒)，则直接抛出JedisConnectionException；  
redis.maxWait=3000
# 在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的  
redis.testOnBorrow=true

在src/main/resources下创建 spring/applicationContext-redis.xml 目录以及文件

<?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:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:cache="http://www.springframework.org/schema/cache"
    xsi:schemaLocation="http://www.springframework.org/schema/beans   
            http://www.springframework.org/schema/beans/spring-beans.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/cache  
            http://www.springframework.org/schema/cache/spring-cache.xsd">

    <context:property-placeholder location="classpath*:properties/*.properties" />

    <!-- redis 相关配置 -->
    <!-- 连接池 -->
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxIdle" value="${redis.maxIdle}" />
        <property name="maxWaitMillis" value="${redis.maxWait}" />
        <property name="testOnBorrow" value="${redis.testOnBorrow}" />
    </bean>

    <!-- 连接工厂 -->
    <bean id="JedisConnectionFactory"
        class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
        p:host-name="${redis.host}" p:port="${redis.port}" p:password="${redis.pass}"
        p:pool-config-ref="poolConfig" />

    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
        <property name="connectionFactory" ref="JedisConnectionFactory" />
    </bean>
</beans>

编写测试代码

TestValue.java

package com.cehae.test;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring/applicationContext-redis.xml")
public class TestValue {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    public void setValue() {
        redisTemplate.boundValueOps("name").set("cehae");
    }

    @Test
    public void getValue() {
        String str = (String) redisTemplate.boundValueOps("name").get();
        System.out.println(str);
    }

    @Test
    public void deleteValue() {
        redisTemplate.delete("name");
    }
}

TestHash.java

package com.cehae.test;

import java.util.List;
import java.util.Set;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring/applicationContext-redis.xml")
public class TestHash {

    @Autowired
    private RedisTemplate redisTemplate;

    public void testSetValue() {
        redisTemplate.boundHashOps("namehash").put("a", "刘备");
        redisTemplate.boundHashOps("namehash").put("b", "关羽");
        redisTemplate.boundHashOps("namehash").put("c", "张飞");
        redisTemplate.boundHashOps("namehash").put("d", "赵云");
    }

    public void testGetKeys() {
        Set s = redisTemplate.boundHashOps("namehash").keys();
        System.out.println(s);
    }

    public void testGetValues() {
        List values = redisTemplate.boundHashOps("namehash").values();
        System.out.println(values);
    }

    public void testGetValueByKey() {
        Object object = redisTemplate.boundHashOps("namehash").get("b");
        System.out.println(object);
    }

    public void testRemoveValueByKey() {
        redisTemplate.boundHashOps("namehash").delete("c");
    }
}

TestList.java

package com.cehae.test;

import java.util.List;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring/applicationContext-redis.xml")
public class TestList {

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 右压栈：后添加的对象排在后边
     * 
     * 刘备 关羽 张飞
     */
    public void testSetValue1() {
        redisTemplate.boundListOps("namelist1").rightPush("刘备");
        redisTemplate.boundListOps("namelist1").rightPush("关羽");
        redisTemplate.boundListOps("namelist1").rightPush("张飞");
    }

    /**
     * 显示右压栈集合
     * 
     * 刘备 关羽 张飞
     */
    public void testGetValue1() {
        List list = redisTemplate.boundListOps("namelist1").range(0, 10);
        System.out.println(list);
    }

    /**
     * 左压栈：后添加的对象排在前边
     * 
     * 张飞 关羽 刘备
     */

    public void testSetValue2() {
        redisTemplate.boundListOps("namelist2").leftPush("刘备");
        redisTemplate.boundListOps("namelist2").leftPush("关羽");
        redisTemplate.boundListOps("namelist2").leftPush("张飞");
    }

    /**
     * 显示左压栈集合
     * 
     * 张飞 关羽 刘备
     */

    public void testGetValue2() {
        List list = redisTemplate.boundListOps("namelist2").range(0, 10);
        System.out.println(list);
    }

    /**
     * 查询集合某个元素 index是从左到右取(从0开始)，-数是从右向左(从1开始)
     */
    public void testSearchByIndex() {
        String s = (String) redisTemplate.boundListOps("namelist2").index(-3);
        System.out.println(s);
    }

    /**
     * 移除集合某个元素
     */

    public void testRemoveByIndex() {
        redisTemplate.boundListOps("namelist1").remove(1, "关羽");
    }

    /**
     * 移除key
     */
    public void testRemoveKey() {
        redisTemplate.delete("namelist1");
        redisTemplate.delete("namelist2");
    }
}

TestSet.java

package com.cehae.test;

import java.util.Set;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring/applicationContext-redis.xml")
public class TestSet {

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 存入值
     */
    public void setValue() {
        redisTemplate.boundSetOps("nameset").add("曹操");
        redisTemplate.boundSetOps("nameset").add("刘备");
        redisTemplate.boundSetOps("nameset").add("孙权");
    }

    /**
     * 提取值
     */
    public void getValue() {
        Set members = redisTemplate.boundSetOps("nameset").members();
        System.out.println(members);
    }

    /**
     * 删除集合中的某一个值
     */
    public void deleteValue() {
        redisTemplate.boundSetOps("nameset").remove("孙权");
    }

    /**
     * 删除整个集合
     */
    public void deleteAllValue() {
        redisTemplate.delete("nameset");
    }
}

源码下载

GitHub

Linux环境安装redis丶搭建redis集群以及Spring

一丶环境准备

二丶安装redis

三丶使用redis-cli

关闭redis

四丶搭建redis集群

redis集群原理

搭建集群

安装所需要的资料可以自行下载，也可以去我GitHub下面下载。欢迎star，转载请私聊，谢谢。

SpringDataRedis的使用

搭建工程引入依赖

配置文件

编写测试代码

TestValue.java

TestHash.java

TestList.java

TestSet.java

源码下载

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读