从0学Redis到精通 看这一篇两万多字文章就够了

最新推荐文章于 2023-04-18 17:05:05 发布
最新推荐文章于 2023-04-18 17:05:05 发布
阅读量331 收藏 6
点赞数 3
分类专栏： Redis数据库 文章标签： 学习Redis 哨兵机制 Redis基本数据类型 Redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38925911/article/details/102752581
版权

目录

一、Redis简介

1.什么是redis?
2.redis使用场景
3.redis优势
4.redis与其他key-value存储有什么不同？

二、Redis安装

1.windows 安装redis
2.linux 安装redis 及启动 修改文件 连接 停止等命令

三、Redis的基本数据类型

1.字符串类型(String) 示例及相关的基本命令
2.列表类型(List)示例及相关的基本命令
3.Redis 集合(Set)示例及相关的基本命令
4.Redis 有序集合(sorted set)示例及相关的基本命令

四、Redis jedis代码操作实例

1.引入Maven依赖
2.java代码示例

五、SpringBoot集成Redis

1.引入Maven依赖
2.新增配置文件信息
3.java代码示例

六、Redis主从复制

1.克隆虚拟机
2.生成新的mack地址
3.主从复制配置
4.修改redis.conf

七、Redis哨兵机制

1.什么是哨兵机制
2.哨兵模式修改配置

八、Redis事物

1.redis事物简介
2.实例
3.redis 事务命令

Redis持久化

1.什么是Redis持久化?
2.AOF与RDB区别

Redis发布订阅

1.实例
2.Redis 发布订阅命令

redis简介

什么是redis？

用官方一点的话说就是

Redis 是完全开源免费的，遵守BSD协议，是一个高性能的key-value数据库。

redis 有以下三个特点：

  1. Redis支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用。
  2. Redis不仅仅支持简单的key-value类型的数据，同时还提供list，set，zset，hash等数据结构的存储。
  3. Redis支持数据的备份，即master-slave模式的数据备份。
Redis应用场景

主要能够体现在 解决数据库的访问压力。
例如:短信验证码时间有效期、session共享解决方案等

Redis优势
  1. 性能极高 – Redis能读的速度是110000次/s,写的速度是81000次/s 。
  2. 丰富的数据类型 – Redis支持二进制案例的 Strings, Lists, Hashes, Sets 及 Ordered Sets 数据类型操作。
  3. 原子 – Redis的所有操作都是原子性的，同时Redis还支持对几个操作全并后的原子性执行。
  4. 丰富的特性 – Redis还支持 publish/subscribe, 通知, key 过期等等特性。
Redis与其他key-value存储有什么不同？
  1. Redis有着更为复杂的数据结构并且提供对他们的原子性操作，这是一个不同于其他数据库的进化路径。Redis的数据类型都是基于基本数据结构的同时对程序员透明，无需进行额外的抽象。
  2. Redis运行在内存中但是可以持久化到磁盘，所以在对不同数据集进行高速读写时需要权衡内存，因为数据量不能大于硬件内存。在内存数据库方面的另一个优点是，相比在磁盘上相同的复杂的数据结构，在内存中操作起来非常简单，这样Redis可以做很多内部复杂性很强的事情。同时，在磁盘格式方面他们是紧凑的以追加的方式产生的，因为他们并不需要进行随机访问。
windows 安装redis

来来来，点此跳转
windows安装比较简单，不做过多赘述

linux 安装redis

