一、引言

1.1 数据库压力过大

由于用户量增大,请求数量也随之增大,数据压力过大

1.2 数据不同步

多台服务器之间,数据不同步

1.3 传统锁失效

多台服务器之间的锁,已经不存在互斥性了。

二、Redis介绍

2.1 NoSQL介绍

  • Redis就是一款NoSQL。
  • NoSQL -> 非关系型数据库 -> Not Only SQL。
  • Key-Value:Redis。。。
  • 文档型:ElasticSearch,Solr,Mongodb。。。 大数据 处理数据分析
  • 面向列:Hbase,Cassandra。。。
  • 图形化:Neo4j。。。
  • 除了关系型数据库都是非关系型数据库。mysql oracle sysbase db2 postgrel sqlserver sql操作

  • NoSQL只是一种概念,泛指非关系型数据库,和关系型数据库做一个区分。

    2.2 Redis介绍

  • 有一位意大利人,在开发一款LLOOGG的统计页面(大屏),因为MySQL的性能不好,自己研发了一款非关系型数据库,并命名为Redis。Salvatore。

  • Redis(Remote Dictionary Server)即远程字典服务,Redis是由C语言去编写,Redis是一款基于Key-Value的NoSQL,而且Redis是基于内存存储数据的,Redis还提供了多种持久化机制,性能可以达到110000/s读取数据以及81000/s写入数据,Redis还提供了主从,哨兵以及集群的搭建方式,可以更方便的横向扩展以及垂直扩展。

Redis教程 - 图1

三、Redis安装

3.1 安装Redis

Docker-Compose安装

  1. version: '3.1'
  2. services:
  3. redis:
  4. image: daocloud.io/library/redis:5.0.7
  5. restart: always
  6. container_name: redis
  7. environment:
  8. - TZ=Asia/Shanghai
  9. ports:
  10. - 6379:6379

3.2 使用redis-cli连接Redis

进去Redis容器的内部
docker exec -it 容器id bash
在容器内部,使用redis-cli连接
Redis教程 - 图2

3.3 使用图形化界面连接Redis

下载地址:https://github.com/lework/RedisDesktopManager-Windows/releases/download/2019.5/redis-desktop-manager-2019.5.zip
傻瓜式安装
Redis教程 - 图3

四、Redis常用命令【重点】

4.1 Redis存储数据的结构

常用的5种数据结构:

  • key-string:一个key对应一个值。
  • key-hash:一个key对应一个Map。
  • key-list:一个key对应一个列表。
  • key-set:一个key对应一个集合。
  • key-zset:一个key对应一个有序的集合。

另外三种数据结构:

  • HyperLogLog:计算近似值的。
  • GEO:地理位置。
  • BIT:一般存储的也是一个字符串,存储的是一个byte[]。

Redis教程 - 图4
key-string:最常用的,一般用于存储一个值。

  • key-hash:存储一个对象数据的。
  • key-list:使用list结构实现栈和队列结构。 分布式锁 红锁
  • key-set:交集,差集和并集的操作。
  • key-zset:排行榜,积分存储等操作。

4.2 string常用命令

Redis教程 - 图5

  1. #1. 添加值
  2. set key value
  3. #2. 取值
  4. get key
  5. #3. 批量操作
  6. mset key value [key value...]
  7. mget key [key...]
  8. #4. 自增命令(自增1)
  9. incr key key必须是integer
  10. #5. 自减命令(自减1)
  11. decr key
  12. #6. 自增或自减指定数量 key必须是integer
  13. incrby key increment(自增数量)
  14. decrby key increment(自减数量)
  15. #7. 设置值的同时,指定生存时间(每次向Redis中添加数据时,尽量都设置上生存时间,秒)重点
  16. setex key second value
  17. #8. 设置值,如果当前key不存在的话(如果这个key存在,什么事都不做,如果这个key不存在,和set命令一样)重点
  18. setnx key value
  19. #9. 在key对应的value后,追加内容
  20. append key value
  21. #10. 查看value字符串的长度
  22. strlen key

4.3 hash常用命令

