• 狂神Redis笔记(上)

    狂神bilibili视频地址：：

    https://www.bilibili.com/video/BV1S54y1R7SB

    一、Nosql概述

    为什么使用Nosql

    1、单机Mysql时代

    在这里插入图片描述

    90年代,一个网站的访问量一般不会太大，单个数据库完全够用。随着用户增多，网站出现以下问题

    1. 数据量增加到一定程度，单机数据库就放不下了
    2. 数据的索引（B+ Tree）,一个机器内存也存放不下
    3. 访问量变大后（读写混合），一台服务器承受不住。

    2、Memcached(缓存) + Mysql + 垂直拆分（读写分离）

    网站80%的情况都是在读，每次都要去查询数据库的话就十分的麻烦！所以说我们希望减轻数据库的压力，我们可以使用缓存来保证效率！

    在这里插入图片描述

    优化过程经历了以下几个过程：

    1. 优化数据库的数据结构和索引(难度大)

    2. 文件缓存，通过IO流获取比每次都访问数据库效率略高，但是流量爆炸式增长时候，IO流也承受不了

    3. MemCache,当时最热门的技术，通过在数据库和数据库访问层之间加上一层缓存，第一次访问时查询数据库，将结果保存到缓存，后续的查询先检查缓存，若有直接拿去使用，效率显著提升。

    3、分库分表 + 水平拆分 + Mysql集群

    在这里插入图片描述

    4、如今最近的年代

    ​ 如今信息量井喷式增长，各种各样的数据出现（用户定位数据，图片数据等），大数据的背景下关系型数据库（RDBMS）无法满足大量数据要求。Nosql数据库就能轻松解决这些问题。

    目前一个基本的互联网项目

    在这里插入图片描述

    为什么要用NoSQL ？

    用户的个人信息，社交网络，地理位置。用户自己产生的数据，用户日志等等爆发式增长！
    这时候我们就需要使用NoSQL数据库的，Nosql可以很好的处理以上的情况！

    什么是Nosql

    NoSQL = Not Only SQL（不仅仅是SQL）

    Not Only Structured Query Language

    关系型数据库：列+行，同一个表下数据的结构是一样的。

    非关系型数据库：数据存储没有固定的格式，并且可以进行横向扩展。

    NoSQL泛指非关系型数据库，随着web2.0互联网的诞生，传统的关系型数据库很难对付web2.0时代！尤其是超大规模的高并发的社区，暴露出来很多难以克服的问题，NoSQL在当今大数据环境下发展的十分迅速，Redis是发展最快的。

    Nosql特点

    1. 方便扩展（数据之间没有关系，很好扩展！）

    2. 大数据量高性能（Redis一秒可以写8万次，读11万次，NoSQL的缓存记录级，是一种细粒度的缓存，性能会比较高！）

    3. 数据类型是多样型的！（不需要事先设计数据库，随取随用）

    4. 传统的 RDBMS 和 NoSQL

      传统的 RDBMS(关系型数据库)
- 结构化组织
- SQL
- 数据和关系都存在单独的表中 row col
- 操作，数据定义语言
- 严格的一致性
- 基础的事务
- ...
      Nosql
- 不仅仅是数据
- 没有固定的查询语言
- 键值对存储，列存储，文档存储，图形数据库（社交关系）
- 最终一致性
- CAP定理和BASE
- 高性能，高可用，高扩展
- ...　

    了解：3V + 3高

    大数据时代的3V ：主要是描述问题的

    1. 海量Velume

    2. 多样Variety

    3. 实时Velocity

    大数据时代的3高 ： 主要是对程序的要求

    1. 高并发

    2. 高可扩

    3. 高性能

    真正在公司中的实践：NoSQL + RDBMS 一起使用才是最强的。

    阿里巴巴演进分析

    推荐阅读：阿里云的这群疯子https://yq.aliyun.com/articles/653511

    1

    在这里插入图片描述

    # 商品信息
- 一般存放在关系型数据库：Mysql,阿里巴巴使用的Mysql都是经过内部改动的。

# 商品描述、评论(文字居多)
- 文档型数据库：MongoDB

# 图片
- 分布式文件系统 FastDFS
- 淘宝：TFS
- Google: GFS
- Hadoop: HDFS
- 阿里云: oss

# 商品关键字 用于搜索
- 搜索引擎：solr,elasticsearch
- 阿里：Isearch 多隆

# 商品热门的波段信息
- 内存数据库：Redis，Memcache

# 商品交易，外部支付接口
- 第三方应用

    Nosql的四大分类

    KV键值对

    • 新浪：Redis
    • 美团：Redis + Tair
    • 阿里、百度：Redis + Memcache

    文档型数据库（bson数据格式）：

    • MongoDB(掌握)

      • 基于分布式文件存储的数据库。C++编写，用于处理大量文档。
      • MongoDB是RDBMS和NoSQL的中间产品。MongoDB是非关系型数据库中功能最丰富的，NoSQL中最像关系型数据库的数据库。

    • ConthDB

    列存储数据库

    • HBase(大数据必学)
    • 分布式文件系统

    图关系数据库

    用于广告推荐，社交网络

    • Neo4j、InfoGrid
    分类Examples举例典型应用场景数据模型优点缺点
    键值对（key-value） Tokyo Cabinet/Tyrant, Redis, Voldemort, Oracle BDB 内容缓存，主要用于处理大量数据的高访问负载，也用于一些日志系统等等。 Key 指向 Value 的键值对，通常用hash table来实现 查找速度快 数据无结构化，通常只被当作字符串或者二进制数据
    列存储数据库 Cassandra, HBase, Riak 分布式的文件系统 以列簇式存储，将同一列数据存在一起 查找速度快，可扩展性强，更容易进行分布式扩展 功能相对局限
    文档型数据库 CouchDB, MongoDb Web应用（与Key-Value类似，Value是结构化的，不同的是数据库能够了解Value的内容） Key-Value对应的键值对，Value为结构化数据 数据结构要求不严格，表结构可变，不需要像关系型数据库一样需要预先定义表结构 查询性能不高，而且缺乏统一的查询语法。
    图形(Graph)数据库 Neo4J, InfoGrid, Infinite Graph 社交网络，推荐系统等。专注于构建关系图谱 图结构 利用图结构相关算法。比如最短路径寻址，N度关系查找等 很多时候需要对整个图做计算才能得出需要的信息，而且这种结构不太好做分布式的集群

    二、Redis入门

    Redis是什么？

    Redis（Remote Dictionary Server )，即远程字典服务。

    是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。

    与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。

    Redis能该干什么？

    1. 内存存储、持久化，内存是断电即失的，所以需要持久化（RDB、AOF）
    2. 高效率、用于高速缓冲
    3. 发布订阅系统
    4. 地图信息分析
    5. 计时器、计数器(eg：浏览量)
    6. 。。。

    特性

    1. 多样的数据类型

    2. 持久化

    3. 集群

    4. 事务

      …

    环境搭建

    官网：https://redis.io/

    推荐使用Linux服务器学习。

    windows版本的Redis已经停更很久了…

    Windows安装

    https://github.com/dmajkic/redis

    解压安装包
    在这里插入图片描述

    1、开启redis-server.exe

    2、启动redis-cli.exe测试

    在这里插入图片描述

    Linux安装(可以使用宝塔一键部署！)

    1. 下载安装包！redis-5.0.8.tar.gz

    2. 解压Redis的安装包！程序一般放在 /opt 目录下

      在这里插入图片描述

    3. 基本环境安装

    yum install gcc-c++
