《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐

文章目录

  • 1. NoSQL数据库简介
    • 1.1 技术发展
      • 1.1.1. Web1.0时代
      • 1.1.2 Web2.0时代
      • 1.1.3. 解决CPU及内存压力(采用分布式)
      • 1.1.4. 解决IO压力
    • 1.2. NoSQL数据库
      • 1.2.1. NoSQL数据库概述
      • 1.2.2 NoSQL适用场景
      • 1.2.3 NoSQL不适用场景
      • 1.2.4 Memcache
      • 1.2.5 Redis
      • 1.2.6. MongoDB
    • 1.3. 行式存储数据库(大数据时代)
      • 1.3.1. 行式数据库
      • 1.3.2. 列式数据库
    • 1.4. 图关系型数据库
    • 1.5. DB-Engines 数据库排名
  • 2. Redis 概述安装
    • 2.1. 应用场景
      • 2.1.1. 配合关系型数据库做高速缓存
      • 2.1.2. 多样的数据结构存储持久化数据
    • 2.2. Redis 安装
      • 2.2.1. 安装版本
      • 2.2.2. 安装步骤
        • 2.2.2.1. 准备工作:下载安装最新版的 gcc 编译器 安装 C 语言的编译环境
        • 2.2.2.2. 下载 redis-6.2.1.tar.gz 放/opt 目录
        • 2.2.2.3. 解压命令:tar -zxvf redis-6.2.1.tar.gz
        • 2.2.2.4. 解压完成后进入目录:cd redis-6.2.1
        • 2.2.2.5. 在 redis-6.2.1 目录下再次执行 make 命令(只 是编译好)
        • 2.2.2.6. 如果没有准备好 C 语言编译环境,make 会报错 —Jemalloc/jemalloc.h:没有那个文件
        • 2.2.2.8. 在 redis-6.2.1 目录下再次执行 make 命令(只 是编译好)
        • 2.2.2.9. 跳过 make test 继续执行: make install
      • 2.2.3. 安装目录:/usr/local/bin
      • 2.2.4. 前台启动(不推荐)
      • 2.2.5. 后台启动(推荐)
        • 2.2.5.1.备份 redis.conf
        • 2.2.5.2.后台启动设置 ==daemonize no 改成 yes==
        • 2.2.5.3.Redis 启动
        • 2.2.5.4.用客户端访问:redis-cli
        • 2.2.5.5.多个端口可以:redis-cli -p6379
        • 2.2.5.6.测试验证: ping
        • 2.2.5.7.Redis 关闭
      • 2.2.6. Redis 介绍相关知识
  • 3. 常用五大数据类型
    • 3.1. Redis 键(key)
    • 3.2. Redis 字符串(String)
      • 3.2.1. 简介
      • 3.2.2. 常用命令
      • 3.2.3. 数据结构
    • 3.3. Redis 列表(List)
      • 3.3.1. 简介
      • 3.3.2. 常用命令
      • 3.3.3 数据结构
      • 3.3.4 补充:原子性
    • 3.4. Redis 集合(Set)
      • 3.4.1. 简介
      • 3.4.2. 常用命令
      • 3.4.3. 数据结构
    • 3.5. Redis 哈希(Hash)
      • 3.5.1. 简介
      • 3.5.2. 常用命令
      • 3.5.3. 数据结构
    • 3.6. Redis 有序集合 Zset(sorted set)
      • 3.6.1. 简介
      • 3.6.2. 常用命令
      • 3.6.3. 数据结构
      • 3.6.4. 跳跃表(跳表)
  • 4. Redis Redis 配置文件介绍
    • 4.1. ###Units 单位###
    • 4.2. ###INCLUDES 包含###
    • 4.3. ### 网络相关配置
      • 4.3.1. bind
      • 4.3.2. protected- -mode
      • 4.3.3. Port
      • 4.3.4. tcp--backlog
      • 4.3.5. timeout
      • 4.3.6. tcp---keepalive
    • 4.4. ###GENERAL 通用###
      • 4.4.1. daemonize
      • 4.4.2. pidfile
      • 4.4.3. loglevel
      • 4.4.4. logfile
      • 4.4.5. databases 16
    • 4.5. ###SECURITY 安全###
      • 4.5.1. 设置密码
    • 4.6. #### LIMITS 限制
      • 4.6.1. maxclients
      • 4.6.2. maxmemory
      • 4.6.3. maxmemory---policy
      • 4.6.4. maxmemory---samples
  • 5. Redis Redis 的发布和订阅
    • 5.1. 什么是发布和订阅
    • 5.2. Redis 的发布和订阅
    • 5.3. 发布订阅命令行实现
  • 6.Redis常见命令
    • 6.1 Redis数据结构介绍
    • 6.2 Redis 通用命令
    • 6.3 Redis命令-String命令
    • 6.4 Redis命令-Key的层级结构
    • 6.5 Redis命令-Hash命令
    • 6.6 Redis命令-List命令
    • 6.7 Redis命令-Set命令
    • 6.8 Redis命令-SortedSet类型
  • 7.Redis的Java客户端-Jedis
    • 7.1 Jedis快速入门
    • 7.2 Jedis连接池
      • 7.2.1.创建Jedis的连接池
      • 7.2.2.改造原始代码
  • 8.Redis的Java客户端-SpringDataRedis
    • 8.1.快速入门
      • 8.1.1 导入pom坐标
      • 8.1.2 配置文件
      • 8.1.3 测试代码
    • 8.2 .数据序列化器
    • 8.3 StringRedisTemplate
    • 8.4 Hash结构操作

1. NoSQL数据库简介

1.1 技术发展

技术的分类

1、解决功能性的问题:Java、Jsp、RDBMS、Tomcat、HTML、Linux、JDBC、SVN

2、解决扩展性的问题:Struts、Spring、SpringMVC、Hibernate、Mybatis

3、解决性能的问题:NoSQL、Java线程、Hadoop、Nginx、MQ、ElasticSearch

1.1.1. Web1.0时代

​ Web1.0的时代,数据访问量很有限,用一夫当关的高性能的单点服务器可以解决大部分问题。

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第1张图片

1.1.2 Web2.0时代

​ 随着Web2.0的时代的到来,用户访问量大幅度提升,同时产生了大量的用户数据。加上后来的智能移动设备的普及,所有的互联网平台都面临了巨大的性能挑战。

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第2张图片

1.1.3. 解决CPU及内存压力(采用分布式)

   但是Session存在哪里?因为每次访问的服务器可能不是同一台.上次用户的数据保存在服务器1,用户是登录状态,下一次可能访问的服务器2,没有该用户的session,用户显示的未登录状态.

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第3张图片

1.1.4. 解决IO压力

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第4张图片

1.2. NoSQL数据库

1.2.1. NoSQL数据库概述

NoSQL(NoSQL = Not Only SQL ),意即“不仅仅是SQL”,泛指==非关系型的数据库==。

NoSQL 不依赖业务逻辑方式存储,而以简单的key-value模式存储。因此大大的增加了数据库的扩展能力。

  • 不遵循SQL标准。

  • 不支持ACID。

  • 远超于SQL的性能。

1.2.2 NoSQL适用场景

  • 对数据高并发的读写

  • 海量数据的读写

  • 对数据高可扩展性的

