【Redis】系列1、——Redis基础

你只管努力，

——剩下的交给时光。

首先我们带着问题来学习

1、什么是Redis？为什么要用它？用它有什么好处？

Redis是一个开源的使用ANSI C语言编写、遵守BSD协议、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。它通常被称为数据结构服务器，因为值（value）可以是 字符串(String), 哈希(Map), 列表(list), 集合(sets) 和有序集合(sorted sets)等类型。以上标红为Redis常用数据类型。

2、Redis的安装

安装教程

Windows安装

在https://github.com/MSOpenTech/redis/releases地址下载后解压，打开命令行进入解压目录运行

redis-server.exe redis.conf（省略则使用默认）

出现下图服务就已经启动成功了

Linux安装

在https://redis.io/地址下载最新版

解压：$ tar -xzf redis-4.0.11.tar.gz
进入解压后目录：$ cd redis-4.0.11
编译：$ make
进入src目录启动服务器：$ cd src
$ ./redis-server
配置
Redis 的配置文件位于 Redis 安装目录下，文件名为 redis.conf。

可以通过 CONFIG 命令查看或设置配置项。

redis 127.0.0.1:6379> CONFIG GET CONFIG_SETTING_NAME
Redis的数据类型
1.1、String（字符串）

string是redis最基本的类型，你可以理解成与Memcached一模一样的类型，一个key对应一个value。

string类型是二进制安全的。意思是redis的string可以包含任何数据。比如jpg图片或者序列化的对象。

string类型是Redis最基本的数据类型，一个键最大能存储512MB。

redis 127.0.0.1:6379> SET name "123"
OK
redis 127.0.0.1:6379> GET name
"123"
相关命令

SET key value                   设置key=value
GET key                         或者键key对应的值
GETRANGE key start end          得到字符串的子字符串存放在一个键
GETSET key value                设置键的字符串值，并返回旧值
GETBIT key offset               返回存储在键位值的字符串值的偏移
MGET key1 [key2..]              得到所有的给定键的值
SETBIT key offset value         设置或清除该位在存储在键的字符串值偏移
SETEX key seconds value         键到期时设置值
SETNX key value                 设置键的值，只有当该键不存在
SETRANGE key offset value       覆盖字符串的一部分从指定键的偏移
STRLEN key                      得到存储在键的值的长度
MSET key value [key value...]   设置多个键和多个值
MSETNX key value [key value...] 设置多个键多个值，只有在当没有按键的存在时
PSETEX key milliseconds value   设置键的毫秒值和到期时间
INCR key                        增加键的整数值一次
INCRBY key increment            由给定的数量递增键的整数值
INCRBYFLOAT key increment       由给定的数量递增键的浮点值
DECR key                        递减键一次的整数值
DECRBY key decrement            由给定数目递减键的整数值
APPEND key value                追加值到一个键

1.2、Hash（哈希）

Redis hash 是一个键值(key=>value)对集合。

Redis hash 是一个 string 类型的 field 和 value 的映射表，hash 特别适合用于存储对象。

redis> HMSET myhash field1 "Hello" field2 "World"
"OK"
redis> HGET myhash field1
"Hello"
redis> HGET myhash field2
"World"

相关命令

ZADD key score1 member1 [score2 member2] 添加一个或多个成员到有序集合，或者如果它已经存在更新其分数

ZCARD key 得到的有序集合成员的数量

ZCOUNT key min max 计算一个有序集合成员与给定值范围内的分数

ZINCRBY key increment member 在有序集合增加成员的分数

ZINTERSTORE destination numkeys key [key ...]多重交叉排序集合，并存储生成一个新的键有序集合。

ZLEXCOUNT key min max 计算一个给定的字典范围之间的有序集合成员的数量

ZRANGE key start stop [WITHSCORES] 由索引返回一个成员范围的有序集合（从低到高）

ZRANGEBYLEX key min max [LIMIT offset count] 返回一个成员范围的有序集合（由字典范围）

ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT]返回有序集key中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员，有序集成员按 score 值递增(从小到大)次序排列

ZRANK key member 确定成员的索引中有序集合

ZREM key member [member ...] 从有序集合中删除一个或多个成员，不存在的成员将被忽略

ZREMRANGEBYLEX key min max 删除所有成员在给定的字典范围之间的有序集合