# 然后进入redis目录下执行
make
# 然后执行
make install

    在这里插入图片描述

    4、redis默认安装路径 /usr/local/bin

    在这里插入图片描述

    5、将redis的配置文件复制到 程序安装目录 /usr/local/bin/kconfig下

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hxvGQ47d-1597890996509)(狂神说 Redis.assets/image-20200813114000868.png)]

    6、redis默认不是后台启动的，需要修改配置文件！

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dDdKTUgd-1597890996510)(狂神说 Redis.assets/image-20200813114019063.png)]

    7、通过制定的配置文件启动redis服务

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jOypL57Z-1597890996511)(狂神说 Redis.assets/image-20200813114030597.png)]

    8、使用redis-cli连接指定的端口号测试，Redis的默认端口6379

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LnDaISQ4-1597890996512)(狂神说 Redis.assets/image-20200813114045299.png)]

    9、查看redis进程是否开启

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9PhN1jC1-1597890996513)(狂神说 Redis.assets/image-20200813114103769.png)]

    10、关闭Redis服务 shutdown

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Y54EuOYm-1597890996514)(狂神说 Redis.assets/image-20200813114116691.png)]

     redis的启动方式：

    1.直接启动
      进入redis根目录，执行命令:
      #加上‘&’号使redis以后台程序方式运行

    ./redis-server &

     2.通过指定配置文件启动
      可以为redis服务启动指定配置文件，例如配置为/etc/redis/6379.conf
      进入redis根目录，输入命令：

    ./redis-server /etc/redis/6379.conf

     #如果更改了端口，使用`redis-cli`客户端连接时，也需要指定端口，例如：

    redis-cli -p 6378

    使用客户端远程连接工具连接Redis

    Redis客户端可视化工具，以及Redis官网下载的Redis都放在这里面了,自取：

    https://www.lanzouq.com/b020t1zud
    密码:fund

    先来说说遇到的坑，在使用客户端工具进行远程连接Redis的时候，出现了read time out错误，参照着大神们的操作按理来说是没有问题的啊，现在来说正确的步骤：

    第一步：关闭防火墙
	1:查看防火状态
		systemctl status firewalld
		service  iptables status
		firewall-cmd --state
	    systemctl list-unit-files|grep firewalld.service
	2:暂时关闭防火墙
		systemctl stop firewalld
		service  iptables stop
	3:永久关闭防火墙
		systemctl disable firewalld
		chkconfig iptables off
	4:重启防火墙
		firewall-cmd --reload
		service iptables restart
		systemctl restart firewalld.service
	5:禁止开机自启
		systemctl disable firewalld.service
		chkconfig iptables off 
第二步：开放6379端口
		我这里使用的是阿里云的服务器，登录阿里云配置安全组规则开放端口即可，如果使用的是其他厂商的服务器
		请自行查阅开放端口的规则
第三步：修改配置文件(redis.conf)
		1.注释这一句,它限制了只能通过本机进行访问：bind 127.0.0.1
		2.将protected-mode配置项设为no
			配置文件中protected-mode配置项默认开启yes，redis处于保护模式状态，会拒绝来自其它主机的连接。
		3.设置密码：requirepass 123456
第四步：使用配置文件重启启动redis
		./redis-server ./redis.conf &
第五步：远程连接
		redis-cli -h IP地址 -p 6379 -a 密码

    测试性能

    **redis-benchmark：**Redis官方提供的性能测试工具，参数选项如下：

    img

    简单测试：进入到redis的安装目录（www/server/redis/src）

    # 测试：100个并发连接 100000请求
redis-benchmark -h localhost -p 6379 -c 100 -n 100000

    　　

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-plMshjFg-1597890996515)(狂神说 Redis.assets/image-20200813114143365.png)]

    redis默认有16个数据库

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-v2S3n3Si-1597890996516)(狂神说 Redis.assets/image-20200813114158322.png)]

    默认使用的第0个;

16个数据库为：DB 0~DB 15
默认使用DB 0 ，可以使用select n切换到DB n，dbsize可以查看当前数据库的大小，与key数量相关。

127.0.0.1:6379> config get databases # 命令行查看数据库数量databases
1) "databases"
2) "16"

127.0.0.1:6379> select 8 # 切换数据库 DB 8
OK
127.0.0.1:6379[8]> dbsize # 查看数据库大小
(integer) 0

