Redis

至，若春和景明

已于 2022-12-28 14:26:44 修改

阅读量325

点赞数

文章标签： redis 数据库 nosql

于 2022-12-28 14:23:59 首次发布

本文链接：https://blog.youkuaiyun.com/weixin_51328633/article/details/128465796

版权

Redis

1.概念：

redis是一款高性能的NOSQL系列的非关系型数据库

1.1.什么是NOSQL

           NoSQL(NoSQL = Not Only SQL)，意即“不仅仅是SQL”，是一项全新的数据库理念，泛指非关系型的数据库。
           随着互联网web2.0网站的兴起，传统的关系数据库在应付web2.0网站，特别是超大规模和高并发的SNS类型的web2.0纯动态网站已经显得力不从心，暴露了很多难以克服的问题，而非关系型的数据库则由于其本身的特点得到了非常迅速的发展。NoSQL数据库的产生就是为了解决大规模数据集合多重数据种类带来的挑战，尤其是大数据应用难题。
           1.1.1.   NOSQL和关系型数据库比较
               优点：
                   1）成本：nosql数据库简单易部署，基本都是开源软件，不需要像使用oracle那样花费大量成本购买使用，相比关系型数据库价格便宜。
                   2）查询速度：nosql数据库将数据存储于缓存之中，关系型数据库将数据存储在硬盘中，自然查询速度远不及nosql数据库。
                   3）存储数据的格式：nosql的存储格式是key,value形式、文档形式、图片形式等等，所以可以存储基础类型以及对象或者是集合等各种格式，而数据库则只支持基础类型。
                   4）扩展性：关系型数据库有类似join这样的多表查询机制的限制导致扩展很艰难。
               缺点：
                   1）维护的工具和资料有限，因为nosql是属于新的技术，不能和关系型数据库10几年的技术同日而语。
                   2）不提供对sql的支持，如果不支持sql这样的工业标准，将产生一定用户的学习和使用成本。
                   3）不提供关系型数据库对事务的处理。
           1.1.2.   非关系型数据库的优势：
               1）性能NOSQL是基于键值对的，可以想象成表中的主键和值的对应关系，而且不需要经过SQL层的解析，所以性能非常高。
               2）可扩展性同样也是因为基于键值对，数据之间没有耦合性，所以非常容易水平扩展。
           1.1.3.   关系型数据库的优势：
               1）复杂查询可以用SQL语句方便的在一个表以及多个表之间做非常复杂的数据查询。
               2）事务支持使得对于安全性能很高的数据访问要求得以实现。对于这两类数据库，对方的优势就是自己的弱势，反之亦然。
           1.1.4.   总结
               关系型数据库与NoSQL数据库并非对立而是互补的关系，即通常情况下使用关系型数据库，在适合使用NoSQL的时候使用NoSQL数据库，让NoSQL数据库对关系型数据库的不足进行弥补。
               一般会将数据存储在关系型数据库中，在nosql数据库中备份存储关系型数据库的数据

1.2.主流的NOSQL产品

           •键值(Key-Value)存储数据库
               相关产品： Tokyo Cabinet/Tyrant、Redis、Voldemort、Berkeley DB
               典型应用：内容缓存，主要用于处理大量数据的高访问负载。
               数据模型：一系列键值对
               优势：快速查询
               劣势：存储的数据缺少结构化
           •列存储数据库
               相关产品：Cassandra, HBase, Riak
               典型应用：分布式的文件系统
               数据模型：以列簇式存储，将同一列数据存在一起
               优势：查找速度快，可扩展性强，更容易进行分布式扩展
               劣势：功能相对局限
           •文档型数据库
               相关产品：CouchDB、MongoDB
               典型应用：Web应用（与Key-Value类似，Value是结构化的）
               数据模型：一系列键值对
               优势：数据结构要求不严格
               劣势：查询性能不高，而且缺乏统一的查询语法
           •图形(Graph)数据库
               相关数据库：Neo4J、InfoGrid、Infinite Graph
               典型应用：社交网络
               数据模型：图结构
               优势：利用图结构相关算法。
               劣势：需要对整个图做计算才能得出结果，不容易做分布式的集群方案。