Redis教程 - 图6
Redis教程 - 图7

  1. #1. 存储数据
  2. hset key field value
  3. #2. 获取数据
  4. hget key field
  5. #3. 批量操作
  6. hmset key field value [field value ...]
  7. hmget key field [field ...]
  8. #4. 自增(指定自增的值)
  9. hincrby key field increment
  10. #5. 设置值(如果key-field不存在,那么就正常添加,如果存在,什么事都不做)
  11. hsetnx key field value
  12. #6. 检查field是否存在
  13. hexists key field
  14. #7. 删除key对应的field,可以删除多个
  15. hdel key field [field ...]
  16. #8. 获取当前hash结构中的全部field和value
  17. hgetall key
  18. #9. 获取当前hash结构中的全部field
  19. hkeys key
  20. #10. 获取当前hash结构中的全部value
  21. hvals key
  22. #11. 获取当前hash结构中field的数量
  23. hlen key

4.4 list常用命令

Redis教程 - 图8

  1. #1. 存储数据(从左侧插入数据,从右侧插入数据)
  2. lpush key value [value ...]
  3. rpush key value [value ...]
  4. #2. 存储数据(如果key不存在,什么事都不做,如果key存在,但是不是list结构,什么都不做)
  5. lpushx key value
  6. rpushx key value
  7. #3. 修改数据(在存储数据时,指定好你的索引位置,覆盖之前索引位置的数据,index超出整个列表的长度,也会失败)
  8. lset key index value
  9. #4. 弹栈方式获取数据(左侧弹出数据,从右侧弹出数据)
  10. lpop key
  11. rpop key
  12. #5. 获取指定索引范围的数据(start从0开始,stop输入-1,代表最后一个,-2代表倒数第二个)
  13. lrange key start stop
  14. #6. 获取指定索引位置的数据
  15. lindex key index
  16. #7. 获取整个列表的长度
  17. llen key
  18. #8. 删除列表中的数据(他是删除当前列表中的count个value值,count > 0从左侧向右侧删除,count < 0从右侧向左侧删除,count == 0删除列表中全部的value)
  19. lrem key count value
  20. #9. 保留列表中的数据(保留你指定索引范围内的数据,超过整个索引范围被移除掉)
  21. ltrim key start stop
  22. #10. 将一个列表中最后的一个数据,插入到另外一个列表的头部位置
  23. rpoplpush list1 list2

4.5 set常用命令

Redis教程 - 图9

  1. #1. 存储数据
  2. sadd key member [member ...]
  3. #2. 获取数据(获取全部数据)
  4. smembers key
  5. #3. 随机获取一个数据(获取的同时,移除数据,count默认为1,代表弹出数据的数量)
  6. spop key [count]
  7. #4. 交集(取多个set集合交集)
  8. sinter set1 set2 ...
  9. #5. 并集(获取全部集合中的数据)
  10. sunion set1 set2 ...
  11. #6. 差集(获取多个集合中不一样的数据)
  12. sdiff set1 set2 ...
  13. # 7. 删除数据
  14. srem key member [member ...]
  15. # 8. 查看当前的set集合中是否包含这个值
  16. sismember key member

4.6 zset的常用命令

Redis教程 - 图10
Redis教程 - 图11

  1. #1. 添加数据(score必须是数值。member不允许重复的。)
  2. zadd key score member [score member ...]
  3. #2. 修改member的分数(如果member是存在于key中的,正常增加分数,如果memeber不存在,这个命令就相当于zadd)
  4. zincrby key increment member
  5. #3. 查看指定的member的分数
  6. zscore key member
  7. #4. 获取zset中数据的数量
  8. zcard key
  9. #5. 根据score的范围查询member数量
  10. zcount key min max
  11. #6. 删除zset中的成员
  12. zrem key member [member...]
  13. #7. 根据分数从小到大排序,获取指定范围内的数据(withscores如果添加这个参数,那么会返回member对应的分数)
  14. zrange key start stop [withscores]
  15. #8. 根据分数从大到小排序,获取指定范围内的数据(withscores如果添加这个参数,那么会返回member对应的分数)
  16. zrevrange key start stop [withscores]
  17. #9. 根据分数的返回去获取member(withscores代表同时返回score,添加limit,就和MySQL中一样,如果不希望等于min或者max的值被查询出来可以采用 ‘(分数’ 相当于 < 但是不等于的方式,最大值和最小值使用+inf和-inf来标识)
  18. zrangebyscore key min max [withscores] [limit offset count]
  19. #10. 根据分数的返回去获取member(withscores代表同时返回score,添加limit,就和MySQL中一样)
  20. zrangebyscore key max min [withscores] [limit offset count]