1.2.3 NoSQL不适用场景

  • 需要事务支持

  • 基于sql的结构化查询存储,处理复杂的关系,需要即席查询。

  • (用不着 sql 的和用了 sql 也不行的情况,请考虑用 NoSql)

1.2.4 Memcache

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第5张图片

1.2.5 Redis

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第6张图片

1.2.6. MongoDB

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第7张图片

1.3. 行式存储数据库(大数据时代)

1.3.1. 行式数据库

image-20220127233719653

1.3.2. 列式数据库

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第8张图片

1.4. 图关系型数据库

image-20220127233900089

主要应用:社会关系,公共交通网络,地图及网络拓谱(n*(n-1)/2)

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第9张图片

1.5. DB-Engines 数据库排名

http://db-engines.com/en/ranking

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第10张图片

2. Redis 概述安装

➢ Redis 是一个开源的 key-value 存储系统

➢ 和 Memcached 类似,它支持存储的 value 类型相对更多,包括 string(字符串)、 list(链表)、set(集合)、zset(sorted set --有序集合)和 hash(哈希类型)

➢ 这些数据类型都支持 push/pop、add/remove 及取交集并集和差集及更丰富的操作, 而且这些操作都是原子性的。

➢ 在此基础上,Redis 支持各种不同方式的排序。

➢ 与 memcached 一样,为了保证效率,数据都是缓存在内存中

➢ 区别的是 Redis 会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记 录文件

➢ 并且在此基础上实现了 master-slave(主从)同步

2.1. 应用场景

2.1.1. 配合关系型数据库做高速缓存

➢ 高频次,热门访问的数据,降低数据库 IO

➢ 分布式架构,做 session 共享

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第11张图片

2.1.2. 多样的数据结构存储持久化数据

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第12张图片

2.2. Redis 安装

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第13张图片

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第14张图片

2.2.1. 安装版本

