增强现实AR>> Redis-Start>> 返回
项目作者： happyflyer

项目描述 ：
Redis入门：https://www.imooc.com/learn/839 学习笔记
高级语言： Java
项目地址: git://github.com/happyflyer/Redis-Start.git
创建时间： 2021-03-08T15:26:03Z
项目社区：https://github.com/happyflyer/Redis-Start
开源协议：
下载


Redis-Start

1. 内容

  • NoSQL 的概述
  • Redis 的概述
  • Redis 的安装和使用
  • Jedis 的入门
  • Redis 的数据类型
  • Keys 的通用操作
  • Redis 的特性
  • Redis 的持久化

2. NoSQL 的概述

NoSQL：NoSQL = Not Only SQL，全新的数据库理念，泛指非关系型数据库。

2.1. 为什么需要 NoSQL

  • High performance - 高并发读写
  • Huge Storage - 海量数据的高效率存储和访问
  • High Scalability && High Availability - 高可扩展性和高可用性

2.2. 主流产品

  • Redis
  • mongoDB
  • CouchDB
  • Cassandra
  • riak
  • membase

2.3. 四大分类

  • 键值（Key-Value）存储
    • Redis
    • 优点：快速查询
    • 缺点：存储的数据缺少结构化
  • 列存储
    • HBase
    • 优点：查找速度快，可扩展性强，更容易进行分布式扩展
    • 缺点：功能相对局限
  • 文档数据库
    • mongoDB
    • 优点：要求数据格式不是很严格
    • 缺点：查询性能不是很好，缺少统一的查询语法
  • 图形数据库
    • InfoGrid
    • 优点：利用图结构相关算法
    • 缺点：需要对整个图做计算才能得出结果，不容易做分布式的集群方案

@main/2021/四类NoSQL数据库比较.53gl5f6sk6w0.jpg" alt="四类NoSQL数据库比较">

2.4. 特点

  • 易扩展（它属于非关系型的，数据之间没有关系）
  • 灵活的数据类型（不需要对读写的数据建立字段）
  • 大数据量，高性能（对于大数据量和高并发的读写性能支持很好）
  • 高可用（在不影响系统性能情况下，可以使用框架）

3. Redis 的概述

Redis：C 语言开发的开源的、高性能的数据库，通过提供多种键值数据类型来适应不同情况下的场景需求。

高性能键值对数据库。

3.1. 数据类型

  • 字符串类型
  • 列表类型
  • 有序集合类型
  • 散列类型
  • 集合类型

3.2. 应用场景

  • 缓存
  • 任务队列
  • 应用排行榜
  • 网站访问统计
  • 数据过期处理
  • 分布式集群架构中的 session 分离

4. Redis 安装和使用

4.1. 安装

  1. tar -zxvf redis-6.2.1.tar.gz
  2. cd redis-6.2.1
  3. make
  4. make PREFIX=/usr/local/redis install
  5. cp redis.conf /usr/local/redis
  6. cd /usr/local/redis
  7. # PATH="/usr/local/redis:$PATH"
  1. # 前端启动
  2. redis-server
  1. # vim redis.conf
  2. daemonize yes
  1. # 后端启动
  2. redis-server redis.conf
  1. # 查看进程
  2. ps -ef | grep -i redis
  1. # 停止
  2. redis-cli shutdown
  1. # 客户端
  2. redis-cli

4.2. Docker

  1. docker pull redis:latest
  1. docker run --name some-redis -d -p 63790:6379 redis
  1. docker exec -it some-redis bash

4.3. 简单使用

  1. set name zhangsan
  1. get name
  1. keys *
  1. del name

5. Jedis 的入门

  1. <dependencies>
  2.   <!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
  3.   <dependency>
  4.     <groupId>redis.clients</groupId>
  5.     <artifactId>jedis</artifactId>
  6.     <version>3.5.1</version>
  7.   </dependency>
  8. </dependencies>

5.1. 单实例连接

  1. // 1、设置ip和port
  2. Jedis jedis = new Jedis("192.168.9.16", 63790);
  3. // 2、保存数据
  4. jedis.set("name", "mooc");
  5. // 3、获取数据
  6. String value = jedis.get("name");
  7. System.out.println(value);
  8. // 4、释放资源
  9. jedis.close();

5.2. 连接池

  1. // 1、获取连接池的配置对象
  2. JedisPoolConfig config = new JedisPoolConfig();
  3. // 设置对打连接数
  4. config.setMaxTotal(30);
  5. // 设置最大空闲连接数
  6. config.setMinIdle(10);
  7. // 2、获取连接池
  8. JedisPool pool = new JedisPool(config, "192.168.9.16", 63790);
  9. // 3、获取核心对象
  10. Jedis jedis = null;
  11. try {
  12.     // 通过连接池获得连接
  13.     jedis = pool.getResource();
  14.     // 设置数据
  15.     jedis.set("name", "zhangsan");
  16.     // 获取数据
  17.     System.out.println(jedis.get("name"));
  18. } catch (Exception e) {
  19.     e.printStackTrace();
  20. } finally {
  21.     // 释放资源
  22.     if (jedis != null) {
  23.         jedis.close();
  24.     }
  25.     if (pool != null) {
  26.         pool.close();
  27.     }
  28. }