4.7 key常用命令

  1. #1. 查看Redis中的全部的key(pattern:* ,xxx*,*xxx)
  2. keys pattern
  3. #2. 查看某一个key是否存在(1 - key存在,0 - key不存在)
  4. exists key
  5. #3. 删除key
  6. del key [key ...]
  7. #4. 设置key的生存时间,单位为秒,单位为毫秒,设置还能活多久
  8. expire key second
  9. pexpire key milliseconds
  10. #5. 设置key的生存时间,单位为秒,单位为毫秒,设置能活到什么时间点
  11. expireat key timestamp
  12. pexpireat key milliseconds
  13. #6. 查看key的剩余生存时间,单位为秒,单位为毫秒(-2 - 当前key不存在,-1 - 当前key没有设置生存时间,具体剩余的生存时间)
  14. ttl key
  15. pttl key
  16. #7. 移除key的生存时间(1 - 移除成功,0 - key不存在生存时间,key不存在)
  17. persist key
  18. #8. 选择操作的库
  19. select 0~15
  20. #9. 移动key到另外一个库中
  21. move key db

4.8 库的常用命令

  1. #1. 清空当前所在的数据库
  2. flushdb
  3. #2. 清空全部数据库
  4. flushall
  5. #3. 查看当前数据库中有多少个key
  6. dbsize
  7. #4. 查看最后一次操作的时间
  8. lastsave
  9. #5. 实时监控Redis服务接收到的命令
  10. monitor

五、Java连接Redis【重点】?


5.1 Jedis连接Redis

5.1.1 创建Maven工程

idea创建

5.1.2 导入需要的依赖
  1. <dependencies>
  2. <!-- 1、 Jedis-->
  3. <dependency>
  4. <groupId>redis.clients</groupId>
  5. <artifactId>jedis</artifactId>
  6. <version>2.9.0</version>
  7. </dependency>
  8. <!-- 2、 Junit测试-->
  9. <dependency>
  10. <groupId>junit</groupId>
  11. <artifactId>junit</artifactId>
  12. <version>4.12</version>
  13. </dependency>
  14. <!-- 3、 Lombok-->
  15. <dependency>
  16. <groupId>org.projectlombok</groupId>
  17. <artifactId>lombok</artifactId>
  18. <version>1.16.20</version>
  19. </dependency>
  20. </dependencies>

5.1.3 测试
  1. public class Demo1 {
  2. @Test
  3. public void set(){
  4. //1. 连接Redis
  5. Jedis jedis = new Jedis("192.168.199.109",6379);
  6. //2. 操作Redis - 因为Redis的命令是什么,Jedis的方法就是什么
  7. jedis.set("name","李四");
  8. //3. 释放资源
  9. jedis.close();
  10. }
  11. @Test
  12. public void get(){
  13. //1. 连接Redis
  14. Jedis jedis = new Jedis("192.168.199.109",6379);
  15. //2. 操作Redis - 因为Redis的命令是什么,Jedis的方法就是什么
  16. String value = jedis.get("name");
  17. System.out.println(value);
  18. //3. 释放资源
  19. jedis.close();
  20. }
  21. }

5.2 Jedis存储一个对象到Redis以byte[]的形式

5.2.1 准备一个User实体类
  1. @Data
  2. @NoArgsConstructor
  3. @AllArgsConstructor
  4. public class User implements Serializable {
  5. private Integer id;
  6. private String name;
  7. private Date birthday;
  8. }

5.2.2 导入spring-context依赖
  1. <!-- 4. 导入spring-context -->
  2. <dependency>
  3. <groupId>org.springframework</groupId>
  4. <artifactId>spring-context</artifactId>
  5. <version>4.3.18.RELEASE</version>
  6. </dependency>

