Redis6安装入门教程

1.概述

1.1 NoSQL简介

NoSQL(NoSQL = Not Only SQL )，意即“不仅仅是SQL”，泛指非关系型的数据库。
NoSQL 不依赖业务逻辑方式存储，而以简单的key-value模式存储。因此大大的增加了数据库的扩展能力。

• 不遵循SQL标准。
• 不支持ACID。
• 远超于SQL的性能。

NoSQL适用场景

• 对数据高并发的读写
• 海量数据的读写
• 对数据高可扩展性

NoSQL不适用场景

• 需要事务支持
• 基于sql的结构化查询存储，处理复杂的关系。

1.2 非关系型数据库

NoSQL数据库	介绍
Memcache	(1) 很早出现的NoSql数据库 (2) 数据都在内存中，一般不持久化 (3) 支持简单的key-value模式，支持类型单一 (4) 一般是作为缓存数据库辅助持久化的数据库
Redis	(1) 数据都在内存中，支持持久化，主要用作备份恢复 (2) 除了支持简单的key-value模式，还支持多种数据结构的存储，比如list、set、hash、zset等。(3) 一般是作为缓存数据库辅助持久化的数据库
MongoDB	(1) 高性能、开源、模式自由(schema free)的文档型数据库 (2)数据都在内存中， 如果内存不足，把不常用的数据保存到硬盘 (3) 虽然是key-value模式，但是对value（尤其是json）提供了丰富的查询功能 (4) 支持二进制数据及大型对象 (5) 可以根据数据的特点替代RDBMS ，成为独立的数据库。或者配合RDBMS，存储特定的数据。

1.3 Redis简介

中文官网：http://redis.cn/
Redis（Remote Dictionary Server )，即远程字典服务，是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。

redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。

2.Redis安装(mac)

2.1 安装brew

brew 是MacOS上的包管理工具,可以简化 macOS 和 Linux 操作系统上软件的安装。
安装命令：
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
如果安装失败，可以使用国内镜像：
/bin/zsh -c "$(curl -fsSL https://gitee.com/cunkai/HomebrewCN/raw/master/Homebrew.sh)"

2.2 安装Redis

安装命令：
brew install redis

2.3 启动Redis

命令：
redis-server /opt/homebrew/etc/redis.conf

这里使用的是前台启动，命令行窗口不能关闭，否则服务器停止。

2.4 访问客户端

命令：
redis-cli

3.五大常用数据类型

Redis常见数据类型操作命令http://www.redis.cn/commands.html

3.1 Redis键操作(key)

命令	含义
keys *	查看当前库所有key (匹配：keys *1)
exists key	判断某个key是否存在
type key	查看你的key是什么类型
del key	删除指定的key数据
unlink key	根据value选择非阻塞删除 仅将keys从keyspace元数据中删除，真正的删除会在后续异步操作。
expire key 10	10秒钟：为给定的key设置过期时间
ttl key	查看还有多少秒过期，-1表示永不过期，-2表示已过期
select	命令切换数据库
dbsize	查看当前数据库的key的数量
flushdb	清空当前库
flushall	通杀全部库

3.2 String

String类型是二进制安全的。意味着Redis的string可以包含任何数据。比如jpg图片或者序列化的对象。
String类型是Redis最基本的数据类型，一个Redis中字符串value最多可以是512M。

3.2.1 Stirng操纵常用命令