# 不同数据库之间 数据是不能互通的，并且dbsize 是根据库中key的个数。
127.0.0.1:6379> set name sakura 
OK
127.0.0.1:6379> SELECT 8
OK
127.0.0.1:6379[8]> get name # db8中并不能获取db0中的键值对。
(nil)
127.0.0.1:6379[8]> DBSIZE
(integer) 0
127.0.0.1:6379[8]> SELECT 0
OK
127.0.0.1:6379> keys *
1) "counter:__rand_int__"
2) "mylist"
3) "name"
4) "key:__rand_int__"
5) "myset:__rand_int__"
127.0.0.1:6379> DBSIZE # size和key个数相关
(integer) 5

    keys * ：查看当前数据库中所有的key。

    flushdb：清空当前数据库中的键值对。

    flushall：清空所有数据库的键值对。

    Redis是单线程的，Redis是基于内存操作的。

    所以Redis的性能瓶颈不是CPU,而是机器内存和网络带宽。

    那么为什么Redis的速度如此快呢，性能这么高呢？QPS达到10W+

    Redis为什么单线程还这么快？

    • 误区1：高性能的服务器一定是多线程的？
    • 误区2：多线程（CPU上下文会切换！）一定比单线程效率高！

    核心：Redis是将所有的数据放在内存中的，所以说使用单线程去操作效率就是最高的，多线程（CPU上下文会切换：耗时的操作！），对于内存系统来说，如果没有上下文切换效率就是最高的，多次读写都是在一个CPU上的，在内存存储数据情况下，单线程就是最佳的方案。

    三、五大数据类型

    ​　　Redis是一个开源（BSD许可），内存存储的数据结构服务器，可用作数据库，高速缓存和消息队列代理。它支持字符串、哈希表、列表、集合、有序集合，位图，hyperloglogs等数据类型。内置复制、Lua脚本、LRU收回、事务以及不同级别磁盘持久化功能，同时通过Redis Sentinel提供高可用，通过Redis Cluster提供自动分区。

    Redis-key

    在redis中无论什么数据类型，在数据库中都是以key-value形式保存，通过进行对Redis-key的操作，来完成对数据库中数据的操作。

    下面学习的命令：

    • keys *          : 获取当前数据库所有的key
    • set key value      : 设置key的值
    • get key        : 获取key的值
    • exists key    : 判断键是否存在
    • del key        : 删除key
    • move key db : 移动当前数据库的key到哪个数据库(db)
    • expire key 秒 ：设置key的过期时间，超过时间后，将会自动删除该key
    • ...

    关于TTL命令

    Redis的key，通过TTL命令返回key的过期时间，一般来说有3种：

    1. 当前key没有设置过期时间，所以会返回-1.
    2. 当前key有设置过期时间，而且key已经过期，所以会返回-2.
    3. 当前key有设置过期时间，且key还没有过期，故会返回key的正常剩余时间.

    关于重命名RENAME和RENAMENX

    • RENAME key newkey修改 key 的名称
    • RENAMENX key newkey仅当 newkey 不存在时，将 key 改名为 newkey 。

    更多命令学习：https://www.redis.net.cn/order/

    String(字符串)

    普通的set、get直接略过

    命令描述示例
    APPEND key value 向指定的key的value后追加字符串 127.0.0.1:6379> set msg hello OK 127.0.0.1:6379> append msg " world" (integer) 11 127.0.0.1:6379> get msg “hello world”
    DECR/INCR key 将指定key的value数值进行+1/-1(仅对于数字) 127.0.0.1:6379> set age 20 OK 127.0.0.1:6379> incr age (integer) 21 127.0.0.1:6379> decr age (integer) 20
    INCRBY/DECRBY key n 按指定的步长对数值进行加减 127.0.0.1:6379> INCRBY age 5 (integer) 25 127.0.0.1:6379> DECRBY age 10 (integer) 15
    INCRBYFLOAT key n 为数值加上浮点型数值 127.0.0.1:6379> INCRBYFLOAT age 5.2 “20.2”
    STRLEN key 获取key保存值的字符串长度 127.0.0.1:6379> get msg “hello world” 127.0.0.1:6379> STRLEN msg (integer) 11
    GETRANGE key start end 按起止位置获取字符串（闭区间，起止位置都取） 127.0.0.1:6379> get msg “hello world” 127.0.0.1:6379> GETRANGE msg 3 9 “lo worl”
    SETRANGE key offset value 用指定的value 替换key中 offset开始的值 127.0.0.1:6379> SETRANGE msg 2 hello (integer) 7 127.0.0.1:6379> get msg “tehello”
    GETSET key value 将给定 key 的值设为 value ，并返回 key 的旧值(old value)。 127.0.0.1:6379> GETSET msg test “hello world”
    SETNX key value 仅当key不存在时进行set 127.0.0.1:6379> SETNX msg test (integer) 0 127.0.0.1:6379> SETNX name sakura (integer) 1
    SETEX key seconds value set 键值对并设置过期时间 127.0.0.1:6379> setex name 10 root OK 127.0.0.1:6379> get name (nil)
    MSET key1 value1 [key2 value2..] 批量set键值对 127.0.0.1:6379> MSET k1 v1 k2 v2 k3 v3 OK
    MSETNX key1 value1 [key2 value2..] 批量设置键值对，仅当参数中所有的key都不存在时执行 127.0.0.1:6379> MSETNX k1 v1 k4 v4 (integer) 0
    MGET key1 [key2..] 批量获取多个key保存的值 127.0.0.1:6379> MGET k1 k2 k3 1) “v1” 2) “v2” 3) “v3”
    PSETEX key milliseconds value 和 SETEX 命令相似，但它以毫秒为单位设置 key 的生存时间，  
    getset key value 如果不存在值，则返回nil，如果存在值，获取原来的值，并设置新的值  
    String类似的使用场景：value除了是字符串还可以是数字，用途举例：
    • 计数器
    • 统计多单位的数量：uid:123666：follow 0
    • 粉丝数
    • 对象存储缓存

    List(列表)

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

    一个列表最多可以包含 232 - 1 个元素 (4294967295, 每个列表超过40亿个元素)。

    首先我们列表，可以经过规则定义将其变为队列、栈、双端队列等

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VPvbIltc-1597890996518)(狂神说 Redis.assets/image-20200813114255459.png)]

    正如图Redis中List是可以进行双端操作的，所以命令也就分为了LXXX和RLLL两类，有时候L也表示List例如LLEN

    命令描述
    LPUSH/RPUSH key value1[value2..] 从从此队列的左边/右边向列表中PUSH值(一个或者多个)。
    LRANGE key start end 获取list 起止元素（索引从左往右 递增） lrange key 0 -1
    LPUSHX/RPUSHX key value 向已存在的列名中push值（一个或者多个）
    LINSERT key BEFORE|AFTER pivot value 在指定列表元素的前/后 插入value
    LLEN key 查看列表长度
    LINDEX key index 通过索引获取列表元素
    LSET key index value 通过索引为元素设值
    LPOP/RPOP key 从最左边/最右边移除值 并返回
    RPOPLPUSH source destination 将列表的尾部(右)最后一个值弹出，并返回，然后加到另一个列表的头部
    LTRIM key start end 通过下标截取指定范围内的列表
    LREM key count value List中是允许value重复的 count > 0：从头部开始搜索 然后删除指定的value 至多删除count个 count < 0：从尾部开始搜索… count = 0：删除列表中所有的指定value。
    BLPOP/BRPOP key1[key2] timout 移出并获取列表的第一个/最后一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。
    BRPOPLPUSH source destination timeout 和RPOPLPUSH功能相同，如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。

    　

    　

     lpush：在队列的左/右 插入数据

    #########################
127.0.0.1:6379> LPUSH list1 "one" "two" "three"
(integer) 3
127.0.0.1:6379> LRANGE list1 0 -1
1) "three"
2) "two"
3) "one"
#########################
127.0.0.1:6379> RPUSH list2 "one" "two" "three"
(integer) 3
127.0.0.1:6379> LRANGE list2 0 -1
1) "one"
2) "two"
3) "three"
#########################

    lrange：移除队列左(第一个)/右(最后一个)元素

    127.0.0.1:6379> LRANGE list1 0 -1
1) "three"
2) "two"
3) "one"
127.0.0.1:6379> LPOP list1
"three"
127.0.0.1:6379> RPOP list1
"one"

    lindex：获取队列的元素下标对应的元素 和 返回队列长度

    #######################
127.0.0.1:6379> LRANGE list2 0 -1
1) "one"
2) "two"
3) "three"
127.0.0.1:6379> LINDEX list2 0
"one"
#######################
127.0.0.1:6379> LLEN list2
(integer) 3

    lrem：移除元素：移除集合中指定个数的value

    #######################
127.0.0.1:6379> LRANGE list2 0 -1
1) "one"
2) "two"
3) "three"
127.0.0.1:6379> LREM list2 1 two
(integer) 1
127.0.0.1:6379> LRANGE list2 0 -1
1) "one"
2) "three"
#######################

    rpoplpush：删除列表的最后一个元素，并将其移动到新的列表当中（不存在会创建）

    #############################
127.0.0.1:6379> LPUSH list "t1" "t2" "t3"
(integer) 3
127.0.0.1:6379> LRANGE list 0 -1
1) "t3"
2) "t2"
3) "t1"
127.0.0.1:6379> rpoplpush list list1 
"t1"
#############################
127.0.0.1:6379> LRANGE list1 0 -1
1) "t1"
#############################

    lset：设置队列里面一个元素的值（修改0号下标元素的值为xxx）

    #############################
127.0.0.1:6379> lrange list1 0 -1
1) "t2"
2) "t1"
127.0.0.1:6379> lset list1 0 "test"
OK
127.0.0.1:6379> lrange list1 0 -1
1) "test"
2) "t1"
#############################

    linsert：在列表的指定元素的前面/后面插入一个元素

    #############################
