1.Redis概述

第1关：Redis简介

REmote DIctionary Server(Redis) 是一个由Salvatore Sanfilippo写的key-value存储系统。

Redis是一个开源的使用ANSI C语言编写、遵守BSD协议、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。

它通常被称为数据结构服务器，因为值（value）可以是字符串(String), 哈希(Hash), 列表(list), 集合(sets) 和有序集合(sorted sets)等类型。

任务代码

编程要求

现有键值对：key1:welcome，key2:to，key3:www，key4:educoder，key5:net。根据提示，在右侧编辑器 Begin-End 区间补充redisExec(Jedis jedis)方法的代码，实现如下功能：

把上面这些键值对存入Redis中；
根据key从Redis中取出value的值，拼成一个字符串并返回，相邻value之间有空格。

返回的字符串为welcome to www educoder net ，测试代码会输出返回的字符串。

RedisDemo.java

package com.test;

import redis.clients.jedis.Jedis;

public class RedisDemo {
    private static String[] keys = new String[]{"key1", "key2", "key3", "key4", "key5"};
    private static String[] values = new String[]{"welcome", "to", "www", "educoder", "net"};

    //jedis对象已经连接Redis数据库，请直接使用jedis对象操作
    public String redisExec(Jedis jedis) {
        
        //retStr保存拼接的字符串
        //期望的返回结果是welcome to www educoder net
        StringBuilder retStr = new StringBuilder();

        /********** Begin *********/
        String val="";
         for(int i=0;i<keys.length;i++){
            jedis.set(keys[i],values[i]);
            val=val+jedis.get(keys[i])+' ';
         }
        jedis.close();
        retStr.append(val);
        /********** End *********/
        
        return retStr.toString();
    }
}

2.Redis常用数据结构

第1关：Redis中的数据结构

名称	类型	数据存储选项	查询类型	附加功能
`Redis`	基于内存的非关系型数据库	字符串、列表、集合、哈希、有序集合	针对数据类型有专属命令，另有批量操作和不完全的事务支持	发布与订阅、复制、持久化、脚本扩展
`memcached`	基于内存的键值缓存	键值映射	创建、读取、更新、删除等	多线程支持
`MySQL`	关系型数据库	数据表、视图等	查询、插入、更新、删除、内置函数、自定义存储过程等	支持 `ACID` 性质、复制等
`MongoDB`	基于硬盘的非关系型文档存储数据库	无 `schema` 的 `BSON` 文档	创建、读取、更新、删除、条件查询等	复制、分片、空间索引等

结构类型	存储的值
`STRING`	字符串、整数或浮点数
`LIST`	一个链表，上面的每个节点都是一个字符串
`SET`	包含若干个字符串的无序集合，且集合中的元素都是唯一的
`HASH`	包含键值对的无序散列表
`ZSET`	成员中的字符串与分值的有序映射，其排序由分值决定

任务代码

编程要求

根据提示，打开命令行，启动 Redis 客户端并创建一些值：

使用默认配置后台启动 Redis 服务器
启动 Redis 客户端 redis-cli
设置字符串
- 键为 hello
- 值为 redis
设置列表，键为 educoder-list
- 从列表左侧推入元素 hello
- 从列表右侧推入元素 educoder
  从列表右侧推入元素 bye
- 从列表右侧弹出一个元素
设置集合，键为 educoder-set
- 添加元素 c
- 添加元素 python
- 添加元素 redis
- 删除元素 c
设置哈希，键为 educoder-hash
- 添加键：python，值为：language
- 添加键：ruby，值为：language
- 添加键: redis，值为：database
- 删除键 ruby
设置有序列表，键为 educoder-zset
- 添加成员 jack，分值为 200
- 添加成员 rose，分值为 400
- 添加成员 lee，分值为 100

命令行

redis-cli
set hello redis
rpush educoder-list hello
rpush educoder-list educoder
sadd educoder-set python
sadd educoder-set redis
hset educoder-hash python language
hset educoder-hash redis database
zadd educoder-zset 100.0 lee
zadd educoder-zset 200.0 jack
zadd educoder-zset 400.0 rose

命令行粘贴：Ctrl+Shift+v 或者鼠标右键粘贴

示例图

第2关：Java操作Redis的数据

连接 Redis

1
2
3

String redisHost = "127.0.0.1";
int redisPort=6379;
Jedis jedis = new Jedis(redisHost,redisPort);

任务代码

编程要求

根据提示，在右侧编辑器补充代码，根据以下要求去使用Java 操作 Redis: 1、哈希表名为name_password。

查询出用户有多少。
将lisi的密码修改为ls456789。

2、有序列表名为student_scores。

查询出分数为600分到800分之间的同学学生姓名和分数
小红的分数少加了20分，请给她加上去

Step2RedisTest.java