ZREMRANGEBYRANK key start stop 在给定的索引之内删除所有成员的有序集合

ZREMRANGEBYSCORE key min max 在给定的分数之内删除所有成员的有序集合

ZREVRANGE key start stop [WITHSCORES] 返回一个成员范围的有序集合，通过索引，以分数排序，从高分到低分

ZREVRANGEBYSCORE key max min [WITHSCORES] 返回一个成员范围的有序集合，以socre排序从高到低

ZREVRANK key member 确定一个有序集合成员的索引，以分数排序，从高分到低分

ZSCORE key member 获取给定成员相关联的分数在一个有序集合

ZUNIONSTORE destination numkeys key [key ...] 添加多个集排序，所得排序集合存储在一个新的键

ZSCAN key cursor [MATCH pattern] [COUNT count]增量迭代排序元素集和相关的分数

Redis键命令

DEL key_name   删除键
DUMP key_name   序列化键，并返回序列化后的值
EXISTS key_name   是否存在键
EXPIPE key_name seconds   设置键过期时间（秒为单位）
EXPIPE key_name timestamp   接受的时间参数是 UNIX 时间戳(unix timestamp)。
PEXPIPE  key_name millseconds   设置键过期时间（豪秒为单位）
PEXPIPE  key_name timestrap   接受的时间参数是 UNIX 时间戳(unix timestamp，毫秒计)。
KEYS pattern   查找所有符合给定模式( pattern)的 key 。
MOVE KEY_NAME DESTINATION_DATABASE   将当前数据库的 key 移动到给定的数据库 db 当中。
PERSIST KEY_NAME   移除给定 key 的过期时间，使得 key 永不过期。
PTTL KEY_NAME   以毫秒为单位返回 key 的剩余过期时间。
TTL KEY_NAME   以秒为单位返回 key 的剩余过期时间。
RANDOMKEY   从当前数据库中随机返回一个 key 。
RENAME OLD_KEY_NAME NEW_KEY_NAME   用于修改 key 的名称。
RENAMENX OLD_KEY_NAME NEW_KEY_NAME   用于在新的 key 不存在时修改 key 的名称。
TYPE KEY_NAME   用于返回 key 所储存的值的类型。

持久化
Redis提供了两种持久化方法，一种叫快照（snapshotting），它可以将存在于某一时刻的所有数据都写入硬盘。另一种是只追加文件（append-only file）它会将所有写命令记录在硬盘里。两者可以同时使用。

持久化配置选项

###快照持久化选项

save 60 1000 ###自动快照间隔时长
stop-write-on-bgsave-error ###创建快照失败后是否仍然继续执行写命令
rdbcompression yes ###是否对快照进行压缩
dbfilename dump。rdb ###快照命名

###AOF持久化选项
appendonly no ###是否进行AOF持久化
appendfaync everysec ###自动AOF间隔时长
no-appendfaync-on-rewrite no ###压缩时能否进行同步操作
auto-aof-rewrite-percentage 100 ###相比上一次重写之后体积大于一倍（100%）执行压缩操作
auto-aof-rewrite-min-size 64mb ###体积大于64mb时执行压缩操作

dir ./ ###快照文件和AOF文件保存位置
手动快照的方法

客户端发送BGSAVE命令，Redis会调用fork来创建一个子进程负责写快照，主进程继续处理请求
客户端发送SAVE命令，主进程响应操作，快照创建完毕之前不再响应其它命令，Redis收到SHUTDOWN关闭服务器命令或者接收到标准TERM信号时，也会执行SAVE命令
当一个Redis连接另一个Redis服务器，并向对方发送SYNC命令来开始一次复制操作时，如果主服务器目前没有在执行BGSAVE操作，或者主服务器并非刚刚执行完BGSAVE，那么主服务器会执行BGSAVE命令。
重写/压缩AOF文件

随着Redis不断运行，AOF文件会非常大，这可能会占满硬盘空间和使还原操作执行时间非常长。可以向Redsi发送BGREWRITEAOF命令重写AOF文件。也可以设置auto-aof-rewrite-percentage和auto-aof-rewrite-min-size来自动执行BGREWRITEAOF

复制