127.0.0.1:6379> lpush mylist "hello" "world"
(integer) 2
#############################
127.0.0.1:6379> lrange mylist 0 -1
1) "world"
2) "hello"
127.0.0.1:6379> linsert mylist before "hello" "zhixi"
(integer) 3
#############################
127.0.0.1:6379> lrange mylist 0 -1
1) "world"
2) "zhixi"
3) "hello"
#############################

    小结：　

    • 他实际上是一-个链表, before Node after，left , right都可以插入值
    • 如果key不存在,创建新的链表
    • 如果key存在,新增内容
    • 如果移除了所有key，表示是一个空链表(不存在)
    • 在两边插入或者改动值,效率最高!中间元素,相对来说效率会低一点~

    Set(集合)

    　　Redis的Set是string类型的无序集合。集合成员是唯一的，这就意味着集合中不能出现重复的数据。

    Redis 中 集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是O(1)。

    集合中最大的成员数为 232 - 1 (4294967295, 每个集合可存储40多亿个成员)。

    命令 描述：

    ---------------SADD--SCARD--SMEMBERS--SISMEMBER--------------------

127.0.0.1:6379> SADD myset m1 m2 m3 m4 # 向myset中增加成员 m1~m4
(integer) 4
127.0.0.1:6379> SCARD myset # 获取集合的成员数目
(integer) 4
127.0.0.1:6379> smembers myset # 获取集合中所有成员
1) "m4"
2) "m3"
3) "m2"
4) "m1"
127.0.0.1:6379> SISMEMBER myset m5 # 查询m5是否是myset的成员
(integer) 0 # 不是，返回0
127.0.0.1:6379> SISMEMBER myset m2
(integer) 1 # 是，返回1
127.0.0.1:6379> SISMEMBER myset m3
(integer) 1

---------------------SRANDMEMBER--SPOP----------------------------------

127.0.0.1:6379> SRANDMEMBER myset 3 # 随机返回3个成员
1) "m2"
2) "m3"
3) "m4"
127.0.0.1:6379> SRANDMEMBER myset # 随机返回1个成员
"m3"
127.0.0.1:6379> SPOP myset 2 # 随机移除并返回2个成员
1) "m1"
2) "m4"
# 将set还原到{m1,m2,m3,m4}

---------------------SMOVE--SREM----------------------------------------

127.0.0.1:6379> SMOVE myset newset m3 # 将myset中m3成员移动到newset集合
(integer) 1
127.0.0.1:6379> SMEMBERS myset
1) "m4"
2) "m2"
3) "m1"
127.0.0.1:6379> SMEMBERS newset
1) "m3"
127.0.0.1:6379> SREM newset m3 # 从newset中移除m3元素
(integer) 1
127.0.0.1:6379> SMEMBERS newset
(empty list or set)

# 下面开始是多集合操作,多集合操作中若只有一个参数默认和自身进行运算
# setx=>{m1,m2,m4,m6}, sety=>{m2,m5,m6}, setz=>{m1,m3,m6}

-----------------------------SDIFF------------------------------------

127.0.0.1:6379> SDIFF setx sety setz # 等价于setx-sety-setz
1) "m4"
127.0.0.1:6379> SDIFF setx sety # setx - sety
1) "m4"
2) "m1"
127.0.0.1:6379> SDIFF sety setx # sety - setx
1) "m5"


-------------------------SINTER---------------------------------------
# 共同关注（交集）

127.0.0.1:6379> SINTER setx sety setz # 求 setx、sety、setx的交集
1) "m6"
127.0.0.1:6379> SINTER setx sety # 求setx sety的交集
1) "m2"
2) "m6"

-------------------------SUNION---------------------------------------

127.0.0.1:6379> SUNION setx sety setz # setx sety setz的并集
1) "m4"
2) "m6"
3) "m3"
4) "m2"
5) "m1"
6) "m5"
127.0.0.1:6379> SUNION setx sety # setx sety 并集
1) "m4"
2) "m6"
3) "m2"
4) "m1"
5) "m5"

    Hash（哈希）

    Redis hash 是一个string类型的field和value的映射表，hash特别适合用于存储对象。

Set就是一种简化的Hash,只变动key,而value使用默认值填充。可以将一个Hash表作为一个对象进行存储，表中存放对象的信息。

    命令 描述

    ------------------------HSET--HMSET--HSETNX----------------
127.0.0.1:6379> HSET studentx name sakura # 将studentx哈希表作为一个对象，设置name为sakura
(integer) 1
127.0.0.1:6379> HSET studentx name gyc # 重复设置field进行覆盖，并返回0
(integer) 0
127.0.0.1:6379> HSET studentx age 20 # 设置studentx的age为20
(integer) 1
127.0.0.1:6379> HMSET studentx sex 1 tel 15623667886 # 设置sex为1，tel为15623667886
OK
127.0.0.1:6379> HSETNX studentx name gyc # HSETNX 设置已存在的field
(integer) 0 # 失败
127.0.0.1:6379> HSETNX studentx email 12345@qq.com
(integer) 1 # 成功

----------------------HEXISTS--------------------------------
127.0.0.1:6379> HEXISTS studentx name # name字段在studentx中是否存在
(integer) 1 # 存在
127.0.0.1:6379> HEXISTS studentx addr
(integer) 0 # 不存在

-------------------HGET--HMGET--HGETALL-----------
127.0.0.1:6379> HGET studentx name # 获取studentx中name字段的value
"gyc"
127.0.0.1:6379> HMGET studentx name age tel # 获取studentx中name、age、tel字段的value
1) "gyc"
2) "20"
3) "15623667886"
127.0.0.1:6379> HGETALL studentx # 获取studentx中所有的field及其value
1) "name"
2) "gyc"
3) "age"
4) "20"
5) "sex"
6) "1"
7) "tel"
8) "15623667886"
9) "email"
10) "12345@qq.com"


--------------------HKEYS--HLEN--HVALS--------------
127.0.0.1:6379> HKEYS studentx # 查看studentx中所有的field
1) "name"
2) "age"
3) "sex"
4) "tel"
5) "email"
127.0.0.1:6379> HLEN studentx # 查看studentx中的字段数量
(integer) 5
127.0.0.1:6379> HVALS studentx # 查看studentx中所有的value
1) "gyc"
2) "20"
3) "1"
4) "15623667886"
5) "12345@qq.com"

-------------------------HDEL--------------------------
127.0.0.1:6379> HDEL studentx sex tel # 删除studentx 中的sex、tel字段
(integer) 2
127.0.0.1:6379> HKEYS studentx
1) "name"
2) "age"
3) "email"

-------------HINCRBY--HINCRBYFLOAT------------------------
127.0.0.1:6379> HINCRBY studentx age 1 # studentx的age字段数值+1
(integer) 21
127.0.0.1:6379> HINCRBY studentx name 1 # 非整数字型字段不可用
(error) ERR hash value is not an integer
127.0.0.1:6379> HINCRBYFLOAT studentx weight 0.6 # weight字段增加0.6
"90.8"

    ​ Hash变更的数据user name age，尤其是用户信息之类的，经常变动的信息！Hash更适合于对象的存储，Sring更加适合字符串存储！

    Zset（有序集合）
    不同的是每个元素都会关联一个double类型的分数（score）。redis正是通过分数来为集合中的成员进行从小到大的排序。

    score相同：按字典顺序排序

    有序集合的成员是唯一的,但分数(score)却可以重复。

    命令 描述：http://www.redis.cn/commands.html#sorted_set

     

    -------------------ZADD--ZCARD--ZCOUNT--------------
127.0.0.1:6379> ZADD myzset 1 m1 2 m2 3 m3 # 向有序集合myzset中添加成员m1 score=1 以及成员m2 score=2..
(integer) 2
127.0.0.1:6379> ZCARD myzset # 获取有序集合的成员数
(integer) 2
127.0.0.1:6379> ZCOUNT myzset 0 1 # 获取score在 [0,1]区间的成员数量
(integer) 1
127.0.0.1:6379> ZCOUNT myzset 0 2
(integer) 2