➢ 6.2.1 for Linux(redis-6.2.1.tar.gz

➢ 不用考虑在 windows 环境下对 Redis 的支持

2.2.2. 安装步骤

2.2.2.1. 准备工作:下载安装最新版的 gcc 编译器 安装 C 语言的编译环境

yum install centos-release-scl scl-utils-build 
yum install -y devtoolset-8-toolchain 
scl enable devtoolset-8 bash 

测试 gcc 版本

gcc --version

image-20220130170103407

2.2.2.2. 下载 redis-6.2.1.tar.gz 放/opt 目录

2.2.2.3. 解压命令:tar -zxvf redis-6.2.1.tar.gz

2.2.2.4. 解压完成后进入目录:cd redis-6.2.1

2.2.2.5. 在 redis-6.2.1 目录下再次执行 make 命令(只 是编译好)

2.2.2.6. 如果没有准备好 C 语言编译环境,make 会报错 —Jemalloc/jemalloc.h:没有那个文件

解决方案:先安装gcc,之后运行 make distclean

2.2.2.8. 在 redis-6.2.1 目录下再次执行 make 命令(只 是编译好)

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第15张图片

2.2.2.9. 跳过 make test 继续执行: make install

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第16张图片

2.2.3. 安装目录:/usr/local/bin

查看默认安装目录:

  • redis-benchmark:性能测试工具,可以在自己本子运行,看看自己本子性能如何

  • redis-check-aof:修复有问题的 AOF 文件,rdb 和 aof 后面讲

  • redis-check-dump:修复有问题的 dump.rdb 文件

  • redis-sentinel:Redis 集群使用

  • redis-server:Redis 服务器启动命令

  • redis-cli:客户端,操作入口

2.2.4. 前台启动(不推荐)

前台启动,命令行窗口不能关闭,否则服务器停止

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第17张图片

2.2.5. 后台启动(推荐)

2.2.5.1.备份 redis.conf

拷贝一份 redis.conf 到其他目录,防止后期把文件修改坏无法恢复.

cp /opt/module/redis-6.2.6/redis.conf /etc/redis.conf

2.2.5.2.后台启动设置 daemonize no 改成 yes

修改 redis.conf(257 行)文件将里面的 daemonize no 改成 yes,让服务在后台启动

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第18张图片

2.2.5.3.Redis 启动

redis-server /etc/redis.conf

2.2.5.4.用客户端访问:redis-cli

2.2.5.5.多个端口可以:redis-cli -p6379

2.2.5.6.测试验证: ping

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第19张图片

2.2.5.7.Redis 关闭

shutdown+quit

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第20张图片

exit+kill

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第21张图片

2.2.6. Redis 介绍相关知识

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第22张图片

Redis 是**单线程+多路 IO 复用技术 **

多路复用是指使用一个线程来检查多个文件描述符(Socket)的就绪状态,比如调用 select 和 poll 函数,传入多个文件描述符,如果有一个文件描述符就绪,则返回,否则 阻塞直到超时。得到就绪状态后进行真正的操作可以在同一个线程里执行,也可以启 动线程执行(比如使用线程池)

串行 vs 多线程+锁(memcached) vs 单线程+多路 IO 复用(Redis)

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第23张图片

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 数据

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第24张图片

  • unlink key 根据 value 选择非阻塞删除

仅将 keys 从 keyspace 元数据中删除,真正的删除会在后续异步操作。

  • expire key 10 10 秒钟:为给定的 key 设置过期时间

  • ttl key 查看还有多少秒过期,-1 表示永不过期,-2 表示已过期

  • select 命令切换数据库

  • dbsize 查看当前数据库的 key 的数量

  • flushdb 清空当前库

  • flushall 通杀全部库

image-20220130172423322

3.2. Redis 字符串(String)

3.2.1. 简介

  • String 是 Redis 最基本的类型,你可以理解成与 Memcached 一模一样的类型,一个 key 对应一个 value。
  • String 类型是二进制安全的。意味着 Redis 的 string 可以包含任何数据。比如 jpg 图片 或者序列化的对象。
  • String 类型是 Redis 最基本的数据类型,一个 Redis 中字符串 value 最多可以是 512M

3.2.2. 常用命令

set <key> <value> #添加键值对

注意: 当数据库中 key 不存在时,可以将 key-value 添加数据,如果存在时,新value将覆盖旧value.

  • get 查询对应键值

  • append 将给定的 追加到原值的末尾

  • strlen 获得值的长度

  • setnx 只有在 key 不存在时 设置 key 的值

  • incr

    将 key 中储存的数字值增1

    只能对数字值操作,如果为空,新增值为1

  • decr

    将 key 中储存的数字值减1

    只能对数字值操作,如果为空,新增值为-1

  • incrby / decrby <步长> 将 key 中储存的数字值增减。自定义步长。

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第25张图片

  • mset

    同时设置一个或多个 key-value对

  • mget

    同时获取一个或多个 value

  • msetnx

    同时设置一个或多个 key-value 对,当且仅当所有给定 key 都不存在。

原子性,有一个失败则都失败

  • getrange <起始位置><结束位置>

    获得值的范围,类似java中的substring,前包,后包

  • setrange <起始位置>

    用 覆写所储存的字符串值,从<起始位置>开始(索引从0****开始)。

  • setex <过期时间>

    设置键值的同时,设置过期时间,单位秒。

  • getset

    以新换旧,设置了新值同时获得旧值。

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第26张图片

3.2.3. 数据结构

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

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第27张图片

如图中所示,内部为当前字符串实际分配的空间capacity一般要高于实际字符串长度len。当字符串长度小于1M时,扩容都是加倍现有的空间,如果超过1M,扩容时一次只会多扩1M的空间。需要注意的是字符串最大长度为512M。

3.3. Redis 列表(List)

3.3.1. 简介

单键多值

Redis 列表是简单的字符串列表,按照插入顺序排序。你可以添加一个元素到列表的头部(左边)或者尾部(右边)。

它的底层实际是个双向链表,对两端的操作性能很高,通过索引下标的操作中间的节点性能会较差。

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第28张图片

3.3.2. 常用命令

  • lpush/rpush … 从左边/右边插入一个或多个值。

  • lpop/rpop 从左边/右边吐出一个值。值在键在,值光键亡。

  • rpop/lpush 从列表右边吐出一个值,插到列表左边。

  • lrange 按照索引下标获得元素(从左到右)

  • lrange mylist 0 -1 0左边第一个,-1右边第一个,(0-1表示获取所有)

  • lindex 按照索引下标获得元素(从左到右)

  • llen 获得列表长度

  • linsert before 在的后面插入插入值

  • lrem 从左边删除n个value(从左到右)

  • lset将列表key下标为index的值替换成value

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第29张图片

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第30张图片

3.3.3 数据结构

List 的数据结构为快速链表 quickList

首先在列表元素较少的情况下会使用一块连续的内存存储,这个结构是 ziplist,也即是 压缩列表。

它将所有的元素紧挨着一起存储,分配的是一块连续的内存。 当数据量比较多的时候才会改成 quicklist。 因为普通的链表需要的附加指针空间太大,会比较浪费空间。比如这个列表里存的只 是 int 类型的数据,结构上还需要两个额外的指针 prev 和 next。

image-20220210214301430

Redis 将链表和 ziplist 结合起来组成了 quicklist。也就是将多个 ziplist 使用双向指 针串起来使用。这样既满足了快速的插入删除性能,又不会出现太大的空间冗余。

3.3.4 补充:原子性

所谓原子操作是指不会被线程调度机制打断的操作
这种操作一旦开始,就一直运行到结束,中间不会有任何 context switch (切换到另
一个线程)。
(1)在单线程中, 能够在单条指令中完成的操作都可以认为是"原子操作",因为中
断只能发生于指令之间。
(2)在多线程中,不能被其它进程(线程)打断的操作就叫原子操作。
Redis 单命令的原子性主要得益于 Redis的单线程。

案例:
java 中的 i++是否是原子操作?不是
i=0;两个线程分别对 i进行++100次,值是多少?

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第31张图片

3.4. Redis 集合(Set)

3.4.1. 简介

Redis set 对外提供的功能与 list 类似是一个列表的功能,特殊之处在于 set 是可以自动排重的,当你需要存储一个列表数据,又不希望出现重复数据时,set 是一个很好的选 择,并且 set 提供了判断某个成员是否在一个 set 集合内的重要接口,这个也是 list 所不能提供的。

Redis 的 Set 是 string 类型的无序集合。它底层其实是一个 value 为 null 的 hash 表,所 以添加,删除,查找的复杂度都是 O(1)。

一个算法,随着数据的增加,执行时间的长短,如果是 O(1),数据增加,查找数据的 时间不变

3.4.2. 常用命令

  • sadd … 将一个或多个 member 元素加入到集合 key 中,已经存在的 member 元素将被忽略

  • smembers 取出该集合的所有值

  • sismember 判断集合是否为含有该值,有 1,没有 0

  • scard 返回该集合的元素个数。

  • srem … 删除集合中的某个元素。

  • **spop **随机从该集合中吐出一个值。

  • **srandmember **随机从该集合中取出 n 个值。不会从集合中删除 。

  • move value 把集合中一个值从一个集合移动到另一个集合

  • **sinter **返回两个集合的交集元素。

  • **sunion **返回两个集合的并集元素。

  • **sdiff **返回两个集合的差集元素(key1 中的,不包含 key2中的)

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第32张图片

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第33张图片

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第34张图片

3.4.3. 数据结构

Set 数据结构是 dict字典,字典是用哈希表实现的。
Java 中 HashSet 的内部实现使用的是 HashMap,只不过所有的 value 都指向同一个对象。
Redis的 set结构也是一样,它的内部也使用 hash结构,所有的 value都指向同一个内部值。

3.5. Redis 哈希(Hash)

3.5.1. 简介

Redis hash 是一个键值对集合。
Redis hash 是一个 string 类型的 field 和 value 的映射表,hash 特别适合用于存储对象。
类似 Java 里面的 Map
用户 ID 为查找的 key,存储的 value用户对象包含姓名,年龄,生日等信息,如果用
普通的 key/value结构来存储
主要有以下 3 种存储方式:

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第35张图片

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第36张图片

3.5.2. 常用命令

  • hset : 给集合中的 键赋值
  • **hget : **从集合取出 value
  • **hmset … : ** 批量设置 hash 的值
  • **hexists: **查看哈希表 key 中,给定域 field 是否存在。
  • **hkeys : **列出该 hash 集合的所有 field
  • **hvals : **列出该 hash 集合的所有 value
  • **hincrby : **为哈希表 key 中的域 field 的值加上增量 1 -1
  • **hsetnx : **将哈希表 key 中的域 field 的值设置为 value ,当且仅当域
    field 不存在

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第37张图片

3.5.3. 数据结构

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

3.6. Redis 有序集合 Zset(sorted set)

3.6.1. 简介

Redis 有序集合 zset与普通集合 set 非常相似,是一个没有重复元素的字符串集合
不同之处是有序集合的每个成员都关联了一个评分(score),这个评分(score)被用来按照从最低分到最高分的方式排序集合中的成员。集合的成员是唯一的,但是评分可以是重复了
因为元素是有序的, 所以你也可以很快的根据评分(score)或者次序(position)来获取一个范围的元素。
访问有序集合的中间元素也是非常快的,因此你能够使用有序集合作为一个没有重复成员的智能列表。

3.6.2. 常用命令

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

案例:如何利用 zset 实现一个文章访问量的排行榜?

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第38张图片

3.6.3. 数据结构

SortedSet(zset)是 Redis 提供的一个非常特别的数据结构,一方面它等价于 Java的数据结构 Map,可以给每一个元素 value 赋予一个权重 score,另一方面它又类似于 TreeSet内部的元素会按照权重 score 进行排序,可以得到每个元素的名次,还可以通过 score 的范围来获取元素的列表。

zset 底层使用了两个数据结构:
(1)hash,hash 的作用就是关联元素 value 和权重 score,保障元素 value 的唯一性,可以通过元素 value 找到相应的 score 值。
(2)跳跃表,跳跃表的目的在于给元素 value 排序,根据 score 的范围获取元素列表。

3.6.4. 跳跃表(跳表)

1、简介
有序集合在生活中比较常见,例如根据成绩对学生排名,根据得分对玩家排名等。对于有序集合的底层实现,可以用数组、平衡树、链表等。数组不便元素的插入、删除;平衡树或红黑树虽然效率高但结构复杂;链表查询需要遍历所有效率低。Redis采用的是跳跃表。跳跃表效率堪比红黑树,实现远比红黑树简单。

2、实例
对比有序链表和跳跃表,从链表中查询出 51

(1) 有序链表

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第39张图片

(2) 跳跃表

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第40张图片

从此可以看出跳跃表比有序链表效率要高

https://www.aliyundrive.com/s/ebUnLzhokVr

4. Redis Redis 配置文件介绍

自定义目录:/etc/redis.conf

4.1. ###Units 单位###

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第41张图片

4.2. ###INCLUDES 包含###

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第42张图片

类似 jsp 中的 include,多实例的情况可以把公用的配置文件提取出来

4.3. ### 网络相关配置

4.3.1. bind

默认情况 bind=127.0.0.1 只能接受本机的访问请求. 不写的情况下,无限制接受任何 ip 地址的访问
生产环境肯定要写你应用服务器的地址;服务器是需要远程访问的,所以需要将其注释掉

如果开启了 protected-mode,那么在没有设定 bind ip且没有设密码的情况下,Redis
只允许接受本机的响应
(后续将对其进行关闭)

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第43张图片

4.3.2. protected- -mode

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第44张图片

4.3.3. Port

端口号,默认 6379

image-20220216220542814

4.3.4. tcp–backlog

设置 tcp 的 backlog,backlog 其实是一个连接队列,backlog队列总和=未完成三次握手队列 + 已经完成三次握手队列。
在高并发环境下你需要一个高 backlog 值来避免慢客户端连接问题。
注意 Linux内核会将这个值减小到/proc/sys/net/core/somaxconn 的值(128),所以需要确认增大/proc/sys/net/core/somaxconn 和/proc/sys/net/ipv4/tcp_max_syn_backlog(128)两个值来达到想要的效果

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第45张图片

4.3.5. timeout

一个空闲的客户端维持多少秒会关闭,0 表示关闭该功能。即永不关闭。

image-20220216221234044

4.3.6. tcp—keepalive

对访问客户端的一种心跳检测,每隔n 秒检测一次。
单位为秒,如果设置为 0,则不会进行 Keepalive检测,建议设置成 60

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第46张图片

4.4. ###GENERAL 通用###

4.4.1. daemonize

是否为后台进程,设置为 yes. 守护进程,后台启动

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第47张图片

4.4.2. pidfile

存放 pid 文件的位置,每个实例会产生一个不同的 pid文件

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第48张图片

4.4.3. loglevel

指定日志记录级别,Redis 总共支持四个级别:debug、verbose、notice、warning,默认为 notice
四个级别根据使用阶段来选择,生产环境选择 notice 或者 warning

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第49张图片

4.4.4. logfile

日志文件名称

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第50张图片

4.4.5. databases 16

设定库的数量 默认 16,默认数据库为 0,可以使用 SELECT 命令在连接上指定数据库 id

image-20220216222829307

4.5. ###SECURITY 安全###

4.5.1. 设置密码

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第51张图片

访问密码的查看、设置和取消在命令中设置密码,只是临时的。重启 redis服务器,密码就还原了。
永久设置,需要再配置文件中进行设置。

4.6. #### LIMITS 限制

4.6.1. maxclients

➢ 设置 redis 同时可以与多少个客户端进行连接。
➢ 默认情况下为 10000 个客户端。
➢ 如果达到了此限制,redis 则会拒绝新的连接请求,并且向这些连接请求方发出“max number of clients reached”以作回应。

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第52张图片

4.6.2. maxmemory

➢ 建议**必须设置**,否则,将内存占满,造成服务器宕机
➢ 设置 redis 可以使用的内存量。一旦到达内存使用上限,redis将会试图移除内部数据,移除规则可以通过 maxmemory-policy 来指定。
➢ 如果 redis 无法根据移除规则来移除内存中的数据,或者设置了“不允许移除”,那么 redis则会针对那些需要申请内存的指令返回错误信息,比如 SET、LPUSH等。 但是对于无内存申请的指令,仍然会正常响应,比如 GET 等。
➢如果你的 redis 是主redis(说明你的 redis 有从 redis),那么在设置内存使用上限时,需要在系统中留出一些内存空间给同步队列缓存,只有在你设置的是“不移除”的情况下,才不用考虑这个因素。

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第53张图片

4.6.3. maxmemory—policy

➢ volatile-lru:使用 LRU算法移除 key,只对设置了过期时间的键;(最近最少使用)
➢ allkeys-lru:在所有集合 key中,使用 LRU算法移除 key
➢ volatile-random:在过期集合中移除随机的 key,只对设置了过期时间的键
➢ allkeys-random:在所有集合 key中,移除随机的 key
➢ volatile-ttl:移除那些 TTL值最小的 key,即那些最近要过期的 key
➢ noeviction:不进行移除。针对写操作,只是返回错误信息

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第54张图片

4.6.4. maxmemory—samples

➢ 设置样本数量,LRU 算法和最小 TTL算法都并非是精确的算法,而是估算值,所以你可以设置样本的大小,redis 默认会检查这么多个 key 并选择其中 LRU 的那个。
➢ 一般设置 3 到 7的数字,数值越小样本越不准确,但 性能消耗越小。

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第55张图片

5. Redis Redis 的发布和订阅

5.1. 什么是发布和订阅

Redis 发布订阅 (pub/sub) 是一种消息通信模式:发送者 (pub) 发送消息,订阅者(sub) 接收消息
Redis 客户端可以订阅任意数量的频道。

5.2. Redis 的发布和订阅

1、客户端可以订阅频道如下图

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第56张图片

2、当给这个频道发布消息后,消息就会发送给订阅的客户端

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第57张图片

5.3. 发布订阅命令行实现

1、 打开一个客户端订阅 channel1— SUBSCRIBE channel1

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第58张图片

2、打开另一个客户端,给 channel1 发布消息 hello —publish channel1 hello

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第59张图片

返回的 1 是订阅者数量

3、打开第一个客户端可以看到发送的消息

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第60张图片

注:发布的消息没有持久化,如果在订阅的客户端收不到 hello,只能收到订阅后发布的消息

6.Redis常见命令

6.1 Redis数据结构介绍

Redis是一个key-value的数据库,key一般是String类型,不过value的类型多种多样:

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第61张图片

贴心小建议:命令不要死记,学会查询就好啦

Redis为了方便我们学习,将操作不同数据类型的命令也做了分组,在官网( https://redis.io/commands )可以查看到不同的命令:

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第62张图片

当然我们也可以通过Help命令来帮助我们去查看命令

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第63张图片

6.2 Redis 通用命令

通用指令是部分数据类型的,都可以使用的指令,常见的有:

  • KEYS:查看符合模板的所有key
  • DEL:删除一个指定的key
  • EXISTS:判断key是否存在
  • EXPIRE:给一个key设置有效期,有效期到期时该key会被自动删除
  • TTL:查看一个KEY的剩余有效期

通过help [command] 可以查看一个命令的具体用法,例如:

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第64张图片

课堂代码如下

  • KEYS
127.0.0.1:6379> keys *
1) "name"
2) "age"
127.0.0.1:6379>