package com.test;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Tuple;
import java.util.Set;
public class Step2RedisTest {
    public static void main(String[] args) {
        String redisHost = "127.0.0.1";
        int redisPort = 6379;
        Jedis jedis = new Jedis(redisHost, redisPort);
        AddRedis addRedis=new AddRedis();
        addRedis.add();
        /**********Begin**********/
        //查询出用户有多少
        System.out.println("用户数量为："+jedis.hlen("name_password"));
        System.out.println("------------------------");
        //将lisi的密码修改为ls456789
        jedis.hset("name_password","lisi","ls456789");
        System.out.println("修改后的密码为："+jedis.hget("name_password","lisi"));
        System.out.println("------------------------");
        //查询出分数为600分到800分之间的同学学生姓名和分数
        Set<Tuple> student_scores = jedis.zrangeByScoreWithScores("student_scores", 600, 800);
        System.out.println("600分到800分之间的同学为：");
        for (Tuple score:student_scores){
            System.out.println(score.getElement()+"-"+score.getScore());
        }
        System.out.println("------------------------");
        //小红的分数错误了，少加了20分，请给她加上去
        jedis.zincrby("student_scores",20,"xiaohong");
        Double zscore = jedis.zscore("student_scores", "xiaohong");
        System.out.println("小红的修改后的分数为："+zscore);
        /**********End**********/
        //删除所有key值
        jedis.flushDB();
        jedis.close();
    }
}

3.Redis一些常用的技术

第1关：Redis 事务与锁机制

1.Redis 的基础事务。 2.Redis 事务回滚。 3.使用 watch 命令监控事务。

命令	说明	备注
multi	开始事务命令，之后的命令进入队列，而不会马上执行	在事务生存期间，所有的 Redis 关于数据结构的命令都会入队
watch key1 [key2 ……]	监听某些键，当被监听的键在事务执行前被修改，则事务会被回滚	使用乐观锁
unwatch key1 [key2 ……]	取消监听某些键
exec	执行事务，如果被监听的键没有被修改，则采用执行命令，否则就回滚命令	在执行事务队列存储的命令前，Redis 会检测被监听的键值对有没有发生变化，如果没有则执行命令，否则就回滚事务
discard	回滚事务	回滚进入队列的事务命令，之后就不能再用 exec命令提交了

任务代码

编程要求

根据提示，在右侧编辑器Begin-End补充代码，根据以下要求完成一个模拟一次银行卡支付扣款的流程：

1、当余额不足时，放弃所有被监控的键，返回false。

2、在余额扣除消费的金额，在支付金额里加上消费的金额。

TestRedis.java

package com.test;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;

import java.util.List;

public class TestRedis {
    private static String host = "127.0.0.1";
    private static int port = 6379;
    private static Jedis jedis = new Jedis(host, port);
    public static boolean payMent(int deduction) throws InterruptedException {
        int balance=0;  // 余额
        //设置余额金额
        
        jedis.set("balance", "100");
        jedis.set("deduction", "10");
        //监控扣款和余额
        jedis.watch("balance", "deduction");
        /***********Begin***********/
        // 余额不足
        balance=Integer.parseInt(jedis.get("balance"));
        if(balance<deduction){
             return false;
        }
        // 开启事务
        Transaction transaction = jedis.multi();
        //扣钱
        transaction.set("balance", "90");
        transaction.set("deduction", "10");
        //事务执行
        transaction.exec();
        //返回
        return true;
        /***********End***********/
    }
    public static void main(String[] args) throws InterruptedException {
    
        boolean resultValue = payMent(10);
        if (resultValue==true){
            System.out.println("支付成功");
            int balance = Integer.parseInt(jedis.get("balance"));
            int deduction = Integer.parseInt(jedis.get("deduction"));
            System.out.printf("本次扣款"+deduction+"元，余额为"+balance+"元");
        }else{
            System.out.println("支付失败");
        }
    
        jedis.close();
    }
    }

第2关：流水线

1.Redis 的流水线技术。

任务代码

编程要求

根据提示，在右侧编辑器Begin-End补充代码，按照以下要求开启一次流水线技术：

开启流水线。
测试十万条读写操作,设置 key 值为 key0 、 key1 、 key2 …key99998、key99999，对应 value 值为 value0 、value1、value2…value99998、value99999。
结束流水线。

RedisPipeline.java

package com.test;
import redis.clients.jedis.*;
import java.util.List;
public class RedisPipeline {

    public  boolean pipeline() {
        String redisHost = "127.0.0.1";
        int redisPort = 6379;
        Jedis jedis = new Jedis(redisHost, redisPort);
        jedis.flushDB();
        /**********Begin**********/
        long start = System.currentTimeMillis();
        // 开启流水线
        Pipeline pipeline = jedis.pipelined();
        System.out.println("开启流水线");
    
        // 测试十万条读写操作
        for (int i = 0; i < 100000; i++) {
            pipeline.set("key"+i,"value"+i);
            pipeline.get("key" + i);
        }
    
        long end = System.currentTimeMillis();
        //关闭流水线
        List result = pipeline.syncAndReturnAll();
        System.out.println("消耗时间："+(end-start)+"毫秒");
        System.out.println("关闭流水线");
        /**********End**********/
        return true;
    
    }
}