命令	说明
SET KEY_NAME VALUE	SET 命令用于设置给定 key 的值。如果 key 已经存储其他值， SET 就覆写旧值，且无视类型。
get <key>	查询对应键值
append <key><value>	将给定的<value> 追加到原值的末尾
strlen <key>	获得值的长度
setnx <key><value>	只有在 key 不存在时 设置 key 的值
incr <key>	将 key 中储存的数字值增1,只能对数字值操作，如果为空，新增值为1
decr <key>	将 key 中储存的数字值减1,只能对数字值操作，如果为空，新增值为-1
incrby / decrby <key><步长>	将 key 中储存的数字值增减。自定义步长。
mset <key1><value1><key2><value2> .....	同时设置一个或多个 key-value对
mget <key1><key2><key3> .....	同时获取一个或多个 value
msetnx <key1><value1><key2><value2> .....	同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在。
getrange <key><起始位置><结束位置>	获得值的范围，类似java中的substring，前包，后包
setrange <key><起始位置><value>	用 <value> 覆写<key>所储存的字符串值，从<起始位置>开始(索引从0开始)。
setex <key><过期时间><value>	设置键值的同时，设置过期时间，单位秒。
getset <key><value>	以新换旧，设置了新值同时获得旧值。

3.2.2 String数据结构

String的数据结构为简单动态字符串(Simple Dynamic String,缩写SDS)。是可以修改的字符串，内部结构实现上类似于Java的ArrayList，采用预分配冗余空间的方式来减少内存的频繁分配.

3.3 List

单键多值
Redis列表是简单的字符串列表，按照插入顺序排序。
它的底层实际是个双向链表，对两端的操作性能很高，通过索引下标的操作中间的节点性能会较差。

3.3.1 List常用命令

命令	说明
lpush/rpush <key><value1><value2>....	从左边/右边插入一个或多个值。
lpop/rpop <key>	从左边/右边吐出一个值。值在键在，值光键亡。
rpoplpush <key1><key2>从<key1>	列表右边吐出一个值，插到<key2>列表左边。
lrange <key><start><stop>	按照索引下标获得元素(从左到右)
lrange mylist 0 -1	0左边第一个，-1右边第一个，（0-1表示获取所有）
lindex <key><index>	按照索引下标获得元素(从左到右)
llen <key>	获得列表长度
linsert <key> before <value><newvalue>	在<value>的后面插入<newvalue>插入值
lrem <key><n><value>	从左边删除n个value(从左到右)
lset<key><index><value>	将列表key下标为index的值替换成value

3.3.2 List数据结构

列表元素较少的情况下是压缩列表ziplist,当数据量比较多的时候才会改成快速链表quicklist。
Redis将链表和ziplist结合起来组成了quicklist。也就是将多个ziplist使用双向指针串起来使用：

3.4 Set

Redis set对外提供的功能与list类似是一个列表的功能，set不同于List的事是set可以自动排重。
Set是string类型的无序集合。它底层其实是一个value为null的hash表，所以添加，删除，查找的复杂度都是O(1)。

3.4.1 常用命令

命令	说明
sadd <key><value1><value2> .....	将一个或多个 member 元素加入到集合 key 中，已经存在的 member 元素将被忽略
smembers <key>	取出该集合的所有值。
sismember <key><value>	判断集合是否为含有该值，有1，没有0
scard<key>	返回该集合的元素个数。
srem <key><value1><value2> ....	删除集合中的某个元素。
spop <key>	随机从该集合中吐出一个值。
srandmember <key><n>	随机从该集合中取出n个值。不会从集合中删除 。
smove <source><destination>value	把集合中一个值从一个集合移动到另一个集合
sinter <key1><key2>	返回两个集合的交集元素。
sunion <key1><key2>	返回两个集合的并集元素。
sdiff <key1><key2>	返回两个集合的差集元素(key1中的，不包含key2中的)

3.4.2 Set数据结构

Set数据结构是dict字典，字典是基于哈希表实现。

3.5 Hash

Redis hash 是一个键值对集合。
Redis hash是一个string类型的field和value的映射表，hash特别适合用于存储对象。
类似Java里面的Map<String,Object>。

3.5.1 常用命令