# 查询以a开头的key
127.0.0.1:6379> keys a*
1) "age"
127.0.0.1:6379>

贴心小提示:在生产环境下,不推荐使用keys 命令,因为这个命令在key过多的情况下,效率不高

  • DEL
127.0.0.1:6379> help del

  DEL key [key ...]
  summary: Delete a key
  since: 1.0.0
  group: generic

127.0.0.1:6379> del name #删除单个
(integer) 1  #成功删除1个

127.0.0.1:6379> keys *
1) "age"

127.0.0.1:6379> MSET k1 v1 k2 v2 k3 v3 #批量添加数据
OK

127.0.0.1:6379> keys *
1) "k3"
2) "k2"
3) "k1"
4) "age"

127.0.0.1:6379> del k1 k2 k3 k4
(integer) 3   #此处返回的是成功删除的key,由于redis中只有k1,k2,k3 所以只成功删除3个,最终返回
127.0.0.1:6379>

127.0.0.1:6379> keys * #再查询全部的key
1) "age"	#只剩下一个了
127.0.0.1:6379>

贴心小提示:同学们在拷贝代码的时候,只需要拷贝对应的命令哦~

  • EXISTS
127.0.0.1:6379> help EXISTS

  EXISTS key [key ...]
  summary: Determine if a key exists
  since: 1.0.0
  group: generic