Redis的官方下载网址是：点击这里 (这里下载的是Linux版的Redis源码包）
Redis服务器端的默认端口是6379。
这里以虚拟机中的Linux系统如何安装Redis进行讲解。
在windows系统中下载好Redis的源码包。

1. 通过WinSCP工具，将Redis的源码包由windows上传到Linux系统的这个目录/opt/redis (即根目录下的lamp文件夹）。
2. 解压缩。           
    tar -zxf redis-2.6.17.tar.gz
3. 切换到解压后的目录。
cd redis-2.6.17            ( 一般来说，解压目录里的INSTALL文件或README文件里写有安装说明，可参考之）
4. 编译。
make        
（注意，编译需要C语言编译器gcc的支持，如果没有，需要先安装gcc。可以使用rpm -q gcc查看gcc是否安装）
（利用yum在线安装gcc的命令    yum -y install gcc )
（如果编译出错，请使用make clean清除临时文件。之后，找到出错的原因，解决问题后再来重新安装。 ）
5. 进入到src目录。       
cd src
6. 执行安装。
make install    
到此就安装完成。但是，由于安装redis的时候，我们没有选择安装路径，故是默认位置安装。在此，我们可以将可执行文件和配置文件移动到习惯的目录。
cd /usr/local
mkdir -p /usr/local/redis/bin    
mkdir -p /usr/local/redis/etc
cd /lamp/redis-2.6.17
cp ./redis.conf /usr/local/redis/etc
cd src
cp mkreleasehdr.sh redis-benchmark redis-check-aof redis-check-dump redis-cli redis-server redis-sentinel /usr/local/redis/bin
7．开放linux 6379 端口
1.编辑 /etc/sysconfig/iptables 文件：vi /etc/sysconfig/iptables
加入内容并保存：-A RH-Firewall-1-INPUT -m state –state NEW -m tcp -p tcp –dport 6379 -j ACCEPT
2.重启服务：/etc/init.d/iptables restart
3.查看端口是否开放：/sbin/iptables -L -n
比较重要的3个可执行文件：
redis-server：Redis服务器程序
redis-cli：Redis客户端程序，它是一个命令行操作工具。也可以使用telnet根据其纯文本协议操作。
redis-benchmark：Redis性能测试工具，测试Redis在你的系统及配置下的读写性能。

Redis的启动命令：
/usr/local/redis/bin/redis-server
或
cd /usr/local/redis/bin
./redis-server /usr/local/redis/etc/redis.conf    为redis-server指定配置文
4.2.2修改 redis.conf文件
daemonize yes --- 修改为yes  后台启动
requirepass 123456  ----注释取消掉设置账号密码
ps aux | grep '6379'  --- 查询端口
kill -15 9886 --- 杀死重置
kill -9 9886 --- 强制杀死
service iptables stop 停止防火强
4.2.3 redis命令连接方式
./redis-cli -h 127.0.0.1 -p 6379 -a "123456"  --- redis 使用账号密码连接

PING 结果表示成功
4.2.4 停止redis
redis-cli shutdown  或者 kill redis进程的pid

4.2.5 关闭防火墙
Redis的基本数据类型
1.字符串类型(String)
redis 127.0.0.1:6379> SET mykey "redis" 
OK 
redis 127.0.0.1:6379> GET mykey 
"redis"

在上面的例子中，SET和GET是redis中的命令，而mykey是键的名称。
Redis字符串命令用于管理Redis中的字符串值。以下是使用Redis字符串命令的语法。

redis 127.0.0.1:6379> COMMAND KEY_NAME
Shell

示例

redis 127.0.0.1:6379> SET mykey "redis" 
OK 
redis 127.0.0.1:6379> GET mykey 
"redis"
Shell

在上面的例子中，SET和GET是redis中的命令，而mykey是键的名称。
下表列出了一些用于在Redis中管理字符串的基本命令。

编号命令描述说明
1SET key value此命令设置指定键的值。
2GET key获取指定键的值。
3GETRANGE key start end获取存储在键上的字符串的子字符串。
4GETSET key value设置键的字符串值并返回其旧值。
5GETBIT key offset返回在键处存储的字符串值中偏移处的位值。
6MGET key1 [key2…]获取所有给定键的值
7SETBIT key offset value存储在键上的字符串值中设置或清除偏移处的位
8SETEX key seconds value使用键和到期时间来设置值
9SETNX key value设置键的值，仅当键不存在时
10SETRANGE key offset value在指定偏移处开始的键处覆盖字符串的一部分
11STRLEN key获取存储在键中的值的长度
12MSET key value [key value …]为多个键分别设置它们的值
13MSETNX key value [key value …]为多个键分别设置它们的值，仅当键不存在时
14PSETEX key milliseconds value设置键的值和到期时间(以毫秒为单位)
15INCR key将键的整数值增加1
16INCRBY key increment将键的整数值按给定的数值增加
17INCRBYFLOAT key increment将键的浮点值按给定的数值增加
18DECR key将键的整数值减1
19DECRBY key decrement按给定数值减少键的整数值
20APPEND key value将指定值附加到键
2.列表类型(List)

Redis列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部（左边）或者尾部（右边）
一个列表最多可以包含 232 - 1 个元素 (4294967295, 每个列表超过40亿个元素)。

redis 127.0.0.1:6379> LPUSH runoobkey redis
(integer) 1
redis 127.0.0.1:6379> LPUSH runoobkey mongodb
(integer) 2
redis 127.0.0.1:6379> LPUSH runoobkey mysql
(integer) 3
redis 127.0.0.1:6379> LRANGE runoobkey 0 10

1) "mysql"
2) "mongodb"
3) "redis"

下表列出了列表相关的基本命令：

编号命令描述说明
1BLPOP key1 [key2 ] timeout移出并获取列表的第一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。
2BRPOP key1 [key2 ] timeout移出并获取列表的最后一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。
3BRPOPLPUSH source destination timeout从列表中弹出一个值，将弹出的元素插入到另外一个列表中并返回它； 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。
4LINDEX key index通过索引获取列表中的元素
5LINSERT key BEFOREAFTER pivot value
6LLEN key获取列表长度
7LPOP key移出并获取列表的第一个元素
8LPUSH key value1 [value2]将一个或多个值插入到列表头部
9LPUSHX key value将一个值插入到已存在的列表头部
10LRANGE key start stop获取列表指定范围内的元素
11LREM key count value移除列表元素
12LSET key index value通过索引设置列表元素的值
13LTRIM key start stop对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。
14RPOP key移除并获取列表最后一个元素
15RPOPLPUSH source destination移除列表的最后一个元素，并将该元素添加到另一个列表并返回
16RPUSH key value1 [value2]在列表中添加一个或多个值
17RPUSHX key value为已存在的列表添加值
3.Redis 集合(Set)

Redis的Set是string类型的无序集合。集合成员是唯一的，这就意味着集合中不能出现重复的数据。
Redis 中 集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是O(1)。
集合中最大的成员数为 232 - 1 (4294967295, 每个集合可存储40多亿个成员)。
实例：

redis 127.0.0.1:6379> SADD runoobkey redis
(integer) 1
redis 127.0.0.1:6379> SADD runoobkey mongodb
(integer) 1
redis 127.0.0.1:6379> SADD runoobkey mysql
(integer) 1
redis 127.0.0.1:6379> SADD runoobkey mysql
(integer) 0
redis 127.0.0.1:6379> SMEMBERS runoobkey

1) "mysql"
2) "mongodb"
3) "redis"

在以上实例中我们通过 SADD 命令向名为 runoobkey 的集合插入的三个元素。
下表列出了 Redis 集合基本命令：