复制可以让其他服务器拥有一个不断更新的数据副本，从而使拥有数据副本的服务器可以用于处理客户端发送的读请求。
在启动Redis服务器时，指定一个包含slaveof host port选项的配置文件，Redis服务器就可以根据指定的IP地址和端口号来连接主服务器；需要注意的一点是：在进行同步时，从服务器会清空自己的所有数据而对于一个正在运行的Redis服务器，可以通过发送SLAVEOF no one命令终止复制操作
主从链

从服务器也可以拥有自己的从服务器，形成主从链。
负载不断上升，主服务器可能会无法快速更新所有从服务器，可以创建一个由Redis主从节点组成的中间层来承担主服务器的复制工作

用户首先需要为主服务器设置多个从服务器，然后对每个从服务器设置appendonly yes选项和append everysec选项，这样的话，就可以让多台服务器以每秒一次的频率将数据同步到硬盘上。
验证快照文件和AOF文件
Redis提供了两个命令行程序redis-check-aof和redis-check-dump，故障发生之后，检查AOF文件和快照文件的状态，并在有需要的情况下对文件进行修复。

如果给定--fix参数，将对AOF文件进行修复，扫描AOF文件，发现第一个出错命令时，则删除出错命令及之后的所有命令。而快照文件无法修复，因为经过压缩操作。

事务
Redis 事务可以一次执行多个命令，并且带有以下三个重要的保证：

1.批量操作在发送 EXEC 命令前被放入队列缓存。

2.收到 EXEC 命令后进入事务执行，事务中任意命令执行失败，其余的命令依然被执行。

3.在事务执行过程，其他客户端提交的命令请求不会插入到事务执行命令序列中。

一个事务从开始到执行会经历以下三个阶段：

1.开始事务。

2.命令入队。

3.执行事务。

redis 127.0.0.1:6379> MULTI
OK

redis 127.0.0.1:6379> SET book-name "Mastering C++ in 21 days"
QUEUED

redis 127.0.0.1:6379> GET book-name
QUEUED

redis 127.0.0.1:6379> SADD tag "C++" "Programming" "Mastering Series"
QUEUED

redis 127.0.0.1:6379> SMEMBERS tag
QUEUED

redis 127.0.0.1:6379> EXEC
1) OK
2) "Mastering C++ in 21 days"
3) (integer) 3
4) 1) "Mastering Series"
2) "C++"
3) "Programming"
安全
通过 redis 的配置文件设置密码参数，这样客户端连接到 redis 服务就需要密码验证。默认情况下 requirepass 参数是空的，这就意味着你无需通过密码验证就可以连接到 redis 服务。可以通过以下命令来修改该参数：

127.0.0.1:6379> CONFIG set requirepass "test"
OK
Java 使用 Redis（Jedis）
配置类

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

public class JedisUtils {
   //创建连接池
   private static JedisPoolConfig config;
   private static JedisPool pool;

   static{
   config=new JedisPoolConfig();
   //最大连接数, 默认8个
   config.setMaxTotal(30);
   //控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值是8。
   config.setMaxIdle(2);
   //连接超时时是否阻塞，false时报异常,ture阻塞直到超时, 默认true
config.setBlockWhenExhausted(true);
//逐出策略（默认DefaultEvictionPolicy(当连接超过最大空闲时间,或连接数超过最大空闲连接数)）
config.setEvictionPolicyClassName("org.apache.commons.pool2.impl.DefaultEvictionPolicy");
//获取连接时的最大等待毫秒数(如果设置为阻塞时BlockWhenExhausted),如果超时就抛异常, 小于零:阻塞不确定的时间, 默认-1
config.setMaxWaitMillis(-1);
//逐出连接的最小空闲时间默认1800000毫秒(30分钟)
config.setMinEvictableIdleTimeMillis(1800000);
//最小空闲连接数, 默认0
config.setMinIdle(0);
//每次逐出检查时逐出的最大数目如果为负数就是 : 1/abs(n), 默认3
config.setNumTestsPerEvictionRun(3);
//对象空闲多久后逐出, 当空闲时间>该值且空闲连接>最大空闲数时直接逐出,不再根据MinEvictableIdleTimeMillis判断 (默认逐出策略)
config.setSoftMinEvictableIdleTimeMillis(1800000);
// 获取连接时的最大等待毫秒数(如果设置为阻塞时BlockWhenExhausted),如果超时就抛异常, 小于零:阻塞不确定的时间,
// 默认-1
config.setMaxWaitMillis(100);
//对拿到的connection进行validateObject校验
config.setTestOnBorrow(true);
//在进行returnObject对返回的connection进行validateObject校验
config.setTestOnReturn(true);
//定时对线程池中空闲的链接进行validateObject校验
config.setTestWhileIdle(true);

pool=new JedisPool(config, "127.0.0.1", 6379);
   }