127.0.0.1:6379> exists age
(integer) 1

127.0.0.1:6379> exists name
(integer) 0
  • EXPIRE

贴心小提示:内存非常宝贵,对于一些数据,我们应当给他一些过期时间,当过期时间到了之后,他就会自动被删除~

127.0.0.1:6379> expire age 10
(integer) 1

127.0.0.1:6379> ttl age
(integer) 8

127.0.0.1:6379> ttl age
(integer) 6

127.0.0.1:6379> ttl age
(integer) -2

127.0.0.1:6379> ttl age
(integer) -2  #当这个key过期了,那么此时查询出来就是-2 

127.0.0.1:6379> keys *
(empty list or set)

127.0.0.1:6379> set age 10 #如果没有设置过期时间
OK

127.0.0.1:6379> ttl age
(integer) -1  # ttl的返回值就是-1

6.3 Redis命令-String命令

String类型,也就是字符串类型,是Redis中最简单的存储类型。

其value是字符串,不过根据字符串的格式不同,又可以分为3类:

  • string:普通字符串
  • int:整数类型,可以做自增.自减操作
  • float:浮点类型,可以做自增.自减操作

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第65张图片

String的常见命令有:

  • SET:添加或者修改已经存在的一个String类型的键值对
  • GET:根据key获取String类型的value
  • MSET:批量添加多个String类型的键值对
  • MGET:根据多个key获取多个String类型的value
  • INCR:让一个整型的key自增1
  • INCRBY:让一个整型的key自增并指定步长,例如:incrby num 2 让num值自增2
  • INCRBYFLOAT:让一个浮点类型的数字自增并指定步长
  • SETNX:添加一个String类型的键值对,前提是这个key不存在,否则不执行
  • SETEX:添加一个String类型的键值对,并且指定有效期

贴心小提示:以上命令除了INCRBYFLOAT 都是常用命令

  • SET 和GET: 如果key不存在则是新增,如果存在则是修改
127.0.0.1:6379> set name Rose  //原来不存在
OK

127.0.0.1:6379> get name 
"Rose"

127.0.0.1:6379> set name Jack //原来存在,就是修改
OK

127.0.0.1:6379> get name
"Jack"
  • MSET和MGET
127.0.0.1:6379> MSET k1 v1 k2 v2 k3 v3
OK

127.0.0.1:6379> MGET name age k1 k2 k3
1) "Jack" //之前存在的name
2) "10"   //之前存在的age
3) "v1"
4) "v2"
5) "v3"
  • INCR和INCRBY和DECY
127.0.0.1:6379> get age 
"10"

127.0.0.1:6379> incr age //增加1
(integer) 11
    
127.0.0.1:6379> get age //获得age
"11"

127.0.0.1:6379> incrby age 2 //一次增加2
(integer) 13 //返回目前的age的值
    
127.0.0.1:6379> incrby age 2
(integer) 15
    
127.0.0.1:6379> incrby age -1 //也可以增加负数,相当于减
(integer) 14
    
127.0.0.1:6379> incrby age -2 //一次减少2个
(integer) 12
    
127.0.0.1:6379> DECR age //相当于 incr 负数,减少正常用法
(integer) 11
    
127.0.0.1:6379> get age 
"11"

  • SETNX
127.0.0.1:6379> help setnx

  SETNX key value
  summary: Set the value of a key, only if the key does not exist
  since: 1.0.0
  group: string

127.0.0.1:6379> set name Jack  //设置名称
OK
127.0.0.1:6379> setnx name lisi //如果key不存在,则添加成功
(integer) 0
127.0.0.1:6379> get name //由于name已经存在,所以lisi的操作失败
"Jack"
127.0.0.1:6379> setnx name2 lisi //name2 不存在,所以操作成功
(integer) 1
127.0.0.1:6379> get name2 
"lisi"
  • SETEX
127.0.0.1:6379> setex name 10 jack
OK

127.0.0.1:6379> ttl name
(integer) 8

127.0.0.1:6379> ttl name
(integer) 7

127.0.0.1:6379> ttl name
(integer) 5

6.4 Redis命令-Key的层级结构

Redis没有类似MySQL中的Table的概念,我们该如何区分不同类型的key呢?

例如,需要存储用户.商品信息到redis,有一个用户id是1,有一个商品id恰好也是1,此时如果使用id作为key,那就会冲突了,该怎么办?

我们可以通过给key添加前缀加以区分,不过这个前缀不是随便加的,有一定的规范:

Redis的key允许有多个单词形成层级结构,多个单词之间用’:'隔开,格式如下:

1652941631682

这个格式并非固定,也可以根据自己的需求来删除或添加词条。

例如我们的项目名称叫 heima,有user和product两种不同类型的数据,我们可以这样定义key:

  • user相关的key:heima:user:1

  • product相关的key:heima:product:1

如果Value是一个Java对象,例如一个User对象,则可以将对象序列化为JSON字符串后存储:

KEY VALUE
heima:user:1 {“id”:1, “name”: “Jack”, “age”: 21}
heima:product:1 {“id”:1, “name”: “小米11”, “price”: 4999}

一旦我们向redis采用这样的方式存储,那么在可视化界面中,redis会以层级结构来进行存储,形成类似于这样的结构,更加方便Redis获取数据

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第66张图片

6.5 Redis命令-Hash命令

Hash类型,也叫散列,其value是一个无序字典,类似于Java中的HashMap结构。

String结构是将对象序列化为JSON字符串后存储,当需要修改对象某个字段时很不方便:

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第67张图片

Hash结构可以将对象中的每个字段独立存储,可以针对单个字段做CRUD:

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第68张图片

Hash类型的常见命令

  • HSET key field value:添加或者修改hash类型key的field的值

  • HGET key field:获取一个hash类型key的field的值

  • HMSET:批量添加多个hash类型key的field的值

  • HMGET:批量获取多个hash类型key的field的值

  • HGETALL:获取一个hash类型的key中的所有的field和value

  • HKEYS:获取一个hash类型的key中的所有的field

  • HINCRBY:让一个hash类型key的字段值自增并指定步长

  • HSETNX:添加一个hash类型的key的field值,前提是这个field不存在,否则不执行