编号命令描述说明
1SADD key member1 [member2]向集合添加一个或多个成员
2SCARD key获取集合的成员数
3SDIFF key1 [key2]返回给定所有集合的差集
4SDIFFSTORE destination key1 [key2]返回给定所有集合的差集并存储在 destination 中
5SINTER key1 [key2]返回给定所有集合的交集
6SINTERSTORE destination key1 [key2]返回给定所有集合的交集并存储在 destination 中
7SISMEMBER key member判断 member 元素是否是集合 key 的成员
8SMEMBERS key返回集合中的所有成员
9SMOVE source destination member将 member 元素从 source 集合移动到 destination 集合
10SPOP key移除并返回集合中的一个随机元素
11SRANDMEMBER key [count]返回集合中一个或多个随机数
12SREM key member1 [member2]移除集合中一个或多个成员
13SUNION key1 [key2]返回所有给定集合的并集
14SUNIONSTORE destination key1 [key2]所有给定集合的并集存储在 destination 集合中
15SSCAN key cursor [MATCH pattern] [COUNT count]迭代集合中的元素
4.Redis 有序集合(sorted set)

Redis 有序集合和集合一样也是string类型元素的集合,且不允许重复的成员。
不同的是每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。
有序集合的成员是唯一的,但分数(score)却可以重复。
集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是O(1)。 集合中最大的成员数为 232 - 1 (4294967295, 每个集合可存储40多亿个成员)。
实例：

redis 127.0.0.1:6379> ZADD runoobkey 1 redis
(integer) 1
redis 127.0.0.1:6379> ZADD runoobkey 2 mongodb
(integer) 1
redis 127.0.0.1:6379> ZADD runoobkey 3 mysql
(integer) 1
redis 127.0.0.1:6379> ZADD runoobkey 3 mysql
(integer) 0
redis 127.0.0.1:6379> ZADD runoobkey 4 mysql
(integer) 0
redis 127.0.0.1:6379> ZRANGE runoobkey 0 10 WITHSCORES

1) "redis"
2) "1"
3) "mongodb"
4) "2"
5) "mysql"
6) "4"

在以上实例中我们通过命令 ZADD 向 redis 的有序集合中添加了三个值并关联上分数。
下表列出了 redis 有序集合的基本命令:

编号命令描述说明
1ZADD key score1 member1 [score2 member2]向有序集合添加一个或多个成员，或者更新已存在成员的分数
2ZCARD key获取有序集合的成员数
3ZCOUNT key min max计算在有序集合中指定区间分数的成员数
4ZINCRBY key increment member有序集合中对指定成员的分数加上增量 increment
5ZINTERSTORE destination numkeys key [key …]计算给定的一个或多个有序集的交集并将结果集存储在新的有序集合 key 中
6ZLEXCOUNT key min max在有序集合中计算指定字典区间内成员数量
7ZRANGE key start stop [WITHSCORES]通过索引区间返回有序集合成指定区间内的成员
8ZRANGEBYLEX key min max [LIMIT offset count]通过字典区间返回有序集合的成员
9ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT]通过分数返回有序集合指定区间内的成员
10ZRANK key member返回有序集合中指定成员的索引
11ZREM key member [member …]移除有序集合中的一个或多个成员
12ZREMRANGEBYLEX key min max移除有序集合中给定的字典区间的所有成员
13ZREMRANGEBYRANK key start stop移除有序集合中给定的排名区间的所有成员
14ZREMRANGEBYSCORE key min max移除有序集合中给定的分数区间的所有成员
15ZREVRANGE key start stop [WITHSCORES]返回有序集中指定区间内的成员，通过索引，分数从高到底
16ZREVRANGEBYSCORE key max min [WITHSCORES]返回有序集中指定分数区间内的成员，分数从高到低排序
17ZREVRANK key member返回有序集合中指定成员的排名，有序集成员按分数值递减(从大到小)排序
18ZSCORE key member返回有序集中，成员的分数值
19ZUNIONSTORE destination numkeys key [key …]计算给定的一个或多个有序集的并集，并存储在新的 key 中
20ZSCAN key cursor [MATCH pattern] [COUNT count]迭代有序集合中的元素（包括元素成员和元素分值）
5.Redis 哈希(Hash)

Redis hash 是一个string类型的field和value的映射表，hash特别适合用于存储对象。
Redis 中每个 hash 可以存储 232 - 1 键值对（40多亿）。
实例:

127.0.0.1:6379>  HMSET runoobkey name "redis tutorial" description "redis basic commands for caching" likes 20 visitors 23000
OK
127.0.0.1:6379>  HGETALL runoobkey
1) "name"
2) "redis tutorial"
3) "description"
4) "redis basic commands for caching"
5) "likes"
6) "20"
7) "visitors"
8) "23000"
hset  key  mapHey MapValue

在以上实例中，我们设置了 redis 的一些描述信息(name, description, likes, visitors) 到哈希表的 runoobkey 中。
下表列出了 redis hash 基本的相关命令：

编号命令描述说明
1HDEL key field2 [field2]删除一个或多个哈希表字段
2HEXISTS key field查看哈希表 key 中，指定的字段是否存在。
3HGET key field获取存储在哈希表中指定字段的值。
4HGETALL key获取在哈希表中指定 key 的所有字段和值
5HINCRBY key field increment为哈希表 key 中的指定字段的整数值加上增量 increment 。
6HINCRBYFLOAT key field increment为哈希表 key 中的指定字段的浮点数值加上增量 increment 。
7HKEYS key获取所有哈希表中的字段
8HLEN key获取哈希表中字段的数量
9HMGET key field1 [field2]获取所有给定字段的值
10HMSET key field1 value1 [field2 value2 ]同时将多个 field-value (域-值)对设置到哈希表 key 中。
11HSET key field value将哈希表 key 中的字段 field 的值设为 value 。
12HSETNX key field value只有在字段 field 不存在时，设置哈希表字段的值。
13HVALS key获取哈希表中所有值
14HSCAN key cursor [MATCH pattern] [COUNT count]迭代哈希表中的键值对。
Redis jedis代码操作实例
引入Maven依赖
  <!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>2.9.0</version>