   //获取连接的方法
   public static Jedis getJedis(){
       return pool.getResource();
   }


   //释放连接
   public static void closeJedis(Jedis j){
       j.close();
   }
}

测试类

import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import redis.clients.jedis.Jedis;

public class TestRedis {

   public static void main(String[] args) {
       Jedis jedis = JedisUtils.getJedis();
       // redis存储字符串
       // -----添加数据----------
       jedis.set("name", "a");// 向key-->name中放入了value-->xinxin
       System.out.println(jedis.get("name"));// 执行结果：xinxin
       jedis.append("name", " b"); // 拼接
       System.out.println(jedis.get("name"));
       jedis.del("name"); // 删除某个键
       System.out.println(jedis.get("name"));
       // 设置多个键值对
       jedis.mset("name", "zhangsan", "age", "23", "qq", "xxxxxxxxxxx");
       jedis.incr("age"); // 进行加1操作
       System.out.println(jedis.get("name") + "-" + jedis.get("age") + "-" + jedis.get("qq"));

       // redis操作Map
       // -----添加数据----------
       Map<String, String> map = new HashMap<String, String>();
       map.put("name", "a");
       map.put("age", "22");
       map.put("qq", "xxxxx");
       jedis.hmset("user", map);
       // 取出user中的name，注意结果是一个泛型的List
       // 第一个参数是存入redis中map对象的key，后面跟的是放入map中的对象的key，后面的key可以跟多个，是可变参数
       List<String> rsmap = jedis.hmget("user", "name", "age", "qq");
       System.out.println(rsmap);
       // 删除map中的某个键值
       jedis.hdel("user", "age");
       System.out.println(jedis.hmget("user", "age")); // 因为删除了，所以返回的是null
       System.out.println(jedis.hlen("user")); // 返回key为user的键中存放的值的个数2
       System.out.println(jedis.exists("user"));// 是否存在key为user的记录返回true
       System.out.println(jedis.hkeys("user"));// 返回map对象中的所有key
       System.out.println(jedis.hvals("user"));// 返回map对象中的所有value
       Iterator<String> iter = jedis.hkeys("user").iterator();
       while (iter.hasNext()) {
           String key = iter.next();
           System.out.println(key + ":" + jedis.hmget("user", key));
       }

       // jedis操作List
       // 开始前，先移除所有的内容
       jedis.del("java framework");
       System.out.println(jedis.lrange("java framework", 0, -1));
       // 先向key java framework中存放三条数据
       jedis.lpush("java framework", "spring");
       jedis.lpush("java framework", "struts");
       jedis.lpush("java framework", "hibernate");
       // 再取出所有数据jedis.lrange是按范围取出，
       // 第一个是key，第二个是起始位置，第三个是结束位置，jedis.llen获取长度 -1表示取得所有
       System.out.println(jedis.lrange("java framework", 0, -1));
       jedis.del("java framework");
       jedis.rpush("java framework", "spring");
       jedis.rpush("java framework", "struts");
       jedis.rpush("java framework", "hibernate");
       System.out.println(jedis.lrange("java framework", 0, -1));

       // jedis操作Set
       // 清空数据
       System.out.println(jedis.flushDB());
       // 添加
       jedis.sadd("name", "a");
       jedis.sadd("name", "b");
       jedis.sadd("name", "c");
       jedis.sadd("name", "d");
       jedis.sadd("name", "e");
       // 移除noname
       jedis.srem("name", "c");
       System.out.println(jedis.smembers("name"));// 获取所有加入的value
       System.out.println(jedis.sismember("name", "c"));// 判断 c 是否是user集合的元素
       System.out.println(jedis.srandmember("name")); // 返回集合中的一个随机元素
       System.out.println(jedis.scard("name"));// 返回集合的元素个数

       //// jedis操作ZSet
       jedis.zadd("hackers", 1940, "Alan Kay");
       jedis.zadd("hackers", 1953, "Richard Stallman");
       jedis.zadd("hackers", 1965, "Yukihiro Matsumoto");
       jedis.zadd("hackers", 1916, "Claude Shannon");
       jedis.zadd("hackers", 1969, "Linus Torvalds");
       jedis.zadd("hackers", 1912, "Alan Turing");
       Set<String> setValues = jedis.zrange("hackers", 0, -1);//zset中的所有元素
       System.out.println(setValues);
       Set<String> setValues2 = jedis.zrevrange("hackers", 0, -1);//按分数值递减(从大到小)来排列
       System.out.println(setValues2);
       // 清空数据
       System.out.println(jedis.flushDB());
       // 添加数据
       jedis.zadd("zset", 10.1, "hello");
       jedis.zadd("zset", 10.0, ":");
       jedis.zadd("zset", 9.0, "zset");
       jedis.zadd("zset", 11.0, "zset!");
       // 元素个数
       System.out.println(jedis.zcard("zset"));
       // 元素下标
       System.out.println(jedis.zscore("zset", "zset"));
       // 集合子集
       System.out.println(jedis.zrange("zset", 0, -1));
       // 删除元素
       System.out.println(jedis.zrem("zset", "zset!"));
       System.out.println(jedis.zcount("zset", 9.5, 10.5));
       // 整个集合值
       System.out.println(jedis.zrange("zset", 0, -1));

       JedisUtils.closeJedis(jedis);
   }

}
Spring使用Redis（SpringDataRedis）
配置文件

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

   <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
       <property name="maxIdle" value="2" />
       <property name="maxWaitMillis" value="-1" />
       <property name="testOnBorrow" value="true" />
   </bean>

   <bean id="jedisConnFactory"
       class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
       p:use-pool="true" p:host-name="127.0.0.1" p:port="6379"
       p:pool-config-ref="poolConfig" />

   
   <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate"
       p:connection-factory-ref="jedisConnFactory" p:keySerializer-ref="stringRedisSerializer"
       p:valueSerializer-ref="stringRedisSerializer" />

   <bean id="stringRedisSerializer"
       class="org.springframework.data.redis.serializer.StringRedisSerializer" />