命令	说明
hset <key><field><value>	给<key>集合中的 <field>键赋值<value>
hget <key1><field>	从<key1>集合<field>取出 value
hmset <key1><field1><value1><field2><value2>...	批量设置hash的值
hexists<key1><field>	查看哈希表 key 中，给定域 field 是否存在。
hkeys <key>	列出该hash集合的所有field
hvals <key>	列出该hash集合的所有value
hincrby <key><field><increment>	为哈希表 key 中的域 field 的值加上增量 1 -1
hsetnx <key><field><value>	将哈希表 key 中的域 field 的值设置为 value ，当且仅当域 field 不存在 .

3.5.2 Hash数据结构

Hash类型对应的数据结构是两种：ziplist（压缩列表），hashtable（哈希表）。当field-value长度较短且个数较少时，使用ziplist，否则使用hashtable。

3.6 Zset

Redis有序集合zset与普通集合set非常相似，是一个没有重复元素的字符串集合。

3.6.1 Zset常用命令

命令	说明
zadd <key><score1><value1><score2><value2>…	将一个或多个 member 元素及其 score 值加入到有序集 key 当中。
zrange <key><start><stop> [WITHSCORES]	返回有序集 key 中，下标在<start><stop>之间的元素,带 WITHSCORES，可以让分数一起和值返回到结果集。
zrangebyscore key minmax [withscores] [limit offset count]	返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从小到大)次序排列。
zrevrangebyscore key maxmin [withscores] [limit offset count]	同上，改为从大到小排列。
zincrby <key><increment><value>	为元素的score加上增量
zrem <key><value>	删除该集合下，指定值的元素
zcount <key><min><max>	统计该集合，分数区间内的元素个数
zrank <key><value>	返回该值在集合中的排名，从0开始。

3.6.2 Zset数据结构

zset底层使用了两个数据结构

• （1）hash，hash的作用就是关联元素value和权重score，保障元素value的唯一性，可以通过元素value找到相应的score值。
• （2）跳跃表，跳跃表的目的在于给元素value排序，根据score的范围获取元素列表。

4.发布订阅

4.1 Redis发布订阅简介

Redis 发布订阅 (pub/sub) 是一种消息通信模式：发送者 (pub) 发送消息，订阅者 (sub) 接收消息。

4.2 命令行实现

1.客户端- A
使用命令SUBSCRIBE channel1使得客户端A订阅channel1的消息。

2.发布端发布消息：
命令：publish channel1 hello

返回的1是订阅者数量

3.客户端- A收到发布端发布的消息

5.Jedis操作Redis

5.1 引入依赖

 <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.2.0</version>
        </dependency>

5.2 Jedis-Key操作

public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1",6379);
        jedis.set("k1", "v1");
        jedis.set("k2", "v2");
        jedis.set("k3", "v3");
        Set<String> keys = jedis.keys("*");
        System.out.println(keys.size());
        for (String key : keys) {
            System.out.println(key);
        }
        System.out.println(jedis.exists("k1"));
        System.out.println(jedis.ttl("k1"));
        System.out.println(jedis.get("k1"));

        jedis.close();
    }

5.3 Jedis-String操作

public class StringTest {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1",6379);
        jedis.mset("str1","v1","str2","v2","str3","v3");
        System.out.println(jedis.mget("str1","str2","str3"));
        jedis.close();
    }
}

5.4 Jedis- List操作

public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1",6379);
        List<String> list = jedis.lrange("mylist",0,-1);
        for (String element : list) {
            System.out.println(element);
        }
        jedis.close();
    }

5.5 Jedis-hash操作

public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1",6379);
        jedis.hset("hash1","userName","lisi");
        System.out.println(jedis.hget("hash1","userName"));
        Map<String,String> map = new HashMap<String,String>();
        map.put("telphone","13810169999");
        map.put("address","atguigu");
        map.put("email","abc@163.com");
        jedis.hmset("hash2",map);
        List<String> result = jedis.hmget("hash2", "telphone","email");
        for (String element : result) {
            System.out.println(element);
        }
        jedis.close();
    }