----------------ZINCRBY--ZSCORE--------------------------
127.0.0.1:6379> ZINCRBY myzset 5 m2 # 将成员m2的score +5
"7"
127.0.0.1:6379> ZSCORE myzset m1 # 获取成员m1的score
"1"
127.0.0.1:6379> ZSCORE myzset m2
"7"

--------------ZRANK--ZRANGE-----------------------------------
127.0.0.1:6379> ZRANK myzset m1 # 获取成员m1的索引，索引按照score排序，score相同索引值按字典顺序顺序增加
(integer) 0
127.0.0.1:6379> ZRANK myzset m2
(integer) 2
127.0.0.1:6379> ZRANGE myzset 0 1 # 获取索引在 0~1的成员
1) "m1"
2) "m3"
127.0.0.1:6379> ZRANGE myzset 0 -1 # 获取全部成员
1) "m1"
2) "m3"
3) "m2"

#testset=>{abc,add,amaze,apple,back,java,redis} score均为0
------------------ZRANGEBYLEX---------------------------------
127.0.0.1:6379> ZRANGEBYLEX testset - + # 返回所有成员
1) "abc"
2) "add"
3) "amaze"
4) "apple"
5) "back"
6) "java"
7) "redis"
127.0.0.1:6379> ZRANGEBYLEX testset - + LIMIT 0 3 # 分页 按索引显示查询结果的 0,1,2条记录
1) "abc"
2) "add"
3) "amaze"
127.0.0.1:6379> ZRANGEBYLEX testset - + LIMIT 3 3 # 显示 3,4,5条记录
1) "apple"
2) "back"
3) "java"
127.0.0.1:6379> ZRANGEBYLEX testset (- [apple # 显示 (-,apple] 区间内的成员
1) "abc"
2) "add"
3) "amaze"
4) "apple"
127.0.0.1:6379> ZRANGEBYLEX testset [apple [java # 显示 [apple,java]字典区间的成员
1) "apple"
2) "back"
3) "java"

-----------------------ZRANGEBYSCORE---------------------
127.0.0.1:6379> ZRANGEBYSCORE myzset 1 10 # 返回score在 [1,10]之间的的成员
1) "m1"
2) "m3"
3) "m2"
127.0.0.1:6379> ZRANGEBYSCORE myzset 1 5
1) "m1"
2) "m3"

--------------------ZLEXCOUNT-----------------------------
127.0.0.1:6379> ZLEXCOUNT testset - +
(integer) 7
127.0.0.1:6379> ZLEXCOUNT testset [apple [java
(integer) 3

------------------ZREM--ZREMRANGEBYLEX--ZREMRANGBYRANK--ZREMRANGEBYSCORE--------------------------------
127.0.0.1:6379> ZREM testset abc # 移除成员abc
(integer) 1
127.0.0.1:6379> ZREMRANGEBYLEX testset [apple [java # 移除字典区间[apple,java]中的所有成员
(integer) 3
127.0.0.1:6379> ZREMRANGEBYRANK testset 0 1 # 移除排名0~1的所有成员
(integer) 2
127.0.0.1:6379> ZREMRANGEBYSCORE myzset 0 3 # 移除score在 [0,3]的成员
(integer) 2


# testset=> {abc,add,apple,amaze,back,java,redis} score均为0
# myzset=> {(m1,1),(m2,2),(m3,3),(m4,4),(m7,7),(m9,9)}
----------------ZREVRANGE--ZREVRANGEBYSCORE--ZREVRANGEBYLEX-----------
127.0.0.1:6379> ZREVRANGE myzset 0 3 # 按score递减排序，然后按索引，返回结果的 0~3
1) "m9"
2) "m7"
3) "m4"
4) "m3"
127.0.0.1:6379> ZREVRANGE myzset 2 4 # 返回排序结果的 索引的2~4
1) "m4"
2) "m3"
3) "m2"
127.0.0.1:6379> ZREVRANGEBYSCORE myzset 6 2 # 按score递减顺序 返回集合中分数在[2,6]之间的成员
1) "m4"
2) "m3"
3) "m2"
127.0.0.1:6379> ZREVRANGEBYLEX testset [java (add # 按字典倒序 返回集合中(add,java]字典区间的成员
1) "java"
2) "back"
3) "apple"
4) "amaze"

-------------------------ZREVRANK------------------------------
127.0.0.1:6379> ZREVRANK myzset m7 # 按score递减顺序，返回成员m7索引
(integer) 1
127.0.0.1:6379> ZREVRANK myzset m2
(integer) 4


# mathscore=>{(xm,90),(xh,95),(xg,87)} 小明、小红、小刚的数学成绩
# enscore=>{(xm,70),(xh,93),(xg,90)} 小明、小红、小刚的英语成绩
-------------------ZINTERSTORE--ZUNIONSTORE-----------------------------------
127.0.0.1:6379> ZINTERSTORE sumscore 2 mathscore enscore # 将mathscore enscore进行合并 结果存放到sumscore
(integer) 3
127.0.0.1:6379> ZRANGE sumscore 0 -1 withscores # 合并后的score是之前集合中所有score的和
1) "xm"
2) "160"
3) "xg"
4) "177"
5) "xh"
6) "188"

127.0.0.1:6379> ZUNIONSTORE lowestscore 2 mathscore enscore AGGREGATE MIN # 取两个集合的成员score最小值作为结果的
(integer) 3
127.0.0.1:6379> ZRANGE lowestscore 0 -1 withscores
1) "xm"
2) "70"
3) "xg"
4) "87"
5) "xh"
6) "93"　

    应用案例：

    • set排序 存储班级成绩表 工资表排序！
    • 普通消息，1.重要消息 2.带权重进行判断
    • 排行榜应用实现，取Top N测试

    四、三种特殊数据类型

    Geospatial(地理位置)

    使用经纬度定位地理坐标并用一个有序集合zset保存，所以zset命令也可以使用

    命令 描述:经纬度坐标查询：https://jingweidu.bmcx.com/

    添加城市：

     计算两个城市之间的距离：

    返回地理空间的经纬度

     

    GEO底层实现原理是ZSet，可以通过Zset命令操作GEO

     

     Hyperloglog(基数统计)

    Redis HyperLogLog 是用来做基数统计的算法，HyperLogLog 的优点是，在输入元素的数量或者体积非常非常大时，计算基数所需的空间总是固定的、并且是很小的。