</beans>
测试类

package springdataredis;

import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.core.ZSetOperations;

public class SpringDataRedisTest {

   static ApplicationContext context;

   public static void main(String[] args) {
       // 加载配置文件
       context = new ClassPathXmlApplicationContext("classpath:application-redis.xml");
       RedisTemplate<String, Object> redisTemplate = (RedisTemplate<String, Object>) context.getBean("redisTemplate");

       // -----------------String类型数据操作 start--------------------
       // String类型数据存储，不设置过期时间，永久性保存
       redisTemplate.boundValueOps("name").set("a");
       // 取值
       String str = (String) redisTemplate.boundValueOps("name").get();
       System.out.println(str);
       // String类型数据存储，设置过期时间为80秒，采用TimeUnit控制时间单位
       redisTemplate.boundValueOps("name").set("a", 80, TimeUnit.SECONDS);
       // 判断key值是否存在，存在则不存储，不存在则存储
       ValueOperations<String, Object> stringOperations = redisTemplate.opsForValue();
       stringOperations.setIfAbsent("string1", "c");
       stringOperations.setIfAbsent("string3", "d");
       String value1 = (String) stringOperations.get("string1");
       String value2 = (String) stringOperations.get("string3");
       System.out.println(value1);
       System.out.println(value2);
       // -----------------String类型数据操作 end--------------------

       // -----------------List数据类型操作 start------------------
       // 右压栈 : 后添加的元素排在后边
       redisTemplate.boundListOps("namelist1").rightPush("刘备");
       redisTemplate.boundListOps("namelist1").rightPush("关羽");
       redisTemplate.boundListOps("namelist1").rightPush("张飞");
       // 显示右压栈的值
       List list = redisTemplate.boundListOps("namelist1").range(0, 10);
       System.out.println(list);
       // 删除键
       redisTemplate.delete("namelist1");
       // 删除键
       redisTemplate.delete("namelist2");
       // 左压栈
       redisTemplate.boundListOps("namelist2").leftPush("刘备");
       redisTemplate.boundListOps("namelist2").leftPush("关羽");
       redisTemplate.boundListOps("namelist2").leftPush("张飞");
       // 删除值
       redisTemplate.boundListOps("namelist2").remove(0, "刘备");
       // 显示左压栈的值
       List list1 = redisTemplate.boundListOps("namelist2").range(0, 10);
       System.out.println(list1);
       // -----------------List数据类型操作 end------------------

       // -----------------set数据类型操作 start------------------
       redisTemplate.boundSetOps("nameset").add("曹操");
       redisTemplate.boundSetOps("nameset").add("刘备");
       redisTemplate.boundSetOps("nameset").add("孙权");
       redisTemplate.boundSetOps("nameset").remove("孙权");
       Set set = redisTemplate.boundSetOps("nameset").members();
       System.out.println(set);
       redisTemplate.delete("nameset");
       // -----------------set数据类型操作 end------------------

       // -----------------zset数据类型操作 start------------------
       ZSetOperations<String, Object> zSetOperations = redisTemplate.opsForZSet();
       zSetOperations.add("zset", "刘备", 0);
       zSetOperations.add("zset", "关羽", 1);
       System.out.println(zSetOperations.rangeByScore("zset", 0, 1));
       // -----------------zset数据类型操作 end------------------

       // -----------------hash数据类型操作 start------------------
       // 存值
       redisTemplate.boundHashOps("namehash").put("a", "唐僧");
       redisTemplate.boundHashOps("namehash").put("b", "悟空");
       redisTemplate.boundHashOps("namehash").put("c", "八戒");
       redisTemplate.boundHashOps("namehash").put("d", "沙僧");
       // 根据KEY取值
       String str1 = (String) redisTemplate.boundHashOps("namehash").get("b");
       System.out.println(str1);
       // 移除某个小key的值
       redisTemplate.boundHashOps("namehash").delete("c");
       // 获取所有的key
       Set keys = redisTemplate.boundHashOps("namehash").keys();
       System.out.println(keys);
       // 获取所有的值
       List list11 = redisTemplate.boundHashOps("namehash").values();
       System.out.println(list11);
       // -----------------hash数据类型操作 start------------------
   }

}