贴心小提示:哈希结构也是我们以后实际开发中常用的命令哟

  • HSET和HGET
127.0.0.1:6379> HSET heima:user:3 name Lucy//大key是 heima:user:3 小key是name,小value是Lucy
(integer) 1
127.0.0.1:6379> HSET heima:user:3 age 21// 如果操作不存在的数据,则是新增
(integer) 1
127.0.0.1:6379> HSET heima:user:3 age 17 //如果操作存在的数据,则是修改
(integer) 0
127.0.0.1:6379> HGET heima:user:3 name 
"Lucy"
127.0.0.1:6379> HGET heima:user:3 age
"17"
  • HMSET和HMGET
127.0.0.1:6379> HMSET heima:user:4 name HanMeiMei
OK
127.0.0.1:6379> HMSET heima:user:4 name LiLei age 20 sex man
OK
127.0.0.1:6379> HMGET heima:user:4 name age sex
1) "LiLei"
2) "20"
3) "man"
  • HGETALL
127.0.0.1:6379> HGETALL heima:user:4
1) "name"
2) "LiLei"
3) "age"
4) "20"
5) "sex"
6) "man"
  • HKEYS和HVALS
127.0.0.1:6379> HKEYS heima:user:4
1) "name"
2) "age"
3) "sex"
127.0.0.1:6379> HVALS heima:user:4
1) "LiLei"
2) "20"
3) "man"
  • HINCRBY
127.0.0.1:6379> HINCRBY  heima:user:4 age 2
(integer) 22
127.0.0.1:6379> HVALS heima:user:4
1) "LiLei"
2) "22"
3) "man"
127.0.0.1:6379> HINCRBY  heima:user:4 age -2
(integer) 20
  • HSETNX
127.0.0.1:6379> HSETNX heima:user4 sex woman
(integer) 1
127.0.0.1:6379> HGETALL heima:user:3
1) "name"
2) "Lucy"
3) "age"
4) "17"
127.0.0.1:6379> HSETNX heima:user:3 sex woman
(integer) 1
127.0.0.1:6379> HGETALL heima:user:3
1) "name"
2) "Lucy"
3) "age"
4) "17"
5) "sex"
6) "woman"

6.6 Redis命令-List命令

Redis中的List类型与Java中的LinkedList类似,可以看做是一个双向链表结构。既可以支持正向检索和也可以支持反向检索。

特征也与LinkedList类似:

  • 有序
  • 元素可以重复
  • 插入和删除快
  • 查询速度一般

常用来存储一个有序数据,例如:朋友圈点赞列表,评论列表等。

List的常见命令有:

  • LPUSH key element … :向列表左侧插入一个或多个元素
  • LPOP key:移除并返回列表左侧的第一个元素,没有则返回nil
  • RPUSH key element … :向列表右侧插入一个或多个元素
  • RPOP key:移除并返回列表右侧的第一个元素
  • LRANGE key star end:返回一段角标范围内的所有元素
  • BLPOP和BRPOP:与LPOP和RPOP类似,只不过在没有元素时等待指定时间,而不是直接返回nil

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第69张图片

  • LPUSH和RPUSH
127.0.0.1:6379> LPUSH users 1 2 3
(integer) 3
127.0.0.1:6379> RPUSH users 4 5 6
(integer) 6
  • LPOP和RPOP
127.0.0.1:6379> LPOP users
"3"
127.0.0.1:6379> RPOP users
"6"
  • LRANGE
127.0.0.1:6379> LRANGE users 1 2
1) "1"
2) "4"

6.7 Redis命令-Set命令

Redis的Set结构与Java中的HashSet类似,可以看做是一个value为null的HashMap。因为也是一个hash表,因此具备与HashSet类似的特征:

  • 无序
  • 元素不可重复
  • 查找快
  • 支持交集.并集.差集等功能

Set类型的常见命令

  • SADD key member … :向set中添加一个或多个元素
  • SREM key member … : 移除set中的指定元素
  • SCARD key: 返回set中元素的个数
  • SISMEMBER key member:判断一个元素是否存在于set中
  • SMEMBERS:获取set中的所有元素
  • SINTER key1 key2 … :求key1与key2的交集
  • SDIFF key1 key2 … :求key1与key2的差集
  • SUNION key1 key2 …:求key1和key2的并集

例如两个集合:s1和s2:

求交集:SINTER s1 s2

求s1与s2的不同:SDIFF s1 s2

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第70张图片

具体命令

127.0.0.1:6379> sadd s1 a b c
(integer) 3
127.0.0.1:6379> smembers s1
1) "c"
2) "b"
3) "a"
127.0.0.1:6379> srem s1 a
(integer) 1
    
127.0.0.1:6379> SISMEMBER s1 a
(integer) 0
    
127.0.0.1:6379> SISMEMBER s1 b
(integer) 1
    
127.0.0.1:6379> SCARD s1
(integer) 2

案例

  • 将下列数据用Redis的Set集合来存储:
  • 张三的好友有:李四.王五.赵六
  • 李四的好友有:王五.麻子.二狗
  • 利用Set的命令实现下列功能:
  • 计算张三的好友有几人
  • 计算张三和李四有哪些共同好友
  • 查询哪些人是张三的好友却不是李四的好友
  • 查询张三和李四的好友总共有哪些人
  • 判断李四是否是张三的好友
  • 判断张三是否是李四的好友
  • 将李四从张三的好友列表中移除
127.0.0.1:6379> SADD zs lisi wangwu zhaoliu
(integer) 3
    
127.0.0.1:6379> SADD ls wangwu mazi ergou
(integer) 3
    
127.0.0.1:6379> SCARD zs
(integer) 3
    
127.0.0.1:6379> SINTER zs ls
1) "wangwu"
    
127.0.0.1:6379> SDIFF zs ls
1) "zhaoliu"
2) "lisi"
    
127.0.0.1:6379> SUNION zs ls
1) "wangwu"
2) "zhaoliu"
3) "lisi"
4) "mazi"
5) "ergou"
    
127.0.0.1:6379> SISMEMBER zs lisi
(integer) 1
    
127.0.0.1:6379> SISMEMBER ls zhangsan
(integer) 0
    
127.0.0.1:6379> SREM zs lisi
(integer) 1
    
127.0.0.1:6379> SMEMBERS zs
1) "zhaoliu"
2) "wangwu"

6.8 Redis命令-SortedSet类型

Redis的SortedSet是一个可排序的set集合,与Java中的TreeSet有些类似,但底层数据结构却差别很大。SortedSet中的每一个元素都带有一个score属性,可以基于score属性对元素排序,底层的实现是一个跳表(SkipList)加 hash表。

SortedSet具备下列特性:

  • 可排序
  • 元素不重复
  • 查询速度快

因为SortedSet的可排序特性,经常被用来实现排行榜这样的功能。