5.2.3 创建Demo测试类,编写内容
  1. public class Demo2 {
  2. // 存储对象 - 以byte[]形式存储在Redis中
  3. @Test
  4. public void setByteArray(){
  5. //1. 连接Redis服务
  6. Jedis jedis = new Jedis("192.168.199.109",6379);
  7. //------------------------------------------------
  8. //2.1 准备key(String)-value(User)
  9. String key = "user";
  10. User value = new User(1,"张三",new Date());
  11. //2.2 将key和value转换为byte[]
  12. byte[] byteKey = SerializationUtils.serialize(key);
  13. byte[] byteValue = SerializationUtils.serialize(value);
  14. //2.3 将key和value存储到Redis
  15. jedis.set(byteKey,byteValue);
  16. //------------------------------------------------
  17. //3. 释放资源
  18. jedis.close();
  19. }
  20. // 获取对象 - 以byte[]形式在Redis中获取
  21. @Test
  22. public void getByteArray(){
  23. //1. 连接Redis服务
  24. Jedis jedis = new Jedis("192.168.199.109",6379);
  25. //------------------------------------------------
  26. //2.1 准备key
  27. String key = "user";
  28. //2.2 将key转换为byte[]
  29. byte[] byteKey = SerializationUtils.serialize(key);
  30. //2.3 jedis去Redis中获取value
  31. byte[] value = jedis.get(byteKey);
  32. //2.4 将value反序列化为User对象
  33. User user = (User) SerializationUtils.deserialize(value);
  34. //2.5 输出
  35. System.out.println("user:" + user);
  36. //------------------------------------------------
  37. //3. 释放资源
  38. jedis.close();
  39. }
  40. }

5.3 Jedis存储一个对象到Redis以String的形式

5.3.1 导入依赖
  1. <!-- 导入fastJSON -->
  2. <dependency>
  3. <groupId>com.alibaba</groupId>
  4. <artifactId>fastjson</artifactId>
  5. <version>1.2.47</version>
  6. </dependency>

5.3.2 测试
  1. public class Demo3 {
  2. // 存储对象 - 以String形式存储
  3. @Test
  4. public void setString(){
  5. //1. 连接Redis
  6. Jedis jedis = new Jedis("192.168.199.109",6379);
  7. //2.1 准备key(String)-value(User)
  8. String stringKey = "stringUser";
  9. User value = new User(2,"李四",new Date());
  10. //2.2 使用fastJSON将value转化为json字符串
  11. String stringValue = JSON.toJSONString(value);
  12. //2.3 存储到Redis中
  13. jedis.set(stringKey,stringValue);
  14. //3. 释放资源
  15. jedis.close();
  16. }
  17. // 获取对象 - 以String形式获取
  18. @Test
  19. public void getString(){
  20. //1. 连接Redis
  21. Jedis jedis = new Jedis("192.168.199.109",6379);
  22. //2.1 准备一个key
  23. String key = "stringUser";
  24. //2.2 去Redis中查询value
  25. String value = jedis.get(key);
  26. //2.3 将value反序列化为User
  27. User user = JSON.parseObject(value, User.class);
  28. //2.4 输出
  29. System.out.println("user:" + user);
  30. //3. 释放资源
  31. jedis.close();
  32. }
  33. }

5.4 Jedis连接池的操作

  1. @Test
  2. public void pool2(){
  3. //1. 创建连接池配置信息
  4. GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
  5. poolConfig.setMaxTotal(100); // 连接池中最大的活跃数
  6. poolConfig.setMaxIdle(10); // 最大空闲数
  7. poolConfig.setMinIdle(5); // 最小空闲数
  8. poolConfig.setMaxWaitMillis(3000); // 当连接池空了之后,多久没获取到Jedis对象,就超时
  9. //2. 创建连接池
  10. JedisPool pool = new JedisPool(poolConfig,"192.168.199.109",6379);
  11. //3. 通过连接池获取jedis对象
  12. Jedis jedis = pool.getResource();
  13. //4. 操作
  14. String value = jedis.get("stringUser");
  15. System.out.println("user:" + value);
  16. //5. 释放资源
  17. jedis.close();
  18. }