</dependency>
Java代码
public class TestRedis {
    private Jedis jedis; 
    
    @Before
    public void setup() {
        //连接redis服务器，192.168.0.100:6379
        jedis = new Jedis("192.168.0.100", 6379);
        //权限认证
        jedis.auth("admin");  
    }
    
    /**
     * redis存储字符串
     */
    @Test
    public void testString() {
        //-----添加数据----------  
        jedis.set("name","xinxin");//向key-->name中放入了value-->xinxin  
        System.out.println(jedis.get("name"));//执行结果：xinxin  
        
        jedis.append("name", " is my lover"); //拼接
        System.out.println(jedis.get("name")); 
        
        jedis.del("name");  //删除某个键
        System.out.println(jedis.get("name"));
        //设置多个键值对
        jedis.mset("name","liuling","age","23","qq","476777XXX");
        jedis.incr("age"); //进行加1操作
        System.out.println(jedis.get("name") + "-" + jedis.get("age") + "-" + jedis.get("qq"));
        
    }
    
    /**
     * redis操作Map
     */
    @Test
    public void testMap() {
        //-----添加数据----------  
        Map<String, String> map = new HashMap<String, String>();
        map.put("name", "xinxin");
        map.put("age", "22");
        map.put("qq", "123456");
        jedis.hmset("user",map);
        //取出user中的name，执行结果:[minxr]-->注意结果是一个泛型的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 
     */  
    @Test  
    public void testList(){  
        //开始前，先移除所有的内容  
        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 
     */  
    @Test  
    public void testSet(){  
        //添加  
        jedis.sadd("user","liuling");  
        jedis.sadd("user","xinxin");  
        jedis.sadd("user","ling");  
        jedis.sadd("user","zhangxinxin");
        jedis.sadd("user","who");  
        //移除noname  
        jedis.srem("user","who");  
        System.out.println(jedis.smembers("user"));//获取所有加入的value  
        System.out.println(jedis.sismember("user", "who"));//判断 who 是否是user集合的元素  
        System.out.println(jedis.srandmember("user"));  
        System.out.println(jedis.scard("user"));//返回集合的元素个数  
    }  
  
    @Test  
    public void test() throws InterruptedException {  
        //jedis 排序  
        //注意，此处的rpush和lpush是List的操作。是一个双向链表（但从表现来看的）  
        jedis.del("a");//先清除数据，再加入数据进行测试  
        jedis.rpush("a", "1");  
        jedis.lpush("a","6");  
        jedis.lpush("a","3");  
        jedis.lpush("a","9");  
        System.out.println(jedis.lrange("a",0,-1));// [9, 3, 6, 1]  
        System.out.println(jedis.sort("a")); //[1, 3, 6, 9]  //输入排序后结果  
        System.out.println(jedis.lrange("a",0,-1));  
    }  
    
    @Test
    public void testRedisPool() {
        RedisUtil.getJedis().set("newname", "中文测试");
        System.out.println(RedisUtil.getJedis().get("newname"));
    }
SpringBoot集成Redis
1.引入maven依赖
<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.3.RELEASE</version>
	</parent>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
	</dependencies>
2.新增配置文件信息
########################################################
###Redis (RedisConfiguration)
########################################################
spring.redis.database=0
spring.redis.host=127.0.0.1
spring.redis.port=6379
spring.redis.password=123456
spring.redis.pool.max-idle=8
spring.redis.pool.min-idle=0
spring.redis.pool.max-active=8
spring.redis.pool.max-wait=-1
spring.redis.timeout=5000
Java代码
@Service
public class RedisService {
	@Autowired
	private StringRedisTemplate stringRedisTemplate;
	public void setStr(String key, String value) {
		setStr(key, value, null);
	}

	public void setStr(String key, String value, Long time) {
		stringRedisTemplate.opsForValue().set(key, value);
		if (time != null)
			stringRedisTemplate.expire(key, time, TimeUnit.SECONDS);
	}

	public Object getKey(String key) {
		return stringRedisTemplate.opsForValue().get(key);
	}

	public void delKey(String key) {
		stringRedisTemplate.delete(key);
	}
}
Redis主从复制

克隆三台linux虚拟机

1.克隆虚拟机

xscsacsacdsvf在这里插入图片描述

2.生成新的mack地址

在这里插入图片描述

3.主从复制配置

redis主从复制
概述

  1. redis的复制功能是支持多个数据库之间的数据同步。一类是主数据库（master）一类是从数据库（slave），主数据库可以进行读写操作，当发生写操作的时候自动将数据同步到从数据库，而从数据库一般是只读的，并接收主数据库同步过来的数据，一个主数据库可以有多个从数据库，而一个从数据库只能有一个主数据库。
  2. 通过redis的复制功能可以很好的实现数据库的读写分离，提高服务器的负载能力。主数据库主要进行写操作，而从数据库负责读操作。
    主从复制过程
    主从复制过程：见下图
    在这里插入图片描述

过程：

  1. 当一个从数据库启动时，会向主数据库发送sync命令，
  2. 主数据库接收到sync命令后会开始在后台保存快照（执行rdb操作），并将保存期间接收到的命令缓存起来
  3. 当快照完成后，redis会将快照文件和所有缓存的命令发送给从数据库。
  4. 从数据库收到后，会载入快照文件并执行收到的缓存的命令。
4.修改redis.conf

修改从redis中的 redis.conf文件

slaveof 192.168.33.130 6379  
masterauth 123456--- 主redis服务器配置了密码,则需要配置
Redis哨兵机制
1.什么是哨兵机制

Redis的哨兵(sentinel) 系统用于管理多个 Redis 服务器,该系统执行以下三个任务:
· 监控(Monitoring): 哨兵(sentinel) 会不断地检查你的Master和Slave是否运作正常。
· 提醒(Notification):当被监控的某个 Redis出现问题时, 哨兵(sentinel) 可以通过 API 向管理员或者其他应用程序发送通知。
· 自动故障迁移(Automatic failover):当一个Master不能正常工作时，哨兵(sentinel) 会开始一次自动故障迁移操作,它会将失效Master的其中一个Slave升级为新的Master, 并让失效Master的其他Slave改为复制新的Master; 当客户端试图连接失效的Master时,集群也会向客户端返回新Master的地址,使得集群可以使用Master代替失效Master。

哨兵(sentinel) 是一个分布式系统,你可以在一个架构中运行多个哨兵(sentinel) 进程,这些进程使用流言协议(gossipprotocols)来接收关于Master是否下线的信息,并使用投票协议(agreement protocols)来决定是否执行自动故障迁移,以及选择哪个Slave作为新的Master.

每个哨兵(sentinel) 会向其它哨兵(sentinel)、master、slave定时发送消息,以确认对方是否”活”着,如果发现对方在指定时间(可配置)内未回应,则暂时认为对方已挂(所谓的”主观认为宕机” Subjective Down,简称sdown).
若“哨兵群”中的多数sentinel,都报告某一master没响应,系统才认为该master"彻底死亡"(即:客观上的真正down机,Objective Down,简称odown),通过一定的vote算法,从剩下的slave节点中,选一台提升为master,然后自动修改相关配置.

虽然哨兵(sentinel) 释出为一个单独的可执行文件 redis-sentinel ,但实际上它只是一个运行在特殊模式下的 Redis 服务器，你可以在启动一个普通 Redis 服务器时通过给定 --sentinel 选项来启动哨兵(sentinel).
哨兵(sentinel) 的一些设计思路和zookeeper非常类似
单个哨兵(sentinel):在这里插入图片描述

2.哨兵模式修改配置

实现步骤:

1.拷贝到etc目录
cp sentinel.conf  /usr/local/redis/etc
2.修改sentinel.conf配置文件
sentinel monitor mymast  192.168.110.133 6379 1  #主节点 名称 IP 端口号 选举次数
3. 修改心跳检测 5000毫秒
sentinel down-after-milliseconds mymaster 5000
4.sentinel parallel-syncs mymaster 2 --- 做多多少合格节点
5. 启动哨兵模式
./redis-server /usr/local/redis/etc/sentinel.conf --sentinel &
6. 停止哨兵模式
Redis事物
1.Redis事物简介

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

  1. 事务是一个单独的隔离操作：事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。
  2. 事务是一个原子操作：事务中的命令要么全部被执行，要么全部都不执行。
    一个事务从开始到执行会经历以下三个阶段：
    开始事务。
    命令入队。
    执行事务。
2.实例

以下是一个事务的例子， 它先以 MULTI 开始一个事务， 然后将多个命令入队到事务中， 最后由 EXEC 命令触发事务， 一并执行事务中的所有命令：

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"
3.Redis 事务命令

下表列出了 redis 事务的相关命令：

编号命令描述说明
1DISCARD取消事务，放弃执行事务块内的所有命令。
2EXEC执行所有事务块内的命令。
3MULTI标记一个事务块的开始。
4UNWATCH取消 WATCH 命令对所有 key 的监视。
5WATCH key [key …]监视一个(或多个) key ，如果在事务执行之前这个(或这些) key 被其他命令所改动，那么事务将被打断。
Redis持久化
1.什么是Redis持久化?

什么是Redis持久化,就是将内存数据保存到硬盘。
Redis 持久化存储 (AOF 与 RDB 两种模式)

  1. RDB持久化
    RDB 是在某个时间点将数据写入一个临时文件，持久化结束后，用这个临时文件替换上次持久化的文件，达到数据恢复。
    优点：使用单独子进程来进行持久化，主进程不会进行任何 IO 操作，保证了 redis 的高性能
    缺点：RDB 是间隔一段时间进行持久化，如果持久化之间 redis 发生故障，会发生数据丢失。所以这种方式更适合数据要求不严谨的时候
    这里说的这个执行数据写入到临时文件的时间点是可以通过配置来自己确定的，通过配置redis 在 n 秒内如果超过 m 个 key 被修改这执行一次 RDB 操作。这个操作就类似于在这个时间点来保存一次 Redis 的所有数据，一次快照数据。所有这个持久化方法也通常叫做 snapshots
    RDB 默认开启
    redis.conf 中的具体配置参数如下；
#dbfilename：持久化数据存储在本地的文件
dbfilename dump.rdb
#dir：持久化数据存储在本地的路径，如果是在/redis/redis-3.0.6/src下启动的redis-cli，则数据会存储在当前src目录下
dir ./
##snapshot触发的时机，save    
##如下为900秒后，至少有一个变更操作，才会snapshot  
##对于此值的设置，需要谨慎，评估系统的变更操作密集程度  
##可以通过“save “””来关闭snapshot功能  
#save时间，以下分别表示更改了1个key时间隔900s进行持久化存储；更改了10个key300s进行存储；更改10000个key60s进行存储。
save 900 1
save 300 10
save 60 10000
##当snapshot时出现错误无法继续时，是否阻塞客户端“变更操作”，“错误”可能因为磁盘已满/磁盘故障/OS级别异常等  
stop-writes-on-bgsave-error yes  
##是否启用rdb文件压缩，默认为“yes”，压缩往往意味着“额外的cpu消耗”，同时也意味这较小的文件尺寸以及较短的网络传输时间  
rdbcompression yes
  1. AOF持久化
    Append-only file，将“操作 + 数据”以格式化指令的方式追加到操作日志文件的尾部，在 append 操作返回后(已经写入到文件或者即将写入)，才进行实际的数据变更，“日志文件”保存了历史所有的操作过程；当 server 需要数据恢复时，可以直接 replay 此日志文件，即可还原所有的操作过程。AOF 相对可靠，它和 mysql 中 bin.log、apache.log、zookeeper 中 txn-log 简直异曲同工。AOF 文件内容是字符串，非常容易阅读和解析。
    优点：可以保持更高的数据完整性，如果设置追加 file 的时间是 1s，如果 redis 发生故障，最多会丢失 1s 的数据；且如果日志写入不完整支持 redis-check-aof 来进行日志修复；AOF 文件没被 rewrite 之前（文件过大时会对命令进行合并重写），可以删除其中的某些命令（比如误操作的 flushall）。
    缺点：AOF 文件比 RDB 文件大，且恢复速度慢。
    我们可以简单的认为 AOF 就是日志文件，此文件只会记录“变更操作”(例如：set/del 等)，如果 server 中持续的大量变更操作，将会导致 AOF 文件非常的庞大，意味着 server 失效后，数据恢复的过程将会很长；事实上，一条数据经过多次变更，将会产生多条 AOF 记录，其实只要保存当前的状态，历史的操作记录是可以抛弃的；因为 AOF 持久化模式还伴生了“AOF rewrite”。
    AOF 的特性决定了它相对比较安全，如果你期望数据更少的丢失，那么可以采用 AOF 模式。如果 AOF 文件正在被写入时突然 server 失效，有可能导致文件的最后一次记录是不完整，你可以通过手工或者程序的方式去检测并修正不完整的记录，以便通过 aof 文件恢复能够正常；同时需要提醒，如果你的 redis 持久化手段中有 aof，那么在 server 故障失效后再次启动前，需要检测 aof 文件的完整性。
    AOF 默认关闭，开启方法，
    修改配置文件 reds.conf：
appendonly yes
##此选项为aof功能的开关，默认为“no”，可以通过“yes”来开启aof功能  
##只有在“yes”下，aof重写/文件同步等特性才会生效  
appendonly yes  

##指定aof文件名称  
appendfilename appendonly.aof  

##指定aof操作中文件同步策略，有三个合法值：always everysec no,默认为everysec  
appendfsync everysec  
##在aof-rewrite期间，appendfsync是否暂缓文件同步，"no"表示“不暂缓”，“yes”表示“暂缓”，默认为“no”  
no-appendfsync-on-rewrite no  

##aof文件rewrite触发的最小文件尺寸(mb,gb),只有大于此aof文件大于此尺寸是才会触发rewrite，默认“64mb”，建议“512mb”  
auto-aof-rewrite-min-size 64mb  

##相对于“上一次”rewrite，本次rewrite触发时aof文件应该增长的百分比。  
##每一次rewrite之后，redis都会记录下此时“新aof”文件的大小(例如A)，那么当aof文件增长到A*(1 + p)之后  
##触发下一次rewrite，每一次aof记录的添加，都会检测当前aof文件的尺寸。  
auto-aof-rewrite-percentage 100

AOF 是文件操作，对于变更操作比较密集的 server，那么必将造成磁盘 IO 的负荷加重；此外 linux 对文件操作采取了“延迟写入”手段，即并非每次 write 操作都会触发实际磁盘操作，而是进入了 buffer 中，当 buffer 数据达到阀值时触发实际写入(也有其他时机)，这是 linux 对文件系统的优化，但是这却有可能带来隐患，如果 buffer 没有刷新到磁盘，此时物理机器失效(比如断电)，那么有可能导致最后一条或者多条 aof 记录的丢失。通过上述配置文件，可以得知 redis 提供了 3 中种aof 记录同步选项：
always：每一条 aof 记录都立即同步到文件，这是最安全的方式，也以为更多的磁盘操作和阻塞延迟，是 IO 开支较大。
everysec：每秒同步一次，性能和安全都比较中庸的方式，也是 redis 推荐的方式。如果遇到物理服务器故障，有可能导致最近一秒内 aof 记录丢失(可能为部分丢失)。
no：redis 并不直接调用文件同步，而是交给操作系统来处理，操作系统可以根据 buffer 填充情况 / 通道空闲时间等择机触发同步；这是一种普通的文件操作方式。性能较好，在物理服务器故障时，数据丢失量会因 OS 配置有关。
其实，我们可以选择的太少，everysec 是最佳的选择。如果你非常在意每个数据都极其可靠，建议你选择一款“关系性数据库”吧。
AOF 文件会不断增大，它的大小直接影响“故障恢复”的时间, 而且 AOF 文件中历史操作是可以丢弃的。AOF rewrite 操作就是“压缩”AOF 文件的过程，当然 redis 并没有采用“基于原 aof 文件”来重写的方式，而是采取了类似 snapshot 的方式：基于 copy-on-write，全量遍历内存中数据，然后逐个序列到 aof 文件中。因此 AOF rewrite 能够正确反应当前内存数据的状态，这正是我们所需要的；rewrite 过程中，对于新的变更操作将仍然被写入到原 AOF 文件中，同时这些新的变更操作也会被 redis 收集起来(buffer，copy-on-write 方式下，最极端的可能是所有的 key 都在此期间被修改，将会耗费 2 倍内存)，当内存数据被全部写入到新的 aof 文件之后，收集的新的变更操作也将会一并追加到新的 aof 文件中，此后将会重命名新的 aof 文件为 appendonly.aof, 此后所有的操作都将被写入新的 aof 文件。如果在 rewrite 过程中，出现故障，将不会影响原 AOF 文件的正常工作，只有当 rewrite 完成之后才会切换文件，因为 rewrite 过程是比较可靠的。
触发 rewrite 的时机可以通过配置文件来声明，同时 redis 中可以通过 bgrewriteaof 指令人工干预。

redis-cli -h ip -p port bgrewriteaof

因为 rewrite 操作 /aof 记录同步 /snapshot 都消耗磁盘 IO，redis 采取了“schedule”策略：无论是“人工干预”还是系统触发，snapshot 和 rewrite 需要逐个被执行。
AOF rewrite 过程并不阻塞客户端请求。系统会开启一个子进程来完成。

2.AOF与RDB区别

AOF 和 RDB 各有优缺点，这是有它们各自的特点所决定：

  1. AOF 更加安全，可以将数据更加及时的同步到文件中，但是 AOF 需要较多的磁盘 IO 开支，AOF 文件尺寸较大，文件内容恢复数度相对较慢。
  2. snapshot，安全性较差，它是“正常时期”数据备份以及 master-slave 数据同步的最佳手段，文件尺寸较小，恢复数度较快。

可以通过配置文件来指定它们中的一种，或者同时使用它们(不建议同时使用)，或者全部禁用，在架构良好的环境中，master 通常使用 AOF，slave 使用 snapshot，主要原因是 master 需要首先确保数据完整性，它作为数据备份的第一选择；slave 提供只读服务(目前 slave 只能提供读取服务)，它的主要目的就是快速响应客户端 read 请求；但是如果你的 redis 运行在网络稳定性差 / 物理环境糟糕情况下，建议你 master 和 slave 均采取 AOF，这个在 master 和 slave 角色切换时，可以减少“人工数据备份”/“人工引导数据恢复”的时间成本；如果你的环境一切非常良好，且服务需要接收密集性的 write 操作，那么建议 master 采取 snapshot，而 slave 采用 AOF。

Redis发布订阅

Redis 发布订阅(pub/sub)是一种消息通信模式：发送者(pub)发送消息，订阅者(sub)接收消息。
Redis 客户端可以订阅任意数量的频道。
下图展示了频道 channel1 ， 以及订阅这个频道的三个客户端 —— client2 、 client5 和 client1 之间的关系：
在这里插入图片描述
当有新消息通过 PUBLISH 命令发送给频道 channel1 时， 这个消息就会被发送给订阅它的三个客户端：
在这里插入图片描述

1.实例

以下实例演示了发布订阅是如何工作的。在我们实例中我们创建了订阅频道名为 redisChat:

redis 127.0.0.1:6379> SUBSCRIBE redisChat

Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "redisChat"
3) (integer) 1
现在，我们先重新开启个 redis 客户端，然后在同一个频道 redisChat 发布两次消息，订阅者就能接收到消息。
redis 127.0.0.1:6379> PUBLISH redisChat "Redis is a great caching technique"

(integer) 1

redis 127.0.0.1:6379> PUBLISH redisChat "Learn redis by runoob.com"

(integer) 1

订阅者的客户端会显示如下消息

1) "message"
2) "redisChat"
3) "Redis is a great caching technique"
1) "message"
2) "redisChat"
3) "Learn redis by runoob.com"
2.Redis 发布订阅命令