1.3 什么是Redis

           Redis是用C语言开发的一个开源的高性能键值对（key-value）数据库，官方提供测试数据，50个并发执行100000个请求,读的速度是110000次/s,写的速度是81000次/s ，且Redis通过提供多种键值数据类型来适应不同场景下的存储需求，目前为止Redis支持的键值数据类型如下：
               1) 字符串类型 string
               2) 哈希类型 hash
               3) 列表类型 list
               4) 集合类型 set
               5) 有序集合类型 sortedset
           1.3.1 redis的应用场景
               •缓存（数据查询、短连接、新闻内容、商品内容等等）
               •聊天室的在线好友列表
               •任务队列。（秒杀、抢购、12306等等）
               •应用排行榜
               •网站访问统计
               •数据过期处理（可以精确到毫秒
               •分布式集群架构中的session分离

2. 下载安装

       1. 官网：https://redis.io
       2. 中文网：http://www.redis.net.cn/
       3. 解压直接可以使用：
           * redis.windows.conf：配置文件
           * redis-cli.exe：redis的客户端
           * redis-server.exe：redis服务器端

3. 命令操作

       1. redis的数据结构：
           * redis存储的是：key,value格式的数据，其中key都是字符串，value有5种不同的数据结构
               * value的数据结构：
                   1) 字符串类型 string
                   2) 哈希类型 hash ： map格式
                   3) 列表类型 list ： linkedlist格式。支持重复元素
                   4) 集合类型 set ：不允许重复元素
                   5) 有序集合类型 sortedset：不允许重复元素，且元素有顺序
       2. 字符串类型 string--------<www.redis.net.cn>
           1. 存储： set key value
               127.0.0.1:6379> set username zhangsan
               OK
           2. 获取： get key
               127.0.0.1:6379> get username
               "zhangsan"
           3. 删除： del key
               127.0.0.1:6379> del age
               (integer) 1
       3. 哈希类型 hash
           1. 存储： hset key field value
               127.0.0.1:6379> hset myhash username lisi
               (integer) 1
               127.0.0.1:6379> hset myhash password 123
               (integer) 1
           2. 获取：
               * hget key field: 获取指定的field对应的值
                   127.0.0.1:6379> hget myhash username
                   "lisi"
               * hgetall key：获取所有的field和value
                   127.0.0.1:6379> hgetall myhash
                   1) "username"
                   2) "lisi"
                   3) "password"
                   4) "123"
           3. 删除： hdel key field
               127.0.0.1:6379> hdel myhash username
               (integer) 1
       4. 列表类型 list:可以添加一个元素到列表的头部（左边）或者尾部（右边）
           1. 添加：
               1. lpush key value: 将元素加入列表左表(边)

               2. rpush key value：将元素加入列表右边

                   127.0.0.1:6379> lpush myList a
                   (integer) 1
                   127.0.0.1:6379> lpush myList b
                   (integer) 2
                   127.0.0.1:6379> rpush myList c
                   (integer) 3
           2. 获取：
               * lrange key start end ：范围获取
                   127.0.0.1:6379> lrange myList 0 -1
                   1) "b"
                   2) "a"
                   3) "c"
           3. 删除：
               * lpop key：删除列表最左边的元素，并将元素返回
               * rpop key：删除列表最右边的元素，并将元素返回
       5. 集合类型 set ：不允许重复元素
           1. 存储：sadd key value
               127.0.0.1:6379> sadd myset a
               (integer) 1
               127.0.0.1:6379> sadd myset a
               (integer) 0
           2. 获取：smembers key:获取set集合中所有元素
               127.0.0.1:6379> smembers myset
               1) "a"
           3. 删除：srem key value:删除set集合中的某个元素
               127.0.0.1:6379> srem myset a
               (integer) 1
       6. 有序集合类型 sortedset：不允许重复元素，且元素有顺序.每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。
           1. 存储：zadd key score value
               127.0.0.1:6379> zadd mysort 60 zhangsan
               (integer) 1
               127.0.0.1:6379> zadd mysort 50 lisi
               (integer) 1
               127.0.0.1:6379> zadd mysort 80 wangwu
               (integer) 1
           2. 获取：zrange key start end [withscores]
               127.0.0.1:6379> zrange mysort 0 -1
               1) "lisi"
               2) "zhangsan"
               3) "wangwu"
               127.0.0.1:6379> zrange mysort 0 -1 withscores
               1) "zhangsan"
               2) "60"
               3) "wangwu"
               4) "80"
               5) "lisi"
               6) "500"
           3. 删除：zrem key value
               127.0.0.1:6379> zrem mysort lisi
               (integer) 1
       7. 通用命令
           1. keys * : 查询所有的键
           2. type key ：获取键对应的value的类型
           3. del key：删除指定的key value