5.5 Redis的管道操作

因为在操作Redis的时候,执行一个命令需要先发送请求到Redis服务器,这个过程需要经历网络的延迟,Redis还需要给客户端一个响应。
如果我需要一次性执行很多个命令,上述的方式效率很低,可以通过Redis的管道,先将命令放到客户端的一个Pipeline中,之后一次性的将全部命令都发送到Redis服务,Redis服务一次性的将全部的返回结果响应给客户端。

  1. // Redis管道的操作
  2. @Test
  3. public void pipeline(){
  4. //1. 创建连接池
  5. JedisPool pool = new JedisPool("192.168.199.109",6379);
  6. long l = System.currentTimeMillis();
  7. /*//2. 获取一个连接对象
  8. Jedis jedis = pool.getResource();
  9. //3. 执行incr - 100000次
  10. for (int i = 0; i < 100000; i++) {
  11. jedis.incr("pp");
  12. }
  13. //4. 释放资源
  14. jedis.close();*/
  15. //================================
  16. //2. 获取一个连接对象
  17. Jedis jedis = pool.getResource();
  18. //3. 创建管道
  19. Pipeline pipelined = jedis.pipelined();
  20. //3. 执行incr - 100000次放到管道中
  21. for (int i = 0; i < 100000; i++) {
  22. pipelined.incr("qq");
  23. }
  24. //4. 执行命令
  25. pipelined.syncAndReturnAll();
  26. //5. 释放资源
  27. jedis.close();
  28. System.out.println(System.currentTimeMillis() - l);
  29. }

六、Redis其他配置及集群【重点】

修改yml文件,以方便后期修改Redis配置信息

  1. version: '3.1'
  2. services:
  3. redis:
  4. image: daocloud.io/library/redis:5.0.7
  5. restart: always
  6. container_name: redis
  7. environment:
  8. - TZ=Asia/Shanghai
  9. ports:
  10. - 6379:6379
  11. volumes:
  12. - ./conf/redis.conf:/usr/local/redis/redis.conf
  13. command: ["redis-server","/usr/local/redis/redis.conf"]

6.1 Redis的AUTH

image.png
方式一:通过修改Redis的配置文件,实现Redis的密码校验
# redis.conf
requirepass 密码
三种客户端的连接方式

  • redis-cli:在输入正常命令之前,先输入auth 密码即可。
  • 图形化界面:在连接Redis的信息中添加上验证的密码。
  • Jedis客户端:
    • jedis.auth(password);
  • 使用JedisPool的方式

// 使用当前有参构造设置密码

  1. public JedisPool(final GenericObjectPoolConfig poolConfig, final String host, int port,int timeout, final String password)

6.2 Redis的事务

Redis的事务:一次事务操作,改成功的成功,该失败的失败。
先开启事务,执行一些列的命令,但是命令不会立即执行,会被放在一个队列中,如果你执行事务,那么这个队列中的命令全部执行,如果取消了事务,一个队列中的命令全部作废。

  • 开启事务:multi
  • 输入要执行的命令:被放入到一个队列中
  • 执行事务:exec
  • 取消事务:discard

Redis的事务向发挥功能,需要配置watch监听机制
在开启事务之前,先通过watch命令去监听一个或多个key,在开启事务之后,如果有其他客户端修改了我监听的key,事务会自动取消。
如果执行了事务,或者取消了事务,watch监听自动消除,一般不需要手动执行unwatch。

6.3 Redis持久化机制

6.3.1 RDB
  1. #密码
  2. requirepass 123456
  3. save 3600 1
  4. save 300 100
  5. save 60 10000
  6. dbfilename redis.rdb

RDB是Redis默认的持久化机制

  • RDB持久化文件,速度比较快,而且存储的是一个二进制的文件,传输起来很方便。
  • RDB持久化的时机:save 900 1:在900秒内,有1个key改变了,就执行RDB持久化。save 300 10:在300秒内,有10个key改变了,就执行RDB持久化。save 60 10000:在60秒内,有10000个key改变了,就执行RDB持久化。
  • RDB无法保证数据的绝对安全。