花费 12 KB 内存，就可以计算接近 2^64 个不同元素的基数。

    　　因为 HyperLogLog 只会根据输入元素来计算基数，而不会储存输入元素本身，所以 HyperLogLog 不能像集合那样，返回输入的各个元素。

    其底层使用string数据类型

    什么是基数？

    数据集中不重复的元素的个数。

    应用场景：

    网页的访问量（UV）：一个用户多次访问，也只能算作一个人。

    BitMaps(位图)

    　　统计用户信息，活跃,不活跃!登录、未登录!打卡, 365打卡!两个状态的,都可以使用Bitmaps !
    Bitmaps位图,数据结构!都是操作二进制位来进行记录,就只有0和1两个状态!
    365天= 365 bit 1字节=8bit 46 个字节左右!　　
    　　使用位存储，信息状态只有 0 和 1Bitmap是一串连续的2进制数字（0或1），每一位所在的位置为偏移(offset)，在bitmap上可执行AND,OR,XOR,NOT以及其它位操作。

    应用场景

    签到统计、状态统计

    　　0表示缺勤，1表示出勤进行统计：

     查看某一趟是否出勤：

     统计一周的出勤率：

    五、事务

    　　Redis的单条命令是保证原子性的，但是redis事务不能保证原子性

    Redis事务本质：一组命令的集合。

    事务中每条命令都会被序列化，执行过程中按顺序执行，不允许其他命令进行干扰。

    1. 一次性
    2. 顺序性
    3. 排他性
    4. Redis事务没有隔离级别的概念
    5. Redis单条命令是保证原子性的，但是事务不保证原子性！

    redis事务的操作过程：

    • 1. MULTI：        使用该命令，标记一个事务块的开始，通常在执行之后会回复OK，（但不一定真的OK），这个时候用户可以输入多个操作来代替逐条操作，redis会将这些操作放入队列中。
    • 2. EXEC：        执行这个事务内的所有命令
    • 3. DISCARD：  放弃事务，即该事务内的所有命令都将取消
    • 4. WATCH：     监控一个或者多个key，如果这些key在提交事务（EXEC）之前被其他用户修改过，那么事务将执行失败，需要重新获取最新数据重头操作（类似于乐观锁）。
    • 5. UNWATCH：取消WATCH命令对多有key的监控，所有监控锁将会被取消。

    测试：

    事务的执行：

     取消事务：

     

     redis中的异常：

    编译时异常(代码写错)：

     运行时异常(10/0)：如果事务队列存在语法性，那么我们在执行命令的时候，其他命令可以正常执行，错误的命令会抛出异常

    监控

    悲观锁：

    　　很悲观，认为什么时候都会出现问题，无论做什么都会加锁

    乐观锁：

    很乐观，认为什么时候都不会出现问题，所以不会上锁！更新数据的时候去判断一下，在此期间是否有人修改过这个数据

    • 获取version
    • 更新的时候比较version
    • 使用watch key监控指定数据，相当于乐观锁加锁。

    正常执行

    127.0.0.1:6379> set money 100 # 设置余额:100
OK
127.0.0.1:6379> set use 0 # 支出使用:0
OK
127.0.0.1:6379> watch money # 监视money (上锁)
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> DECRBY money 20
QUEUED
127.0.0.1:6379> INCRBY use 20
QUEUED
127.0.0.1:6379> exec # 监视值没有被中途修改，事务正常执行
1) (integer) 80
2) (integer) 20

    测试多线程修改值，使用watch可以当做redis的乐观锁操作（相当于getversion）

    我们启动另外一个客户端模拟插队线程。

    线程1：

    127.0.0.1:6379> watch money # money上锁
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> DECRBY money 20
QUEUED
127.0.0.1:6379> INCRBY use 20
QUEUED
127.0.0.1:6379> # 此时事务并没有执行

    模拟线程插队，线程2：

    127.0.0.1:6379> INCRBY money 500 # 修改了线程一中监视的money
(integer) 600

    回到线程1，执行事务：

    127.0.0.1:6379> EXEC # 执行之前，另一个线程修改了我们的值，这个时候就会导致事务执行失败
(nil) # 没有结果，说明事务执行失败

127.0.0.1:6379> get money # 线程2 修改生效
"600"
127.0.0.1:6379> get use # 线程1事务执行失败，数值没有被修改
"0"

    解锁获取最新值，然后再加锁进行事务。

    unwatch进行解锁。

    注意：每次提交执行exec后都会自动释放锁，不管是否成功

    六、Jedis

    　　使用Java来操作Redis，Jedis是Redis官方推荐使用的Java连接redis的客户端。

     1、编写项目并导入依赖

    创建一个新的maven项目，并添加依赖：

    <dependencies>
    <!--jedis依赖-->
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>3.5.1</version>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.75</version>
    </dependency>
</dependencies>

     2、服务器端口配置

    1.进入阿里云服务器管理控制台的安全组，开放端口6379（如果是用宝塔的也要记得要在宝塔中配置一下） 

    2.修改redis的配置文件：redis.config

    关掉保护模式

    3.重启redis服务

    ./redis-server /www/server/redis/redis.conf

    3、编写测试文件进行测试连通　　

     1 package com.zhixi;
 2 
 3 import redis.clients.jedis.Jedis;
 4 
 5 /**
 6  * @author zhangzhixi
 7  * @date 2021/2/28 21:36
 8  */
 9 public class TestPing {
10     public static void main(String[] args) {
11         Jedis jedis = new Jedis("182.92.209.212", 6379);
12         System.out.println(jedis.ping());
13     }
14 }

     

     4、事务

     1 package com.zhixi;
 2 
 3 import com.alibaba.fastjson.JSONObject;
 4 import redis.clients.jedis.Jedis;
 5 import redis.clients.jedis.Transaction;
 6 
 7 /**
 8  * @author zhangzhixi
 9  * @date 2021/2/28 21:36
10  */
11 public class TestPing {
12     public static void main(String[] args) {
13         // 连接redis
14         Jedis jedis = new Jedis("182.92.209.212", 6379);
15         jedis.flushDB();
16 
17         JSONObject jsonObject = new JSONObject();
18         jsonObject.put("name", "zhangsan");
19         jsonObject.put("age", 21);
20         // 开启事务
21         Transaction multi = jedis.multi();
22         String string = jsonObject.toJSONString();
23         try {
24             multi.set("key1", string);
25             multi.set("key2", string);
26             // 模拟错误
27             int i = 10 / 0;
28             // 执行事务
29             multi.exec();
30         } catch (Exception e) {
31             // 抛出异常就放弃事务
32             multi.discard();
33             e.printStackTrace();
34         } finally {
35             System.out.println(jedis.get("key1"));
36             System.out.println(jedis.get("key2"));
37             multi.close();
38         }
39     }
40 }

     7、SpringBoot整合

    　　SpringBoot 操作数据：spring-data jpa jdbc mongodb redis！

    SpringData 也是和 SpringBoot 齐名的项目！

    　　说明： 在 SpringBoot2.x 之后，原来使用的jedis 被替换为了 lettuce? 参考博客：https://blog.csdn.net/catoop/article/details/93756295

    jedis : 采用的直连，多个线程操作的话，是不安全的，如果想要避免不安全的，使用 jedis pool 连接池！ 更像 BIO 模式

    lettuce : 采用netty，实例可以再多个线程中进行共享，不存在线程不安全的情况！可以减少线程数据了，更像 NIO 模式

    源码分析：

    我们在学习SpringBoot自动配置的原理时，整合一个组件并进行配置一定会有一个自动配置类xxxAutoConfiguration,并且在spring.factories中也一定能找到这个类的完全限定名。Redis也不例外。

     

    那么就一定还存在一个RedisProperties类

     

    之前我们说SpringBoot2.x后默认使用Lettuce来替换Jedis，现在我们就能来验证了。

    先看Jedis:

     

     

    @ConditionalOnClass注解中有两个类是默认不存在的，所以Jedis是无法生效的

    然后再看Lettuce：

     

    完美生效。

    现在我们回到RedisAutoConfiguratio

     1 @Bean
 2 // 我们可以自己定义一个RedisTemplate来替换原本的这个
 3 @ConditionalOnMissingBean(name = "redisTemplate")
 4 public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)
 5         throws UnknownHostException {
 6     // 默认的RedisTemplate没有过多的设置，redis对象都是需要序列化！
 7     //  两个泛型都是object,object 的类型,我们如果要使用就需要进行强制转换<String,Object>
 8     RedisTemplate<Object, Object> template = new RedisTemplate<>();
 9     template.setConnectionFactory(redisConnectionFactory);
10     return template;
11 }
12 @Bean
13 @ConditionalOnMissingBean
14 // 由于String是redis中最常用的类型，所以单独提出来一个bean
15 public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory)
16         throws UnknownHostException {
17     StringRedisTemplate template = new StringRedisTemplate();
18     template.setConnectionFactory(redisConnectionFactory);
19     return template;
20 }　　

    只有两个简单的Bean

    • RedisTemplate
    • StringRedisTemplate

    当看到xxTemplate时可以对比RestTemplat、SqlSessionTemplate,通过使用这些Template来间接操作组件。那么这俩也不会例外。分别用于操作Redis和Redis中的String数据类型。

    在RedisTemplate上也有一个条件注解，说明我们是可以对其进行定制化的

    说完这些，我们需要知道如何编写配置文件然后连接Redis，就需要阅读RedisProperties

     

    这是一些基本的配置属性。

    还有一些连接池相关的配置。注意使用时一定使用Lettuce的连接池。

    整合测试

    1、导入依赖

    <dependencies>
        <!-- 操作redis -->
        <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>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>com.taobao.arthas</groupId>
            <artifactId>arthas-spring-boot-starter</artifactId>
            <version>3.4.3</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>
    View Code

    2、配置连接

    # ============配置redis============