4. 持久化

       1. redis是一个内存数据库，当redis服务器重启，获取电脑重启，数据会丢失，我们可以将redis内存中的数据持久化保存到硬盘的文件中。
       2. redis持久化机制：
           1. RDB：默认方式，不需要进行配置，默认就使用这种机制
               * 在一定的间隔时间中，检测key的变化情况，然后持久化数据
               1. 编辑redis.windwos.conf文件
                   # after 900 sec (15 min) if at least 1 key changed
                   save 900 1
                   # after 300 sec (5 min) if at least 10 keys changed
                   save 300 10
                   # after 60 sec if at least 10000 keys changed
                   save 60 10000

               2. 重新启动redis服务器，并指定配置文件名称
                   D:\JavaWeb2018\day23_redis\资料\redis\windows-64\redis-2.8.9>redis-server.exe redis.windows.conf
           2. AOF：日志记录的方式，可以记录每一条命令的操作。可以每一次命令操作后，持久化数据
               1. 编辑redis.windwos.conf文件
                   appendonly no（关闭aof） --> appendonly yes （开启aof）

                   # appendfsync always ：每一次操作都进行持久化
                   appendfsync everysec ：每隔一秒进行一次持久化
                   # appendfsync no   ：不进行持久化

5. Java客户端 Jedis

       * Jedis: 一款java操作redis数据库的工具.
       * 使用步骤：
           1. 下载jedis的jar包
           2. 使用

  //1. 获取连接
Jedis jedis = new Jedis("localhost",6379);
//2. 操作
jedis.set("username","zhangsan");
//3. 关闭连接
jedis.close();

       * Jedis操作各种redis中的数据结构
           1) 字符串类型 string
               set
               get

   //1. 获取连接
Jedis jedis = new Jedis();//如果使用空参构造，默认值 "localhost",   
//2. 操作
//存储
jedis.set("username","zhangsan");
//获取
String username = jedis.get("username");
System.out.println(username);
        
//可以使用setex()方法存储可以指定过期时间的 key value
jedis.setex("activecode",20,"hehe");//将activecode：hehe键值对存入redis，并且20秒后自动删除该键值对
    