前言
Redis在互联网技术存储方面使用如此广泛，几乎所有的后端技术面试官都要在Redis的使用和原理方面对小伙伴们进行360°的刁难。作为一个在互联网公司面一次拿一次offer的面霸（请允许我使用一下夸张的修辞手法），打败了无数竞争对手，每次都只能看到无数落寞的身影失望的离开，略感愧疚，在一个寂寞难耐的夜晚，我痛定思痛，决定开始写吊打面试官系列，希望能帮助各位读者以后面试势如破竹，对面试官进行360°的反击，吊打问你的面试官，吊打一同面试的同僚（好像不太好），疯狂收割大厂offer！

面试开始
一个大腹便便，穿着格子衬衣的中年男子，拿着一个满是划痕的mac向你走来，看着快秃顶的头发，心想着肯定是尼玛顶级架构师吧！但是我们腹有诗书气自华，虚都不虚。

小伙子您好，看你简历上写了你项目里面用到了Redis，你们为啥用Redis？
心里忍不住暗骂，这叫啥问题，大家不都是用的这个嘛，但是你不能说出来。

认真回答道：帅气迷人的面试官您好，因为传统的关系型数据库如Mysql已经不能适用所有的场景了，比如秒杀的库存扣减，APP首页的访问流量高峰等等，都很容易把数据库打崩，所以引入了缓存中间件，目前市面上比较常用的缓存中间件有Redis 和 Memcached 不过中和考虑了他们的优缺点，最后选择了Redis。

至于更细节的对比朋友们记得查阅Redis 和 Memcached 的区别，比如两者的优缺点对比和各自的场景，后续我有时间也会写出来。

那小伙子，我再问你，Redis有哪些数据结构呀？
字符串String、字典Hash、列表List、集合Set、有序集合SortedSet。

这里我相信99%的读者都能回答上来Redis的5个基本数据类型。如果回答不出来的小伙伴我们就要加油补课哟，大家知道五种类型最适合的场景更好。

但是，如果你是Redis中高级用户，而且你要在这次面试中突出你和其他候选人的不同，还需要加上下面几种数据结构HyperLogLog、Geo、Pub/Sub。

如果你还想加分，那你说还玩过Redis Module，像BloomFilter，RedisSearch，Redis-ML，这个时候面试官得眼睛就开始发亮了，心想这个小伙子有点东西啊。