spring.redis.host=182.92.209.212
# Redis服务器连接端口
spring.redis.port=6379
# Redis数据库索引（默认为0）
spring.redis.database=0
# Redis服务器连接密码（默认为空）
spring.redis.password=
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.pool.max-active=200
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool.max-wait=-1
# 连接池中的最大空闲连接
spring.redis.pool.max-idle=10
# 连接池中的最小空闲连接
spring.redis.pool.min-idle=0
# 连接超时时间（毫秒）
spring.redis.timeout=1000

    3、测试连接　

     @Test
    void contextLoads() {
        // redisTemplate
        // opsForValue() 操作字符串 类似 String
        // opsForList() 操作List 类似 List
        // opsForSet()
        // opsForHash()
        // opsForZSet()
        // opsForGeo()
        // opsForHyperLogLog()

        // 除了基本操作, 常用的方法都可以直接 redisTemplate 操作 例如事务的CRUD

        // 获取 redis 连接对象
//        RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
//        connection.flushDb();
//        connection.flushAll();


        redisTemplate.opsForValue().set("mykey", "xz");
        System.out.println(redisTemplate.opsForValue().get("mykey"));
    }

    序列化测试：

     1、实体类

    @Component
@AllArgsConstructor
@NoArgsConstructor
@Data
public class User {
    private String name;
    private int age;
}

    2、测试：

     @Test
    void test() throws JsonProcessingException {
        // 真实开发都是使用 json 来传递对象
        User user = new User("张三", 2);
        String jsonUser = new ObjectMapper().writeValueAsString(user);
        redisTemplate.opsForValue().set("user", user);  //set("user", jsonUser)
        System.out.println(redisTemplate.opsForValue().get("user"));
    }

    这种写法会报 org.springframework.data.redis.serializer.SerializationException: Cannot serialize; 错误　

    所有对象都需要序列化.

    • 使用json传递对象 set("user", jsonUser)
    • User 类实现 Serializable 接口

    3、编写自定义的 RedisConfig　

    import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.rmi.UnknownHostException;

/**
 * @author zhangzhixi
 */
@Configuration
public class RedisConfig {
    @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        // 自定义 String Object
        RedisTemplate<String, Object> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);

        // Json 序列化配置
        Jackson2JsonRedisSerializer<Object> objectJackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
        // ObjectMapper 转译
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        objectJackson2JsonRedisSerializer.setObjectMapper(objectMapper);

        // String 的序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

        // key 采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash 的key也采用 String 的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value 序列化方式采用 jackson
        template.setValueSerializer(objectJackson2JsonRedisSerializer);
        // hash 的 value 采用 jackson
        template.setHashValueSerializer(objectJackson2JsonRedisSerializer);
        template.afterPropertiesSet();

        return template;
    }
}

    RedisUtils：　　

    在企业开发中, 我们80%的情况下, 都不会使用原生方式去编写代码,这里编写一个工具类：

    package com.zhixi.utils;

/**
 * @author zhangzhixi
 * @date 2021/3/1 23:33
 */
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * @author mxz
 */
@Component
public final class RedisUtil {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 指定缓存失效时间
     *
     * @param key  键
     * @param time 时间(秒)
     * @return
     */
    public boolean expire(String key, long time) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据 key 获取过期时间
     *
     * @param key 键(不能为 Null)
     * @return 时间(秒) 返回0代表永久有效
     */
    public long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    /**
     * 判断 key 是否存在
     *
     * @param key 键(不能为 Null)
     * @return true 存在 false 不存在
     */
    public boolean hashKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除缓存
     *
     * @param key 可以传一个值 或多个
     */
    public void del(String... key) {
        if (key != null && key.length > 0) {
            redisTemplate.delete(key[0]);
        } else {
            redisTemplate.delete(CollectionUtils.arrayToList(key));
        }
    }


    //==================================String====================================