6.3.2 AOF

AOF持久化机制默认是关闭的,Redis官方推荐同时开启RDB和AOF持久化,更安全,避免数据丢失。

  • AOF持久化的速度,相对RDB较慢的,存储的是一个文本文件,到了后期文件会比较大,传输困难。
  • AOF持久化时机。appendfsync always:每执行一个写操作,立即持久化到AOF文件中,性能比较低。appendfsync everysec:每秒执行一次持久化。appendfsync no:会根据你的操作系统不同,环境的不同,在一定时间内执行一次持久化。
  • AOF相对RDB更安全,推荐同时开启AOF和RDB。 ```xml appendonly yes appendfilename redis.aof appendfsync everysec

appendfsync always

appendfsync no

  1. ![](https://cdn.nlark.com/yuque/0/2021/png/25361323/1638263409284-0414a38e-592e-41b7-841a-8af596574201.png#from=url&height=254&id=TtTor&margin=%5Bobject%20Object%5D&originHeight=334&originWidth=467&originalType=binary&ratio=1&status=done&style=none&width=355)
  2. <a name="vPLdX"></a>
  3. ##### 6.3.3 注意事项
  4. 同时开启RDBAOF的注意事项:<br />如果同时开启了AOFRDB持久化,那么在Redis宕机重启之后,需要加载一个持久化文件,优先选择AOF文件。<br />如果先开启了RDB,再次开启AOF,如果RDB执行了持久化,那么RDB文件中的内容会被AOF覆盖掉。
  5. <a name="H2MAG"></a>
  6. #### 6.4 Redis的主从架构
  7. ![](https://cdn.nlark.com/yuque/0/2021/png/25361323/1637479460989-1be7c015-af23-4141-b22a-064df8f9a7ec.png#from=url&height=299&id=FtoqP&margin=%5Bobject%20Object%5D&originHeight=541&originWidth=1278&originalType=binary&ratio=1&status=done&style=none&width=705.4000244140625)<br />指定yml文件
  8. ```yaml
  9. version: "3.1"
  10. services:
  11. redis1:
  12. image: daocloud.io/library/redis:5.0.7
  13. restart: always
  14. container_name: redis1
  15. environment:
  16. - TZ=Asia/Shanghai
  17. ports:
  18. - 7001:6379
  19. volumes:
  20. - ./conf/redis1.conf:/usr/local/redis/redis.conf
  21. command: ["redis-server","/usr/local/redis/redis.conf"]
  22. redis2:
  23. image: daocloud.io/library/redis:5.0.7
  24. restart: always
  25. container_name: redis2
  26. environment:
  27. - TZ=Asia/Shanghai
  28. ports:
  29. - 7002:6379
  30. volumes:
  31. - ./conf/redis2.conf:/usr/local/redis/redis.conf
  32. links:
  33. - redis1:master
  34. command: ["redis-server","/usr/local/redis/redis.conf"]
  35. redis3:
  36. image: daocloud.io/library/redis:5.0.7
  37. restart: always
  38. container_name: redis3
  39. environment:
  40. - TZ=Asia/Shanghai
  41. ports:
  42. - 7003:6379
  43. volumes:
  44. - ./conf/redis3.conf:/usr/local/redis/redis.conf
  45. links:
  46. - redis1:master
  47. command: ["redis-server","/usr/local/redis/redis.conf"]
  1. # redis2和redis3从节点配置
  2. replicaof master 6379

6.5 哨兵

  1. 哨兵可以帮助我们解决主从架构中的单点故障问题