6. Redis 的数据结构

  • 字符串（String）
  • 哈希（hash）
  • 字符串列表（list）
  • 字符串集合（set）
  • 有序字符串集合（sorted-set）

Key 定义的注意点：

  • 不要过长，浪费内存，降低性能
  • 不要过短，可读性差
  • 统一的命名规范

6.1. String

  • 二进制是安全的，存入和获取的数据相同
  • Value 最多可以容纳的数据长度是 512M
  1. # 赋值
  2. set name zhangsan
  3. getset name lisi
  4. # 取值
  5. get name
  6. # 删除
  7. del name
  8. # 数值增减
  9. incr num
  10. decr num
  11. incrby num 5
  12. decrby num 3
  13. # 字符串追加，返回字符串的长度
  14. append num 5

6.2. hash

  • String Key 和 String Value 的 map 容器
  • 每一个 Hash 可以存储 4294967295 个键值对
  1. # 赋值
  2. hset myhash username jack
  3. hset myhash age 18
  4. hmset myhash2 username rose age 21
  5. # 取值
  6. hget myhash username
  7. hmget myhash username age
  8. hgetall myhash
  9. # 删除
  10. hdel myhash2 username
  11. hdel myhash2 username age
  12. del myhash2
  13. # 数值增减
  14. hincrby myhash age 5
  15. hdecrby myhash age 3
  16. # 键存在
  17. hexists myhash username
  18. hexists myhash password
  19. # 长度
  20. hlen myhash
  21. # 键值查看
  22. hkeys myhash
  23. hvals myhash

6.3. list

  • ArrayList 使用数组方式
  • LinkedList 使用双向链接方式
  • 双向链表中增加数据
  • 双向链表中删除数据
  1. # 两端添加
  2. lpush mylist a b c
  3. lpush mylist 1 2 3
  4. rpush mylist2 a b c
  5. rpush mylist2 1 2 3
  6. # 查看列表
  7. lrange mylist 0 5
  8. lrange mylist20 -1
  9. lrange mylist20 -2
  10. # 两端弹出
  11. lpop mylist
  12. rpop mylist2
  13. # 获取列表元素个数
  14. llen mylist
  15. llen mylist3
  16. # 添加成功
  17. lpushx mylist x
  18. rpushx mylist2 y
  19. # 失败
  20. lpushx mylist3 x
  1. lpush mylist3 1 2 3
  2. lpush mylist3 1 2 3
  3. lpush mylist3 1 2 3
  4. lrange mylist3 0 -1
  5. # 删除从左边开始2个3
  6. lrem mylist3 2 3
  7. lrange mylist3 0 -1
  8. # 删除从右边开始2个1
  9. lrem mylist3 -2 1
  10. lrange mylist3 0 -1
  11. # 删除所有的2
  12. lrem mylist3 0 2
  13. lrange mylist3 0 -1
  1. # 设置下标为3（下标从0开始）的元素值为mmm
  2. lset mylist 3 mmm
  1. lpush mylist4 a b c
  2. lpush mylist4 a b c
  3. lrange mylist4 0 -1
  4. linsert mylist4 before b 11
  5. linsert mylist4 after b 22
  1. lpush mylist5 1 2 3
  2. lpush mylist6 a b c
  3. lrange mylist5 0 -1
  4. lrange mylist6 0 -1
  5. rpoplpush mylist5 mylist6
  6. lrange mylist5 0 -1
  7. lrange mylist6 0 -1

@main/2021/rpoplpush使用场景.10n4z5iftj5s.jpg" alt="rpoplpush使用场景">

6.4. set

  • 和 List 类型不同的是，Set 集合中不允许出现重复的元素
  • Set 可包含的最大元素数量是 4294967295
  1. # 添加、删除元素
  2. sadd myset a b c
  3. sadd mysey a
  4. sadd myset 1 2 3
  5. srem myset 1 2
  6. # 获得集合中的元素
  7. smembers myset
  8. sismember myset x
  9. # 集合的差集运算
  10. sadd mya1 a b c
  11. sadd myb1 a c 1 2
  12. sdiff mya1 myb1
  13. sdiffstore my1 mya1 myb1
  14. # 集合的交集运算
  15. sinter mya1 myb1
  16. sinterstore my2 mya1 myb1
  17. # 集合的并集运算
  18. sunion mya1 myb1
  19. sunionstore my3 mya1 myb1
  20. # 数量
  21. scard myset
  22. # 随机
  23. srandmember myset