SortedSet的常见命令有:

  • ZADD key score member:添加一个或多个元素到sorted set ,如果已经存在则更新其score值
  • ZREM key member:删除sorted set中的一个指定元素
  • ZSCORE key member : 获取sorted set中的指定元素的score值
  • ZRANK key member:获取sorted set 中的指定元素的排名
  • ZCARD key:获取sorted set中的元素个数
  • ZCOUNT key min max:统计score值在给定范围内的所有元素的个数
  • ZINCRBY key increment member:让sorted set中的指定元素自增,步长为指定的increment值
  • ZRANGE key min max:按照score排序后,获取指定排名范围内的元素
  • ZRANGEBYSCORE key min max:按照score排序后,获取指定score范围内的元素
  • ZDIFF.ZINTER.ZUNION:求差集.交集.并集

注意:所有的排名默认都是升序,如果要降序则在命令的Z后面添加REV即可,例如:

  • 升序获取sorted set 中的指定元素的排名:ZRANK key member
  • 降序获取sorted set 中的指定元素的排名:ZREVRANK key memeber

7.Redis的Java客户端-Jedis

在Redis官网中提供了各种语言的客户端,地址:https://redis.io/docs/clients/

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第71张图片

其中Java客户端也包含很多:

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第72张图片

标记为❤的就是推荐使用的java客户端,包括:

  • Jedis和Lettuce:这两个主要是提供了Redis命令对应的API,方便我们操作Redis,而SpringDataRedis又对这两种做了抽象和封装,因此我们后期会直接以SpringDataRedis来学习。
  • Redisson:是在Redis基础上实现了分布式的可伸缩的java数据结构,例如Map.Queue等,而且支持跨进程的同步机制:Lock.Semaphore等待,比较适合用来实现特殊的功能需求。

7.1 Jedis快速入门

入门案例详细步骤

案例分析:

0)创建工程:

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第73张图片

1)引入依赖:


<dependency>
    <groupId>redis.clientsgroupId>
    <artifactId>jedisartifactId>
    <version>3.7.0version>
dependency>

<dependency>
    <groupId>org.junit.jupitergroupId>
    <artifactId>junit-jupiterartifactId>
    <version>5.7.0version>
    <scope>testscope>
dependency>

2)建立连接

新建一个单元测试类,内容如下:

private Jedis jedis;

@BeforeEach
void setUp() {
    // 1.建立连接
    // jedis = new Jedis("192.168.150.101", 6379);
    jedis = JedisConnectionFactory.getJedis();
    // 2.设置密码
    jedis.auth("123321");
    // 3.选择库
    jedis.select(0);
}

3)测试:

@Test
void testString() {
    // 存入数据
    String result = jedis.set("name", "虎哥");
    System.out.println("result = " + result);
    // 获取数据
    String name = jedis.get("name");
    System.out.println("name = " + name);
}

@Test
void testHash() {
    // 插入hash数据
    jedis.hset("user:1", "name", "Jack");
    jedis.hset("user:1", "age", "21");

    // 获取
    Map<String, String> map = jedis.hgetAll("user:1");
    System.out.println(map);
}

4)释放资源

@AfterEach
void tearDown() {
    if (jedis != null) {
        jedis.close();
    }
}

7.2 Jedis连接池

Jedis本身是线程不安全的,并且频繁的创建和销毁连接会有性能损耗,因此我们推荐大家使用Jedis连接池代替Jedis的直连方式

有关池化思想,并不仅仅是这里会使用,很多地方都有,比如说我们的数据库连接池,比如我们tomcat中的线程池,这些都是池化思想的体现。

7.2.1.创建Jedis的连接池

/**
 * @author lxy
 * @version 1.0
 * @Description
 * @date 2022/8/27 21:58
 */
public class JedisConnectionFactory {
    private static final JedisPool jedisPool;

    static {
        // 配置连接池
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        //最大连接数 (最多允许创建的连接数)
        jedisPoolConfig.setMaxTotal(8);
        // 最大空闲连接 (最多预备的连接数)
        jedisPoolConfig.setMaxIdle(8);
        //最小空闲连接(在一段时间内,没有人使用,则可释放连接数到MinIdle)
        jedisPoolConfig.setMinIdle(0);
        //设置最长等待时间,ms (连接池中没有连接时,等待的时长。默认是 -1,无限制的等待)
        jedisPoolConfig.setMaxWaitMillis(200);
        // 创建连接池对象,参数:连接池配置、服务端ip、服务端端口、超时时间、(密码)
        jedisPool = new JedisPool(jedisPoolConfig, "192.168.174.128", 6379, 1000);
    }

    //获取Jedis对象
    public static Jedis getJedis(){
        return jedisPool.getResource();
    }

}

代码说明:

  • 1) JedisConnectionFacotry:工厂设计模式是实际开发中非常常用的一种设计模式,我们可以使用工厂,去降低代的耦合,比如Spring中的Bean的创建,就用到了工厂设计模式

  • 2)静态代码块:随着类的加载而加载,确保只能执行一次,我们在加载当前工厂类的时候,就可以执行static的操作完成对 连接池的初始化

  • 3)最后提供返回连接池中连接的方法.

7.2.2.改造原始代码

代码说明:

1.在我们完成了使用工厂设计模式来完成代码的编写之后,我们在获得连接时,就可以通过工厂来获得。而不用直接去new对象,降低耦合,并且使用的还是连接池对象。

2.当我们使用了连接池后,当我们关闭连接其实并不是关闭,而是将Jedis还回连接池的。

    @BeforeEach
    void setUp(){
        //建立连接
        /*jedis = new Jedis("127.0.0.1",6379);*/
        jedis = JedisConnectionFacotry.getJedis();
         //选择库
        jedis.select(0);
    }

   @AfterEach
    void tearDown() {
        if (jedis != null) {
            jedis.close();
        }
    }

注意此时jedis.close();的底层调用的不再是关闭连接,而是将连接放回到连接池中

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第74张图片

8.Redis的Java客户端-SpringDataRedis

SpringData是Spring中数据操作的模块,包含对各种数据库的集成,其中对Redis的集成模块就叫做SpringDataRedis,官网地址:https://spring.io/projects/spring-data-redis

  • 提供了对不同Redis客户端的整合(Lettuce和Jedis)
  • 提供了RedisTemplate统一API来操作Redis
  • 支持Redis的发布订阅模型
  • 支持Redis哨兵和Redis集群
  • 支持基于Lettuce的响应式编程
  • 支持基于JDK.JSON.字符串.Spring对象的数据序列化及反序列化
  • 支持基于Redis的JDKCollection实现(基于Redis重新实现)

SpringDataRedis中提供了RedisTemplate工具类,其中封装了各种对Redis的操作。并且将不同数据类型的操作API封装到了不同的类型中:

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第75张图片

8.1.快速入门

SpringBoot已经提供了对SpringDataRedis的支持,使用非常简单:

8.1.1 导入pom坐标


<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>
    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.5.7version>
        <relativePath/> 
    parent>
    <groupId>com.heimagroupId>
    <artifactId>redis-demoartifactId>
    <version>0.0.1-SNAPSHOTversion>
    <name>redis-demoname>
    <description>Demo project for Spring Bootdescription>
    <properties>
        <java.version>1.8java.version>
    properties>
    <dependencies>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-data-redisartifactId>
        dependency>
        
        <dependency>
            <groupId>org.apache.commonsgroupId>
            <artifactId>commons-pool2artifactId>
        dependency>
        
        <dependency>
            <groupId>com.fasterxml.jackson.coregroupId>
            <artifactId>jackson-databindartifactId>
        dependency>
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
            <optional>trueoptional>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
        dependency>
    dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-maven-pluginartifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombokgroupId>
                            <artifactId>lombokartifactId>
                        exclude>
                    excludes>
                configuration>
            plugin>
        plugins>
    build>