Redis教程 - 图13

  1. 修改了以下docker-compose.yml,为了可以在容器内部使用哨兵的配置(建议先在conf下创建sentinel1(2、3).conf文件)

    1. version: "3.1"
    2. services:
    3. redis1:
    4. image: daocloud.io/library/redis:5.0.7
    5. restart: always
    6. container_name: redis1
    7. environment:
    8. - TZ=Asia/Shanghai
    9. ports:
    10. - 7001:6379
    11. volumes:
    12. - ./conf/redis1.conf:/usr/local/redis/redis.conf
    13. - ./conf/sentinel1.conf:/data/sentinel.conf # 添加的内容
    14. command: ["redis-server","/usr/local/redis/redis.conf"]
    15. redis2:
    16. image: daocloud.io/library/redis:5.0.7
    17. restart: always
    18. container_name: redis2
    19. environment:
    20. - TZ=Asia/Shanghai
    21. ports:
    22. - 7002:6379
    23. volumes:
    24. - ./conf/redis2.conf:/usr/local/redis/redis.conf
    25. - ./conf/sentinel2.conf:/data/sentinel.conf # 添加的内容
    26. links:
    27. - redis1:master
    28. command: ["redis-server","/usr/local/redis/redis.conf"]
    29. redis3:
    30. image: daocloud.io/library/redis:5.0.7
    31. restart: always
    32. container_name: redis3
    33. environment:
    34. - TZ=Asia/Shanghai
    35. ports:
    36. - 7003:6379
    37. volumes:
    38. - ./conf/redis3.conf:/usr/local/redis/redis.conf
    39. - ./conf/sentinel3.conf:/data/sentinel.conf # 添加的内容
    40. links:
    41. - redis1:master
    42. command: ["redis-server","/usr/local/redis/redis.conf"]
  2. 准备哨兵的配置文件,并且在容器内部手动启动哨兵即可

    1. # 哨兵需要后台启动
    2. daemonize yes
    3. # 指定Master节点的ip和端口(主)
    4. sentinel monitor master localhost 6379 2
    5. # 指定Master节点的ip和端口(从)
    6. sentinel monitor master master 6379 2
    7. # 哨兵每隔多久监听一次redis架构
    8. sentinel down-after-milliseconds mymaster 10000
  3. 在Redis容器内部启动sentinel即可(先启动容器在启动哨兵)

    1. redis-sentinel sentinel.conf

    6.6 Redis的集群

Redis集群在保证主从加哨兵的基本功能之外,还能够提升Redis存储数据的能力。
Redis教程 - 图14
准备yml文件

  1. # docker-compose.yml
  2. version: "3.1"
  3. services:
  4. redis1:
  5. image: daocloud.io/library/redis:5.0.7
  6. restart: always
  7. container_name: redis1
  8. environment:
  9. - TZ=Asia/Shanghai
  10. ports:
  11. - 7001:7001
  12. - 17001:17001
  13. volumes:
  14. - ./conf/redis1.conf:/usr/local/redis/redis.conf
  15. command: ["redis-server","/usr/local/redis/redis.conf"]
  16. redis2:
  17. image: daocloud.io/library/redis:5.0.7
  18. restart: always
  19. container_name: redis2
  20. environment:
  21. - TZ=Asia/Shanghai
  22. ports:
  23. - 7002:7002
  24. - 17002:17002
  25. volumes:
  26. - ./conf/redis2.conf:/usr/local/redis/redis.conf
  27. command: ["redis-server","/usr/local/redis/redis.conf"]
  28. redis3:
  29. image: daocloud.io/library/redis:5.0.7
  30. restart: always
  31. container_name: redis3
  32. environment:
  33. - TZ=Asia/Shanghai
  34. ports:
  35. - 7003:7003
  36. - 17003:17003
  37. volumes:
  38. - ./conf/redis3.conf:/usr/local/redis/redis.conf
  39. command: ["redis-server","/usr/local/redis/redis.conf"]
  40. redis4:
  41. image: daocloud.io/library/redis:5.0.7
  42. restart: always
  43. container_name: redis4
  44. environment:
  45. - TZ=Asia/Shanghai
  46. ports:
  47. - 7004:7004
  48. - 17004:17004
  49. volumes:
  50. - ./conf/redis4.conf:/usr/local/redis/redis.conf
  51. command: ["redis-server","/usr/local/redis/redis.conf"]
  52. redis5:
  53. image: daocloud.io/library/redis:5.0.7
  54. restart: always
  55. container_name: redis5
  56. environment:
  57. - TZ=Asia/Shanghai
  58. ports:
  59. - 7005:7005
  60. - 17005:17005
  61. volumes:
  62. - ./conf/redis5.conf:/usr/local/redis/redis.conf
  63. command: ["redis-server","/usr/local/redis/redis.conf"]
  64. redis6:
  65. image: daocloud.io/library/redis:5.0.7
  66. restart: always
  67. container_name: redis6
  68. environment:
  69. - TZ=Asia/Shanghai
  70. ports:
  71. - 7006:7006
  72. - 17006:17006
  73. volumes:
  74. - ./conf/redis6.conf:/usr/local/redis/redis.conf
  75. command: ["redis-server","/usr/local/redis/redis.conf"]
  1. # redis.conf
  2. # 指定redis的端口号
  3. port 7001
  4. # 开启Redis集群
  5. cluster-enabled yes
  6. # 集群信息的文件
  7. cluster-config-file nodes-7001.conf
  8. # 集群的对外ip地址
  9. cluster-announce-ip 192.168.199.109
  10. # 集群的对外port
  11. cluster-announce-port 7001
  12. # 集群的总线端口
  13. cluster-announce-bus-port 17001