5.6 Jedis-zset操作

 public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1",6379);
        jedis.zadd("zset01", 100d, "z3");
        jedis.zadd("zset01", 90d, "l4");
        jedis.zadd("zset01", 80d, "w5");
        jedis.zadd("zset01", 70d, "z6");
        Set<String> zrange = jedis.zrange("zset01", 0, -1);
        for (String e : zrange) {
            System.out.println(e);
        }
        jedis.close();
    }

6.Redis与Spring Boot整合

6.1 引入redis-starter依赖

<!-- redis -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

<!-- spring2.X集成redis所需common-pool2-->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
<version>2.6.0</version>
</dependency>

6.2 application.properties配置

#Redis服务器地址
spring.redis.host=127.0.0.1
#Redis服务器连接端口
spring.redis.port=6379
#Redis数据库索引（默认为0）
spring.redis.database= 0
#连接超时时间（毫秒）
spring.redis.timeout=1800000
#连接池最大连接数（使用负值表示没有限制）
spring.redis.lettuce.pool.max-active=20
#最大阻塞等待时间(负数表示没限制)
spring.redis.lettuce.pool.max-wait=-1
#连接池中的最大空闲连接
spring.redis.lettuce.pool.max-idle=5
#连接池中的最小空闲连接
spring.redis.lettuce.pool.min-idle=0

6.3 添加redis配置类

@EnableCaching
@Configuration
public class RedisConfig extends CachingConfigurerSupport {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        template.setConnectionFactory(factory);
//key序列化方式
        template.setKeySerializer(redisSerializer);
//value序列化
        template.setValueSerializer(jackson2JsonRedisSerializer);
//value hashmap序列化
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        return template;
    }

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
//解决查询缓存转换异常的问题
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
// 配置序列化（解决乱码的问题）,过期时间600秒
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofSeconds(600))
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
                .disableCachingNullValues();
        RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
                .cacheDefaults(config)
                .build();
        return cacheManager;
    }
}

6.4 使用

@RestController
@RequestMapping("/redisTest")
public class RedisTestController {
    @Autowired
    private RedisTemplate redisTemplate;

    @GetMapping
    public String testRedis() {
        //设置值到redis
        redisTemplate.opsForValue().set("name","lucy");
        //从redis获取值
        String name = (String)redisTemplate.opsForValue().get("name");
        return name;
    }
}

7.Redis事务锁机制

Redis事务是一个单独的隔离操作：事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。
Redis事务的主要作用就是串联多个命令防止别的命令插队。

7.1 Multi、Exec、discard

从输入Multi命令开始，输入的命令都会依次进入命令队列中，但不会执行，直到输入Exec后，Redis会将之前的命令队列中的命令依次执行。
组队的过程中可以通过discard来放弃组队。

组队中某个命令出现了报告错误，执行时整个的所有队列都会被取消。

如果执行阶段某个命令报出了错误，则只有报错的命令不会被执行，而其他的命令都会执行，不会回滚。

8.Redis持久化

Redis 提供了2个不同形式的持久化方式。

• RDB（Redis DataBase）
• AOF（Append Of File）

8.1 RDB

在指定的时间间隔内将内存中的数据集快照写入磁盘。

Redis会单独创建（fork）一个子进程来进行持久化，会先将数据写入到 一个临时文件中，待持久化过程都结束了，再用这个临时文件替换上次持久化好的文件。 整个过程中，主进程是不进行任何IO操作的，这就确保了极高的性能 如果需要进行大规模数据的恢复，且对于数据恢复的完整性不是非常敏感，那RDB方式要比AOF方式更加的高效。RDB的缺点是最后一次持久化后的数据可能丢失。

优势：

• 适合大规模的数据恢复
• 对数据完整性和一致性要求不高更适合使用
• 节省磁盘空间
• 恢复速度快

劣势