第3关：发布订阅

1.Redis 发布订阅技术。2. 利用 Java 来实现发布订阅的流程。

任务代码

编程要求

根据提示，在右侧编辑器Begin-End补充代码，按照以下要求：

在SubThread类中订阅指定频道redis。

SubThread.java

package com.test;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
public class SubThread extends  Thread {
    private final JedisPool jedisPool;
    private final Subscriber subscriber = new Subscriber();
    private final String channel = "redis";
    public SubThread(JedisPool jedisPool) {
        super("SubThread");
        this.jedisPool = jedisPool;
    }
    @Override
    public void run() {
        System.out.println(String.format("订阅redis, 订阅频道为 %s, 线程将被阻塞", channel));
        Jedis jedis = null;
        System.out.println(String.format("订阅redis频道成功, 频道为 %s, 订阅频道为 1",
                channel));
        System.out.println("请输入传输的信息：");
        try {
            /************* Begin ***************/
            jedis = jedisPool.getResource();
            jedis.subscribe(subscriber, channel);
             /************* End ***************/
        } catch (Exception e) {
            System.out.println(String.format("订阅频道错误, %s", e));
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
    }
}

第4关：超时命令

1.Redis 的超时命令。 2.使用 Spring 操作 Redis 超时命令。

命令	说明	备注
persist key	持久化key,取消超时时间	移除key的超时时间
ttl	查看key的超时时间	以秒计算，-1代表没有超时时间，如果不存在key或者key已经超时则为-2
expire key seconds	设置超时时间戳	以秒为单位
expireat key timestamp	设置超时时间点	用unix时间戳确定
pptl key milliseconds	查看key的超时时间戳	用毫秒计算
pexpire key	设置键值超时的时间	以毫秒为单位
pexpireat key stamptimes	设置超时时间点	以毫秒为单位的unix时间戳

任务代码

编程要求

根据提示，在右侧编辑器Begin-End补充代码，按照以下要求使用 Spring 操作 Redis 超时命令过程：
- 创建键值对：key 值为“今天你吃了吗？”
- 获取 key 值
- 设置 key 的过期时间为 5 秒

OverTimeRedisTest.java

package com.redis;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.data.redis.core.RedisOperations;
import org.springframework.data.redis.core.RedisTemplate;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import java.util.concurrent.TimeUnit;
public class OverTimeRedisTest {
    @SuppressWarnings({ "unchecked", "rawtypes", "resource" })
    public static void main(String[] args) {
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        RedisTemplate redisTemplate=applicationContext.getBean(RedisTemplate.class);
        redisTemplate.execute((RedisOperations ops) -> {
       /************Begin************/
        ops.boundValueOps("key").set("今天你吃了吗？");
        String value = (String) ops.boundValueOps("key").get();
        System.out.println(value);
        ops.expire("key", 5L, TimeUnit.SECONDS);
        /************End************/
        //睡眠6秒，使得key值过期
        try {
            Thread.sleep(6000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        //获取key值
        System.out.println((String)ops.boundValueOps("key").get());
        //结束所有线程，退出系统
        System.exit(0);
        return null;
        });
    }
}

第5关：使用Lua语言

在 Redis 的 2.6 以上版本中，除了可以使用命令外，还可以使用 Lua 语言操作 Redis。从前面的命令可以看出 Redis 命令的计算能力并不算很强大，而使用 Lua 语言则在很大程度上弥补了 Redis 的这个不足。只是在 Redis 中，执行 Lua 语言是原子性的，也就说 Redis 执行 Lua 的时候是不会被中断的，具备原子性，这个特性有助于 Redis 对并发数据一致性的支持。 Redis 支持两种方法运行脚本，一种是直接输入一些 Lua 语言的程序代码：另外一种是将 Lua 语言编写成文件。在实际应用中，一些简单的脚本可以采取第一种方式，对于有一定逻辑的一般采用第二种方式。

1.执行输入 Lua 程序代码。 2.执行 Lua 文件。

任务代码

编程要求

根据提示，在右侧编辑器 Begin - End 处补充代码，根据以下要求完成一次手机销售库存的操作：
- 编写 ItemRedisTest.lua 文件，判断销售量是否比库存数量多，如果库存数量大于这次销售量，将新的库存数量更新到原来的 key 值上。
- 编写 ItemRedisTest.java 文件，使用 BufferedReader 读取ItemRedisTest.lua 文件，使用 eval 命令执行文件里的字符串，设置手机销售量为10。
- ItemRedisTest.lua 地址为：/data/workspace/myshixun/step5/ItemRedisTest.lua

ItemRedisTest.java

package com.redis;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.data.redis.core.RedisTemplate;
import redis.clients.jedis.Jedis;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class ItemRedisTest {
    public static void main(String[] args) throws IOException {
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        RedisTemplate redisTemplate=applicationContext.getBean(RedisTemplate.class);
        Jedis jedis=(Jedis)redisTemplate.getConnectionFactory().getConnection().getNativeConnection();
        jedis.set("phone_item_stock", "100");
         /************Begin************/
        BufferedReader in= new BufferedReader(new FileReader("/data/workspace/myshixun/step5/ItemRedisTest.lua"));
        String context =null;
        String script="";
        while (null != (context = in.readLine())){
            script+=context+"\n";
        }
        Object obj =  jedis.eval(script, 1,"phone_item_stock","10");
        /************End************/
        System.out.println("手机库存剩余："+obj);
        //关闭连接
        jedis.close();
        System.exit(0);
    }
}

ItemRedisTest.lua

local count = redis.call('get', KEYS[1])
local a=tonumber(count)
local b=tonumber(ARGV[1])
---Begin
if a>=b then
    redis.call('set',KEYS[1],count-b)
    return redis.call('get', KEYS[1])
end

---End

4.Redis的常用配置

Redis 的常用配置，包括备份、回收策略、主从复制和哨兵模式

第1关：Redis的基础配置文件

1.Redis常见配置redis.conf

任务

编程要求

根据相关知识，按照要求完成右侧选择题任务，包含单选题和多选题。

选择题

第2关：Redis 的高级配置

1.Redis备份（持久化）。

2.Redis内存回收策略。

3.复制。

4.哨兵模式。

相关知识

Redis备份（持久化）

在 Redis 中存在两种方式的备份：一种是快照，它是备份当前瞬间 Redis 在内存中的数据记录；另一种是只追加文件，其作用就是当 Redis 执行写命令后，在一定的条件下将执行过的写命令依次保存在 Redis 的文件中，将来就可以依次执行那些保存的命令恢复 Redis 的数据了。对于快照备份而言，如果当前 Redis 的数据量大，备份可能造成 Redis 卡顿，但是恢复重启时比较快速的；对于 AOF 备份而言，它只是追加写入命令，所以备份一般不会造成 Redis 卡顿，但是恢复重启要执行更多的命令，备份文件可能也很大，使用者使用的时候要注意。在 Redis 中允许使用其中的一种、同时使用两种，或者两者都不用，所以具体使用何种方式进行备份和持久化是用户可以通过配置决定的。我们来介绍一下这些默认配置：

1
2
3

save 900 1
save 300 10
save 60 10000

这3个配置项的含义分别为:

当 900 秒执行 1 个写命令时，启用快照备份。
当 300 秒执行 10 个写命令时，启用快照备份。
当 60 秒内执行 10000 个写命令时，启用快照备份。

Redis 执行 save 命令的时候，将禁止写入命令。

1	`stop-writes-on-bgsave-error yes`

这里先谈谈 bgsave 命令，它是一个异步保存命令，也就是系统将启动另外一条进程，把 Redis 的数据保存到对应的数据文件中。它和 save 命令最大的不同是它不会阻塞客户端的写入，也就是在执行 bgsave 的时候，允许客户端继续读/写 Redis 。在默认情况下，如果 Redis 执行 bgsave 失败后，Redis 将停止接受写操作，这样以一种强硬的方式让用户知道数据不能正确的持久化到磁盘，否则就会没人注意到灾难的发生，如果后台保存进程重新启动工作了， Redis 也将自动允许写操作。然而如果安装了靠谱的监控，可能不希望 Redis 这样做，那么你可以将其修改为 no。

1	`rdbchecksum yes`

这个命令意思是是否对 rbd 文件进行检验，如果是将对 rdb 文件检验。从 dfilename 的配置可以知道，rdb 文件实际是 Redis 持久化的数据文件。

1	`dbfilename dump.rdb`

它是数据文件。当采用快照模式备份（持久化）时，Redis 将使用它保存数据，将来可以使用它恢复数据。

1	`appendonly no`

如果 appendonly 配置 no，则不启用 AOF 方式进行备份。如果 appendonly 配置为 yes，则以 AOF 方式备份 Redis 数据，那么此时 Redis 会按照配置，在特定的时候执行追加命令，用以备份数据。

1	`appendfilename "appendonly.aof"`

这里追加的写入文件为 appendonly.aof，采用 AOF 追加文件备份的时候命令都会写到这里。

1
2
3

# appendfsync always
appendfsync everysec
# appendfsync no

AOF 文件和 Redis 命令是同步频率的，假设配置为 always ，其含义为当 Redis 执行命令的时候，则同时同步到 AOF 文件，这样会使得 Redis 同步刷新 AOF 文件，造成缓慢。而采用 evarysec 则代表每秒同步一次命令到 AOF 文件。采用 no 的时候，则由客户端调用命令执行备份，Redis 本身不备份文件。对于采用 always 配置的时候，每次命令都会持久化，它的好处在于安全，坏处在于每次都持久化性能较差。采用 evarysec 则每秒同步，安全性不如 always ,备份可能会丢失 1 秒以内的命令，但是隐患也不大，安全度尚可，性能可以得到保障。采用 no ,则性能有所保障，但是由于失去备份，所以安全性比较差。

建议采用默认配置 everysec ,这样在保证性能的同时，也在一定程度上保证了安全性。

1	`no-appendfsync-on-rewrite no`

它指定是否在后台 AOF 文件 rewrite (重写)期间调用 fsync ，默认为 no ，表示要调用 fsync（无论后台是否有子进程在刷盘）。Redis 在后台写 RDB 文件或重写 AOF 文件期间会存在大量磁盘I/O，此时，在某些 Linux 系统中，调用 fsync 可能会阻塞。

1	`auto-aof-rewrite-percentage 100`

他指定 Redis 重写 AOF 文件的条件，默认为100，标识与上次 rewire 的 AOF 文件大小相比，当前 AOF 文件增长量超过上次 AOF 文件大小的100%时，就会触发 backgroundrewrite 。若配置为 0，则会禁用自动 rewrite 。

1	`auto-aof-rewrite-min-size 64mb`

它指定触发 rewrite 的 AOF 文件大小。若 AOF 文件小于该值，即使当前文件的增量比例到达 auto-aof-rewrite-percentage 的配置值，也不会触发自动 rewrite。即这两个配置项同时满足时，才会触发 rewrite。

1	`aof-load-truncated yes`

Redis 在恢复时会忽略最后一条可能存在问题的指令，默认为 yes。即在 AOF 写入时，可能存在指令写错的问题（突然断电），这种情况下 yes会 log 并继续，而 no 会直接恢复失败。

Redis内存回收策略

Redis 也会因为内存不足而产生错误，也有时候因为长时间回收导致系统长期的停顿，因此掌握执行回收策略十分有必要。在 Redis 的配置文件中，当Redis的内存到达规定的最大值时，允许配置6种策略中的一种进行淘汰键值，并且将一些键值对进行回收，让我们来看看它们具有哪些特点。

Redis 对其中一个配置项——maxmemory-policy，提供了这样的一段描述：

我们来介绍下这 6 种策略的含义：

valatile-lru：采用最少的淘汰策略删除超时的键值对，作用对象为超时对象。
allkeys-lru：采用最少的淘汰策略删除键值对，作用对象为所有对象。
volatile-random：采用随机淘汰策略随机删除超时的键值对，作用对象为超时对象。
allkeys-random：采用随机淘汰策略随机删除键值对，作用对象为所有对象。
volatile-ttl：删除存活时间最小即将超时的键值对。
noeviction：永不过期，当内存已满时，如果读操作正常工作，而写操作，会返回错误信息。

Redis 默认情况下会采用 noeviction 策略。然而 noeviction 策略当内存已满时，是只能读取不能写入，所以不能满足我们所有的要求，因为对互联网系统而言，常常会涉及数以百万甚至更多的用户，所以往往需要设置回收策略。

这里需要指出的是：LRU 算法或者 TTL 算法都不是很精确的算法，而是一个近似的算法。 Redis 不会通过对全部的键值对进行比较来确定最精确的时间值，从而确定删除哪个键值对，因为这将消耗太多的时间，导致回收垃圾执行的时间太长，造成服务停顿。而在 Redis 的默认配置文件中，存在着参数 maxmemory-samples ,它的默认值为 3 ，假设采取了 volatile-ttl 算法，让我们去了解这样的一个回收过程，假设当前有 4 个即将超时的键值对:

键值对	剩余超时秒数
a	5
b	4
c	6
d	3

因为 maxmemory-samples 的值为 3 ，所以他只会取到前三个样本，然后进行比较。因为 b 剩余秒数最少，所以 b 是最先被删除的。但是剩余超时秒数最短的 d 还在内存中，因为它不属于探测样本中的。这就是 Redis 中采用的近似算法。当设置 maxmemory-samples 越大，则 Redis 探测样本的数量越多，删除的就越精确，但是它的缺点会让使用的时间越长。

回收超时策略不足的是删除必须指明超时的键值对，这样会让代码量增长，加大开发者的工作任务。但是针对所有的键值对进行回收，有可能把正在使用的键值对删除掉，增加了存储的不稳定性。对于垃圾回收的策略，还需要注意的是回收的时间，因为在 Redis 对垃圾的回收期间，会造成系统缓慢。因此，控制其回收时间有一定好处，只是这个时间不能过短或过长。过短则会造成回收次数过于频繁，过长则导致系统单次垃圾回收停顿时间过长，都不利于系统的稳定性，这些都需要设计者在实际的工作中进行思考。

复制

尽管Redis的性能不错，但是面对每秒成千上万的请求，大量的读操作就会到达Redis服务器，触发许许多多的操作，靠一台Redis服务器是完全不够用的。一些服务网站对安全性有较高的要求，当主服务器不能正常工作时，也需要从服务器代替原来的主服务器，作为灾难备份，以保证系统可以继续正常的工作。因此更多的时候我们要将读/写分离，因为读操作远远比写操作频繁的多，如果把数据都存放在多台服务器上那么就可以从多台服务器中读取数据，从而消除了单台服务器的压力，我们也可以基于主从复制，构建哨兵模式与集群，实现Redis的高可用方案。

主从同步基础概念

互联网系统一般是以主从架构为基础的，所谓主从架构的设计的思路大概是：

在多台数据服务器中，只有一台主服务器，而主服务器只负责写入数据，不负责外部程序读取数据。
存在多台从服务器，从服务器不写入数据，只负责同步主服务器的数据，并让外部程序读取数据。
主服务器写入数据后，即刻将写入数据的命令发送给从服务器，从而使得主从数据同步。
应用程序可以随机读取某一台从服务器的数据，这样就可以分摊读取数据的压力。
当从服务器不能工作时，整个系统将不受影响；当主服务器不能工作时，可以方便地从从服务器选举一台来当主服务器。

大家可以看下主从同步机制图，更加理解 Redis 的复制机制：

可以从机制图看出，我们读取数据是在从服务器上读取的，当从服务器是多台的时候，那么单台服务器的压力就大大降低了，这十分有利于系统性能的提高，当主服务器不能工作的情况时，也可以切换为其中的一台从服务器继续让系统稳定运行，所以也有利于系统运行的安全性。当然由于Redis自身具备的特点，所以其也有实现主从同步的特殊方式。

Redis主从同步配置

对Redis进行主从同步的配置分为主机与从机，主机是一台，而从机可以是多台。首先我们要明确主机，关建两个配置是dir和dbfilename选项，dir的默认值为./,dbfilename默认采用Redis当前目录的dump.rbd文件进行同步。其次，明确了从机之后，进行进一步配置所要关注的只有slaveof这个配置选项：

其中masterip代表主机地址，masterport代表主机端口。当从机Redis服务重启时，就会同步对应主机的数据了。当不想让从机继续复制主机的数据时，可以在从机的Redis命令客户端发送slaveof no one 命令，这样从机就不会再接收主服务器的数据更新了。又或者原来主服务器已经无法工作了，而你可能需要复制新的主机，这个时候执行slaveof masterip masterport 就能让从机复制另外一台主机的数据了。在实际的Linux环境中，配置文件redis.conf中还有一个bind的配置，默认为127.0.0.1，也就是只允许本机访问，把它修改为bind 0.0.0.0，其他的服务器就能够访问了。

Redis主从同步的过程

Redis主从同步共分为5步：

主服务器开启后，从服务器连接主服务器，发送SYNC命令
主服务器接收到SYNC命名后，开始执行bgsave命令生成RDB文件并使用缓冲区记录此后执行的所有写命令；
主服务器bgsave执行完后，向所有从服务器发送快照文件，并在发送期间继续记录被执行的写命令,从服务器收到快照文件后丢弃所有旧数据，载入收到的快照；
主服务器快照发送完毕后开始向从服务器发送缓冲区中的写命令；
从服务器完成对快照的载入，开始接收命令请求，并执行来自主服务器缓冲区的写命令。

Redis 主从同步的过程图如下：

只要在主服务器同步到从服务器的过程中，需要备份文件，所以在配置的时候一般需要预留一些内存空间给主服务器，用来腾出空间执行备份命令。一般来说主服务器使用50%~60%的内存空间，为主从复制留下可用的内存空间。

哨兵模式

主从切换技术的方法是：当主机服务器宕机后，需要手动把一台从服务器切换为主服务器，这就需要人工干预，既费时又费力，还会造成一段时间内服务不可用，这不是一个推荐的方式，所以我们考虑哨兵模式，它是当前企业应用的主流方式。

哨兵模式概述

Redis可以存在多台服务器，并且实现了主从复制的功能。哨兵模式是一种特殊的模式，首先 Redis 提供了哨兵的命令，哨兵是一个独立的进程。其原理是哨兵通过发送命令，等待Redis服务器相应，从而监控运行的多个Redis实例。如下图：

这里哨兵有两个作用：

通过发送命令，让Redis服务器返回检测其运行状态，包括主服务器和从服务器。
当哨兵监测到master宕机，会自动将slave切换成master，然后通过发布订阅模式通知到其他的从服务器，修改配置文件，让它们自动切换主机。

只是现实中一个哨兵进程对Redis服务器进行监控，也可能出现问题，为了处理这个问题，还可以使用多个哨兵的监控，而各个哨兵之间还会相互监控，这样就变为了多个哨兵模式。多个哨兵不仅监控各个Redis服务器，而且哨兵之间互相监控，看看哨兵们是否还存在着。论述下故障切换的过程。假设主服务器宕机，哨兵1先检测到这个结果，当时系统并不会马上进行切换操作，而仅仅是哨兵1主观地认为主机不可用，这个现象被称为主观下线。当后面的哨兵监测到了主服务器不可用，并且有了一定的数量的哨兵认为主服务器不可用，那么哨兵之间就会形成一次投票，投票结果由一个哨兵发起，进行故障切换操作，在操作的过程中切换成功后，就会通过发布订阅方式，让各个哨兵把自己监控的服务器实现切换主机，这个过程被称为客观下线。

搭建哨兵模式

配置3个哨兵和1主2从的Redis服务器来演示这个过程。

服务类型	是否主服务器	IP地址	端口
Redis	是	192.168.44.128	6379
Redis	否	192.168.44.129	6379
Redis	否	192.168.44.130	6379
Sentinel	-	192.168.44.128	26379
Sentinel	-	192.168.44.129	26379
Sentinel	-	192.168.44.130	26379

接下来修改redis.conf文件进行配置：

＃使得 Redis 服务器可以跨网络访问
bind 0.0.0.0
＃设置密码
requirepass "redis123"
#指定主服务器，注意:有关slaveof的配置只是配置从服务器，而主服务器不需要配置
slaveof 192.168.44.128 6379
＃主服务器密码，注意：有关 slaveof 的配置只是配置从服务器，而主服务器不需要配置
masterauth redis123

修改sentinel.conf文件进行配置：

#禁止保护模式
protected-mode no
#配置监听的主服务器，这里sentinel monitor 代表监控，
#mymaster代表服务器名称，可以自定义
#192.168.44.128代表监控的主服务器
#6379代表端口
#2 代表只有两个或者两个以上的哨兵认为主服务器不可用的时候，才会做故障切换操作
sentinel monitor mymaster 192.168.44.128 6379 2
#sentinel auth-pass 定义服务的密码
#mymaster服务名称
#redis123 Redis服务器密码
sentinel auth-pass mymaster redis123

上述关闭了保护模式，以便于测试。

我们启动Redis服务器和哨兵：

#启动哨兵进程
./redis-sentinel ../sentinel.conf
#启动Redis服务器进程
./redis-server ../redis.conf

要注意启动的顺序，首先是主机Redis服务进程，然后启动从服务器，最后启动哨兵的服务进程。

在Java中使用哨兵模式

在Java中使用哨兵模式，只需要加入关于哨兵的信息即可：

//连接池配置
      JedisPoolConfig jedisPoolConfig =new JedisPoolConfig();
      jedisPoolConfig.setMaxTotal(10) ;
      jedisPoolConfig.setMaxIdle(5);
      jedisPoolConfig.setMinIdle(5);
      //哨兵信息
      Set<String> sentinels =new HashSet<String>(Arrays.asList(
             "192.168.44.128:26379",
              "192.168.44.129:26379",
              "192.168.44.130:26379"
          ));
      //创建连接池
      //mymaster是我们配置给哨兵的服务名称
      //sentinels是哨兵信息
      //jedisPoolConfig是连接池配置
      //redis123是连接Redis服务器的密码
      JedisSentinelPool pool=new JedisSentinelPool("mymaster",sentinels,jedisPoolConfig,"redis123");
      //获取客户端
      Jedis jedis = pool.getResource();
      //执行两个命令
      jedis.set("mykey","myvalue");
      String myvalue=jedis.get("mykey");
      //打印信息
      System.out.println(myvalue);

通过上述的代码就能够连接Redis服务器了，这个时候将启动主机提供服务。为了验证哨兵的作用，我们可以把主机上的Redis服务器关闭，Redis哨兵会进行投票切换主机，我们就可以得到下面的日志：从从日志可以看到，我们现在使用的是从服务器192.168.44.130，这是因为主服务器192.168.44.128不可用后，哨兵们经过投票最终切换为从服务器192.168.44.130，通过这样的自动切换就保证服务能够持续稳定运行了。

同样的，通过配置也可以实现在SpringBoot中测试哨兵：

配置application.yml文件:

spring:
  redis:
    cluster:
      # 集群模式下，逗号分隔的键值对（主机：端口）形式的服务器列表
      nodes: 192.168.44.128:6379,192.168.44.129:6379,192.168.44.130:6379
      #集群模式下，集群最大转发的数量
      max-redirects: 3
    sentinel:
      #哨兵模式下，逗号分隔的键值对（主机：端口）形式的服务器列表
      nodes: 192.168.44.128:26379,192.168.44.129:26379,192.168.44.130:26379
      #哨兵模式下，Redis主服务器地址
      master: mymaster
    # 使用数据库的索引编号，一个示例有16个数据库 0 到 15
    database: 0
    lettuce:
      pool:
        # 连接池最大连接数(使用负值表示没有限制) 默认为8
        max-active: 8
        # 连接池最大阻塞等待时间(使用负值表示没有限制) 默认为-1
        max-wait: -1
        # 连接池中的最大空闲连接 默认为8
        max-idle: 8
        # 连接池中的最小空闲连接 默认为 0
        min-idle: 0
    # Redis服务器的密码
    password: redis123
    # 连接超时，毫秒为单位
    timeout: 6000

要注意这里使用的是 lettuce 客户端而不是 Jedis 客户端，因为在 springboot 1.5.x版本的默认的Redis客户端是 Jedis实现的，springboot 2.x版本中默认客户端是用 lettuce实现的。这两个客户端的区别：

Jedis是直接连接redis server ,如果在多线程环境下是非线程安全的，这个时候只有使用连接池，为每个 Jedis 实例增加物理连接。
Lettuce的连接是基于Netty的，连接实例可以在多个线程间并发访问，应为StatefulRedisConnection是线程安全的，所以一个连接实例就可以满足多线程环境下的并发访问，当然这个也是可伸缩的设计，一个连接实例不够的情况也可以按需增加连接实例。

单元测试：

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.test.context.junit4.SpringRunner;
@RunWith(SpringRunner.class)
@SpringBootTest
public class RedisConfigurationTest {
    @Autowired
    private RedisTemplate<String,String>  redisTemplate;
    @Test
    public void test(){
        ValueOperations<String, String> opsForValue = redisTemplate.opsForValue();
        opsForValue.set("redisTest","HelloWorld");
        System.out.println(opsForValue.get("redisTest"));
    }
}

输出结果为：HelloWorld

任务代码

编程要求

根据提示，在右侧编辑器补充代码，根据以下要求测试连接单节点Redis和哨兵。在application.yml文件中配置

spring.redis.cluster.node 为127.0.0.1:6379
spring.redis.sentinel.nodes为 127.0.0.1:26379
spring.redis.sentinel.master为mymaster

在RedisController编写代码，实现设置key值为HelloWorld并返回key值。

RedisController.java

package com.example.springredis.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class RedisController {
    @Autowired
    RedisTemplate<String,String> redisTemplate;

    @RequestMapping("/index")
    @ResponseBody
    public String get(){
    	 ValueOperations<String, String> opsForValue = redisTemplate.opsForValue();
        //*********** Begin ***********
        opsForValue.set("redisTest","HelloWorld");
        return opsForValue.get("redisTest");
        //*********** End ***********
    }
}

application.yml

spring:
  redis:
    #************ Begin ************
    cluster:
      # 集群模式下，逗号分隔的键值对（主机：端口）形式的服务器列表
     nodes: 127.0.0.1:6379,127.0.0.1:6379,127.0.0.1:6379
    sentinel:
      #哨兵模式下，逗号分隔的键值对（主机：端口）形式的服务器列表
      nodes: 127.0.0.1:26379,127.0.0.1:26379,127.0.0.1:26379
      #哨兵模式下，Redis主服务器地址
      master: mymaster
    #************ End ************
    # 使用数据库的索引编号，一个示例有16个数据库 0 到 15
    database: 0
    lettuce:
      pool:
        # 连接池最大连接数(使用负值表示没有限制) 默认为8
        max-active: 8
        # 连接池最大阻塞等待时间(使用负值表示没有限制) 默认为-1
        max-wait: -1
        # 连接池中的最大空闲连接 默认为8
        max-idle: 8
        # 连接池中的最小空闲连接 默认为 0
        min-idle: 0
    # 连接超时，毫秒为单位
    timeout: 6000

END

任务地址：
头歌编程：Redis概述
头歌编程：Redis常用数据结构
头歌编程：Redis一些常用的技术
头歌编程：Redis的常用配置

Java > SSM

#Java #笔记 #SSM #Redis

SSM框架-Redis

http://example.com/2021/10/06/SSM关于Redis/

Author

lzdong

Posted on

October 6, 2021

Licensed under

SSM框架-SpringBoot初体验 Previous

数据结构-栈和队列 Next

SSM框架-Redis

1.Redis概述

第1关：Redis简介

相关知识

Redis是什么？

Redis 的优势

Redis 的用途

Java 中连接Redis

Redis 字符串实例

任务代码

2.Redis常用数据结构

第1关：Redis中的数据结构

相关知识

Redis简介

Redis与其他数据库的对比

Redis的特性

快速安装 Redis

Redis数据结构简介

Redis中的字符串

Redis中的列表

Redis中的集合

Redis中的哈希

Redis中的有序集合

任务代码

第2关：Java操作Redis的数据

相关知识

String数据类型

linked-list链表

集合

Hash类型集合

有序集合

任务代码

3.Redis一些常用的技术

第1关：Redis 事务与锁机制

相关知识

Redis的基础事务

Redis 事务回滚

使用 watch 命令监控事务

任务代码

第2关：流水线

相关知识

Redis 的流水线技术

任务代码

第3关：发布订阅

相关知识

Redis 发布订阅技术

利用 Java 来实现发布订阅的流程

任务代码

第4关：超时命令

相关知识

Redis的超时命令

使用 Spring 操作Redis超时命令

任务代码

第5关：使用Lua语言

相关知识

执行输入 Lua 程序代码

执行 Lua 文件

任务代码

4.Redis的常用配置

第1关：Redis的基础配置文件

相关知识

Redis常见配置redis.conf

任务

第2关：Redis 的高级配置

相关知识

Redis备份（持久化）

Redis内存回收策略

复制

主从同步基础概念

Redis主从同步配置

Redis主从同步的过程

哨兵模式

哨兵模式概述

搭建哨兵模式

在Java中使用哨兵模式

任务代码

END