启动了6个Redis的节点。
随便跳转到一个容器内部,使用redis-cli管理集群

  1. redis-cli --cluster create 192.168.199.109:7001 192.168.199.109:7002 192.168.199.109:7003 192.168.199.109:7004 192.168.199.109:7005 192.168.199.109:7006 --cluster-replicas 1

6.7 Java连接Redis集群

使用JedisCluster对象连接Redis集群

  1. @Test
  2. public void test(){
  3. // 创建Set<HostAndPort> nodes
  4. Set<HostAndPort> nodes = new HashSet<>();
  5. nodes.add(new HostAndPort("192.168.199.109",7001));
  6. nodes.add(new HostAndPort("192.168.199.109",7002));
  7. nodes.add(new HostAndPort("192.168.199.109",7003));
  8. nodes.add(new HostAndPort("192.168.199.109",7004));
  9. nodes.add(new HostAndPort("192.168.199.109",7005));
  10. nodes.add(new HostAndPort("192.168.199.109",7006));
  11. // 创建JedisCluster对象
  12. JedisCluster jedisCluster = new JedisCluster(nodes);
  13. // 操作
  14. String value = jedisCluster.get("b");
  15. System.out.println(value);
  16. }

七、Redis常见问题【重点】

7.1 key的生存时间到了,Redis会立即删除吗?

不会立即删除。

  • 定期删除:Redis每隔一段时间就去会去查看Redis设置了过期时间的key,会再100ms的间隔中默认查看3个key。
  • 惰性删除:如果当你去查询一个已经过了生存时间的key时,Redis会先查看当前key的生存时间,是否已经到了,直接删除当前key,并且给用户返回一个空值。

    7.2 Redis的淘汰机制

    在Redis内存已经满的时候,添加了一个新的数据,执行淘汰机制。

  • volatile-lru:在内存不足时,Redis会在设置过了生存时间的key中干掉一个最近最少使用的key。
  • allkeys-lru:在内存不足时,Redis会在全部的key中干掉一个最近最少使用的key。

  • volatile-lfu:在内存不足时,Redis会在设置过了生存时间的key中干掉一个最近最少频次使用的key。
  • allkeys-lfu:在内存不足时,Redis会在全部的key中干掉一个最近最少频次使用的key。

  • volatile-random:在内存不足时,Redis会在设置过了生存时间的key中随机干掉一个。
  • allkeys-random:在内存不足时,Redis会再全部的key中随机干掉一个。

  • volatile-ttl:在内存不足时,Redis会在设置过了生存时间的key中干掉一个剩余生存时间最少的key。
  • noeviction:(默认)在内存不足时,直接报错。

指定淘汰机制的方式:maxmemory-policy 具体策略,设置Redis的最大内存:maxmemory 字节大小

7.3 缓存的常问题

7.3.1 缓存穿透问题

缓存穿透
Redis教程 - 图15

7.3.2 缓存击穿问题

缓存击穿
Redis教程 - 图16

7.3.4 缓存倾斜问题

缓存倾斜
Redis教程 - 图17