//3. 关闭连接
jedis.close();

           2) 哈希类型 hash ： map格式
               hset
               hget
               hgetAll

   //1. 获取连接
             Jedis jedis = new Jedis();//如果使用空参构造，默认值 "localhost",6379端口
             //2. 操作
             // 存储hash
             jedis.hset("user","name","lisi");
             jedis.hset("user","age","23");
             jedis.hset("user","gender","female");

             // 获取hash
             String name = jedis.hget("user", "name");
             System.out.println(name);

                // 获取hash的所有map中的数据
                Map<String, String> user = jedis.hgetAll("user");
        
                // keyset
                Set<String> keySet = user.keySet();
                for (String key : keySet) {
                    //获取value
                    String value = user.get(key);
                    System.out.println(key + ":" + value);
                }
          //3. 关闭连接
            jedis.close();

           3) 列表类型 list ： linkedlist格式。支持重复元素
               lpush / rpush
               lpop / rpop
               lrange start end : 范围获取

  //1. 获取连接
            Jedis jedis = new Jedis();//如果使用空参构造，默认值 "localhost",6379端口
            //2. 操作
            // list 存储
            jedis.lpush("mylist","a","b","c");//从左边存
            jedis.rpush("mylist","a","b","c");//从右边存
    
            // list 范围获取
            List<String> mylist = jedis.lrange("mylist", 0, -1);
            System.out.println(mylist);
            
            // list 弹出
            String element1 = jedis.lpop("mylist");//c
            System.out.println(element1);
    
            String element2 = jedis.rpop("mylist");//c
            System.out.println(element2);
    
            // list 范围获取
            List<String> mylist2 = jedis.lrange("mylist", 0, -1);
            System.out.println(mylist2);
    
            //3. 关闭连接
            jedis.close();

           4) 集合类型 set ：不允许重复元素
               sadd
               smembers:获取所有元素

    //1. 获取连接
Jedis jedis = new Jedis();//如果使用空参构造，默认值 "localhost",6379端口
//2. 操作
        
// set 存储
 jedis.sadd("myset","java","php","c++");
        
// set 获取
Set<String> myset = jedis.smembers("myset");
System.out.println(myset);
        
/3. 关闭连接
jedis.close();

           5)有序集合类型 sortedset：不允许重复元素，且元素有顺序
               zadd
               zrange

    //1. 获取连接
             Jedis jedis = new Jedis();//如果使用空参构造，默认值 "localhost",6379端口
             //2. 操作
             // sortedset 存储
             jedis.zadd("mysortedset",3,"亚瑟");
             jedis.zadd("mysortedset",30,"后裔");
             jedis.zadd("mysortedset",55,"孙悟空");

             // sortedset 获取
             Set<String> mysortedset = jedis.zrange("mysortedset", 0, -1);

             System.out.println(mysortedset);


        
                //3. 关闭连接
                jedis.close();

       * jedis连接池： JedisPool
           使用：
               1. 创建JedisPool连接池对象
               2. 调用方法 getResource()方法获取Jedis连接

  //0.创建一个配置对象
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxTotal(50);
config.setMaxIdle(10);
            
//1.创建Jedis连接池对象
JedisPool jedisPool = new JedisPool(config,"localhost",6379);
            

 //2.获取连接
Jedis jedis = jedisPool.getResource();
//3. 使用
 jedis.set("hehe","heihei");


 //4. 关闭 归还到连接池中
 jedis.close();

连接池工具类