project>

8.1.2 配置文件

spring:
  redis:
    host: 192.168.174.128
    port: 6379
    password: 123321
    lettuce:
      pool:
        max-active: 8  #最大连接
        max-idle: 8   #最大空闲连接
        min-idle: 0   #最小空闲连接
        max-wait: 100ms #连接等待时间

8.1.3 测试代码

@SpringBootTest
class RedisDemoApplicationTests {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Test
    void testString() {
        // 写入一条String数据
        redisTemplate.opsForValue().set("name", "虎哥");
        // 获取string数据
        Object name = redisTemplate.opsForValue().get("name");
        System.out.println("name = " + name);
    }
}

贴心小提示:SpringDataJpa使用起来非常简单,记住如下几个步骤即可

SpringDataRedis的使用步骤:

  • 引入spring-boot-starter-data-redis依赖
  • 在application.yml配置Redis信息
  • 注入RedisTemplate

8.2 .数据序列化器

RedisTemplate可以接收任意Object作为值写入Redis:

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第76张图片

当我们执行完上面6.1 的测试方法后,从redis-cli下 获取name的值,结果如下:

image-20221030174718267

为啥我们存入的值 和我们看到的不一样呢?

因为写入前后会把 Java对象 利用 JDK序列化器转成可处理的字节 来存储到Redis中,而序列化器底层是ObjectOutputStream。得到的结果就是上面那样

public class RedisTemplate<K, V> extends RedisAccessor implements RedisOperations<K, V>, BeanClassLoaderAware {
	//四个序列化器
    private @Nullable RedisSerializer keySerializer = null;
	private @Nullable RedisSerializer valueSerializer = null;
	private @Nullable RedisSerializer hashKeySerializer = null;
	private @Nullable RedisSerializer hashValueSerializer = null;
    
    public void afterPropertiesSet() {

		super.afterPropertiesSet();

		boolean defaultUsed = false;

		if (defaultSerializer == null) {

			defaultSerializer = new JdkSerializationRedisSerializer(
					classLoader != null ? classLoader : this.getClass().getClassLoader());
		}
    }

}

//JdkSerializationRedisSerializer底层
ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);

缺点:

  • 可读性差
  • 内存占用较大

分析系统中的序列化器:

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第77张图片

我们可以自定义RedisTemplate的序列化方式,代码如下:

/**
 * @author lxy
 * @version 1.0 
 * @date 2022/11/12 18:36
 * @Description 配置Redis的序列化器 
 * key:使用字符串序列化器,value的类型不确定,也就是Object,所以我们使用JSON序列化器
 */
@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate <String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        // 创建RedisTemplate对象
        RedisTemplate <String, Object> template = new RedisTemplate <>();
        // 创建连接工厂
        template.setConnectionFactory(connectionFactory);
        // 创建JSON序列化器
        //RedisSerializer.string(),RedisSerializer.json() 也可以得到对应的序列化器.
        GenericJackson2JsonRedisSerializer jsonRedisSerializer =
                new GenericJackson2JsonRedisSerializer();
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // 设置key的序列化
        template.setKeySerializer(stringRedisSerializer);
        template.setHashKeySerializer(stringRedisSerializer);
        // 设置Value的序列化
        template.setValueSerializer(jsonRedisSerializer);
        template.setHashValueSerializer(jsonRedisSerializer);
        // 返回
        return template;
    }
}

最终结果如图:

  • 当存储字符串时

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第78张图片

  • 当存储对象时

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第79张图片

整体可读性有了很大提升,并且能将Java对象自动的序列化为JSON字符串,并且查询时能自动把JSON反序列化为Java对象。不过,其中记录了序列化时对应的class名称,目的是为了查询时实现自动反序列化。这会带来额外的内存开销。

注意:如果运行后报下面的错误,可能是需要引入 jackson-databind

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第80张图片

8.3 StringRedisTemplate

尽管JSON的序列化方式可以满足我们的需求,但依然存在一些问题,如图:

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第81张图片

为了在反序列化时知道对象的类型,JSON序列化器会将类的class类型写入json结果中,存入Redis,会带来额外的内存开销。

为了减少内存的消耗,我们可以采用手动序列化的方式。换句话说,就是不借助默认的序列化器,而是我们自己来控制序列化的动作,同时,我们只采用String的序列化器,这样,在存储value时,我们就不需要在内存中就不用多存储数据,从而节约我们的内存空间

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第82张图片

这种用法比较普遍,因此SpringDataRedis就提供了RedisTemplate的子类:StringRedisTemplate,它的key和value的序列化方式默认就是String方式。

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第83张图片

省去了我们自定义RedisTemplate的序列化方式的步骤,而是直接使用:

@SpringBootTest
class RedisTemplateTests {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;


    @Test
    void testString() {
        // 写入一条String数据
        stringRedisTemplate.opsForValue().set("name", "大李");
        // 获取String数据
        Object name = stringRedisTemplate.opsForValue().get("name");
        System.out.println("name"+name);
    }


    @Test
    public void testSaveUser() throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
        //创建对象
        User user = new User("大李", 21);
        //手动序列化(这里也可以使用fastjson的相关方法)
        String json = mapper.writeValueAsString(user);
        //写入数据
        stringRedisTemplate.opsForValue().set("user:200",json);
        //获取数据
        String jsonUser =  stringRedisTemplate.opsForValue().get("user:200");
        User user1 = mapper.readValue(jsonUser, User.class);
        System.out.println("user1:"+user1);
    }
}

此时我们再来看一看存储的数据,小伙伴们就会发现那个class数据已经不在了,节约了我们的空间~

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第84张图片

总结:RedisTemplate的两种序列化实践方案

  • 方案一:

    • 自定义RedisTemplate
    • 修改RedisTemplate的序列化器为GenericJackson2JsonRedisSerializer
  • 方案二:

    • 使用StringRedisTemplate
    • 写入Redis时,手动把对象序列化为JSON
    • 读取Redis时,手动把读取到的JSON反序列化为对象

8.4 Hash结构操作

在基础篇的最后,咱们对Hash结构操作一下,收一个小尾巴,这个代码咱们就不再解释啦

马上就开始新的篇章~~~进入到我们的Redis实战篇

@SpringBootTest
class RedisStringTests {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;


    @Test
    void testHash(){
        stringRedisTemplate.opsForHash().put("user:400","name","大李");
        stringRedisTemplate.opsForHash().put("user:400","age","21");
		// 获取所有的键值对
        Map <Object, Object> entries = stringRedisTemplate.opsForHash().entries("user:400");
        System.out.println("entries = "+entries);
		// 获取所有的keys
        Set <Object> keys = stringRedisTemplate.opsForHash().keys("user:400");
        System.out.println("keys = "+keys);
        //获取所有的values
        List <Object> values = stringRedisTemplate.opsForHash().values("user:400");
        System.out.println("values = "+values);
    }
}

结果如下:

《Redis基础篇》带你走进Redis的世界 ~ ⭐必看必看⭐_第85张图片

你可能感兴趣的:(Redis从入门到入土,redis,java,数据库)