下表列出了 redis 发布订阅常用命令：

编号命令描述说明
1PSUBSCRIBE pattern [pattern …]订阅一个或多个符合给定模式的频道。
2PUBSUB subcommand [argument [argument …]]查看订阅与发布系统状态。
3PUBLISH channel message将信息发送到指定的频道。
4PUNSUBSCRIBE [pattern [pattern …]]退订所有给定模式的频道。
5SUBSCRIBE channel [channel …]订阅给定的一个或多个频道的信息。
6UNSUBSCRIBE [channel [channel …]]指退订给定的频道。
Zorione
关注
  • 3
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RedisTemplate
naonao2014的专栏
03-17 2873
Jedis与RedisTemplate的区别： Jedis是Redis官方推荐的面向Java的操作Redis的客户端，可以用JedisPool来获得连接进行get、set、del等操作相对简单，而RedisTemplate是SpringDataRedis中对JedisApi的高度封装。 SpringDataRedis相对于Jedis来说可以方便地更换Redis的Java客户端，比Jedis多了...
Jedis和RedisTemplate有何区别
热门推荐
qq_37208934的博客
07-09 2万+
Jedis是Redis官方推荐的面向Java的操作Redis的客户端，而RedisTemplate是SpringDataRedis中对JedisApi的高度封装。 SpringDataRedis相对于Jedis来说可以方便地更换Redis的Java客户端，比Jedis多了自动管理连接池的特性，方便与其他Spring框架进行搭配使用如：SpringCache 对于那个一个效率更高，自己做了插入str...
RedisTemplate和Jedis的区别以及Spring Data Redis的使用
Tobenumerator的博客
08-26 2637
1.SpringBoot2.x后RedisTemplate默认底层lettuce,大并发下lettuce（底层为netty,是非阻塞性的nio）效率更高,而Jedis底层是阻塞性的IO，效率相对低。Spring Data是用于简化数据库访问的开源框架，包括：jdbc,jpa,elasticsearch,redis.......Spring Data Redis的启动器为：spring-boot-starter-data-redis。创建配置类，配置通用序列化器。...
Jedis和RedisTemplate
韩猿外的博客
04-18 2870
RedisTemplate是对jedis和lettuce的封装，springboot2.0之后，默认使用 lettuce。jedis性能较强，jedis的性能至少是RedisTemplate的3倍以上，jedis结合jedisPool使用既可以有高性能又可以保证redis的连接可控。在性能要求、并发操作不高的场景建议使用RedisTemplate，在并发高，性能要求高的场景下建议使用jedis。
Jedis、RedisTemplate、StringRedisTemplate的区别和使用
pan_junbiao的博客
09-29 3553
1、Jedis、RedisTemplate的区别 Jedis 是 Redis 官方推荐的面向 Java 的操作 Redis 的客户端，而 RedisTemplate 是 SpringDataRedis 中对 JedisApi 的高度封装。 SpringDataRedis 相对于 Jedis 来说可以方便地更换 Redis 的 Java 客户端，比 Jedis 多了自动管理连接池的特性，方便与其他 Spring 框架进行搭配使用如：SpringCache。 2、RedisTemplate、StringR
学Redis这篇就够了
01-27
Redis 是一个高性能的开源键值数据库，它以其高效和丰富的数据类型而闻名。Redis 的设计遵循了 BSD 许可协议，允许用户免费使用并进行修改。与其他键值缓存产品相比，Redis 的主要特点包括数据持久化、多种数据结构...
redis数据类型八股文，看这一篇就够了
最新发布
05-05
redis数据类型八股文，看这一篇就够了
Redis看完这篇文章还不理解redis算我输
02-24
redis是一款高性能的NOSQL系列的非关系型数据库。NoSQL(NoSQL=NotOnlySQL)，意即“不仅仅是SQL”，是一项全新的数据库理念，泛指非关系型的数据库。随着互联网web2.0网站的兴起，传统的关系数据库在应付web2.0网站，...
Jedis和RedisTemplate 全方位对比总结
孙德超的博客
09-22 4103
#全方位对比 性能对比 jedis – 极强 RedisTemplate – 逊色 拓展性对比 jedis – redis提供官方API 使用时自构建 jedisPool RedisTemplate – 基于Spring ，拓展性 极强 使用上 jedis – 十分不优美，看着low ，但十分简单 RedisTemplate – 比较优美 ， 使用较为复杂 ...
RedisTemplate与jedis
sunweiking的博客
05-08 6218
在java开发中操作redis常用的就是集成RedisTemplate与jedis这两种方式。RedisTemplate与spring整合较好，配置、操作比较简单。jedis性能较强，经过本人实际测试，jedis的性能至少是RedisTemplate的3倍以上，jedis结合jedisPool使用既可以有高性能又可以保证redis的连接可控。在性能要求、并发操作不高的场景建议使用RedisTemplate，在并发高，性能要求高的场景下建议使用jedis。下面是两种方式的集成方法，以在springboot中使
redis、jedis、RedisTemplate、Spring-data-redis、spring-boot-starter-data-redis和redis desktop manager区别
GarfieldGosling的博客
03-18 1974
redis、jedis、RedisTemplate、Spring-data-redis、spring-boot-starter-data-redis和redis desktop manager区别
redis集群搭建
qq_45317823的博客
12-17 995
准备redis包，我这里使用的是5.0.5版本 资源包网站里有，不让我上传了，我也不会用。公司限制百度网盘也不能用，我就暂时不传了，以后想起来再说吧。大家也可以去网上下载传到服务器，或者服务器连着外网的话，直接下载也行。 wget http://download.redis.io/releases/redis-5.0.5.tar.gz ----------------------------------------redis单机版安装部署-----------------------------
redisTemplate、jedis、lettuce、redission的对比
no problem的博客
11-09 9664
redis的四大常用客户端有什么不同呢？一起来看看吧
RedisTemplate与JedisPool的区别
qq_37060233的博客
01-02 8769
1、RedisTemplate是SpringDataRedis中对JedisApi的高度封装。而Jedis是Redis官方推荐的面向Java的操作Redis的客户端，可以用JedisPool来获得连接进行get、set、del等操作相对简单...
Jedis，lettuce，RedisTemplate，Redission区别
QQQQQQQQYY的博客
01-16 4810
1.Jedis: Redis官方推荐使用Jedis操作Redis，Jedis的方法和Redis的指令一一对应。 Jedis和lettuce都是可以操作redis的平台 使用时： 导包 <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> </depend
开源作品-PHP写的Redis管理工具(单文件绿色版)-SuRedisAdmin_PHP_1_0
withoutfear的博客
11-05 463
前言： 项目开发用到了Redis，但是在调试Redis数据的时候，没有一款通用的可视化管理工具。在网络找了一些，但是感觉功能上都不尽人意，于是决定抽出一点时间，开发一个用起来顺手的Redis管理工具。 秉承自己开发的小工具一贯的风格，首先是要尽可能绿色单文件，尽量不依赖其他文件，然后是容易部署。 这样才能方便在项目中提高生产力!简介： SuRedisAdmin_PHP是一个用于在线管理Redis内存数据库的单文件绿色版PHP程序，和phpinfo.php一样可以方便放到项目中使用。 开发项目过程中，调试Re
Redis内存参数优化处理报告
csyup1的博客
09-20 293
zabbix频繁报“memory usage is too high”，通过内存使用性能曲线图发现每个实例内存实际使用基本在6.2G左右。当前maxmemory值为8000000000
linux启动redis进程,redis 进程使用root用户启动，
weixin_39610964的博客
04-29 1059
redis 进程使用root用户启动，最近内部风险整改， 各种进程使用root身份进行启动不符合要求，于是各路神仙各施其法，为的就是让 某进程不以root 启动：先以 redis 为例：原有进程如下：#超一流标准的执行文件位置及配置文件位置root 9602 1 0 23:25 ? 00:00:00 /usr/bin/redis-server /etc/re...
redis 从入门到精通
07-30
这样可以实现一主两从的Redis配置。[1] 3. 学习使用Lua脚本可以提升Redis的性能。Lua脚本可以将复杂或多步的Redis操作写为一个脚本，一次提交给Redis执行，减少了反复连接Redis的次数，提升了性能。此外，Lua脚本...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值