使用场景：

  • 跟踪一些唯一性数据
  • 用于维护数据对象之间的关联关系

6.5. sorted-set

  • sorted-set 和 set 的区别
  • sorted-set 中的成员在集合中的位置是有序的
  1. # 添加元素
  2. zadd mysort 70 zhangsan 80 lisi 90 wangwu
  3. zadd mysort 100 zhangsan
  4. zadd mysort 85 jack 95 rose
  5. zadd mysort 60 tom
  6. # 获得元素
  7. zscore mysort zhangsan
  8. zcard mysort
  9. # 删除元素
  10. zrem mysort tom wangwu
  11. # 范围查询
  12. zrange mysort 0 -1
  13. zrange mysort 0 -1 withscores
  14. zrevrange mysort 0 -1 withscores
  15. # 按排序删除
  16. zremrangebyrank mysort 0 4
  17. # 按分数范围删除
  18. zremrangebyscore mysort 80 90
  19. # 按分数过滤
  20. zrangebyscore mysort 80 90 withscores
  21. zrevrangebyscore mysort 90 80 withscores
  22. zrevrangebyscore mysort 90 80 withscores limit 0 2
  23. # 数值增减
  24. zincrby mysort 3 lisi
  25. zscore mysort lisi
  26. # 按分数计数
  27. zcount mysort 80 90

使用场景：

  • 如大型在线游戏积分排行榜
  • 构建索引数据

7. Keys 的通用操作

  1. keys *
  2. keys my?
  3. del my1 my2 my3
  4. exists my1
  5. exists mya1
  1. get company
  2. rename company new_company
  3. get new_company
  1. # 单位：秒
  2. expire new_company 1000
  3. # 剩余时间
  4. ttl new_company
  1. type new_company
  2. type mylist
  3. type myset
  4. type myhash
  5. type mysort

8. Redis 的特性

8.1. 多数据库

  1. # 从 0 到 15
  2. select 0
  1. # 将 set 移动到 1 号数据库
  2. move myset 1

8.2. Redis 事务

  1. # multi 开启事务
  1. # exec 提交事务
  1. # discard 回滚事务

9. Redis 的持久化

两种持久化的方式：

  • RDB 方式
  • AOF 方式

持久化使用的方式：

  • RDB 持久化：默认支持，在指定的时间间隔内，将内存中的数据集快照写入到磁盘
  • AOF 持久化：日志的形式记录服务器处理的每一个操作，服务器启动之初，读取文件，重新构建数据库
  • 无持久化：通过配置禁用 Redis 持久化功能，Redis 缓存机制
  • 同时使用 RDB 和 AOF

9.1. RDB 方式

9.1.1. 优势

  • 数据库只包含一个文件，通过文件备份策略，定期配置，恢复系统灾难
  • 压缩文件转移到其他介质上
  • 性能最大化，Redis 开始持久化时，分叉出进程，由子进程完成持久化的工作，避免服务器进程执行 I/O 操作，启动效率高

9.1.2. 劣势

  • 无法高可用：系统一定在定时持久化之前宕机，数据还没写入，数据已经丢失
  • 通过 fork 分叉子进程完成工作，数据集大的时候，服务器需要停止几百毫秒甚至 1 秒

9.1.3. 配置

  1. # vim redis.conf
  2. # 每 900 秒（15min）至少有 1 个key 发生变化，那么就保存快照
  3. save 900 1
  4. # 每 300 秒（5min）至少有 10 个key 发生变化，那么就保存快照
  5. save 300 10
  6. # 每 60 秒（1min）至少有 10000 个key 发生变化，那么就保存快照
  7. save 60 10000
  1. dbfilename dump.rdb
  2. dir ./

9.2. AOF 方式

9.2.1. 优势

  • 同步：
    • 每秒同步：异步完成，效率高，一旦系统宕机，修改的数据丢失
    • 每修改同步：同步持久化，每分钟发生的变化记录到磁盘中，效率低，安全
    • 不同步
  • 日志写入操作追加模式 append
    • 系统宕机，不影响存在的内容
    • 写入一半数据，若系统崩溃，下次启动 redis，redis-check-aof 工具解决数据一致性
  • 如果日志过大，自动重写机制，修改的数据写入到到磁盘文件，创建新文件，记录产生的修改命令，重写切换时，保证数据安全
  • 格式清晰的日志文件，完成数据的重建

9.2.2. 劣势

  • 对于相同数据文件，相比 RDB，AOF 文件较大
  • 效率低

9.2.3. 配置

  1. # vim redis.conf
  2. appendonly no
  1. appendfsync always
  2. # appendfsync everysec
  3. # appendfsync no