* public class JedisPoolUtils {

                private static JedisPool jedisPool;
            
                static{
                    //读取配置文件
                    InputStream is = JedisPoolUtils.class.getClassLoader().getResourceAsStream("jedis.properties");
                    //创建Properties对象
                    Properties pro = new Properties();
                    //关联文件
                    try {
                        pro.load(is);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    //获取数据，设置到JedisPoolConfig中
                    JedisPoolConfig config = new JedisPoolConfig();
                    config.setMaxTotal(Integer.parseInt(pro.getProperty("maxTotal")));
                    config.setMaxIdle(Integer.parseInt(pro.getProperty("maxIdle")));
            
                    //初始化JedisPool
                    jedisPool = new JedisPool(config,pro.getProperty("host"),Integer.parseInt(pro.getProperty("port")));


                
                
                    }


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

redis缓存

       注意：使用redis缓存一些不经常发生变化的数据。
           * 数据库的数据一旦发生改变，则需要更新缓存。
               * 数据库的表执行增删改的相关操作，需要将redis缓存数据情况，再次存入
               * 在service对应的增删改方法中，将redis数据删除。

缓存击穿

高并发时，当一个key非常热点（类似于爆款），在不停的扛着大并发，当这个key在失效的瞬间，持续的大并发就穿破缓存，直接请求数据库并设置到缓存中，导致性能下降。

           解决方案：
               永不过期(数据设置永不过期)
                  加锁排队
               提前将热门数据放入redis缓存中
               对热门key进行监控，定期进行续期
               对不同级别的key设置不同的缓存时间
               设置分布式锁：

缓存雪崩

缓存集中过度，或者缓存服务器宕机，导致大量请求访问数据库，造成数据库瞬间压力过大，宕机。

           解决方案：
               加锁排队
               随机失效时间
               redis高可用

Redis哨兵与高可用原理

主——从模式，主节点主要负责写数据，从节点主要负责写数据，然后做好数据同步，读写分离提高性能。另外主节点崩溃了，从节点就顶上去，还能实现高可用。

主节点负责数据写入和同步：

命令传播：如果主节点有数据写入删除、写入、修改命令，也会把这些命令挨个通知到从节点

通过这样的方式，主节点与从节点之间的数据就能保持同步了。

假设掉线：主节点内部准备一个缓冲区，后面传播命令的时候，除了同步给从节点，也往缓冲区写一份。下次从节点再掉线了，主节点就把最近的命令发给从节点就好了，就不用全部从头再来了

主节点怎么知道主节点缓存的和从节点缺失的能不能对得上呢?又怎么知道该发缓存中的哪些给从节点呢? 整个游标，叫做复制偏移量，最开始从0开始，随着数据复制和同步，大家一起更新，后面只需要比较各自的这个偏移量，就能知道缺失哪些数据了！

新的同步策略：效率高了不少

偶尔掉个线：

也能很快的将数据补上;

虽然有主从复制，但主节点要是挂了,还是需要程序员们来手动选择从节点升级为主节点来提供写入服务,感觉不够智能啊

要不这样，咱们选一个人出来当管理员,不用负责数据的读写,专门来统筹协调,谁要是掉线了，就在从节点里面选择一个出来顶上? 就把这个管理员叫做哨兵（Sentinel）吧！

不过一个管理员怕是不够,万一管理员挂了,那不完蛋了，得多找几个管理员。

为了及时获得和更新主从节点的信息，哨兵每隔10秒钟就要用info命令去问候一下主节点，。主节点会告诉哨兵主节点有哪些从节点，为了更加既是知道主从节点是否掉线，哨兵每隔一秒就要用ping命令问候一下所有节点和相关哨兵，如果在设置的时间内没有回复，哨兵就知晓这个节点可能掉线了，哨兵就该启动故障转移了。

为了防止误判：管理员发现主节点掉线后，这时候判定为主观下线。然后来这个群确认一下，如果有多个管理员都判定为下线,才能认定为客观下线。具体需要几个管理员同时认定,大家可以自己定义

故障转移;

第一步:选个新主节点。

第二步，让其他从节点从新的主节点那里同步数据。

第三步,把原来旧的主节点改成从节点。

得定一套选择新的主节点的规则才行可以给不同节点设定优先级，硬件配置高的优先级越高,挑选的时候参考这个优先级来

可以优先选择跟主节点断开连接最短的节点，这样它的数据会更新一点

还可以参考一下复制偏移量,越大的数据应该越全

/**新主节点选择标准**/

/**优先级越高

 **断开主节点时间越短

 **复制偏移量越大
**/

Redis集群

前提：不仅有主从复制可以备份数据，还有哨兵节点负责监控管理。

但是只能解决高可用问题；解决不了数据量大的问题。节点虽多，但是都是存储的全量数据，所以对于数据容量提升，并没有什么帮助。

一个节点的内存空间不够，那就将三个节点的内存空间拼起来，每个节点负责一部分数据，合体进化成一个大的缓存服务器。变成一个集群。

既是集群，首要问题当让是团队建设了，得想一套办法来组建团队，还要考虑到以后可能会扩容，会有新的伙伴加入，采用TCP的三次握手，也搞了一个握手协议出来。

想要加入集群的有一个人介绍才行。通过团队里的任何一个成员都行，只要告诉成员（1）IP和端口，成员（1）就给他发送一个MEET信息发起握手，对方得回成员（1）一个PONG信息同意入伙，最后成员（1）再回他一个PINGF信息，三次握手就完成了。

然后成员（1）再将这件事情告诉团队其他成员，然后新的伙伴就成为我们的一份子

第二件事情就是要解决数据存储的公平问题，最后学习使用哈希表的方法，划分成16384的哈希桶，成为槽位Slot，程序员可以按照我们能力大小给我们各自分配一部分槽位

数据读写的时候对键值做一下哈希计算映射到哪个槽就由谁负责。

为了让大家的信息达成一致，启动的时候每个人都得把自己负责的槽位信息告诉其他伙伴。

因为传输的槽位很多因此为了压缩空间每个槽位干脆就用一个bit来表示，自己负责这一位就是1，否则就是0 ，总共也就才16384个bit，也就是2048个字节,传输起来轻便快捷，一口气就发送过去了。

这样传输的数据是轻量了，但是真正工作时还是不方便

定义一个数组

这16384个槽位都得有人负责：即为上线状态，否则就是下线状态

既是数据分派的问题解决了

正常工作：

既是数据读写的时候多了一个步骤，得先检查数据是不是由自己负责，如果是自己负责则进行处理，不然的话就要返回一个MOVED错误给请求端同时把槽号、IP和端口告诉他，让他知道该去找谁处理。

经过磨合：

某个成员失效：整个集群都要下线

既是每个成员都得有一个backup才行

遇到故障时：从节点也能在关键补上。

缓存穿透

数据库不存在缓存也不存在，导致每次请求都会去查询数据库，这时的用户很可能是攻击者，如发起为id为"-1"的数据或id为特别大（不存在的数据），导致数据库压力过大或宕机。

           解决方案:
               参数校验
                   设置有规律的id，如果不满足规则条件则拦截
                  缓存空对象
                   缓存一个特定的值，代表数据库中不存在，如空值
                  布隆过滤器
                   使用redis布隆过滤器：如果不存在那就一定不存在，如果存在但是不一定存在
                   设置有规律的id，如果不满足规则条件则拦截
           布隆过滤器
               布隆过滤器（Bloom Filter）是1970年由布隆提出的。它实际上是一个很长的二进制向量和一系列随机映射函数。布隆过滤器可以用于检索一个元素是否在一个集合中。它的优点是空间效率和查询时间都比一般的算法要好的多，缺点是有一定的误识别率和删除困难。
               优点：
                   相比于其它的数据结构，布隆过滤器在空间和时间方面都有巨大的优势。布隆过滤器存储空间和插入/查询时间都是常数。另外, Hash函数相互之间没有关系，方便由硬件并行实现。布隆过滤器不需要存储元素本身，在某些对保密要求非常严格的场合有优势。
                   布隆过滤器可以表示全集，其它任何数据结构都不能。
               缺点：
                   但是布隆过滤器的缺点和优点一样明显。误算率是其中之一。随着存入的元素数量增加，误算率随之增加。常见的补救办法是建立一个小的白名单，存储那些可能被误判的元素。但是如果元素数量太少，则使用散列表足矣。
                          另外，一般情况下不能从布隆过滤器中删除元素。我们很容易想到把位列阵变成整数数组，每插入一个元素相应的计数器加1, 这样删除元素时将计数器减掉就可以了。然而要保证安全的删除元素并非如此简单。首先我们必须保证删除的元素的确在布隆过滤器里面. 这一点单凭这个过滤器是无法保证的。另外计数器回绕也会造成问题。
                          在降低误算率方面，有不少工作，使得出现了很多布隆过滤器的变种。