• Fork的时候，内存中的数据被克隆了一份，大致2倍的膨胀性需要考虑
• 虽然Redis在fork时使用了写时拷贝技术,但是如果数据庞大时还是比较消耗性能。
• 在备份周期在一定间隔时间做一次备份，所以如果Redis意外down掉的话，就会丢失最后一次快照后的所有修改。
  

8.2 AOF

以日志的形式来记录每个写操作（增量保存），将Redis执行过的所有写指令记录下来(读操作不记录)， 只许追加文件但不可以改写文件。AOF默认不开启。

• （1）客户端的请求写命令会被append追加到AOF缓冲区内；
• （2）AOF缓冲区根据AOF持久化策略[always,everysec,no]将操作sync同步到磁盘的AOF文件中；
• （3）AOF文件大小超过重写策略或手动重写时，会对AOF文件rewrite重写，压缩AOF文件容量；
• （4）Redis服务重启时，会重新load加载AOF文件中的写操作达到数据恢复的目的；

优势

• 备份机制更稳健，丢失数据概率更低。
• 可读的日志文本，通过操作AOF稳健，可以处理误操作。

劣势

• 比起RDB占用更多的磁盘空间。
• 恢复备份速度要慢。
• 每次读写都同步的话，有一定的性能压力。
• 存在个别Bug。

8.3 持久化小结

官方建议同时开启两种持久化方式。

9.Redis集群

9.1 主从复制

主机数据更新后根据配置和策略， 自动同步到备机的master/slaver机制，Master以写为主，Slave以``读`为主。

• 读写分离，性能扩展
• 容灾快速恢复
  

9.2 哨兵模式

能够后台监控主机是否故障，如果故障了根据投票数自动将从库转换为主库。

9.3 cluster集群

Redis 集群实现了对Redis的水平扩容，即启动N个redis节点，将整个数据库分布存储在这N个节点中，每个节点存储总数据的1/N。
Redis集群通过分区（partition）来提供一定程度的可用性（availability）： 即使集群中有一部分节点失效或者无法进行通讯， 集群也可以继续处理命令请求。

cluster集群方案，采用的是虚拟槽分区，槽范围是0-16383，有16384个槽。集群中有3个主节点，每个节点大致负责5500个槽的读写，节点会维护自身负责的虚拟槽。

键所对应的哈希值通过如下公式计算：CRC16（key）%16384。目前常见的redisson、jedis等客户端工具都已实现。

在实际使用时，set key value命令会计算hash值，把key-value设置到对应的主节点上。

10.Redis常见问题

10.1 缓存穿透

key对应的数据在数据源并不存在，每次针对此key的请求从缓存获取不到，请求都会压到数据源，从而可能压垮数据源。比如用一个不存在的用户id获取用户信息，不论缓存还是数据库都没有，若黑客利用此漏洞进行攻击可能压垮数据库。

解决方案：

• 对空值缓存
• 设置可访问的名单（白名单）
• 采用布隆过滤器
• 进行实时监控

10.2 缓存击穿

key对应的数据存在，但在redis中过期，此时若有大量并发请求过来，这些请求发现缓存过期一般都会从后端DB加载数据并回设到缓存，这个时候大并发的请求可能会瞬间把后端DB压垮。

解决方案：

• 预先设置热门数据
• 实时调整：实时调整key的过期时长
• 使用锁
  

10.3 缓存雪崩

key对应的数据存在，但在redis中过期，此时若有大量并发请求过来，这些请求发现缓存过期一般都会从后端DB加载数据并回设到缓存，这个时候大并发的请求可能会瞬间把后端DB压垮。
缓存雪崩与缓存击穿的区别在于这里针对很多key缓存，前者则是某一个key

正常情况：

缓存雪崩

解决方案：

• 构建多级缓存架构：nginx缓存 + redis缓存 +其他缓存
• 使用锁或队列
• 设置过期标志更新缓存
• 将缓存失效时间分散开