    /**
     * 普通缓存获取
     *
     * @param key 键
     * @return 值
     */
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 普通缓存放入
     *
     * @param key   键
     * @param value 值
     * @return true 成功 false 失败
     */
    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 普通缓存放入并设置时间
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒) time > 0 若 time <= 0 将设置无限期
     * @return true 成功 false 失败
     */
    public boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 递增
     *
     * @param key   键
     * @param delta 要增加几(大于0)
     * @return
     */
    public long incr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * 递减
     *
     * @param key   键
     * @param delta 要减少几(小于0)
     * @return
     */
    public long decr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().decrement(key, delta);
    }


    // ================================Map=================================

    /**
     * HashGet
     *
     * @param key  键 不能为null
     * @param item 项 不能为null
     */
    public Object hget(String key, String item) {
        return redisTemplate.opsForHash().get(key, item);
    }

    /**
     * 获取hashKey对应的所有键值
     *
     * @param key 键
     * @return 对应的多个键值
     */
    public Map<Object, Object> hmget(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * HashSet
     *
     * @param key 键
     * @param map 对应多个键值
     */
    public boolean hmset(String key, Map<String, Object> map) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * HashSet 并设置时间
     *
     * @param key  键
     * @param map  对应多个键值
     * @param time 时间(秒)
     * @return true成功 false失败
     */
    public boolean hmset(String key, Map<String, Object> map, long time) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 向一张hash表中放入数据,如果不存在将创建
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value, long time) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 删除hash表中的值
     *
     * @param key  键 不能为null
     * @param item 项 可以使多个 不能为null
     */
    public void hdel(String key, Object... item) {
        redisTemplate.opsForHash().delete(key, item);
    }


    /**
     * 判断hash表中是否有该项的值
     *
     * @param key  键 不能为null
     * @param item 项 不能为null
     * @return true 存在 false不存在
     */
    public boolean hHasKey(String key, String item) {
        return redisTemplate.opsForHash().hasKey(key, item);
    }


    /**
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
     *
     * @param key  键
     * @param item 项
     * @param by   要增加几(大于0)
     */
    public double hincr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }


    /**
     * hash递减
     *
     * @param key  键
     * @param item 项
     * @param by   要减少记(小于0)
     */
    public double hdecr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, -by);
    }


    // ============================set=============================

    /**
     * 根据key获取Set中的所有值
     *
     * @param key 键
     */
    public Set<Object> sGet(String key) {
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }


    /**
     * 根据value从一个set中查询,是否存在
     *
     * @param key   键
     * @param value 值
     * @return true 存在 false不存在
     */
    public boolean sHasKey(String key, Object value) {
        try {
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 将数据放入set缓存
     *
     * @param key    键
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSet(String key, Object... values) {
        try {
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }


    /**
     * 将set数据放入缓存
     *
     * @param key    键
     * @param time   时间(秒)
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSetAndTime(String key, long time, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().add(key, values);
            if (time > 0) {
                expire(key, time);
            }
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }


    /**
     * 获取set缓存的长度
     *
     * @param key 键
     */
    public long sGetSetSize(String key) {
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }


    /**
     * 移除值为value的
     *
     * @param key    键
     * @param values 值 可以是多个
     * @return 移除的个数
     */

    public long setRemove(String key, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().remove(key, values);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    // ===============================list=================================

    /**
     * 获取list缓存的内容
     *
     * @param key   键
     * @param start 开始
     * @param end   结束 0 到 -1代表所有值
     */
    public List<Object> lGet(String key, long start, long end) {
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }


    /**
     * 获取list缓存的长度
     *
     * @param key 键
     */
    public long lGetListSize(String key) {
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }


    /**
     * 通过索引 获取list中的值
     *
     * @param key   键
     * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
     */
    public Object lGetIndex(String key, long index) {
        try {
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }


    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     */
    public boolean lSet(String key, Object value) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     */
    public boolean lSet(String key, Object value, long time) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }

    }


    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @return
     */
    public boolean lSet(String key, List<Object> value) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }

    }


    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     * @return
     */
    public boolean lSet(String key, List<Object> value, long time) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 根据索引修改list中的某条数据
     *
     * @param key   键
     * @param index 索引
     * @param value 值
     * @return
     */

    public boolean lUpdateIndex(String key, long index, Object value) {
        try {
            redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 移除N个值为value
     *
     * @param key   键
     * @param count 移除多少个
     * @param value 值
     * @return 移除的个数
     */

    public long lRemove(String key, long count, Object value) {
        try {
            Long remove = redisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }

    }

    // ===============================HyperLogLog=================================

    public long pfadd(String key, String value) {
        return redisTemplate.opsForHyperLogLog().add(key, value);
    }

    public long pfcount(String key) {
        return redisTemplate.opsForHyperLogLog().size(key);
    }

    public void pfremove(String key) {
        redisTemplate.opsForHyperLogLog().delete(key);
    }

    public void pfmerge(String key1, String key2) {
        redisTemplate.opsForHyperLogLog().union(key1, key2);
    }


}
    View Code

    测试：

    @SpringBootTest
class Redis02SpringbootApplicationTests {

    @Autowired
    // 指定我们自己定义的redis序列化配置
    private RedisTemplate<String, Object> redisTemplate;

    @Autowired
    private RedisUtil redisUtil;
    @Test
    void test1() {
        // 清空数据库
        redisTemplate.getConnectionFactory().getConnection().flushDb();

        User user = new User("zhangsha", 23);
        redisUtil.set("user", user);
        System.out.println(redisUtil.get("user"));
    }
}

    更重要的是理解 Redis 的思想和每一种数据结构的用处以及作用场景. 

    小结：

    1. 导入依赖 
    2. 编写properties配置
    3. 编写RedisConfig配置(config/RedisConfig)
    4. 编写工具类配置(utils/RedisUtils)
    5. 编写代码

    8、Redis.conf详解

    1、单位

    配置文件 unit单位 对大小写不敏感！

    2.包含

    就是好比我们学习Spring中的Improt， include

     3、网络

    bind 127.0.0.1 # 绑定的ip
protected-mode yes # 保护模式 (如果需要远程连接需要自己开启为no！)
port 6379 # 端口设置

    4、通用GEBERAL

    daemonize yes # 以守护进程的方式运行，默认是no,需要我们自己开启为yes
 
pidfile /var/run/redis_6379.pid # 如果以后台的方式运行，我们就需要指定一个 pid 文件！
 
# 日志
# Specify the server verbosity level.
# This can be one of:
# debug (a lot of information, useful for development/testing)
# verbose (many rarely useful info, but not a mess like the debug level)
# notice (moderately verbose, what you want in production probably) 生产环境
# warning (only very important / critical messages are logged)
loglevel notice

    5、快照　　

    daemonize yes # 以守护进程的方式运行，默认是no,需要我们自己开启为yes
 
pidfile /var/run/redis_6379.pid # 如果以后台的方式运行，我们就需要指定一个 pid 文件！
 
# 日志
# Specify the server verbosity level.
# This can be one of:
# debug (a lot of information, useful for development/testing)
# verbose (many rarely useful info, but not a mess like the debug level)
# notice (moderately verbose, what you want in production probably) 生产环境
# warning (only very important / critical messages are logged)
loglevel notice

    6、SECURITY安全

    可以在这里设置Redis的密码，Redis默认是没有密码的　　

    127.0.0.1:6379> ping 
PONG 
127.0.0.1:6379> config get requirepass # 获取redis的密码 
1) "requirepass" 
2) "" 
127.0.0.1:6379> config set requirepass "123456" # 设置redis的密码
OK
127.0.0.1:6379> config get requirepass # 发现所有的命令都没有权限了
(error) NOAUTH Authentication required. 
127.0.0.1:6379> ping 
(error) NOAUTH Authentication required. 
127.0.0.1:6379> auth 123456 # 使用密码进行登录！ 
OK
127.0.0.1:6379> config get requirepass 
1) "requirepass" 
2) "123456"

    7、限制clients

    maxclients 10000 # 设置能连接上redis的最大客户端的数量 

maxmemory <bytes> # redis 配置最大的内存容量 

maxmemory-policy noeviction # 内存到达上限之后的处理策略 
	1、volatile-lru：只对设置了过期时间的key进行LRU（默认值） 
	2、allkeys-lru ： 删除lru算法的key 
	3、volatile-random：随机删除即将过期key 
	4、allkeys-random：随机删除 
	5、volatile-ttl ： 删除即将过期的 
	6、noeviction ： 永不过期，返回错误

    8、APPEND ONLY 模式 aof配置　　

    appendonly no # 默认是不开启aof模式的，默认是使用rdb方式持久化的，在大部分所有的情况下， rdb完全够用！ 
appendfilename "appendonly.aof" # 持久化的文件的名字 
# appendfsync always # 每次修改都会 sync。消耗性能 
appendfsync everysec # 每秒执行一次 sync，可能会丢失这1s的数据！ 
# appendfsync no # 不执行 sync，这个时候操作系统自己同步数据，速度最快！
  • 相关阅读:
    《需求工程--软件建模与分析》读书笔记一
    软件工程概论课程总结及给老师的意见
    梦断代码阅读笔记之三
    梦断代码阅读笔记之二
    第二阶段小组冲刺第七天总结
    软件工程第十一周学习进度条
    用户场景描述
    软件工程第九、十周学习进度条
    个人工作总结
    软件工程第八周学习进度条
  • 原文地址：https://www.cnblogs.com/zhangzhixi/p/14446050.html
Copyright © 2020-2023  润新知