注：本人在面试回答到Redis相关的问题的时候，经常提到BloomFilter（布隆过滤器）这玩意的使用场景是真的多，而且用起来是真的香，原理也好理解，看一下文章就可以在面试官面前侃侃而谈了，不香么？下方传送门 ↓

避免缓存击穿的利器之BloomFilter

如果有大量的key需要设置同一时间过期，一般需要注意什么？
如果大量的key过期时间设置的过于集中，到过期的那个时间点，redis可能会出现短暂的卡顿现象。严重的话会出现缓存雪崩，我们一般需要在时间上加一个随机值，使得过期时间分散一些。

电商首页经常会使用定时任务刷新缓存，可能大量的数据失效时间都十分集中，如果失效时间一样，又刚好在失效的时间点大量用户涌入，就有可能造成缓存雪崩

那你使用过Redis分布式锁么，它是什么回事？
先拿setnx来争抢锁，抢到之后，再用expire给锁加一个过期时间防止锁忘记了释放。

这时候对方会告诉你说你回答得不错，然后接着问如果在setnx之后执行expire之前进程意外crash或者要重启维护了，那会怎么样？
这时候你要给予惊讶的反馈：唉，是喔，这个锁就永远得不到释放了。紧接着你需要抓一抓自己得脑袋，故作思考片刻，好像接下来的结果是你主动思考出来的，然后回答：我记得set指令有非常复杂的参数，这个应该是可以同时把setnx和expire合成一条指令来用的！

对方这时会显露笑容，心里开始默念：嗯，这小子还不错，开始有点意思了。
假如Redis里面有1亿个key，其中有10w个key是以某个固定的已知的前缀开头的，如何将它们全部找出来？
使用keys指令可以扫出指定模式的key列表。

对方接着追问：如果这个redis正在给线上的业务提供服务，那使用keys指令会有什么问题？
这个时候你要回答redis关键的一个特性：redis的单线程的。keys指令会导致线程阻塞一段时间，线上服务会停顿，直到指令执行完毕，服务才能恢复。这个时候可以使用scan指令，scan指令可以无阻塞的提取出指定模式的key列表，但是会有一定的重复概率，在客户端做一次去重就可以了，但是整体所花费的时间会比直接用keys指令长。

不过，增量式迭代命令也不是没有缺点的：举个例子，使用 SMEMBERS 命令可以返回集合键当前包含的所有元素，但是对于 SCAN 这类增量式迭代命令来说，因为在对键进行增量式迭代的过程中，键可能会被修改，所以增量式迭代命令只能对被返回的元素提供有限的保证。

使用过Redis做异步队列么，你是怎么用的？
一般使用list结构作为队列，rpush生产消息，lpop消费消息。当lpop没有消息的时候，要适当sleep一会再重试。

如果对方追问可不可以不用sleep呢？
list还有个指令叫blpop，在没有消息的时候，它会阻塞住直到消息到来。

如果对方接着追问能不能生产一次消费多次呢？
使用pub/sub主题订阅者模式，可以实现 1:N 的消息队列。

如果对方继续追问 pub/su b有什么缺点？
在消费者下线的情况下，生产的消息会丢失，得使用专业的消息队列如RocketMQ等。

如果对方究极TM追问Redis如何实现延时队列？
这一套连招下来，我估计现在你很想把面试官一棒打死（面试官自己都想打死自己了怎么问了这么多自己都不知道的），如果你手上有一根棒球棍的话，但是你很克制。平复一下激动的内心，然后神态自若的回答道：使用sortedset，拿时间戳作为score，消息内容作为key调用zadd来生产消息，消费者用zrangebyscore指令获取N秒之前的数据轮询进行处理。

到这里，面试官暗地里已经对你竖起了大拇指。并且已经默默给了你A+，但是他不知道的是此刻你却竖起了中指，在椅子背后。

Redis是怎么持久化的？服务主从数据怎么交互的？
RDB做镜像全量持久化，AOF做增量持久化。因为RDB会耗费较长时间，不够实时，在停机的时候会导致大量丢失数据，所以需要AOF来配合使用。在redis实例重启时，会使用RDB持久化文件重新构建内存，再使用AOF重放近期的操作指令来实现完整恢复重启之前的状态。

这里很好理解，把RDB理解为一整个表全量的数据，AOF理解为每次操作的日志就好了，服务器重启的时候先把表的数据全部搞进去，但是他可能不完整，你再回放一下日志，数据不就完整了嘛。不过Redis本身的机制是 AOF持久化开启且存在AOF文件时，优先加载AOF文件；AOF关闭或者AOF文件不存在时，加载RDB文件；加载AOF/RDB文件城后，Redis启动成功； AOF/RDB文件存在错误时，Redis启动失败并打印错误信息

对方追问那如果突然机器掉电会怎样？
取决于AOF日志sync属性的配置，如果不要求性能，在每条写指令时都sync一下磁盘，就不会丢失数据。但是在高性能的要求下每次都sync是不现实的，一般都使用定时sync，比如1s1次，这个时候最多就会丢失1s的数据。

对方追问RDB的原理是什么？
你给出两个词汇就可以了，fork和cow。fork是指redis通过创建子进程来进行RDB操作，cow指的是copy on write，子进程创建后，父子进程共享数据段，父进程继续提供读写服务，写脏的页面数据会逐渐和子进程分离开来。

注：回答这个问题的时候，如果你还能说出AOF和RDB的优缺点，我觉得我是面试官在这个问题上我会给你点赞，两者其实区别还是很大的，而且涉及到Redis集群的数据同步问题等等。想了解的伙伴也可以留言，我会专门写一篇来介绍的。

Pipeline有什么好处，为什么要用pipeline？
可以将多次IO往返的时间缩减为一次，前提是pipeline执行的指令之间没有因果相关性。使用redis-benchmark进行压测的时候可以发现影响redis的QPS峰值的一个重要因素是pipeline批次指令的数目。

Redis的同步机制了解么？
Redis可以使用主从同步，从从同步。第一次同步时，主节点做一次bgsave，并同时将后续修改操作记录到内存buffer，待完成后将RDB文件全量同步到复制节点，复制节点接受完成后将RDB镜像加载到内存。加载完成后，再通知主节点将期间修改的操作记录同步到复制节点进行重放就完成了同步过程。后续的增量数据通过AOF日志同步即可，有点类似数据库的binlog。

是否使用过Redis集群，集群的高可用怎么保证，集群的原理是什么？
Redis Sentinal着眼于高可用，在master宕机时会自动将slave提升为master，继续提供服务。

Redis Cluster着眼于扩展性，在单个redis内存不足时，使用Cluster进行分片存储。

面试结束
小伙子你可以的，什么时候有时间来上班啊，要不明天就来吧？
你强装镇定，这么急啊我还需要租房，要不下礼拜一吧。

好的心想这小子这么NB是不是很多Offer在手上，不行我得叫hr给他加钱。
能撑到最后，你自己都忍不住自己给自己点个赞了（暗示点赞，每次都看了不点赞，你们想白嫖我么？你们好坏喲，不过我喜欢⁄(⁄ ⁄•⁄ω⁄•⁄ ⁄)⁄）。

总结
在技术面试的时候，不管是Redis还是什么问题，如果你能举出实际的例子，或者是直接说自己开发过程的问题和收获会给面试官的印象分会加很多，回答逻辑性也要强一点，不要东一点西一点，容易把自己都绕晕的。

还有一点就是我问你为啥用Redis你不要一上来就直接回答问题了，你可以这样回答：

帅气的面试官您好，首先我们的项目DB遇到了瓶颈，特别是秒杀和热点数据这样的场景DB基本上就扛不住了，那就需要缓存中间件的加入了，目前市面上有的缓存中间件有 Redis 和 Memcached ，他们的优缺点……，综合这些然后再结合我们项目特点，最后我们在技术选型的时候选了谁。

如果你这样有条不紊，有理有据的回答了我的问题而且还说出这么多我问题外的知识点，我会觉得你不只是一个会写代码的人，你逻辑清晰，你对技术选型，对中间件对项目都有自己的理解和思考，说白了就是你的offer有戏了。

鸣谢
老钱：掌阅服务端技术专家，互联网分布式高并发技术十年老兵，现任字节跳动技术专家。

以Redis系列为开始是他给的建议，并且允许我以他其中一篇的风格和大部分内容为自己开始写博客的风格。

日常求赞
好了各位，以上就是这篇文章的全部内容了，能看到这里的人呀，都是人才。

如果本文对你有一点点帮助，那么请点个赞呗，谢谢~