devbox
IT小白
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

狂神说笔记之Redis_狂神redis笔记

作者：IT小白 | 2024-06-04 21:47:34

赞

踩

狂神redis笔记

1.NoSQL概述

1.1为什么用NoSQL

1.1.1、单机MySQL的美好年代

在90年代，一个网站的访问量一般不大，用单个数据库完全可以轻松应付！
在那个时候，更多的都是静态网页，动态交互类型的网站不多。
上述架构下，我们来看看数据存储的瓶颈是什么？
1. 数据量的总大小，一个机器放不下时
2. 数据的索引（B+ Tree）一个机器的内存放不下时
3. 访问量（读写混合）一个实例不能承受
如果满足了上述 1 or 3个，进化....
DAL：数据库访问层
 

1.1.2、Memcached（缓存）+ MySQL + 垂直拆分 

后来，随着访问量的上升，几乎大部分使用MySQL架构的网站在数据库上都开始出现了性能问题，web程序不再仅仅专注在功能上，同时也在追求性能。程序猿们开始大量使用缓存技术来缓解数据库的压力，优化数据库的结构和索引，开始比较流行的是通过文件缓存来缓解数据库压力，但是当访问量继续增大的时候，多台web机器通过文件缓存不能共享，大量的小文件缓存也带了比较高的IO压力，在这个时候，Memcached就自然的成为一个非常时尚的技术产品。

1.1.3、MySQL主从读写分离

由于数据库的写入压力增加，Memcached只能缓解数据库的读取压力，读写集中在一个数据库上让数据库不堪重负，大部分网站开始使用主从复制技术来达到读写分离，以提高读写性能和读库的可扩展性，MySQL的master-slave模式成为这个时候的网站标配了。

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


在Memcached的高速缓存，MySQL的主从复制，读写分离的基础之上，这时MySQL主库的写压力开始出现瓶颈，而数据量的持续猛增，由于MyISAM使用表锁，在高并发下会出现严重的锁问题，大量的高并发MySQL应用开始使用InnoDB引擎代替MyISAM。
同时，开始流行使用分表分库来缓解写压力和数据增长的扩展问题，这个时候，分表分库成了一个热门技术，是面试的热门问题，也是业界讨论的热门技术问题。也就是在这个时候，MySQL推出了还不太稳定的表分区，这也给技术实力一般的公司带来了希望。虽然MySQL推出了MySQL Cluster集群，但性能也不能很好满足互联网的需求，只是在高可靠性上提供了非常大的保证。

1.1.5、MySQL 的扩展性瓶颈

MySQL数据库也经常存储一些大文本的字段，导致数据库表非常的大，在做数据库恢复的时候就导致非常的慢，不容易快速恢复数据库，比如1000万4KB大小的文本就接近40GB的大小，如果能把这些数据从MySQL省去，MySQL将变的非常的小，关系数据库很强大，但是它并不能很好的应付所有的应用场景，MySQL的扩展性差（需要复杂的技术来实现），大数据下IO压力大，表结构更改困难，正是当前使用MySQL的开发人员面临的问题。

1.1.6、今天是什么样子？？

1.1.7、为什么用No SQL？

今天我们可以通过第三方平台（如：Google，FaceBook等）可以很容易的访问和抓取数据。用户的个人信息，社交网络，地理位置，用户生成的数据和用户操作日志已经成倍的增加、我们如果要对这些用户数据进行挖掘，那SQL数据库已经不适合这些应用了，而NoSQL数据库的发展却能很好的处理这些大的数据！

1.2什么是Nosql

1.2.1.NoSQL

NoSQL = Not Only Sql (不仅仅是sql)

泛指非关系型数据库

1.2.2.NoSql特点：

解耦！

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

       NoSQL 数据库种类繁多，但是一个共同的特点都是去掉关系数据库的关系型特性。数据之间无关系，这样就非常容易扩展，也无形之间，在架构的层面上带来了可扩展的能力。

  • 大数据量高性能！（Redis 一秒写8万次，读取11万次）

      NoSQL数据库都具有非常高的读写性能，尤其是在大数据量下，同样表现优秀。这得益于它的非关系性，数据库的结构简单。

     一般MySQL使用Query Cache，每次表的更新Cache就失效，是一种大力度的Cache，在针对Web2.0的交互频繁应用，

     Cache性能不高，而NoSQL的Cache是记录级的，是一种细粒度的Cache，所以NoSQL在这个层面上来说就要性能高很多了。

     官方记录：Redis 一秒可以写8万次，读11万次！

  •   数据类型是多样型的！（不需要实现设计数据库！随取随用！）

    NoSQL无需事先为要存储的数据建立字段，随时可以存储自定义的数据格式，而在关系数据库里，增删字段是一件非常麻烦的事情。

    如果是非常大数据量的表，增加字段简直就是噩梦。
 

传统RDBMS 和 NoSQL

  1. 传统的关系型数据库 RDBMS
  2. - 高度组织化结构化数据
  3. - 结构化查询语言（SQL）
  4. - 数据和关系都存储在单独的表中
  5. - 数据操纵语言，数据定义语言
  6. - 严格的一致性
  7. - 基础事务
  1. No SQL
  2. - 代表着不仅仅是SQL
  3. - 没有声明性查询语言
  4. - 没有预定义的模式
  5. - 键值对存储，列存储，文档存储，图形数据库
  6. - 最终一致性，而非ACID属性
  7. - 非结构化和不可预知的数据
  8. - CAP定理
  9. - 高性能，高可用性 和 可伸缩性

1.2.3.拓展：3V+3高
 

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

  • 海量 Volume
  • 多样 Variety
  • 实时 Velocity

互联网需求的3高 ： 主要是对程序的要求

  • 高并发
  • 高可用
  • 高性能

当下的应用是 SQL 和 NoSQL 一起使用，技术没有高低之分，就看你怎么用，对吧！

 1.3阿里巴巴框架演进

1.演变过程：以下图片资料来源：阿里巴巴中文站架构设计实践

2、第五代

第5代架构使命

和我们相关的，多数据源多数据类型的存储问题

1、商品的基本信息
 

  1. 名称、价格、出厂日期、生产厂商等
  2. 关系型数据库：mysql、oracle目前淘宝在去O化（也即，拿掉Oracle）
  3. 注意，淘宝内部用的My SQL是里面的大牛自己改造过的。
  4. 为什么去IOE：
  5. 2008年,王坚博士加入阿里巴巴，成为首席架构师。把云计算植入阿里IT基因。
  6. 2013年5月17日，阿里集团最后一台IBM小机在支付宝下线。这是自2009年“去IOE”战略透露以来，“去
  7. IOE”非常重要的一个节点。“去 IOE”指的是摆脱掉IT部署中原有的IBM小型机、Oracle数据库以及EMC
  8. 存储的过度依赖。告别最后一台小机，意味着整个阿里集团尽管还有一些Oracle数据库和EMC存储，但是
  9. IBM小型机已全部被替换。2013年7月10日，淘宝重中之重的广告系统使用的Oracle数据库下线，也是整
  10. 个淘宝最后一个 Oracle数据库。这两件事合在一起是阿里巴巴技术发展过程中的一个重要里程碑。

2、商品描述、详情、评价信息（多文字类）

  1. 多文字信息描述类，IO读写性能变差
  2. 存在文档数据库Mong DB中

3、商品的图片

  1. 商品图片展现类
  2. 分布式文件系统中
  3.  - 淘宝自己的  TFS
  4.  - Google的   GFS
  5.  - Hadoop的   HDFS

4、商品的关键字
 

  1. 搜索引擎，淘宝内用
  2. ISearch：多隆一高兴一个人开发的
  3. 所有牛逼的人在牛逼之前,肯定有一段苦逼的岁月,但只要像傻逼一样的坚持,一定终将牛逼

5、商品的波段性的热点高频信息

  1. 内存数据库
  2. Tair、Redis、Memcache等

6、商品的交易，价格计算，积分累计！
 

  1. 外部系统，外部第三方支付接口
  2. 支付宝

大型互联网应用（大数据，高并发，多样数据类型）的难点和解决方案
 

难点：

  • 数据类型的多样性
  • 数据源多样性和变化重构
  • 数据源改造而数据服务平台不需要大面积重构

解决办法：
 

 

 

1.4No SQL数据模型简介

案例设计

以一个电商客户，订单，订购，地址模型来对比下关系型数据库和非关系型数据库
传统的关系型数据库你如何设计？
ER图（1:1/1:N/N:N,主外键等常见）

  • 用户对应多个订单多个地址
  • 每个订单对应每个商品、价格、地址
  • 每个商品对应产品


根据她的信息找到她男朋友的生日就在最近，后台画像已经分析完毕，准备推送广告了，结果她买了一个零食就走了~


90后的程序员真的在一点点的改变生活中的点点滴滴，假设你有幸进入了大厂，你会发现周围的小伙伴都在努力，真的就是那种可以在海底捞吃着吃着饭，突然就掏出笔记本写代码的那种，别人都以为他们是疯子，只有他们自己内心才懂。这才是对技术的痴迷。

NoSQL你如何设计
可以尝试使用BSON。
BSON是一种类json的一种二进制形式的存储格式，简称Binary JSON，它和JSON一样，支持内嵌的文档
对象和数组对象
用BSon画出构建的数据模型
 

  1. {
  2.  "customer":{
  3.    "id":1000,
  4.    "name":"Z3",
  5.    "billingAddress":[{"city":"beijing"}],
  6.    "orders":[
  7.     {
  8.       "id":17,
  9.       "customerId":1000,
  10.       "orderItems":[{"productId":27,"price":77.5,"productName":"thinking in 
  11. java"}],
  12.       "shippingAddress":[{"city":"beijing"}]
  13.       "orderPayment":[{"ccinfo":"111-222-
  14. 333","txnid":"asdfadcd334","billing Address":{"city":"beijing"}}],
  15.       }
  16.     ]
  17.   }
  18. }

想想关系模型数据库你如何查？如果按照我们新设计的BSon，是不是查询起来很简单。

  • 高并发的操作是不太建议有关联查询的，互联网公司用冗余数据来避免关联查询
  • 分布式事务是支持不了太多的并发的 

1.5、nosql 四大分类

==KV键值对：==

  • 新浪：BerkeleyDB+redis
  • 美团：Redis + Tair
  • 阿里、百度：Redis + memecache

==文档型数据库（bson格式比较多)：==

  • MongoDB
    • MonoDB是一个基于分布式文件存储的数据库，C++编写，主要用来处理大量的文档
    • MonoDB是一个介于关系型数据库和非关系型数据库中中间的产品 （MonoDB是非关系型数据库功能最丰富的，最想关系型数据库）
  • ConthDB

==列存储：==

  • HBase
  • 分布式文件系统

==图形化数据库：==

  • 它不是放图形的，放的是关系比如:朋友圈社交网络、广告推荐系统
  • 社交网络，推荐系统等。专注于构建关系图谱
  • Neo4J, InfoGrid

1.5.1、四者对比

1.6、CAP + BASE

传统的ACID分别是什么？
关系型数据库遵循ACID规则，事务在英文中是transaction，和现实世界中的交易很类似，它有如下四个

  •  A (Atomicity) 原子性
  1. 原子性很容易理解，也就是说事务里的所有操作要么全部做完，要么都不做，事务成功的条件是事务
  2. 里的所有操作都成功，只要有一个操作失败，整个事务就失败，需要回滚。
  3. 比如银行转账，从A账户转100元至B账户，分为两个步骤：
  4. 1）从A账户取100元；
  5. 2）存入100元至B账户。
  6. 这两步要么一起完成，要么一起不完成，如果只完成第一步，第二步失败，钱会莫名其妙少了100
  7. 元。
  • C (Consistency) 一致性
事务前后数据的完整性必须保持一致。
  • I (Isolation) 隔离性 
  1. 所谓的独立性是指并发的事务之间不会互相影响，如果一个事务要访问的数据正在被另外一个事务修
  2. 改，只要另外一个事务未提交，它所访问的数据就不受未提交事务的影响。比如现有有个交易是从A
  3. 账户转100元至B账户，在这个交易还未完成的情况下，如果此时B查询自己的账户，是看不到新增加
  4. 的100元的
  • D (Durability) 持久性
持久性是指一旦事务提交后，它所做的修改将会永久的保存在数据库上，即使出现宕机也不会丢失。

1.6.1CAP（三进二）

  • C : Consistency（强一致性）

  • A : Availability（可用性）

  • P : Partition tolerance（分区容错性）

CAP理论就是说在分布式存储系统中，最多只能实现上面的两点。
而由于当前的网络硬件肯定会出现延迟丢包等问题，所以分区容错性是我们必须需要实现的。
所以我们只能在一致性和可用性之间进行权衡，没有NoSQL系统能同时保证这三点。
注意：分布式架构的时候必须做出取舍。
一致性和可用性之间取一个平衡。多余大多数web应用，其实并不需要强一致性。
因此牺牲C换取P，这是目前分布式数据库产品的方向
一致性与可用性的决择
对于web2.0网站来说，关系数据库的很多主要特性却往往无用武之地
数据库事务一致性需求
很多web实时系统并不要求严格的数据库事务，对读一致性的要求很低， 有些场合对写一致性要求并不高。允许实现最终一致性。
数据库的写实时性和读实时性需求
对关系数据库来说，插入一条数据之后立刻查询，是肯定可以读出来这条数据的，但是对于很多web应用来说，并不要求这么高的实时性，比方说发一条消息之 后，过几秒乃至十几秒之后，我的订阅者才看
到这条动态是完全可以接受的。对复杂的SQL查询，特别是多表关联查询的需求任何大数据量的web系统，都非常忌讳多个大表的关联查询，以及复杂的数据分析类型的报表查询，特
别是SNS类型的网站，从需求以及产品设计角度，就避免了这种情况的产生。往往更多的只是单表的主键查询，以及单表的简单条件分页查询，SQL的功能被极大的弱化了。
CAP理论的核心是：一个分布式系统不可能同时很好的满足一致性，可用性和分区容错性这三个需求，
最多只能同时较好的满足两个。因此，根据 CAP 原理将 NoSQL 数据库分成了满足 CA 原则、满足 CP 
原则和满足 AP 原则三 大类：
CA - 单点集群，满足一致性，可用性的系统，通常在可扩展性上不太强大。
CP - 满足一致性，分区容忍必的系统，通常性能不是特别高。
AP - 满足可用性，分区容忍性的系统，通常可能对一致性要求低一些。

1.6.2、BASE 理论


BASE理论是由eBay架构师提出的。BASE是对CAP中一致性和可用性权衡的结果，其来源于对大规模互联网分布式系统实践的总结，是基于CAP定律逐步演化而来。其核心思想是即使无法做到强一致性，但每个应用都

可以根据自身业务特点，采用适当的方式来使系统达到最终一致性。


BASE就是为了解决关系数据库强一致性引起的问题而引起的可用性降低而提出的解决方案。


BASE其实是下面三个术语的缩写：

  • 基本可用(Basically Available)： 基本可用是指分布式系统在出现故障的时候，允许损失部分可用性，即保证核心可用。电商大促时，为了应对访问量激增，部分用户可能会被引导到降级页面，服务层也可能只提供降级服务。这就是损失部分可用性的体现。
  • 软状态(Soft State)： 软状态是指允许系统存在中间状态，而该中间状态不会影响系统整体可用性。分布式存储中一般一份数据至少会有三个副本，允许不同节点间副本同步的延时就是软状态的体现。MySQL Replication 的异步复制也是一种体现。
  • 最终一致性(Eventual Consistency)： 最终一致性是指系统中的所有数据副本经过一定时间后，最终能够达到一致的状态。弱一致性和强一致性相反，最终一致性是弱一致性的一种特殊情况。它的思想是通过让系统放松对某一时刻数据一致性的要求来换取系统整体伸缩性和性能上改观。为什么这么说呢，缘由就在于大型系统往往由于地域分布和极高性能的要求，不可能采用分布式事务来完成这些指标，要想获得这些指标，我们必须采用另外一种方式来完成，这里BASE就是解决这个问题的办法！

解释：
1、分布式：不同的多台服务器上面部署不同的服务模块（工程），他们之间通过Rpc通信和调用，对外
提供服务和组内协作。
2、集群：不同的多台服务器上面部署相同的服务模块，通过分布式调度软件进行统一的调度，对外提供
服务和访问。 

2.Redis入门

2.1概述

2.1.1Redis是什么！

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

是完全开源免费的，用C语言编写的，遵守BSD协议，是一个高性能的（Key/Value）分布式内存数据库，基于内存运行，并支持持久化的NoSQL数据库，是当前最热门的NoSQL数据库之一，也被人们称为数据结构服务器

  • Redis与其他key-value缓存产品有以下三个特点
  • Redis支持数据的持久化，可以将内存中的数据保持在磁盘中，重启的时候可以再次加载进行使用。
  • Redis不仅仅支持简单的 key-value 类型的数据，同时还提供list、set、zset、hash等数据结构的存储。
  • Redis支持数据的备份，即master-slave模式的数据备份。

 Redis能干什么! 

  1. 内存储存、持久化、内存中的数据是断电及失、所以说持久化很重要！(rdb、aof)
  2. 效率高、可以用于告诉缓存
  3. 发布订阅系统
  4. 地图信息分析
  5. 计时器、计数器、（数据浏览量）

 Redis特性! 

  1. 持久化
  2. 多样化数据库
  3. 集群
  4. 事务
  5. ……

常用网站

https://redis.io/ 官网
http://www.redis.cn 中文网
 

2.2 安装Redis

2.2.1 Windows安装

windows ：https://github.com/dmajkic/redis/downloads 

下载完成解压

启动Redis服务器：

双击运行服务 redis-server.exe

image-20210312191028923

运行成功

再次运行redis客户端 启动 redis-cli.exe

  1. 127.0.0.1：6379> ping ----> 测试是否连接成功
  2. PONG
  3. 127.0.0.1：6379> set name changan -----> 设置 key value
  4. OK
  5. 127.0.0.1：6379> get name ------> 用 key 去寻找 value
  6. "changan"

重要提示
由于企业里面做Redis开发，99%都是Linux版的运用和安装，几乎不会涉及到Windows版，上一步的讲解只是为了知识的完整性，Windows版不作为重点，大家可以自己玩，

企业实战就认一个版：Linux版http://www.redis.cn/topics/introduction

2.2.2 Linux安装

官网下载：  http://download.redis.io/releases/redis-5.0.7.tar.gz

安装步骤
1、下载获得 redis-5.0.7.tar.gz 后将它放到我们Linux的目录下 /opt
2、/opt 目录下，解压命令 ：  tar -zxvf redis-5.0.7.tar.gz
3、解压完成后出现文件夹：redis-5.0.7
4、进入目录： cd   redis-5.0.7
5、在 redis-5.0.7 目录下执行 make 命令
 

  1. 运行make命令时故意出现的错误解析：(不同系统可能命令不太一样)
  2. 1. 安装gcc (gcc是linux下的一个编译程序，是c程序的编译工具)
  3.    能上网: yum install gcc-c++
  4.    版本测试: gcc-v
  5. 2. 二次make
  6. 3. Jemalloc/jemalloc.h: 没有那个文件或目录
  7.    运行 make distclean 之后再make
  8. 4. Redis Test（可以不用执行）

安装完成执行 make

image-20210313130749997

执行完成之后在执行一遍

然后执行 make install

image-20210313130858601

redis 的默认路径在 usr/local/bin目录下面              /usr 这是一个非常重要的目录，类似于windows下的Program Files,存放用户的程序

image-20210313131120947

移动 redis.config 到 本目录下

  1. cd /usr/local/bin
  2. ls -l
  3. # 在redis的解压目录下备份redis.conf
  4. mkdir myredis
  5. cp redis.conf myredis  # 拷一个备份，养成良好的习惯，我们就修改这个文件
  6. # 修改配置保证可以后台应用
  7. vim redis.conf

image-20210313131349900

redis默认不是后台启动，我们需要修改配置文件

找到这个修改为 yes

image-20210313131611230

  • A、redis.conf配置文件中daemonize守护线程，默认是NO。
  • B、daemonize是用来指定redis是否要用守护线程的方式启动。

daemonize 设置yes或者no区别

  • daemonize:yes

       redis采用的是单进程多线程的模式。当redis.conf中选项daemonize设置成yes时，代表开启守护进程模式。在该模式下，redis会在后台运行，并将进程pid号写入至redis.conf选项pidfile设置的文件中，此时redis将一直运行，除非手动kill该进程。

  • daemonize:no

       当daemonize选项设置成no时，当前界面将进入redis的命令行界面，exit强制退出或者关闭连接工具(putty,xshell等)都会导致redis进程退出。
 

启动redis 服务

  1. # 【shell】启动redis服务
  2. [root@192 bin]# cd /usr/local/bin
  3. [root@192 bin]# redis-server /opt/redis-5.0.7/redis.conf
  4. # redis客户端连接===> 观察地址的变化，如果连接ok,是直接连上的，redis默认端口号 6379
  5. [root@192 bin]# redis-cli -p 6379
  6. 127.0.0.1:6379> ping
  7. PONG
  8. 127.0.0.1:6379> set k1 helloworld
  9. OK
  10. 127.0.0.1:6379> get k1
  11. "helloworld"
  12. # 【shell】ps显示系统当前进程信息
  13. [root@192 myredis]# ps -ef|grep redis
  14. root      16005      1  0 04:45 ?        00:00:00 redis-server 
  15. 127.0.0.1:6379
  16. root      16031  15692  0 04:47 pts/0    00:00:00 redis-cli -p 6379
  17. root      16107  16076  0 04:51 pts/2    00:00:00 grep --color=auto redis
  18. # 【redis】关闭连接
  19. 127.0.0.1:6379> shutdown
  20. not connected> exit
  21. # 【shell】ps显示系统当前进程信息
  22. [root@192 myredis]# ps -ef|grep redis
  23. root      16140  16076  0 04:53 pts/2    00:00:00 grep --color=auto redis

image-20210313131826979

测试连接

image-20210313132042196

查看redis服务信息

image-20210313132339207

关闭redis

2.3基础知识说明

准备工作：开启redis服务，客户端连接


redis压力测试工具-----Redis-benchmark
 

redis性能测试

    
序号选项描述默认值
1-h指定服务器主机名127.0.0.1
2-p指定服务器端口6379
3-s指定服务器 socket 
4-c指定并发连接数50
5-n指定请求数10000
6-d以字节的形式指定 SET/GET 值的数据大小2
7-k1=keep alive 0=reconnect1
8-rSET/GET/INCR 使用随机 key, SADD 使用随机值 
9-P通过管道传输 <numreq> 请求1
10-q强制退出 redis。仅显示 query/sec 值 
11—csv以 CSV 格式输出 
12-l生成循环，永久执行测试 
13-t仅运行以逗号分隔的测试命令列表。 
14-IIdle 模式。仅打开 N 个 idle 连接并等待。

测试 使用 redis-benchmark

测试 ：100个并发连接， 100000 请求

  1. # 测试一：100个并发连接，100000个请求，检测host为localhost 端口为6379的redis服务器性
  2. 能 
  3. redis-benchmark -h localhost -p 6379 -c 100 -n 100000 
  4. # 测试出来的所有命令只举例一个！
  5. ====== SET ======
  6.   100000 requests completed in 1.88 seconds # 对集合写入测试
  7.   100 parallel clients # 每次请求有100个并发客户端
  8.   3 bytes payload # 每次写入3个字节的数据，有效载荷
  9.   keep alive: 1   # 保持一个连接，一台服务器来处理这些请求
  10. 17.05% <= 1 milliseconds
  11. 97.35% <= 2 milliseconds
  12. 99.97% <= 3 milliseconds
  13. 100.00% <= 3 milliseconds # 所有请求在 3 毫秒内完成
  14. 53248.14 requests per second # 每秒处理 53248.14 次请求

基础知识

 

image-20210318154701720

Redis默认数据库

Redis默认有16个数据库，默认使用第0个

  • select 2 ——> 更换数据库
  • dbsize ——-> 查看数据库大小
  • keys * ———> 查看数据库所有的key
  • flushdb ————> 清空当前数据库
  • flushall ———> 清空所有库

Select命令切换数据库

  1. 127.0.0.1:6379> select 7
  2. OK
  3. 127.0.0.1:6379[7]>
  4. # 不同的库可以存不同的数据

Dbsize查看当前数据库的key的数量
 

  1. 127.0.0.1:6379> select 7
  2. OK
  3. 127.0.0.1:6379[7]> DBSIZE
  4. (integer) 0
  5. 127.0.0.1:6379[7]> select 0
  6. OK
  7. 127.0.0.1:6379> DBSIZE
  8. (integer) 5
  9. 127.0.0.1:6379> keys * # 查看具体的key
  10. 1) "counter:__rand_int__"
  11. 2) "mylist"
  12. 3) "k1"
  13. 4) "myset:__rand_int__"
  14. 5) "key:__rand_int__"

Flushdb：清空当前库
Flushall：清空全部的库
 

  1. 127.0.0.1:6379> DBSIZE
  2. (integer) 5
  3. 127.0.0.1:6379> FLUSHDB
  4. OK
  5. 127.0.0.1:6379> DBSIZE
  6. (integer) 0

为什么redis是单线程


我们首先要明白，Redis很快！官方表示，因为Redis是基于内存的操作，CPU不是Redis的瓶颈，Redis的瓶颈最有可能是机器内存的大小或者

网络带宽。既然单线程容易实现，而且CPU不会成为瓶颈，那就顺理成章地采用单线程的方案了！

Redis采用的是基于内存的采用的是单进程单线程模型的 KV 数据库，由C语言编写，官方提供的数据是可以达到100000+的QPS（每秒内查询次

数）。这个数据不比采用单进程多线程的同样基于内存的 KV 数据库 Memcached 差！

Redis为什么这么快？

1）以前一直有个误区，以为：高性能服务器 一定是多线程来实现的原因很简单因为误区二导致的：多线程 一定比 单线程 效率高，其实不然！
在说这个事前希望大家都能对 CPU 、 内存 、 硬盘的速度都有了解了！
2）redis 核心就是 如果我的数据全都在内存里，我单线程的去操作 就是效率最高的，为什么呢，因为多线程的本质就是 CPU 模拟出来多个线程的情况，这种模拟出来的情况就有一个代价，就是上下文的切换，对于一个内存的系统来说，它没有上下文的切换就是效率最高的。redis 用 单个CPU 绑定一块内存的数据，然后针对这块内存的数据进行多次读写的时候，都是在一个CPU上完成的，所以它是单线程处理这个事。在内存的情况下，这个方案就是最佳方案。
因为一次CPU上下文的切换大概在 1500ns 左右。从内存中读取 1MB 的连续数据，耗时大约为 250us，假设1MB的数据由多个线程读取了1000次，那么就有1000次时间上下文的切换，那么就有1500ns * 1000 = 1500us ，我单线程的读完1MB数据才250us ,你光时间上下文的切换就用了1500us了，我还不算你每次读一点数据 的时间。
 

3. 五种基本数据类型

String （字符串类型）


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

Hash（哈希，类似 Java里的Map）

Redis hash 是一个键值对集合。
Redis hash 是一个String类型的field和value的映射表，hash特别适合用于存储对象。
类似Java里面的Map<String,Object>


List（列表）


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


Set（集合）

Redis的Set是String类型的无序集合，它是通过HashTable实现的 !
 

Zset（sorted set：有序集合）


Redis zset 和 set 一样，也是String类型元素的集合，且不允许重复的成员。
不同的是每个元素都会关联一个double类型的分数。
Redis正是通过分数来为集合中的成员进行从小到大的排序，zset的成员是唯一的，但是分数（Score）却可以重复。
 

Redis-key

  1. # keys * 查看所有的key
  2. 127.0.0.1:6379> keys *
  3. (empty list or set)
  4. 127.0.0.1:6379> set name qinjiang
  5. OK
  6. 127.0.0.1:6379> keys *
  7. 1) "name"
  8. # exists key 的名字，判断某个key是否存在
  9. 127.0.0.1:6379> EXISTS name
  10. (integer) 1
  11. 127.0.0.1:6379> EXISTS name1
  12. (integer) 0
  13. # move key db ---> 当前库就没有了，被移除了
  14. 127.0.0.1:6379> move name 1
  15. (integer) 1
  16. 127.0.0.1:6379> keys *
  17. (empty list or set)
  18. # expire key 秒钟：为给定 key 设置生存时间，当 key 过期时(生存时间为 0 )，它会被自动删
  19. 除。
  20. # ttl key 查看还有多少秒过期，-1 表示永不过期，-2 表示已过期
  21. 127.0.0.1:6379> set name qinjiang
  22. OK
  23. 127.0.0.1:6379> EXPIRE name 10
  24. (integer) 1
  25. 127.0.0.1:6379> ttl name
  26. (integer) 4
  27. 127.0.0.1:6379> ttl name
  28. (integer) 3
  29. 127.0.0.1:6379> ttl name
  30. (integer) 2
  31. 127.0.0.1:6379> ttl name
  32. (integer) 1
  33. 127.0.0.1:6379> ttl name
  34. (integer) -2
  35. 127.0.0.1:6379> keys *
  36. (empty list or set)
  37. # type key 查看你的key是什么类型
  38. 127.0.0.1:6379> set name qinjiang
  39. OK
  40. 127.0.0.1:6379> get name
  41. "qinjiang"
  42. 127.0.0.1:6379> type name
  43. string

字符串String

单值单Value
常用命令说明：
set、get、del、append、strlen

  1. # ===================================================
  2. # set、get、del、append、strlen
  3. # ===================================================
  4. 127.0.0.1:6379> set key1 value1   # 设置值
  5. OK
  6. 127.0.0.1:6379> get key1          # 获得key
  7. "value1"
  8. 127.0.0.1:6379> del key1          # 删除key
  9. (integer) 1
  10. 127.0.0.1:6379> keys *            # 查看全部的key
  11. (empty list or set)
  12. 127.0.0.1:6379> exists key1       # 确保 key1 不存在
  13. (integer) 0
  14. 127.0.0.1:6379> append key1 "hello"  # 对不存在的 key 进行 APPEND ，等同于 SET 
  15. key1 "hello"
  16. (integer) 5     # 字符长度
  17. 127.0.0.1:6379> APPEND key1 "-2333"  # 对已存在的字符串进行 APPEND
  18. (integer) 10    # 长度从 5 个字符增加到 10 个字符
  19. 127.0.0.1:6379> get key1
  20. "hello-2333"
  21. 127.0.0.1:6379> STRLEN key1       # # 获取字符串的长度
  22. (integer) 10

incr、dec

  1. # ===================================================
  2. # incr、decr      一定要是数字才能进行加减，+1 和 -1。
  3. # incrby、decrby  命令将 key 中储存的数字加上指定的增量值。
  4. # ===================================================
  5. 127.0.0.1:6379> set views 0       # 设置浏览量为0
  6. OK
  7. 127.0.0.1:6379> incr views        # 浏览 + 1
  8. (integer) 1
  9. 127.0.0.1:6379> incr views        # 浏览 + 1
  10. (integer) 2
  11. 127.0.0.1:6379> decr views        # 浏览 - 1
  12. (integer) 1
  13. 127.0.0.1:6379> incrby views 10   # +10
  14. (integer) 11
  15. 127.0.0.1:6379> decrby views 10   # -10
  16. (integer) 1

range

  1. # ===================================================
  2. # range [范围]
  3. # getrange 获取指定区间范围内的值，类似between...and的关系，从零到负一表示全部
  4. # ===================================================
  5. 127.0.0.1:6379> set key2 abcd123456  # 设置key2的值
  6. OK
  7. 127.0.0.1:6379> getrange key2 0 -1   # 获得全部的值
  8. "abcd123456"
  9. 127.0.0.1:6379> getrange key2 0 2    # 截取部分字符串
  10. "abc"

setrange 

  1. # ===================================================
  2. # setrange 设置指定区间范围内的值，格式是setrange key值 具体值
  3. # ===================================================
  4. 127.0.0.1:6379> get key2
  5. "abcd123456"
  6. 127.0.0.1:6379> SETRANGE key2 1 xx   # 替换值
  7. (integer) 10
  8. 127.0.0.1:6379> get key2
  9. "axxd123456"

setex

  1. # ===================================================
  2. # setex（set with expire）键秒值
  3. # setnx（set if not exist）
  4. # ===================================================
  5. 127.0.0.1:6379> setex key3 60 expire  # 设置过期时间
  6. OK
  7. 127.0.0.1:6379> ttl key3  # 查看剩余的时间
  8. (integer) 55
  9. 127.0.0.1:6379> setnx mykey "redis"   # 如果不存在就设置，成功返回1
  10. (integer) 1
  11. 127.0.0.1:6379> setnx mykey "mongodb"  # 如果存在就设置，失败返回0
  12. (integer) 0
  13. 127.0.0.1:6379> get mykey
  14. "redis"

mset 

  1. # ===================================================
  2. # mset      Mset 命令用于同时设置一个或多个 key-value 对。
  3. # mget      Mget 命令返回所有(一个或多个)给定 key 的值。 
  4. #           如果给定的 key 里面，有某个 key 不存在，那么这个 key 返回特殊值 nil 。
  5. # msetnx    当所有 key 都成功设置，返回 1 。 
  6. #           如果所有给定 key 都设置失败(至少有一个 key 已经存在)，那么返回 0 。原子操
  7. 作
  8. # ===================================================
  9. 127.0.0.1:6379> mset k10 v10 k11 v11 k12 v12
  10. OK
  11. 127.0.0.1:6379> keys *
  12. 1) "k12"
  13. 2) "k11"
  14. 3) "k10"
  15. 127.0.0.1:6379> mget k10 k11 k12 k13
  16. 1) "v10"
  17. 2) "v11"
  18. 3) "v12"
  19. 4) (nil)
  20. 127.0.0.1:6379> msetnx k10 v10 k15 v15 # 原子性操作！
  21. (integer) 0
  22. 127.0.0.1:6379> get key15
  23. (nil)
  24. # 传统对象缓存
  25. set user:1 value(json数据)
  26. # 可以用来缓存对象
  27. mset user:1:name zhangsan user:1:age 2
  28. mget user:1:name user:1:age

getset（先get再set）
 

  1. # ===================================================
  2. # getset（先get再set）
  3. # ===================================================
  4. 127.0.0.1:6379> getset db mongodb   # 没有旧值，返回 nil
  5. (nil)
  6. 127.0.0.1:6379> get db
  7. "mongodb"
  8. 127.0.0.1:6379> getset db redis     # 返回旧值 mongodb
  9. "mongodb"
  10. 127.0.0.1:6379> get db
  11. "redis"

String数据结构是简单的key-value类型，value其实不仅可以是String，也可以是数字。 
常规key-value缓存应用：

  •  计数器
  • 统计多单位的数量
  • 粉丝数
  • 对象缓存存储


2.列表List

基本的数据类型，单值多Value，列表

在redis里面，我们可以把list玩成 ，栈、队列、阻塞队列！所有的list命令都是用l开头的，Redis不区分大小命令

  1. # ===================================================
  2. # Lpush：将一个或多个值插入到列表头部。（左）
  3. # rpush：将一个或多个值插入到列表尾部。（右）
  4. # lrange：返回列表中指定区间内的元素，区间以偏移量 START 和 END 指定。
  5. # 其中 0 表示列表的第一个元素， 1 表示列表的第二个元素，以此类推。
  6. # 你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此
  7. 类推。 
  8. # ===================================================
  9. 127.0.0.1:6379> LPUSH list "one"
  10. (integer) 1
  11. 127.0.0.1:6379> LPUSH list "two"
  12. (integer) 2
  13. 127.0.0.1:6379> RPUSH list "right"
  14. (integer) 3
  15. 127.0.0.1:6379> Lrange list 0 -1
  16. 1) "two"
  17. 2) "one"
  18. 3) "right"
  19. 127.0.0.1:6379> Lrange list 0 1
  20. 1) "two"
  21. 2) "one"
  22. # ===================================================
  23. # lpop 命令用于移除并返回列表的第一个元素。当列表 key 不存在时，返回 nil 。
  24. # rpop 移除列表的最后一个元素，返回值为移除的元素。
  25. # ===================================================
  26. 127.0.0.1:6379> Lpop list
  27. "two"
  28. 127.0.0.1:6379> Rpop list
  29. "right"
  30. 127.0.0.1:6379> Lrange list 0 -1
  31. 1) "one"
  32. # ===================================================
  33. # Lindex，按照索引下标获得元素（-1代表最后一个，0代表是第一个）
  34. # ===================================================
  35. 127.0.0.1:6379> Lindex list 1
  36. (nil)
  37. 127.0.0.1:6379> Lindex list 0
  38. "one"
  39. 127.0.0.1:6379> Lindex list -1
  40. "one"
  41. # ===================================================
  42. # llen 用于返回列表的长度。
  43. # ===================================================
  44. 127.0.0.1:6379> flushdb
  45. OK
  46. 127.0.0.1:6379> Lpush list "one"
  47. (integer) 1
  48. 127.0.0.1:6379> Lpush list "two"
  49. (integer) 2
  50. 127.0.0.1:6379> Lpush list "three"
  51. (integer) 3
  52. 127.0.0.1:6379> Llen list   # 返回列表的长度
  53. (integer) 3
  54. # ===================================================
  55. # lrem key 根据参数 COUNT 的值，移除列表中与参数 VALUE 相等的元素。
  56. # ===================================================
  57. 127.0.0.1:6379> lrem list 1 "two"
  58. (integer) 1
  59. 127.0.0.1:6379> Lrange list 0 -1
  60. 1) "three"
  61. 2) "one"
  62. # ===================================================
  63. # Ltrim key 对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区
  64. 间之内的元素都将被删除。
  65. # ===================================================
  66. 127.0.0.1:6379> RPUSH mylist "hello"
  67. (integer) 1
  68. 127.0.0.1:6379> RPUSH mylist "hello"
  69. (integer) 2
  70. 127.0.0.1:6379> RPUSH mylist "hello2"
  71. (integer) 3
  72. 127.0.0.1:6379> RPUSH mylist "hello3"
  73. (integer) 4
  74. 127.0.0.1:6379> ltrim mylist 1 2
  75. OK
  76. 127.0.0.1:6379> lrange mylist 0 -1
  77. 1) "hello"
  78. 2) "hello2"
  79. # ===================================================
  80. # rpoplpush 移除列表的最后一个元素，并将该元素添加到另一个列表并返回。
  81. # ===================================================
  82. 127.0.0.1:6379> rpush mylist "hello"
  83. (integer) 1
  84. 127.0.0.1:6379> rpush mylist "foo"
  85. (integer) 2
  86. 127.0.0.1:6379> rpush mylist "bar"
  87. (integer) 3
  88. 127.0.0.1:6379> rpoplpush mylist myotherlist
  89. "bar"
  90. 127.0.0.1:6379> lrange mylist 0 -1
  91. 1) "hello"
  92. 2) "foo"
  93. 127.0.0.1:6379> lrange myotherlist 0 -1
  94. 1) "bar"
  95. # ===================================================
  96. # lset key index value 将列表 key 下标为 index 的元素的值设置为 value 。
  97. # ===================================================
  98. 127.0.0.1:6379> exists list  # 对空列表(key 不存在)进行 LSET
  99. (integer) 0
  100. 127.0.0.1:6379> lset list 0 item # 报错
  101. (error) ERR no such key
  102. 127.0.0.1:6379> lpush list "value1" # 对非空列表进行 LSET
  103. (integer) 1
  104. 127.0.0.1:6379> lrange list 0 0
  105. 1) "value1"
  106. 127.0.0.1:6379> lset list 0 "new"  # 更新值
  107. OK
  108. 127.0.0.1:6379> lrange list 0 0
  109. 1) "new"
  110. 127.0.0.1:6379> lset list 1 "new"  # index 超出范围报错
  111. (error) ERR index out of range
  112. # ===================================================
  113. # linsert key before/after pivot value 用于在列表的元素前或者后插入元素。
  114. # 将值 value 插入到列表 key 当中，位于值 pivot 之前或之后。
  115. # ===================================================
  116. redis> RPUSH mylist "Hello"
  117. (integer) 1
  118. redis> RPUSH mylist "World"
  119. (integer) 2
  120. redis> LINSERT mylist BEFORE "World" "There"
  121. (integer) 3
  122. redis> LRANGE mylist 0 -1
  123. 1) "Hello"
  124. 2) "There"
  125. 3) "World"

性能总结

  • 它是一个字符串链表，left，right 都可以插入添加
  • 如果键不存在，创建新的链表
  • 如果键已存在，新增内容
  • 如果值全移除，对应的键也就消失了
  • 链表的操作无论是头和尾效率都极高，但假如是对中间元素进行操作，效率就很惨淡了。
  •  

list就是链表，略有数据结构知识的人都应该能理解其结构。使用Lists结构，我们可以轻松地实现最新消息排行等功能。List的另一个应用就是消息

队列，可以利用List的PUSH操作，将任务存在List中，然后工作线程再用POP操作将任务取出进行执行。Redis还提供了操作List中某一段的api，

你可以直接查询，删除List中某一段的元素。 

Redis的list是每个子元素都是String类型的双向链表，可以通过push和pop操作从列表的头部或者尾部添加或者删除元素，这样List即可以作为栈，

也可以作为队列。

集合Set  单值多value


set中的值是不能重读的！

  1. # ===================================================
  2. # sadd 将一个或多个成员元素加入到集合中，不能重复
  3. # smembers 返回集合中的所有的成员。
  4. # sismember 命令判断成员元素是否是集合的成员。
  5. # ===================================================
  6. 127.0.0.1:6379> sadd myset "hello"
  7. (integer) 1
  8. 127.0.0.1:6379> sadd myset "kuangshen"
  9. (integer) 1
  10. 127.0.0.1:6379> sadd myset "kuangshen"
  11. (integer) 0
  12. 127.0.0.1:6379> SMEMBERS myset
  13. 1) "kuangshen"
  14. 2) "hello"
  15. 127.0.0.1:6379> SISMEMBER myset "hello"
  16. (integer) 1
  17. 127.0.0.1:6379> SISMEMBER myset "world"
  18. (integer) 0
  19. # ===================================================
  20. # scard，获取集合里面的元素个数
  21. # ===================================================
  22. 127.0.0.1:6379> scard myset
  23. (integer) 2
  24. # ===================================================
  25. # srem key value 用于移除集合中的一个或多个成员元素
  26. # ===================================================
  27. 127.0.0.1:6379> srem myset "kuangshen"
  28. (integer) 1
  29. 127.0.0.1:6379> SMEMBERS myset
  30. 1) "hello"
  31. # ===================================================
  32. # srandmember key 命令用于返回集合中的一个随机元素。
  33. # ===================================================
  34. 127.0.0.1:6379> SMEMBERS myset
  35. 1) "kuangshen"
  36. 2) "world"
  37. 3) "hello"
  38. 127.0.0.1:6379> SRANDMEMBER myset
  39. "hello"
  40. 127.0.0.1:6379> SRANDMEMBER myset 2
  41. 1) "world"
  42. 2) "kuangshen"
  43. 127.0.0.1:6379> SRANDMEMBER myset 2
  44. 1) "kuangshen"
  45. 2) "hello"
  46. # ===================================================
  47. # spop key 用于移除集合中的指定 key 的一个或多个随机元素
  48. # ===================================================
  49. 127.0.0.1:6379> SMEMBERS myset
  50. 1) "kuangshen"
  51. 2) "world"
  52. 3) "hello"
  53. 127.0.0.1:6379> spop myset
  54. "world"
  55. 127.0.0.1:6379> spop myset
  56. "kuangshen"
  57. 127.0.0.1:6379> spop myset
  58. "hello"
  59. # ===================================================
  60. # smove SOURCE DESTINATION MEMBER 
  61. # 将指定成员 member 元素从 source 集合移动到 destination 集合。
  62. # ===================================================
  63. 127.0.0.1:6379> sadd myset "hello"
  64. (integer) 1
  65. 127.0.0.1:6379> sadd myset "world"
  66. (integer) 1
  67. 127.0.0.1:6379> sadd myset "kuangshen"
  68. (integer) 1
  69. 127.0.0.1:6379> sadd myset2 "set2"
  70. (integer) 1
  71. 127.0.0.1:6379> smove myset myset2 "kuangshen"
  72. (integer) 1
  73. 127.0.0.1:6379> SMEMBERS myset
  74. 1) "world"
  75. 2) "hello"
  76. 127.0.0.1:6379> SMEMBERS myset2
  77. 1) "kuangshen"
  78. 2) "set2"
  79. # ===================================================
  80. - 数字集合类
  81.   - 差集： sdiff
  82.   - 交集： sinter
  83.   - 并集： sunion
  84. # ===================================================
  85. 127.0.0.1:6379> sadd key1 "a"
  86. (integer) 1
  87. 127.0.0.1:6379> sadd key1 "b"
  88. (integer) 1
  89. 127.0.0.1:6379> sadd key1 "c"
  90. (integer) 1
  91. 127.0.0.1:6379> sadd key2 "c"
  92. (integer) 1
  93. 127.0.0.1:6379> sadd key2 "d"
  94. (integer) 1
  95. 127.0.0.1:6379> sadd key2 "e"
  96. (integer) 1
  97. 127.0.0.1:6379> SDIFF key1 key2 # 差集
  98. 1) "a"
  99. 2) "b"
  100. 127.0.0.1:6379> SINTER key1 key2 # 交集
  101. 1) "c"
  102. 127.0.0.1:6379> SUNION key1 key2 # 并集
  103. 1) "a"
  104. 2) "b"
  105. 3) "c"
  106. 4) "e"
  107. 5) "d"

在微博应用中，可以将一个用户所有的关注人存在一个集合中，将其所有粉丝存在一个集合。Redis还为集合提供了求交集、并集、差集等操作，可以非常方便的实现如共同关注、共同喜好、二度好友等功能，对上面的所有集合操作，你还可以使用不同的命令选择将结果返回给客户端还是存集到一个新的集合中。

哈希Hash   kv模式不变，但V是一个键值对
 

  1. # ===================================================
  2. # hset、hget 命令用于为哈希表中的字段赋值 。
  3. # hmset、hmget 同时将多个field-value对设置到哈希表中。会覆盖哈希表中已存在的字段。
  4. # hgetall 用于返回哈希表中，所有的字段和值。
  5. # hdel    用于删除哈希表 key 中的一个或多个指定字段
  6. # ===================================================
  7. 127.0.0.1:6379> hset myhash field1 "kuangshen"
  8. (integer) 1
  9. 127.0.0.1:6379> hget myhash field1
  10. "kuangshen"
  11. 127.0.0.1:6379> HMSET myhash field1 "Hello" field2 "World"
  12. OK
  13. 127.0.0.1:6379> HGET myhash field1
  14. "Hello"
  15. 127.0.0.1:6379> HGET myhash field2
  16. "World"
  17. 127.0.0.1:6379> hgetall myhash
  18. 1) "field1"
  19. 2) "Hello"
  20. 3) "field2"
  21. 4) "World"
  22. 127.0.0.1:6379> HDEL myhash field1
  23. (integer) 1
  24. 127.0.0.1:6379> hgetall myhash
  25. 1) "field2"
  26. 2) "World"
  27. # ===================================================
  28. # hlen 获取哈希表中字段的数量。
  29. # ===================================================
  30. 127.0.0.1:6379> hlen myhash
  31. (integer) 1
  32. 127.0.0.1:6379> HMSET myhash field1 "Hello" field2 "World"
  33. OK
  34. 127.0.0.1:6379> hlen myhash
  35. (integer) 2
  36. # ===================================================
  37. # hexists 查看哈希表的指定字段是否存在。
  38. # ===================================================
  39. 127.0.0.1:6379> hexists myhash field1
  40. (integer) 1
  41. 127.0.0.1:6379> hexists myhash field3
  42. (integer) 0
  43. # ===================================================
  44. # hkeys 获取哈希表中的所有域（field）。
  45. # hvals 返回哈希表所有域(field)的值。
  46. # ===================================================
  47. 127.0.0.1:6379> HKEYS myhash
  48. 1) "field2"
  49. 2) "field1"
  50. 127.0.0.1:6379> HVALS myhash
  51. 1) "World"
  52. 2) "Hello"
  53. # ===================================================
  54. # hincrby 为哈希表中的字段值加上指定增量值。
  55. # ===================================================
  56. 127.0.0.1:6379> hset myhash field 5
  57. (integer) 1
  58. 127.0.0.1:6379> HINCRBY myhash field 1
  59. (integer) 6
  60. 127.0.0.1:6379> HINCRBY myhash field -1
  61. (integer) 5
  62. 127.0.0.1:6379> HINCRBY myhash field -10
  63. (integer) -5
  64. # ===================================================
  65. # hsetnx 为哈希表中不存在的的字段赋值 。
  66. # ===================================================
  67. 127.0.0.1:6379> HSETNX myhash field1 "hello"
  68. (integer) 1   # 设置成功，返回 1 。
  69. 127.0.0.1:6379> HSETNX myhash field1 "world"
  70. (integer) 0   # 如果给定字段已经存在，返回 0 。
  71. 127.0.0.1:6379> HGET myhash field1
  72. "hello"

Redis hash是一个string类型的field和value的映射表，hash特别适合用于存储对象。 存储部分变更的数据，如用户信息等。
 

有序集合Zset

 在set基础上，加一个score值。之前set是k1 v1 v2 v3，现在zset是 k1 score1 v1 score2 v2

  1. # ===================================================
  2. # zadd    将一个或多个成员元素及其分数值加入到有序集当中。
  3. # zrange  返回有序集中，指定区间内的成员
  4. # ===================================================
  5. 127.0.0.1:6379> zadd myset 1 "one"
  6. (integer) 1
  7. 127.0.0.1:6379> zadd myset 2 "two" 3 "three"
  8. (integer) 2
  9. 127.0.0.1:6379> ZRANGE myset 0 -1
  10. 1) "one"
  11. 2) "two"
  12. 3) "three"
  13. # ===================================================
  14. # zrangebyscore 返回有序集合中指定分数区间的成员列表。有序集成员按分数值递增(从小到大)
  15. 次序排列。
  16. # ===================================================
  17. 127.0.0.1:6379> zadd salary 2500 xiaoming
  18. (integer) 1
  19. 127.0.0.1:6379> zadd salary 5000 xiaohong
  20. (integer) 1
  21. 127.0.0.1:6379> zadd salary 500 kuangshen
  22. (integer) 1
  23. # Inf无穷大量+∞,同样地,-∞可以表示为-Inf。
  24. 127.0.0.1:6379> ZRANGEBYSCORE salary -inf +inf # 显示整个有序集
  25. 1) "kuangshen"
  26. 2) "xiaoming"
  27. 3) "xiaohong"
  28. 127.0.0.1:6379> ZRANGEBYSCORE salary -inf +inf withscores # 递增排列
  29. 1) "kuangshen"
  30. 2) "500"
  31. 3) "xiaoming"
  32. 4) "2500"
  33. 5) "xiaohong"
  34. 6) "5000"
  35. 127.0.0.1:6379> ZREVRANGE salary 0 -1 WITHSCORES  # 递减排列
  36. 1) "xiaohong"
  37. 2) "5000"
  38. 3) "xiaoming"
  39. 4) "2500"
  40. 5) "kuangshen"
  41. 6) "500"
  42. 127.0.0.1:6379> ZRANGEBYSCORE salary -inf 2500 WITHSCORES # 显示工资 <=2500 
  43. 的所有成员
  44. 1) "kuangshen"
  45. 2) "500"
  46. 3) "xiaoming"
  47. 4) "2500"
  48. # ===================================================
  49. # zrem 移除有序集中的一个或多个成员
  50. # ===================================================
  51. 127.0.0.1:6379> ZRANGE salary 0 -1
  52. 1) "kuangshen"
  53. 2) "xiaoming"
  54. 3) "xiaohong"
  55. 127.0.0.1:6379> zrem salary kuangshen
  56. (integer) 1
  57. 127.0.0.1:6379> ZRANGE salary 0 -1
  58. 1) "xiaoming"
  59. 2) "xiaohong"
  60. # ===================================================
  61. # zcard   命令用于计算集合中元素的数量。
  62. # ===================================================
  63. 127.0.0.1:6379> zcard salary
  64. (integer) 2
  65. OK
  66. # ===================================================
  67. # zcount  计算有序集合中指定分数区间的成员数量。
  68. # ===================================================
  69. 127.0.0.1:6379> zadd myset 1 "hello"
  70. (integer) 1
  71. 127.0.0.1:6379> zadd myset 2 "world" 3 "kuangshen"
  72. (integer) 2
  73. 127.0.0.1:6379> ZCOUNT myset 1 3
  74. (integer) 3
  75. 127.0.0.1:6379> ZCOUNT myset 1 2
  76. (integer) 2
  77. # ===================================================
  78. # zrank  返回有序集中指定成员的排名。其中有序集成员按分数值递增(从小到大)顺序排列。
  79. # ===================================================
  80. 127.0.0.1:6379> zadd salary 2500 xiaoming
  81. (integer) 1
  82. 127.0.0.1:6379> zadd salary 5000 xiaohong
  83. (integer) 1
  84. 127.0.0.1:6379> zadd salary 500 kuangshen
  85. (integer) 1
  86. 127.0.0.1:6379> ZRANGE salary 0 -1 WITHSCORES  # 显示所有成员及其 score 值
  87. 1) "kuangshen"
  88. 2) "500"
  89. 3) "xiaoming"
  90. 4) "2500"
  91. 5) "xiaohong"
  92. 6) "5000"
  93. 127.0.0.1:6379> zrank salary kuangshen  # 显示 kuangshen 的薪水排名，最少
  94. (integer) 0
  95. 127.0.0.1:6379> zrank salary xiaohong   # 显示 xiaohong 的薪水排名，第三
  96. (integer) 2
  97. # ===================================================
  98. # zrevrank 返回有序集中成员的排名。其中有序集成员按分数值递减(从大到小)排序。
  99. # ===================================================
  100. 127.0.0.1:6379> ZREVRANK salary kuangshen # 狂神第三
  101. (integer) 2
  102. 127.0.0.1:6379> ZREVRANK salary xiaohong  # 小红第一
  103. (integer) 0

和set相比，sorted set增加了一个权重参数score，使得集合中的元素能够按score进行有序排列，比如一个存储全班同学成绩的sorted set，其集合

value可以是同学的学号，而score就可以是其考试得分，这样在数据插入集合的时候，就已经进行了天然的排序。可以用sorted set来做带权重的

队列，比如普通消息的score为1，重要消息的score为2，然后工作线程可以选择按score的倒序来获取工作任务。让重要的任务优先执行。

排行榜应用，取TOP N操作 ！

使用场景

set 排序 存储班级成绩，工资排序

普通消息 1、重要消息 2 带权重进行判断

三种特殊数据类型

geospatial 地理位置

Redis 的 Geo 可以去实现 推算2地之间的距离，推算地理位置信息 …… ！

测试数据网站：http：//www.toolzl.com/tools/gps.html

image-20210415171238885

Geoadd 添加地理位置

~ 2极地区无法直接添加，我们一般会下载城市数据，用Java程序导入

==将指定的地理空间位置（纬度、经度、名称）添加到指定的key中==

  • 有效经度为-180至180度。
  • 有效纬度为-85.05112878至85.05112878度。
  1. # 语法
  2. geoadd key longitude latitude member ...
  3. # 将给定的空间元素(纬度、经度、名字)添加到指定的键里面。
  4. # 这些数据会以有序集he的形式被储存在键里面，从而使得georadius和georadiusbymember这样的
  5. 命令可以在之后通过位置查询取得这些元素。
  6. # geoadd命令以标准的x,y格式接受参数,所以用户必须先输入经度,然后再输入纬度。
  7. # geoadd能够记录的坐标是有限的:非常接近两极的区域无法被索引。
  8. # 有效的经度介于-180-180度之间，有效的纬度介于-85.05112878 度至 85.05112878 度之间。，
  9. 当用户尝试输入一个超出范围的经度或者纬度时,geoadd命令将返回一个错误。

测试：百度搜索经纬度查询，模拟真实数据
 

  1. 127.0.0.1:6379> geoadd china:city 116.23 40.22 北京
  2. (integer) 1
  3. 127.0.0.1:6379> geoadd china:city 121.48 31.40 上海 113.88 22.55 深圳 120.21 
  4. 30.20 杭州
  5. (integer) 3
  6. 127.0.0.1:6379> geoadd china:city 106.54 29.40 重庆 108.93 34.23 西安 114.02 
  7. 30.58 武汉
  8. (integer) 3

geopos 查询地理位置

  1. # 语法
  2. geopos key member [member...]
  3. #从key里返回所有给定位置元素的位置（经度和纬度）

测试：

  1. 127.0.0.1:6379> geopos china:city 北京
  2. 1) 1) "116.23000055551528931"
  3.    2) "40.2200010338739844"
  4. 127.0.0.1:6379> geopos china:city 上海 重庆
  5. 1) 1) "121.48000091314315796"
  6.    2) "31.40000025319353938"
  7. 2) 1) "106.54000014066696167"
  8.    2) "29.39999880018641676"
  9. 127.0.0.1:6379> geopos china:city 新疆
  10. 1) (nil)

 

geodist

返回两个给定位置之间的距离。

如果两个位置之间的其中一个不存在， 那么命令返回空值。

指定单位的参数 unit 必须是以下单位的其中一个：

  • m 表示单位为米。
  • km 表示单位为千米。
  • mi 表示单位为英里。
  • ft 表示单位为英尺。
  1. # 语法
  2. geodist key member1 member2 [unit]
  3. # 返回两个给定位置之间的距离，如果两个位置之间的其中一个不存在,那么命令返回空值。
  4. # 指定单位的参数unit必须是以下单位的其中一个：
  5. #    m表示单位为米
  6. #    km表示单位为千米
  7. #    mi表示单位为英里
  8. #    ft表示单位为英尺
  9. #    如果用户没有显式地指定单位参数,那么geodist默认使用米作为单位。
  10. #geodist命令在计算距离时会假设地球为完美的球形,在极限情况下,这一假设最大会造成0.5%的误
  11. 差。

 测试：

  1. 127.0.0.1:6379> geodist china:city 北京 上海
  2. "1088785.4302"
  3. 127.0.0.1:6379> geodist china:city 北京 上海 km
  4. "1088.7854"
  5. 127.0.0.1:6379> geodist china:city 重庆 北京 km
  6. "1491.6716"

georadius   附近的人   

半径搜索

解析：
 

  1. # 语法
  2. georadius key longitude latitude radius m|km|ft|mi [withcoord][withdist]
  3. [withhash][asc|desc][count count]
  4. # 以给定的经纬度为中心， 找出某一半径内的元素

测试：重新连接 redis-cli，增加参数  --raw ，可以强制输出中文，不然会乱码
 

  1. [root@kuangshen bin]# redis-cli --raw -p 6379
  2. # 在 china:city 中寻找坐标 100 30 半径为 1000km 的城市
  3. 127.0.0.1:6379> georadius china:city 100 30 1000 km
  4. 重庆
  5. 西安
  6. # withdist 返回位置名称和中心距离
  7. 127.0.0.1:6379> georadius china:city 100 30 1000 km withdist
  8. 重庆
  9. 635.2850
  10. 西安
  11. 963.3171
  12. # withcoord 返回位置名称和经纬度
  13. 127.0.0.1:6379> georadius china:city 100 30 1000 km withcoord
  14. 重庆
  15. 106.54000014066696167
  16. 29.39999880018641676
  17. 西安
  18. 108.92999857664108276
  19. 34.23000121926852302
  20. #  withdist withcoord 返回位置名称 距离 和经纬度 count 限定寻找个数
  21. 127.0.0.1:6379> georadius china:city 100 30 1000 km withcoord withdist count 
  22. 1
  23. 重庆
  24. 635.2850
  25. 106.54000014066696167
  26. 29.39999880018641676
  27. 127.0.0.1:6379> georadius china:city 100 30 1000 km withcoord withdist count 
  28. 2
  29. 重庆
  30. 635.2850
  31. 106.54000014066696167
  32. 29.39999880018641676
  33. 西安
  34. 963.3171
  35. 108.92999857664108276
  36. 34.23000121926852302

 

GEORADIUSBYMEMBER

找出位于指定元素周围的其他元素

解析：
 

  1. # 语法
  2. georadiusbymember key member radius m|km|ft|mi [withcoord][withdist]
  3. [withhash][asc|desc][count count]
  4. # 找出位于指定范围内的元素，中心点是由给定的位置元素决定

测试：
 

  1. 127.0.0.1:6379> GEORADIUSBYMEMBER china:city 北京 1000 km
  2. 北京
  3. 西安
  4. 127.0.0.1:6379> GEORADIUSBYMEMBER china:city 上海 400 km
  5. 杭州
  6. 上海

删除、查看

geohash

 解析：

  1. # 语法
  2. geohash key member [member...]
  3. # Redis使用geohash将二维经纬度转换为一维字符串，字符串越长表示位置更精确,两个字符串越相似
  4. 表示距离越近。

测试：

  1. 127.0.0.1:6379> geohash china:city 北京 重庆
  2. wx4sucu47r0
  3. wm5z22h53v0
  4. 127.0.0.1:6379> geohash china:city 北京 上海
  5. wx4sucu47r0
  6. wtw6sk5n300

 

zrem

GEO没有提供删除成员的命令，但是因为GEO的底层实现是zset，所以可以借用zrem命令实现对地理位置信息的删除.

  1. 127.0.0.1:6379> geoadd china:city 116.23 40.22 beijin
  2. 1
  3. 127.0.0.1:6379> zrange china:city 0 -1   # 查看全部的元素
  4. 重庆
  5. 西安
  6. 深圳
  7. 武汉
  8. 杭州
  9. 上海
  10. beijin
  11. 北京
  12. 127.0.0.1:6379> zrem china:city beijin  # 移除元素
  13. 1
  14. 127.0.0.1:6379> zrem china:city 北京     # 移除元素
  15. 1
  16. 127.0.0.1:6379> zrange china:city 0 -1
  17. 重庆
  18. 西安
  19. 深圳
  20. 武汉
  21. 杭州
  22. 上海

Hyperloglog 基数统计

什么是基数！

A{ 1、3、5、7、8、7 }

B{ 1、3、5、7、8 }

基数 （不重复的元素）= 5，可以接收误差！

简介

Redis 在 2.8.9 版本添加了 HyperLogLog 结构。

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

定 的、并且是很小的。

在 Redis 里面，每个 HyperLogLog 键只需要花费 12 KB 内存，就可以计算接近 2^64 个不同元素的基 数。这和计算基数时，元素越多耗费内存就

越多的集合形成鲜明对比。

HyperLogLog则是一种算法，它提供了不精确的去重计数方案。

举个栗子：假如我要统计网页的UV（浏览用户数量，一天内同一个用户多次访问只能算一次），传统的解决方案是使用Set来保存用户id，然后统

计Set中的元素数量来获取页面UV。但这种方案只能承载少量用户，一旦用户数量大起来就需要消耗大量的空间来存储用户id。我的目的是统计用

户数量而不是保存用户，这简直是个吃力不讨好的方案！而使用Redis的HyperLogLog最多需要12k就可以统计大量的用户数，尽管它大概有0.81%

的错误率，但对于统计UV这种不需要很精确的数据是可以忽略不计的。

Bitmaps（位图） 位存储

只要是2位数的 数据结构就可以用

如：登录、未登录 活跃、不活跃

设置或者清空key的value(字符串)在offset处的bit值。

那个位置的bit要么被设置，要么被清空，这个由value（只能是0或者1）来决定。当key不存在的时候，就创建一个新的字符串value

什么是基数？

 比如数据集 {1, 3, 5, 7, 5, 7, 8}， 那么这个数据集的基数集为 {1, 3, 5 ,7, 8}, 基数(不重复元素)为5。基数估计就是在误差可接受的范围内，快速计算基数。

基本命令

测试

  1. 127.0.0.1:6379> PFADD mykey a b c d e f g h i j
  2. 1
  3. 127.0.0.1:6379> PFCOUNT mykey
  4. 10
  5. 127.0.0.1:6379> PFADD mykey2 i j z x c v b n m
  6. 1
  7. 127.0.0.1:6379> PFMERGE mykey3 mykey mykey2
  8. OK
  9. 127.0.0.1:6379> PFCOUNT mykey3
  10. 15

Bit Map

简介

在开发中，可能会遇到这种情况：需要统计用户的某些信息，如活跃或不活跃，登录或者不登录；又如需要记录用户一年的打卡情况，打卡了是

1， 没有打卡是0，如果使用普通的 key/value存储，则要记录365条记录，如果用户量很大，需要的空间也会很大，所以 Redis  提供了 Bitmap 位

图这中数据结构，Bitmap 就是通过操作二进制位来进行记录，即为 0 和 1；如果要记录 365 天的打卡情况，使用 Bitmap 表示的形式大概如下：

0101000111000111...........................，这样有什么好处呢？当然就是节约内存了，365 天相当于 365 bit，又 1 字节 = 8 bit , 所以相当于使用 46 个

字节即可。

BitMap 就是通过一个 bit 位来表示某个元素对应的值或者状态, 其中的 key 就是对应元素本身，实际上底层也是通过对字符串的操作来实现。

Redis 从 2.2 版本之后新增了setbit, getbit, bitcount 等几个 bitmap 相关命令。
 

setbit 设置操作

 

测试打卡记录 在2021年4月15日没有打卡等

setbit 存值

getbit 取值

bitcount 查询

SETBIT key offset value : 设置 key 的第 offset 位为value (1或0)
 

  1. # 使用 bitmap 来记录上述事例中一周的打卡记录如下所示：
  2. # 周一：1，周二：0，周三：0，周四：1，周五：1，周六：0，周天：0 （1 为打卡，0 为不打卡）
  3. 127.0.0.1:6379> setbit sign 0 1
  4. 0
  5. 127.0.0.1:6379> setbit sign 1 0
  6. 0
  7. 127.0.0.1:6379> setbit sign 2 0
  8. 0
  9. 127.0.0.1:6379> setbit sign 3 1
  10. 0
  11. 127.0.0.1:6379> setbit sign 4 1
  12. 0
  13. 127.0.0.1:6379> setbit sign 5 0
  14. 0
  15. 127.0.0.1:6379> setbit sign 6 0
  16. 0

getbit 获取操作

GETBIT key offset  获取offset设置的值，未设置过默认返回0
 

  1. 127.0.0.1:6379> getbit sign 3     # 查看周四是否打卡
  2. 1 
  3. 127.0.0.1:6379> getbit sign 6     # 查看周七是否打卡
  4. 0

bitcount 统计操作

bitcount key [start, end] 统计 key 上位为1的个数
 

  1. # 统计这周打卡的记录，可以看到只有3天是打卡的状态：
  2. 127.0.0.1:6379> bitcount sign

 

事务

理论

Redis事务的概念：

Redis 事务的本质是一组命令的集合。事务支持一次执行多个命令，一个事务中所有命令都会被序列化。在事务执行过程，会按照顺序串行化执行

队列中的命令，其他客户端提交的命令请求不会插入到事务执行命令序列中。

总结说：redis事务就是一次性、顺序性、排他性的执行一个队列中的一系列命令。  
 

Redis事务没有隔离级别的概念：

批量操作在发送 EXEC 命令前被放入队列缓存，并不会被实际执行！
 

Redis不保证原子性：

Redis中，单条命令是原子性执行的，但事务不保证原子性，且没有回滚。事务中任意命令执行失败，其余的命令仍会被执行。

Redis事务的三个阶段：

  • 开启事务 （multi）
  • 命令入队 （ ）
  • 执行命令 （exec）

Redis事务相关命令：

  1. watch key1 key2 ...  #监视一或多个key,如果在事务执行之前，被监视的key被其他命令改动，则
  2. 事务被打断 （ 类似乐观锁 ）
  3. multi # 标记一个事务块的开始（ queued ）
  4. exec # 执行所有事务块的命令 （ 一旦执行exec后，之前加的监控锁都会被取消掉 ） 
  5. discard # 取消事务，放弃事务块中的所有命令
  6. unwatch # 取消watch对所有key的监控

实践

正常执行

 

放弃事务

若在事务队列中存在命令性错误（类似于java编译性错误），则执行EXEC命令时，所有命令都不会
执行

若在事务队列中存在语法性错误（类似于java的1/0的运行时异常），则执行EXEC命令时，其他正确
命令会被执行，错误命令抛出异常。

 

监控

悲观锁：

悲观锁(Pessimistic Lock),顾名思义，就是很悲观，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿到

这个数据就会block直到它拿到锁。传统的关系型数据库里面就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在操作之前先上

锁。

乐观锁：

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

  • 获取 version

  • 更新的时候比较 version

乐观锁(Optimistic Lock),顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁。但是在更新的时候会判断一下再此期

间别人有没有去更新这个数据，可以使用版本号等机制，乐观锁适用于多读的应用类型，这样可以提高吞吐量，乐观锁策略：提交版本必须大于记

录当前版本才能执行更新。
测试：
1、初始化信用卡可用余额和欠额
 

  1. 127.0.0.1:6379> set balance 100
  2. OK
  3. 127.0.0.1:6379> set debt 0
  4. OK

 2、使用watch检测balance，事务期间balance数据未变动，事务执行成功

  1. 127.0.0.1:6379> watch balance
  2. OK
  3. 127.0.0.1:6379> MULTI
  4. OK
  5. 127.0.0.1:6379> decrby balance 20
  6. QUEUED
  7. 127.0.0.1:6379> incrby debt 20
  8. QUEUED
  9. 127.0.0.1:6379> exec
  10. 1) (integer) 80
  11. 2) (integer) 20

3、使用watch检测balance，事务期间balance数据变动，事务执行失败！
 

  1. # 窗口一
  2. 127.0.0.1:6379> watch balance
  3. OK
  4. 127.0.0.1:6379> MULTI  # 执行完毕后，执行窗口二代码测试
  5. OK
  6. 127.0.0.1:6379> decrby balance 20
  7. QUEUED
  8. 127.0.0.1:6379> incrby debt 20
  9. QUEUED
  10. 127.0.0.1:6379> exec  # 修改失败！
  11. (nil)
  12. # 窗口二
  13. 127.0.0.1:6379> get balance
  14. "80"
  15. 127.0.0.1:6379> set balance 200
  16. OK
  17. # 窗口一：出现问题后放弃监视，然后重来！
  18. 127.0.0.1:6379> UNWATCH  # 放弃监视
  19. OK
  20. 127.0.0.1:6379> watch balance
  21. OK
  22. 127.0.0.1:6379> MULTI
  23. OK
  24. 127.0.0.1:6379> decrby balance 20
  25. QUEUED
  26. 127.0.0.1:6379> incrby debt 20
  27. QUEUED
  28. 127.0.0.1:6379> exec  # 成功！
  29. 1) (integer) 180
  30. 2) (integer) 40

说明：
一但执行 EXEC 开启事务的执行后，无论事务使用执行成功， WARCH 对变量的监控都将被取消。故当事务执行失败后，需重新执行WATCH命

令对变量进行监控，并开启新的事务进行操作。
小结  
watch指令类似于乐观锁，在事务提交时，如果watch监控的多个KEY中任何KEY的值已经被其他客户端更改，则使用EXEC执行事务时，事务队列

将不会被执行，同时返回Nullmulti-bulk应答以通知调用者事务执行失败。
 

Jedis

什么是Jedis

Jedis是Redis 推荐使用的Java开发工具！使用Java操作中间件！

测试

1、导入依赖

 

  1. <!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
  2. <dependency>
  3.     <groupId>redis.clients</groupId>
  4.     <artifactId>jedis</artifactId>
  5.     <version>3.2.0</version>
  6. </dependency>
  7. <dependency>
  8.     <groupId>com.alibaba</groupId>
  9.     <artifactId>fastjson</artifactId>
  10.     <version>1.2.58</version>
  11. </dependency>

2、编码测试

 

  1. package com.kuang.ping;
  2. import redis.clients.jedis.Jedis;
  3. public class Ping {
  4.     public static void main(String[] args) {
  5.         Jedis jedis = new Jedis("127.0.0.1",6379);
  6.         System.out.println("连接成功");
  7.         //查看服务是否运行
  8.         System.out.println("服务正在运行: "+jedis.ping());
  9.     }
  10. }

本地访问 直接 Jedis jedis = new Jedis("127.0.0.1"，6379);

3、启动redis服务
4、启动测试，结果

  常用API

基本操作

 

  1. public class TestPassword {
  2.     public static void main(String[] args) {
  3.         Jedis jedis = new Jedis("127.0.0.1", 6379);
  4.         //验证密码，如果没有设置密码这段代码省略
  5. //        jedis.auth("password");
  6.         jedis.connect(); //连接
  7.         jedis.disconnect(); //断开连接
  8.         jedis.flushAll(); //清空所有的key
  9.     }
  10. }

 对key操作的命令

 

  1. public class TestKey {
  2.     public static void main(String[] args) {
  3.         Jedis jedis = new Jedis("127.0.0.1", 6379);
  4.         System.out.println("清空数据："+jedis.flush DB());
  5.         System.out.println("判断某个键是否存在："+jedis.exists("username"));
  6.         System.out.println("新增<'username','kuangshen'>的键值
  7. 对："+jedis.set("username", "kuangshen"));
  8.         System.out.println("新增<'password','password'>的键值
  9. 对："+jedis.set("password", "password"));
  10.         System.out.print("系统中所有的键如下：");
  11.         Set<String> keys = jedis.keys("*");
  12.         System.out.println(keys);
  13.         System.out.println("删除键password:"+jedis.del("password"));
  14.         System.out.println("判断键password是否存
  15. 在："+jedis.exists("password"));
  16.         System.out.println("查看键username所存储的值的类
  17. 型："+jedis.type("username"));
  18.         System.out.println("随机返回key空间的一个："+jedis.random Key());
  19.         System.out.println("重命名key："+jedis.rename("username","name"));
  20.         System.out.println("取出改后的name："+jedis.get("name"));
  21.         System.out.println("按索引查询："+jedis.select(0));
  22.         System.out.println("删除当前选择数据库中的所有key："+jedis.flush DB());
  23.         System.out.println("返回当前数据库中key的数目："+jedis.db Size());
  24.         System.out.println("删除所有数据库中的所有key："+jedis.flush All());
  25.     }
  26. }

对String操作的命令

  1. public class TestString {
  2.     public static void main(String[] args) {
  3.         Jedis jedis = new Jedis("127.0.0.1", 6379);
  4.         jedis.flushDB();
  5.         System.out.println("===========增加数据===========");
  6.         System.out.println(jedis.set("key1","value1"));
  7.         System.out.println(jedis.set("key2","value2"));
  8.         System.out.println(jedis.set("key3", "value3"));
  9.  System.out.println("删除键key2:"+jedis.del("key2"));
  10.         System.out.println("获取键key2:"+jedis.get("key2"));
  11.         System.out.println("修改key1:"+jedis.set("key1", "value1Changed"));
  12.         System.out.println("获取key1的值："+jedis.get("key1"));
  13.         System.out.println("在key3后面加入值："+jedis.append("key3", "End"));
  14.         System.out.println("key3的值："+jedis.get("key3"));
  15.         System.out.println("增加多个键值
  16. 对："+jedis.mset("key01","value01","key02","value02","key03","value03"));
  17.         System.out.println("获取多个键值
  18. 对："+jedis.mget("key01","key02","key03"));
  19.         System.out.println("获取多个键值
  20. 对："+jedis.mget("key01","key02","key03","key04"));
  21.         System.out.println("删除多个键值对："+jedis.del("key01","key02"));
  22.         System.out.println("获取多个键值
  23. 对："+jedis.mget("key01","key02","key03"));
  24.         jedis.flushDB();
  25.         System.out.println("===========新增键值对防止覆盖原先值==============");
  26.         System.out.println(jedis.setnx("key1", "value1"));
  27.         System.out.println(jedis.setnx("key2", "value2"));
  28.         System.out.println(jedis.setnx("key2", "value2-new"));
  29.         System.out.println(jedis.get("key1"));
  30.         System.out.println(jedis.get("key2"));
  31.         System.out.println("===========新增键值对并设置有效时间=============");
  32.         System.out.println(jedis.setex("key3", 2, "value3"));
  33.         System.out.println(jedis.get("key3"));
  34.         try {
  35.             TimeUnit.SECONDS.sleep(3);
  36.         } catch (InterruptedException e) {
  37.             e.printStackTrace();
  38.         }
  39.         System.out.println(jedis.get("key3"));
  40.         System.out.println("===========获取原值，更新为新值==========");
  41.         System.out.println(jedis.getSet("key2", "key2GetSet"));
  42.         System.out.println(jedis.get("key2"));
  43.         System.out.println("获得key2的值的字串："+jedis.getrange("key2", 2, 
  44. 4));
  45.     }
  46. }

对List操作命令
 

  1. public class TestList {
  2.     public static void main(String[] args) {
  3.         Jedis jedis = new Jedis("127.0.0.1", 6379);
  4.         jedis.flushDB();
  5.         System.out.println("===========添加一个list===========");
  6.         jedis.lpush("collections", "ArrayList", "Vector", "Stack", 
  7. "Hash Map", "WeakHashMap", "LinkedHashMap");
  8.         jedis.lpush("collections", "HashSet");
  9.         jedis.lpush("collections", "TreeSet");
  10.         jedis.lpush("collections", "TreeMap");
  11.         System.out.println("collections的内容："+jedis.lrange("collections", 
  12. 0, -1));//-1代表倒数第一个元素，-2代表倒数第二个元素,end为-1表示查询全部
  13.  System.out.println("collections区间0-3的元
  14. 素："+jedis.lrange("collections",0,3));
  15.         System.out.println("===============================");
  16.         // 删除列表指定的值 ，第二个参数为删除的个数（有重复时），后add进去的值先被删，类
  17. 似于出栈
  18.         System.out.println("删除指定元素个数："+jedis.lrem("collections", 2, 
  19. "Hash Map"));
  20.         System.out.println("collections的内容："+jedis.lrange("collections", 
  21. 0, -1));
  22.         System.out.println("删除下表0-3区间之外的元
  23. 素："+jedis.ltrim("collections", 0, 3));
  24.         System.out.println("collections的内容："+jedis.lrange("collections", 
  25. 0, -1));
  26.         System.out.println("collections列表出栈（左
  27. 端）："+jedis.lpop("collections"));
  28.         System.out.println("collections的内容："+jedis.lrange("collections", 
  29. 0, -1));
  30.         System.out.println("collections添加元素，从列表右端，与lpush相对
  31. 应："+jedis.rpush("collections", "EnumMap"));
  32.         System.out.println("collections的内容："+jedis.lrange("collections", 
  33. 0, -1));
  34.         System.out.println("collections列表出栈（右
  35. 端）："+jedis.rpop("collections"));
  36.         System.out.println("collections的内容："+jedis.lrange("collections", 
  37. 0, -1));
  38.         System.out.println("修改collections指定下标1的内
  39. 容："+jedis.lset("collections", 1, "LinkedArrayList"));
  40.         System.out.println("collections的内容："+jedis.lrange("collections", 
  41. 0, -1));
  42.         System.out.println("===============================");
  43.         System.out.println("collections的长度："+jedis.llen("collections"));
  44.         System.out.println("获取collections下标为2的元
  45. 素："+jedis.lindex("collections", 2));
  46.         System.out.println("===============================");
  47.         jedis.lpush("sortedList", "3","6","2","0","7","4");
  48.         System.out.println("sortedList排序前："+jedis.lrange("sorted List", 0, 
  49. -1));
  50.         System.out.println(jedis.sort("sortedList"));
  51.         System.out.println("sortedList排序后："+jedis.lrange("sorted List", 0, 
  52. -1));
  53.     }
  54. }

对Set的操作命令
 

  1. public class TestSet {
  2.     public static void main(String[] args) {
  3.         Jedis jedis = new Jedis("127.0.0.1", 6379);
  4.         jedis.flushDB();
  5.         System.out.println("============向集合中添加元素（不重复）
  6. ============");
  7.         System.out.println(jedis.sadd("eleSet", 
  8. "e1","e2","e4","e3","e0","e8","e7","e5"));
  9.         System.out.println(jedis.sadd("eleSet", "e6"));
  10.         System.out.println(jedis.sadd("eleSet", "e6"));
  11.         System.out.println("eleSet的所有元素为："+jedis.smembers("ele Set"));
  12.         System.out.println("删除一个元素e0："+jedis.srem("ele Set", "e0"));
  13. System.out.println("eleSet的所有元素为："+jedis.smembers("ele Set"));
  14.         System.out.println("删除两个元素e7和e6："+jedis.srem("ele Set", 
  15. "e7","e6"));
  16.         System.out.println("eleSet的所有元素为："+jedis.smembers("ele Set"));
  17.         System.out.println("随机的移除集合中的一个元素："+jedis.spop("ele Set"));
  18.         System.out.println("随机的移除集合中的一个元素："+jedis.spop("ele Set"));
  19.         System.out.println("eleSet的所有元素为："+jedis.smembers("ele Set"));
  20.         System.out.println("eleSet中包含元素的个数："+jedis.scard("ele Set"));
  21.         System.out.println("e3是否在ele Set中："+jedis.sismember("ele Set", 
  22. "e3"));
  23.         System.out.println("e1是否在ele Set中："+jedis.sismember("ele Set", 
  24. "e1"));
  25.         System.out.println("e1是否在ele Set中："+jedis.sismember("ele Set", 
  26. "e5"));
  27.         System.out.println("=================================");
  28.         System.out.println(jedis.sadd("eleSet1", 
  29. "e1","e2","e4","e3","e0","e8","e7","e5"));
  30.         System.out.println(jedis.sadd("eleSet2", 
  31. "e1","e2","e4","e3","e0","e8"));
  32.         System.out.println("将ele Set1中删除e1并存入ele Set3
  33. 中："+jedis.smove("ele Set1", "eleSet3", "e1"));//移到集合元素
  34.         System.out.println("将ele Set1中删除e2并存入ele Set3
  35. 中："+jedis.smove("ele Set1", "eleSet3", "e2"));
  36.         System.out.println("eleSet1中的元素："+jedis.smembers("ele Set1"));
  37.         System.out.println("eleSet3中的元素："+jedis.smembers("ele Set3"));
  38.         System.out.println("============集合运算=================");
  39.         System.out.println("eleSet1中的元素："+jedis.smembers("ele Set1"));
  40.         System.out.println("eleSet2中的元素："+jedis.smembers("ele Set2"));
  41.         System.out.println("eleSet1和ele Set2的交
  42. 集:"+jedis.sinter("ele Set1","ele Set2"));
  43.         System.out.println("eleSet1和ele Set2的并
  44. 集:"+jedis.sunion("ele Set1","ele Set2"));
  45.         System.out.println("eleSet1和ele Set2的差
  46. 集:"+jedis.sdiff("ele Set1","ele Set2"));//ele Set1中有，ele Set2中没有
  47.         jedis.sinterstore("eleSet4","eleSet1","eleSet2");//求交集并将交集保存到
  48. dstkey的集合
  49.         System.out.println("eleSet4中的元素："+jedis.smembers("ele Set4"));
  50.     }
  51. }

对Hash的操作命令

  1. public class TestHash {
  2.     public static void main(String[] args) {
  3.         Jedis jedis = new Jedis("127.0.0.1", 6379);
  4.         jedis.flushDB();
  5.         Map<String,String> map = new HashMap<>();
  6.         map.put("key1","value1");
  7.         map.put("key2","value2");
  8.         map.put("key3","value3");
  9.         map.put("key4","value4");
  10.         //添加名称为hash（key）的hash元素
  11.         jedis.hmset("hash",map);
  12.         //向名称为hash的hash中添加key为key5，value为value5元素
  13.         jedis.hset("hash", "key5", "value5");
  14.         System.out.println("散列hash的所有键值对
  15. 为："+jedis.hget All("hash"));//return Map<String,String>
  16.  System.out.println("散列hash的所有键为："+jedis.hkeys("hash"));//return 
  17. Set<String>
  18.         System.out.println("散列hash的所有值为："+jedis.hvals("hash"));//return 
  19. List<String>
  20.         System.out.println("将key6保存的值加上一个整数，如果key6不存在则添加
  21. key6："+jedis.hincr By("hash", "key6", 6));
  22.         System.out.println("散列hash的所有键值对为："+jedis.hget All("hash"));
  23.         System.out.println("将key6保存的值加上一个整数，如果key6不存在则添加
  24. key6："+jedis.hincr By("hash", "key6", 3));
  25.         System.out.println("散列hash的所有键值对为："+jedis.hget All("hash"));
  26.         System.out.println("删除一个或者多个键值对："+jedis.hdel("hash", 
  27. "key2"));
  28.         System.out.println("散列hash的所有键值对为："+jedis.hget All("hash"));
  29.         System.out.println("散列hash中键值对的个数："+jedis.hlen("hash"));
  30.         System.out.println("判断hash中是否存在
  31. key2："+jedis.hexists("hash","key2"));
  32.         System.out.println("判断hash中是否存在
  33. key3："+jedis.hexists("hash","key3"));
  34.         System.out.println("获取hash中的值："+jedis.hmget("hash","key3"));
  35.         System.out.println("获取hash中的
  36. 值："+jedis.hmget("hash","key3","key4"));
  37.     }
  38. }

 

如果我们直接传对象没有序列化 ，会报错

 
  1. @Test
  2. public void UserTest() throws JsonProcessingException {
  3. RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
  4. connection.flushDb();
  5. User user = new User("长安"，23);
  6. redisTemplate.opsForValue().set("user"，user);
  7. System.out.println(redisTemplate.opsForValue().get("user"));
  8. }

//Cannot serialize; nested exception is org.springframework.core.serializer.support.SerializationFailedException： Failed to serialize object using DefaultSerializer; nested exception is java.lang.IllegalArgumentException： DefaultSerializer requires a Serializable payload but received an object of type [com.changan.model.User]

事务

基本操作
 

  1. package com.kuang.multi;
  2. import com.alibaba.fastjson.JSONObject;
  3. import redis.clients.jedis.Jedis;
  4. import redis.clients.jedis.Transaction;
  5. public class TestMulti {
  6.     public static void main(String[] args) {
  7.         //创建客户端连接服务端，redis服务端需要被开启
  8.         Jedis jedis = new Jedis("127.0.0.1", 6379);
  9.         jedis.flushDB();
  10.         JSONObject jsonObject = new JSONObject();
  11.         jsonObject.put("hello", "world");
  12.         jsonObject.put("name", "java");
  13.         //开启事务
  14.         Transaction multi = jedis.multi();
  15.         String result = jsonObject.toJSONString();
  16.         try{
  17.             //向redis存入一条数据
  18.             multi.set("json", result);
  19.             //再存入一条数据
  20.             multi.set("json2", result);
  21.             //这里引发了异常，用0作为被除数
  22.             int i = 100/0;
  23.             //如果没有引发异常，执行进入队列的命令    
  24. multi.exec();
  25.         }catch(Exception e){
  26.             e.printStackTrace();
  27.             //如果出现异常，回滚
  28.             multi.discard();
  29.         }finally{
  30.             System.out.println(jedis.get("json"));
  31.             System.out.println(jedis.get("json2"));
  32.             //最终关闭客户端
  33.             jedis.close();
  34.         }
  35.     }
  36. }

 

SpringBoot整合

说明：在SpringBoot2.x 之后 Jedis 被替换成为了 lettuce

区别：

  • Jedis ： 采用直连方式 、是不安全的，要避免安全隐患要采用 Jedis的pool连接池管理！ <u>像BIO</u>
  • lettuce ： 采用netty 实例可以在多个进程享、不存在线程不安全问题 <u>像NIO**</u>
  •  

在SpringBoot中一般使用RedisTemplate提供的方法来操作Redis。那么使用SpringBoot整合Redis需要那些步骤呢。
1、 Jedis Pool Config   (这个是配置连接池)
2、 Redis Connection Factory  这个是配置连接信息，这里的RedisConnectionFactory是一个接口，我们需要使用它的实现类，在SpringD Data Redis方案中提供了以下四种工厂模型：

  • JredisConnectionFactory
  • JedisConnectionFactory
  • LettuceConnectionFactory
  • SrpConnectionFactory

3、 Redis Template  基本操作

导入依赖

  1. <dependency>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-data-redis</artifactId>
  4. </dependency>

yaml配置

 

  1. spring:
  2.     redis:
  3.       host: 127.0.0.1
  4.       port: 6379
  5.       password: 123456
  6.       jedis:
  7.         pool:
  8.           max-active: 8
  9.           max-wait: -1ms
  10.           max-idle: 500
  11.           min-idle: 0
  12.       lettuce:
  13.         shutdown-timeout: 0ms

测试 

  1. @Spring Boot Test
  2. class SpringbootRedisApplicationTests {
  3.     @Autowired
  4.     private RedisTemplate<String,String> redisTemplate;
  5.     @Test
  6.     void contextLoads() {
  7.         redisTemplate.opsForValue().set("myKey","myValue");
  8.         System.out.println(redisTemplate.opsForValue().get("myKey"));
  9.     }
  10. }

封装工具类

1、新建一个SpringBoot项目
2、导入redis的启动器
 

  1. <dependency>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-data-redis</artifactId>
  4. </dependency>

3、配置redis，可以查看 RedisProperties 分析
 

  1. # Redis服务器地址
  2. spring.redis.host=127.0.0.1
  3. # Redis服务器连接端口
  4. spring.redis.port=6379

4、分析 RedisAutoConfiguration 自动配置类 
 

  1. @Configuration(proxy Bean Methods = false)
  2. @Conditional On Class(Redis Operations.class)
  3. @Enable Configuration Properties(Redis Properties.class)
  4. @Import({ LettuceConnectionConfiguration.class, 
  5. Jedis Connection Configuration.class })
  6. public class RedisAutoConfiguration {
  7.     @Bean
  8.     @ConditionalOnMissingBean(name = "redisTemplate")
  9.     public RedisTemplate<Object, Object> 
  10. redis Template(Redis Connection Factory redisConnectionFactory)
  11.             throws UnknownHostException {
  12.         RedisTemplate<Object, Object> template = new RedisTemplate<>();
  13.         template.setConnectionFactory(redisConnectionFactory);
  14.         return template;
  15.     }
  16.     @Bean
  17.     @ConditionalOnMissingBean
  18.     public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory 
  19. redis Connection Factory)
  20.             throws UnknownHostException {
  21.         StringRedisTemplate template = new StringRedisTemplate();
  22.         template.setConnectionFactory(redisConnectionFactory);
  23.         return template;
  24.     }
  25. }

通过源码可以看出，SpringBoot自动帮我们在容器中生成了一个RedisTemplate和一个StringRedisTemplate。但是，这个RedisTemplate的泛型是

<Object,Object>，写代码不方便，需要写好多类型转换的代码；我们需要一个泛型为<String,Object>形式的RedisTemplate。并且，这个

RedisTemplate没有设置数据存在Redis时，key及value的序列化方式。看到这个@ConditionalOnMissingBean注解后，就知道如果Spring容器中

有了RedisTemplate对象了，这个自动配置的RedisTemplate不会实例化。因此我们可以直接自己写个配置类，配置RedisTemplate。
 

5、既然自动配置不好用，就重新配置一个RedisTemplate
 

  1. package com.kuang.config;
  2. import com.fasterxml.jackson.annotation.JsonAutoDetect;
  3. import com.fasterxml.jackson.annotation.PropertyAccessor;
  4. import com.fasterxml.jackson.databind.ObjectMapper;
  5. import org.springframework.context.annotation.Bean;
  6. import org.springframework.context.annotation.Configuration;
  7. import org.springframework.data.redis.connection.RedisConnectionFactory;
  8. import org.springframework.data.redis.core.RedisTemplate;
  9. import 
  10. org.springframework.data.redis.serializer.Jackson2Json Redis Serializer;
  11. import org.springframework.data.redis.serializer.StringRedisSerializer;
  12. @Configuration
  13. public class RedisConfig {
  14.   @Bean
  15.   @Suppress Warnings("all")
  16.   public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory 
  17. factory) {
  18.       RedisTemplate<String, Object> template = new RedisTemplate<String, 
  19. Object>();
  20.       template.setConnectionFactory(factory);
  21.       Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new 
  22. Jackson2Json Redis Serializer(Object.class);
  23.       ObjectMapper om = new ObjectMapper();
  24.       om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
  25.       om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
  26.       jackson2JsonRedisSerializer.setObjectMapper(om);
  27.       StringRedisSerializer stringRedisSerializer = new 
  28. String Redis Serializer();
  29.       
  30.       // key采用String的序列化方式
  31.       template.setKeySerializer(stringRedisSerializer);
  32.       // hash的key也采用String的序列化方式
  33.       template.setHashKeySerializer(stringRedisSerializer);
  34.       // value序列化方式采用jackson
  35.       template.setValueSerializer(jackson2JsonRedisSerializer);
  36.       // hash的value序列化方式采用jackson
  37.       template.setHashValueSerializer(jackson2JsonRedisSerializer);
  38.       template.afterPropertiesSet();
  39.       
  40.       return template;
  41.   }
  42. }

6、写一个Redis工具类（直接用RedisTemplate操作Redis，需要很多行代码，因此直接封装好一个
RedisUtils，这样写代码更方便点。这个RedisUtils交给Spring容器实例化，使用时直接注解注入。）
 

  1. package com.kuang.utils;
  2. import org.springframework.beans.factory.annotation.Autowired;
  3. import org.springframework.data.redis.core.RedisTemplate;
  4. import org.springframework.stereotype.Component;
  5. import org.springframework.util.CollectionUtils;
  6. import java.util.List;
  7. import java.util.Map;
  8. import java.util.Set;
  9. import java.util.concurrent.TimeUnit;
  10. @Component
  11. public final class RedisUtil {
  12.     @Autowired
  13.     private RedisTemplate<String, Object> redisTemplate;
  14.     
  15.     // =============================common============================
  16.     /**
  17.      * 指定缓存失效时间
  18.      * @param key  键
  19.      * @param time 时间(秒)
  20.      */
  21.     public boolean expire(String key, long time) {
  22.         try {
  23.   if (time > 0) {
  24.                 redisTemplate.expire(key, time, TimeUnit.SECONDS);
  25.             }
  26.             return true;
  27.         } catch (Exception e) {
  28.             e.printStackTrace();
  29.             return false;
  30.         }
  31.     }
  32.     /**
  33.      * 根据key 获取过期时间
  34.      * @param key 键 不能为null
  35.      * @return 时间(秒) 返回0代表为永久有效
  36.      */
  37.     public long getExpire(String key) {
  38.         return redisTemplate.getExpire(key, TimeUnit.SECONDS);
  39.     }
  40.     /**
  41.      * 判断key是否存在
  42.      * @param key 键
  43.      * @return true 存在 false不存在
  44.      */
  45.     public boolean hasKey(String key) {
  46.         try {
  47.             return redisTemplate.hasKey(key);
  48.         } catch (Exception e) {
  49.             e.printStackTrace();
  50.             return false;
  51.         }
  52.     }
  53.     /**
  54.      * 删除缓存
  55.      * @param key 可以传一个值 或多个
  56.      */
  57.     @SuppressWarnings("unchecked")
  58.     public void del(String... key) {
  59.         if (key != null && key.length > 0) {
  60.             if (key.length == 1) {
  61.                 redisTemplate.delete(key[0]);
  62.             } else {
  63.                 redisTemplate.delete(CollectionUtils.arrayToList(key));
  64.             }
  65.         }
  66.     }
  67.     // ============================String=============================
  68.     /**
  69.      * 普通缓存获取
  70.      * @param key 键
  71.      * @return 值
  72.      */
  73. public Object get(String key) {
  74.         return key == null ? null : redisTemplate.opsForValue().get(key);
  75.     }
  76.     
  77.     /**
  78.      * 普通缓存放入
  79.      * @param key   键
  80.      * @param value 值
  81.      * @return true成功 false失败
  82.      */
  83.     public boolean set(String key, Object value) {
  84.         try {
  85.             redisTemplate.opsForValue().set(key, value);
  86.             return true;
  87.         } catch (Exception e) {
  88.             e.printStackTrace();
  89.             return false;
  90.         }
  91.     }
  92.     /**
  93.      * 普通缓存放入并设置时间
  94.      * @param key   键
  95.      * @param value 值
  96.      * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
  97.      * @return true成功 false 失败
  98.      */
  99.     public boolean set(String key, Object value, long time) {
  100.         try {
  101.             if (time > 0) {
  102.                 redisTemplate.opsForValue().set(key, value, time, 
  103. Time Unit.SECONDS);
  104.             } else {
  105.                 set(key, value);
  106.             }
  107.             return true;
  108.         } catch (Exception e) {
  109.             e.printStackTrace();
  110.             return false;
  111.         }
  112.     }
  113.     /**
  114.      * 递增
  115.      * @param key   键
  116.      * @param delta 要增加几(大于0)
  117.      */
  118.     public long incr(String key, long delta) {
  119.         if (delta < 0) {
  120.             throw new RuntimeException("递增因子必须大于0");
  121.         }
  122.         return redisTemplate.opsForValue().increment(key, delta);
  123.     }
  124. /**
  125.      * 递减
  126.      * @param key   键
  127.      * @param delta 要减少几(小于0)
  128.      */
  129.     public long decr(String key, long delta) {
  130.         if (delta < 0) {
  131.             throw new RuntimeException("递减因子必须大于0");
  132.         }
  133.         return redisTemplate.opsForValue().increment(key, -delta);
  134.     }
  135.     // ================================Map=================================
  136.     /**
  137.      * HashGet
  138.      * @param key  键 不能为null
  139.      * @param item 项 不能为null
  140.      */
  141.     public Object hget(String key, String item) {
  142.         return redisTemplate.opsForHash().get(key, item);
  143.     }
  144.     
  145.     /**
  146.      * 获取hash Key对应的所有键值
  147.      * @param key 键
  148.      * @return 对应的多个键值
  149.      */
  150.     public Map<Object, Object> hmget(String key) {
  151.         return redisTemplate.opsForHash().entries(key);
  152.     }
  153.     
  154.     /**
  155.      * HashSet
  156.      * @param key 键
  157.      * @param map 对应多个键值
  158.      */
  159.     public boolean hmset(String key, Map<String, Object> map) {
  160.         try {
  161.             redisTemplate.opsForHash().putAll(key, map);
  162.             return true;
  163.         } catch (Exception e) {
  164.             e.printStackTrace();
  165.             return false;
  166.         }
  167.     }
  168.     /**
  169.      * HashSet 并设置时间
  170.      * @param key  键
  171.      * @param map  对应多个键值
  172.      * @param time 时间(秒)
  173.      * @return true成功 false失败
  174.      */
  175.     public boolean hmset(String key, Map<String, Object> map, long time) {
  176.  try {
  177.             redisTemplate.opsForHash().putAll(key, map);
  178.             if (time > 0) {
  179.                 expire(key, time);
  180.             }
  181.             return true;
  182.         } catch (Exception e) {
  183.             e.printStackTrace();
  184.             return false;
  185.         }
  186.     }
  187.     /**
  188.      * 向一张hash表中放入数据,如果不存在将创建
  189.      *
  190.      * @param key   键
  191.      * @param item  项
  192.      * @param value 值
  193.      * @return true 成功 false失败
  194.      */
  195.     public boolean hset(String key, String item, Object value) {
  196.         try {
  197.             redisTemplate.opsForHash().put(key, item, value);
  198.             return true;
  199.         } catch (Exception e) {
  200.             e.printStackTrace();
  201.             return false;
  202.         }
  203.     }
  204.     /**
  205.      * 向一张hash表中放入数据,如果不存在将创建
  206.      *
  207.      * @param key   键
  208.      * @param item  项
  209.      * @param value 值
  210.      * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
  211.      * @return true 成功 false失败
  212.      */
  213.     public boolean hset(String key, String item, Object value, long time) {
  214.         try {
  215.             redisTemplate.opsForHash().put(key, item, value);
  216.             if (time > 0) {
  217.                 expire(key, time);
  218.             }
  219.             return true;
  220.         } catch (Exception e) {
  221.             e.printStackTrace();
  222.             return false;
  223.         }
  224.     }
  225.     /**
  226.      * 删除hash表中的值
  227.      *
  228.      * @param key  键 不能为null
  229.  * @param item 项 可以使多个 不能为null
  230.      */
  231.     public void hdel(String key, Object... item) {
  232.         redisTemplate.opsForHash().delete(key, item);
  233.     }
  234.     /**
  235.      * 判断hash表中是否有该项的值
  236.      *
  237.      * @param key  键 不能为null
  238.      * @param item 项 不能为null
  239.      * @return true 存在 false不存在
  240.      */
  241.     public boolean hHasKey(String key, String item) {
  242.         return redisTemplate.opsForHash().hasKey(key, item);
  243.     }
  244.     /**
  245.      * hash递增 如果不存在,就会创建一个 并把新增后的值返回
  246.      *
  247.      * @param key  键
  248.      * @param item 项
  249.      * @param by   要增加几(大于0)
  250.      */
  251.     public double hincr(String key, String item, double by) {
  252.         return redisTemplate.opsForHash().increment(key, item, by);
  253.     }
  254.     /**
  255.      * hash递减
  256.      *
  257.      * @param key  键
  258.      * @param item 项
  259.      * @param by   要减少记(小于0)
  260.      */
  261.     public double hdecr(String key, String item, double by) {
  262.         return redisTemplate.opsForHash().increment(key, item, -by);
  263.     }
  264.     // ============================set=============================
  265.     /**
  266.      * 根据key获取Set中的所有值
  267.      * @param key 键
  268.      */
  269.     public Set<Object> sGet(String key) {
  270.         try {
  271.             return redisTemplate.opsForSet().members(key);
  272.         } catch (Exception e) {
  273.             e.printStackTrace();
  274.             return null;
  275.         }
  276.     }
  277. /**
  278.      * 根据value从一个set中查询,是否存在
  279.      *
  280.      * @param key   键
  281.      * @param value 值
  282.      * @return true 存在 false不存在
  283.      */
  284.     public boolean sHasKey(String key, Object value) {
  285.         try {
  286.             return redisTemplate.opsForSet().isMember(key, value);
  287.         } catch (Exception e) {
  288.             e.printStackTrace();
  289.             return false;
  290.         }
  291.     }
  292.     /**
  293.      * 将数据放入set缓存
  294.      *
  295.      * @param key    键
  296.      * @param values 值 可以是多个
  297.      * @return 成功个数
  298.      */
  299.     public long sSet(String key, Object... values) {
  300.         try {
  301.             return redisTemplate.opsForSet().add(key, values);
  302.         } catch (Exception e) {
  303.             e.printStackTrace();
  304.             return 0;
  305.         }
  306.     }
  307.     /**
  308.      * 将set数据放入缓存
  309.      *
  310.      * @param key    键
  311.      * @param time   时间(秒)
  312.      * @param values 值 可以是多个
  313.      * @return 成功个数
  314.      */
  315.     public long sSetAndTime(String key, long time, Object... values) {
  316.         try {
  317.             Long count = redisTemplate.opsForSet().add(key, values);
  318.             if (time > 0)
  319.                 expire(key, time);
  320.             return count;
  321.         } catch (Exception e) {
  322.             e.printStackTrace();
  323.             return 0;
  324.         }
  325.     }
  326.     /**
  327.      * 获取set缓存的长度
  328.  * @param key 键
  329.      */
  330.     public long sGetSetSize(String key) {
  331.         try {
  332.             return redisTemplate.opsForSet().size(key);
  333.         } catch (Exception e) {
  334.             e.printStackTrace();
  335.             return 0;
  336.         }
  337.     }
  338.     /**
  339.      * 移除值为value的
  340.      *
  341.      * @param key    键
  342.      * @param values 值 可以是多个
  343.      * @return 移除的个数
  344.      */
  345.     public long setRemove(String key, Object... values) {
  346.         try {
  347.             Long count = redisTemplate.opsForSet().remove(key, values);
  348.             return count;
  349.         } catch (Exception e) {
  350.             e.printStackTrace();
  351.             return 0;
  352.         }
  353.     }
  354.     // ===============================list=================================
  355.     
  356.     /**
  357.      * 获取list缓存的内容
  358.      *
  359.      * @param key   键
  360.      * @param start 开始
  361.      * @param end   结束 0 到 -1代表所有值
  362.      */
  363.     public List<Object> lGet(String key, long start, long end) {
  364.         try {
  365.             return redisTemplate.opsForList().range(key, start, end);
  366.         } catch (Exception e) {
  367.             e.printStackTrace();
  368.             return null;
  369.         }
  370.     }
  371.     /**
  372.      * 获取list缓存的长度
  373.      *
  374.      * @param key 键
  375.      */
  376.     public long lGetListSize(String key) {
  377.         try {
  378.             return redisTemplate.opsForList().size(key);
  379. } catch (Exception e) {
  380.             e.printStackTrace();
  381.             return 0;
  382.         }
  383.     }
  384.     /**
  385.      * 通过索引 获取list中的值
  386.      *
  387.      * @param key   键
  388.      * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0
  389. 时，-1，表尾，-2倒数第二个元素，依次类推
  390.      */
  391.     public Object lGetIndex(String key, long index) {
  392.         try {
  393.             return redisTemplate.opsForList().index(key, index);
  394.         } catch (Exception e) {
  395.             e.printStackTrace();
  396.             return null;
  397.         }
  398.     }
  399.     /**
  400.      * 将list放入缓存
  401.      *
  402.      * @param key   键
  403.      * @param value 值
  404.      */
  405.     public boolean lSet(String key, Object value) {
  406.         try {
  407.             redisTemplate.opsForList().rightPush(key, value);
  408.             return true;
  409.         } catch (Exception e) {
  410.             e.printStackTrace();
  411.             return false;
  412.         }
  413.     }
  414.     /**
  415.      * 将list放入缓存
  416.      * @param key   键
  417.      * @param value 值
  418.      * @param time  时间(秒)
  419.      */
  420.     public boolean lSet(String key, Object value, long time) {
  421.         try {
  422.             redisTemplate.opsForList().rightPush(key, value);
  423.             if (time > 0)
  424.                 expire(key, time);
  425.             return true;
  426.         } catch (Exception e) {
  427.             e.printStackTrace();
  428.             return false;
  429.         }
  430.  }
  431.     /**
  432.      * 将list放入缓存
  433.      *
  434.      * @param key   键
  435.      * @param value 值
  436.      * @return
  437.      */
  438.     public boolean lSet(String key, List<Object> value) {
  439.         try {
  440.             redisTemplate.opsForList().rightPushAll(key, value);
  441.             return true;
  442.         } catch (Exception e) {
  443.             e.printStackTrace();
  444.             return false;
  445.         }
  446.     }
  447.     /**
  448.      * 将list放入缓存
  449.      *
  450.      * @param key   键
  451.      * @param value 值
  452.      * @param time  时间(秒)
  453.      * @return
  454.      */
  455.     public boolean lSet(String key, List<Object> value, long time) {
  456.         try {
  457.             redisTemplate.opsForList().rightPushAll(key, value);
  458.             if (time > 0)
  459.                 expire(key, time);
  460.             return true;
  461.         } catch (Exception e) {
  462.             e.printStackTrace();
  463.             return false;
  464.         }
  465.     }
  466.     /**
  467.      * 根据索引修改list中的某条数据
  468.      *
  469.      * @param key   键
  470.      * @param index 索引
  471.      * @param value 值
  472.      * @return
  473.      */
  474.     public boolean lUpdateIndex(String key, long index, Object value) {
  475.         try {
  476.             redisTemplate.opsForList().set(key, index, value);
  477.             ren true;
  478.         } catch (Exception e) {
  479.             e.printStackTrace();
  480.             return false;
  481.  }
  482.     }
  483.     /**
  484.      * 移除N个值为value
  485.      *
  486.      * @param key   键
  487.      * @param count 移除多少个
  488.      * @param value 值
  489.      * @return 移除的个数
  490.      */
  491.     public long lRemove(String key, long count, Object value) {
  492.         try {
  493.             Long remove = redisTemplate.opsForList().remove(key, count, 
  494. value);
  495.             return remove;
  496.         } catch (Exception e) {
  497.             e.printStackTrace();
  498.             return 0;
  499.         }
  500.     }
  501. }

Redis.conf详解

位置
 

Redis 的配置文件位于 Redis 安装目录下，文件名为 redis.conf
 

config get *  # 获取全部的配置

配置文件的地址：
 

我们一般情况下，会单独拷贝出来一份进行操作。来保证初始文件的安全。
 

Units 单位

 

1、配置大小单位，开头定义了一些基本的度量单位，只支持bytes，不支持bit
2、对 大小写 不敏感

INCLUDES 包含

 

 

和Spring配置文件类似，可以通过includes包含，redis.conf 可以作为总文件，可以包含其他文件！
 

  1. 这里包括一个或多个其他配置文件。这很有用，如果你
  2. 有一个标准的模板，去所有的Redis服务器，但也需要
  3. 自定义一些服务器设置。包括文件可以包括
  4. 其他文件，所以明智地使用这个。
  5. 注意选项“include”不会被命令“CONFIG REWRITE”重写
  6. 从admin或Redis哨兵。因为Redis总是使用最后处理的
  7. line作为配置指令的值，你最好放包含
  8. 在这个文件的开头，以避免在运行时覆盖配置更改。
  9. 如果你有兴趣使用include覆盖配置
  10. options，最好使用include作为最后一行。
  11. include /path/to/local.conf
  12. include /path/to/other.conf

网络 NETWORK

image-20210420093312397

  1. bind 127.0.0.1      # 绑定的ip
  2. protected-mode yes  # 保护模式
  3. port 6379           # 默认端口

指定多个ip 访问 ip 用空格 隔开

image-20210420093502139

protected-mode yes 开启受保护模式

prot 6379 默认端口号

通用 GENERAL

  1. daemonize yes  # 默认情况下，Redis不作为守护进程运行。需要开启的话，改为 yes
  2. supervised no  # 可通过upstart和systemd管理Redis守护进程
  3. pidfile /var/run/redis_6379.pid  #  以后台进程方式运行redis，则需要指定pid 文件
  4. loglevel notice # 日志级别。可选项有：
  5.                 # debug（记录大量日志信息，适用于开发、测试阶段）；  
  6.                 # verbose（较多日志信息）；  
  7. # notice（适量日志信息，使用于生产环境）；
  8.                 # warning（仅有部分重要、关键信息才会被记录）。
  9.  
  10. logfile ""      # 日志文件的位置，当指定为空字符串时，为标准输出
  11. databases 16    # 设置数据库的数目。默认的数据库是DB 0
  12. always-show-logo yes  # 是否总是显示logo
  1. daemonize yes 以守护进程的方式运行，默认是 no 我们需要自己设置为yes
  2.  
  3. pidfile /www/server/redis/redis.pid 如果是守护进程方式运行，我们需要指定一个pid文件
  4.  
  5. logfile "/www/server/redis/redis.log" 日志的文件位置
  1. # Specify the server verbosity level.
  2. # This can be one of：
  3. # debug (a lot of information， useful for development/testing)
  4. # verbose (many rarely useful info， but not a mess like the debug level)
  5. # notice (moderately verbose， what you want in production probably)
  6. # warning (only very important / critical messages are logged)
  7. loglevel notice
  8.  
  9. #指定服务器详细级别。
  10. #这个可以是：
  11. # debug(大量信息，对开发/测试有用)
  12. # verbose(很多很少有用的信息，但不像调试级别那样混乱)
  13. # notice(有点冗长，可能是在生产中需要的内容)
  14. # warning(只记录非常重要/关键的消息)
  1. # Set the number of databases. The default database is DB 0， you can select
  2. # a different one on a per-connection basis using SELECT <dbid> where
  3. # dbid is a number between 0 and 'databases'-1
  4. databases 16
  5.  
  6.  
  7. #设置数据库个数。默认数据库为“DB 0”，可选择
  8. #在每个连接上使用SELECT where
  9. # dbid是一个介于0和'databases'-1之间的数字
  10. databases 默认的数据库数量 16 个
  1. # By default Redis shows an ASCII art logo only when started to log to the
  2. # standard output and if the standard output is a TTY. Basically this means
  3. # that normally a logo is displayed only in interactive sessions.
  4. #
  5. # However it is possible to force the pre-4.0 behavior and always show a
  6. # ASCII art logo in startup logs by setting the following option to yes.
  7. always-show-logo yes
  8. always-show-logo yes 是否显示log 默认为开启

快照 SNAPSHOTTING

image-20210420095513960

持久化数据 因为 Redis是内存数据库 如果断电等因素 会失去数据 所以我们需要在一定时间里 持久化数据

 

  1. # 900秒（15分钟）内至少1个key值改变（则进行数据库保存--持久化）
  2. save 900 1
  3. # 300秒（5分钟）内至少10个key值改变（则进行数据库保存--持久化）
  4. save 300 10
  5. # 60秒（1分钟）内至少10000个key值改变（则进行数据库保存--持久化）
  6. save 60 10000
  7. stop-writes-on-bgsave-error yes  # 持久化出现错误后，是否依然进行继续进行工作
  8. rdbcompression yes   # 使用压缩rdb文件 yes：压缩，但是需要一些cpu的消耗。no：不压
  9. 缩，需要更多的磁盘空间
  10. rdbchecksum yes      # 是否校验rdb文件，更有利于文件的容错性，但是在保存rdb文件的时
  11. 候，会有大概10%的性能损耗
  12. dbfilename dump.rdb  # dbfilenamerdb文件名称
  13. dir ./    # dir 数据目录，数据库的写入会在这个目录。rdb、aof文件也会写在这个目录

 stop-writes-on-bgsave-error yes 持久化 出错了是否继续工作 默认继续

image-20210420095830031

rdbcompression yes 是否压缩 rdb文件
默认压缩 压缩会消耗cpu资源

  1. # Compress string objects using LZF when dump .rdb databases?
  2. # For default that's set to 'yes' as it's almost always a win.
  3. # If you want to save some CPU in the saving child set it to 'no' but
  4. # the dataset will likely be bigger if you have compressible values or keys.
  5. rdbcompression yes

rdbchecksum yes 保存 rdb 文件时进行错误的校验

  1. # Since version 5 of RDB a CRC64 checksum is placed at the end of the file.
  2. # This makes the format more resistant to corruption but there is a performance
  3. # hit to pay (around 10%) when saving and loading RDB files， so you can disable it
  4. # for maximum performances.
  5. #
  6. # RDB files created with checksum disabled have a checksum of zero that will
  7. # tell the loading code to skip the check.
  8. rdbchecksum yes

rdb 文件保存的目录 

  1. # The working directory.
  2. #
  3. # The DB will be written inside this directory， with the filename specified
  4. # above using the 'dbfilename' configuration directive.
  5. #
  6. # The Append Only File will also be created inside this directory.
  7. #
  8. # Note that you must specify a directory here， not a file name.
  9. dir /www/server/redis/

安全 SECURITY

requirepass xxxxx 设置redis 登录密码

  1. # Require clients to issue AUTH <PASSWORD> before processing any other
  2. # commands. This might be useful in environments in which you do not trust
  3. # others with access to the host running redis-server.
  4. #
  5. # This should stay commented out for backward compatibility and because most
  6. # people do not need auth (e.g. they run their own servers).
  7. #
  8. # Warning： since Redis is pretty fast an outside user can try up to
  9. # 150k passwords per second against a good box. This means that you should
  10. # use a very strong password otherwise it will be very easy to break.
  11. #
  12. # requirepass foobared

 

  1.  #要求客户端在处理任何其他密码之前发出AUTH
  2. #命令。这在您不信任的环境中可能很有用
  3. #其他可以访问运行redis-server的主机。
  4. #这个应该被注释掉，以便向后兼容，因为大多数
  5. #人们不需要认证(例如，他们运行自己的服务器)
  6. #警告：由于Redis是相当快的外部用户可以尝试
  7. # 150k密码每秒对一个好的盒子。这意味着你应该这么做
  8. #使用一个非常强的密码，否则它会很容易被破解

 访问密码的查看，设置和取消

  1. # 启动redis
  2. # 连接客户端
  3. # 获得和设置密码
  4. config get requirepass
  5. config set requirepass "123456"
  6. #测试ping，发现需要验证
  7. 127.0.0.1:6379> ping
  8. NOAUTH Authentication required.
  9. # 验证
  10. 127.0.0.1:6379> auth 123456
  11. OK
  12. 127.0.0.1:6379> ping
  13. PONG

限制 CLIENTS

 

  1. maxclients 10000   # 设置能连上redis的最大客户端连接数量
  2. maxmemory <bytes>   # redis配置的最大内存容量
  3. maxmemory-policy noeviction   # maxmemory-policy 内存达到上限的处理策略
  4.         #volatile-lru：利用LRU算法移除设置过过期时间的key。
  5.         #volatile-random：随机移除设置过过期时间的key。
  6.         #volatile-ttl：移除即将过期的key，根据最近过期时间来删除（辅以TTL）
  7.         #allkeys-lru：利用LRU算法移除任何key。
  8.         #allkeys-random：随机移除任何key。
  9.         #noeviction：不移除任何key，只是返回一个写错误。

aof配置 APPEND ONLY MODE

基本配置

 

  1.  appendonly no   # 是否以append only模式作为持久化方式，默认使用的是rdb方式持久化，这种
  2. 方式在许多应用中已经足够用了
  3. appendfilename "appendonly.aof"   # appendfilename AOF 文件名称
  4. appendfsync everysec  # appendfsync aof持久化策略的配置
  5.     # no表示不执行fsync，由操作系统保证数据同步到磁盘，速度最快。
  6.     # always表示每次写入都执行fsync，以保证数据同步到磁盘。
  7.     # everysec表示每秒执行一次fsync，可能会导致丢失这1s数据。
  • # appendfsync always // 每修改一个key都会执行 sync，消耗性能
  • appendfsync everysec // 每一秒执行一次 sync，可能会丢失这1s的数据
  • # appendfsync no // 不执行 sync，这个时候操作系统会自己同步数据速度是最快的

常见配置介绍

1、Redis默认不是以守护进程的方式运行，可以通过该配置项修改，使用yes启用守护进程

daemonize no

2、当Redis以守护进程方式运行时，Redis默认会把pid写入/var/run/redis.pid文件，可以通过pidfile指定

pidfile /var/run/redis.pid

3、指定Redis监听端口，默认端口为6379，作者在自己的一篇博文中解释了为什么选用6379作为默认端口，因为6379在手机按键上MERZ对应的号码，而MERZ取自意大利歌女Alessia Merz的名字

port 6379

4、绑定的主机地址

bind 127.0.0.1

5、当 客户端闲置多长时间后关闭连接，如果指定为0，表示关闭该功能

timeout 300

6、指定日志记录级别，Redis总共支持四个级别：debug、verbose、notice、warning，默认为verbose

loglevel verbose


7、日志记录方式，默认为标准输出，如果配置Redis为守护进程方式运行，而这里又配置为日志记录方式为标准输出，则日志将会发送给/dev/null

logfile stdout

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

databases 16

9、指定在多长时间内，有多少次更新操作，就将数据同步到数据文件，可以多个条件配合

save 

Redis默认配置文件中提供了三个条件：
save 900 1
save 300 10
save 60 10000
分别表示900秒（15分钟）内有1个更改，300秒（5分钟）内有10个更改以及60秒内有10000个更改。

10、指定存储至本地数据库时是否压缩数据，默认为yes，Redis采用LZF压缩，如果为了节省CPU时间，可以关闭该选项，但会导致数据库文件变的巨大

rdbcompression yes

11、指定本地数据库文件名，默认值为dump.rdb

dbfilename dump.rdb

12、指定本地数据库存放目录

dir ./

13、设置当本机为slav服务时，设置master服务的IP地址及端口，在Redis启动时，它会自动从master进行数据同步

slaveof

14、当master服务设置了密码保护时，slav服务连接master的密码

masterauth

15、设置Redis连接密码，如果配置了连接密码，客户端在连接Redis时需要通过AUTH 命令提供密码，
默认关闭

requirepass foobared

16、设置同一时间最大客户端连接数，默认无限制，Redis可以同时打开的客户端连接数为Redis进程可以打开的最大文件描述符数，如果设置 maxclients 0，表示不作限制。当客户端连接数到达限制时，Redis会关闭新的连接并向客户端返回max number of clients reached错误信息

maxclients 128

17、指定Redis最大内存限制，Redis在启动时会把数据加载到内存中，达到最大内存后，Redis会先尝试清除已到期或即将到期的Key，当此方法处理 后，仍然到达最大内存设置，将无法再进行写入操作，但仍然可以进行读取操作。Redis新的vm机制，会把Key存放内存，Value会存放在swap区

maxmemory

18、指定是否在每次更新操作后进行日志记录，Redis在默认情况下是异步的把数据写入磁盘，如果不开启，可能会在断电时导致一段时间内的数据丢失。因为 redis本身同步数据文件是按上面save条件来同步的，所以有的数据会在一段时间内只存在于内存中。默认为no

appendonly no

19、指定更新日志文件名，默认为appendonly.aof

appendfilename appendonly.aof

20、指定更新日志条件，共有3个可选值：

no：表示等操作系统进行数据缓存同步到磁盘（快）
always：表示每次更新操作后手动调用fsync()将数据写到磁盘（慢，安全）
everysec：表示每秒同步一次（折衷，默认值）
appendfsync everysec

21、指定是否启用虚拟内存机制，默认值为no，简单的介绍一下，VM机制将数据分页存放，由Redis将访问量较少的页即冷数据swap到磁盘上，访问多的页面由磁盘自动换出到内存中（在后面的文章我会仔细分析Redis的VM机制）

vm-enabled no

22、虚拟内存文件路径，默认值为/tmp/redis.swap，不可多个Redis实例共享

vm-swap-file /tmp/redis.swap

23、将所有大于vm-max-memory的数据存入虚拟内存,无论vm-max-memory设置多小,所有索引数据都是内存存储的(Redis的索引数据 就是keys),也就是说,当vm-max-memory设置为0的时候,其实是所有value都存在于磁盘。默认值为0

vm-max-memory 0

24、Redis swap文件分成了很多的page，一个对象可以保存在多个page上面，但一个page上不能被多个对象共享，vm-page-size是要根据存储的 数据大小来设定的，作者建议如果存储很多小对象，page大小最好设置为32或者64bytes；如果存储很大大对象，则可以使用更大的page，如果不 确定，就使用默认值

vm-page-size 32

25、设置swap文件中的page数量，由于页表（一种表示页面空闲或使用的bitmap）是在放在内存中的，在磁盘上每8个pages将消耗1byte的内存。

vm-pages 134217728

26、设置访问swap文件的线程数,最好不要超过机器的核数,如果设置为0,那么所有对swap文件的操作都是串行的，可能会造成比较长时间的延迟。默认值为4

vm-max-threads 4

27、设置在向客户端应答时，是否把较小的包合并为一个包发送，默认为开启

glueoutputbuf yes

28、指定在超过一定的数量或者最大的元素超过某一临界值时，采用一种特殊的哈希算法

hash-max-zipmap-entries 64
hash-max-zipmap-value 512

29、指定是否激活重置哈希，默认为开启（后面在介绍Redis的哈希算法时具体介绍）

activerehashing yes

30、指定包含其它的配置文件，可以在同一主机上多个Redis实例之间使用同一份配置文件，而同时各个实例又拥有自己的特定配置文件

include /path/to/local.conf

Redis持久化

因为Redis是内存数据库，如果不把数据保存到磁盘中，那么如果机器出现断电等，数据就会丢失，所以Redis提供了持久化功能

RDB (Redis DataBase)

什么是RDB

在指定的时间间隔内将内存中的数据集快照写入磁盘，也就是行话讲的Snapshot快照，它恢复时是将快照文件直接读到内存里。 

Redis会单独创建（fork）一个子进程来进行持久化，会先将数据写入到一个临时文件中，待持久化过程都结束了，再用这个临时文件替换上次持

久化好的文件。整个过程中，主进程是不进行任何IO操作的。这就确保了极高的性能。如果需要进行大规模数据的恢复，且对于数据恢复的完整性

不是非常敏感，那RDB方式要比AOF方式更加的高效。RDB的缺点是最后一次持久化后的数据可能丢失。
 

image-20210420173941820

 Fork

Fork的作用是复制一个与当前进程一样的进程。新进程的所有数据（变量，环境变量，程序计数器等）
数值都和原进程一致，但是是一个全新的进程，并作为原进程的子进程。

Rdb 默认保存的文件叫做 dump.rdb

image-20210420174644255

 配置位置及SNAPSHOTTING解析 快照

这里的触发条件机制，我们可以修改测试一下：

 save 120 10  # 120秒内修改10次则触发RDB

RDB 是整合内存的压缩过的Snapshot，RDB 的数据结构，可以配置复合的快照触发条件。
默认：

  • 1分钟内改了1万次
  • 5分钟内改了10次
  • 15分钟内改了1次

如果想禁用RDB持久化的策略，只要不设置任何save指令，或者给save传入一个空字符串参数也可以。若要修改完毕需要立马生效，可以手动使用 save 命令！立马生效 !

如何回复rdb文件

  1. 只需要将rdb文件放到Redis启动目录下就可以，Redis启动的时候自动检查dump.rdb回复其数据
  2. 可以用 config get dir 查询我们需要将文件放在那个目录下

其余命令解析

Stop-writes-on-bgsave-error：如果配置为no，表示你不在乎数据不一致或者有其他的手段发现和控
制，默认为yes。
rbdcompression：对于存储到磁盘中的快照，可以设置是否进行压缩存储。如果是的话，redis会采用
LZF算法进行压缩，如果你不想消耗CPU来进行压缩的话，可以设置为关闭此功能。
rdbchecksum：在存储快照后，还可以让redis使用CRC64算法来进行数据校验，但是这样做会增加大约
10%的性能消耗，如果希望获取到最大的性能提升，可以关闭此功能。默认为yes。
 

如何触发RDB快照

1、配置文件中默认的快照配置，建议多用一台机子作为备份，复制一份 dump.rdb
2、命令save或者是bgsave

  • save 时只管保存，其他不管，全部阻塞
  • bgsave，Redis 会在后台异步进行快照操作，快照同时还可以响应客户端请求。可以通过lastsave命令获取最后一次成功执行快照的时间。

3、执行flushall命令，也会产生 dump.rdb 文件，但里面是空的，无意义 !
4、退出的时候也会产生 dump.rdb 文件！

如何恢复

1、将备份文件（dump.rdb）移动到redis安装目录并启动服务即可
2、CONFIG GET dir 获取目录
 

  1. 127.0.0.1:6379> config get dir
  2. dir
  3. /usr/local/bin

优点和缺点

优点

适合大规模数据恢复

对数据的完成性数据不高可以使用

缺点

需要一定的时间间隔进行操作 ，如果在最后一次操作的时候当机了 那么最后修改的数据就没了

fork 一条进程的时候会占用一定的内存空间

小结

 

 

 

AOF (Append Only File)

Aof是什么

以日志的形式来记录每个写操作，将Redis执行过的所有指令记录下来（读操作不记录），只许追加文件但不可以改写文件，redis启动之初会读取

该文件重新构建数据，换言之，redis重启的话就根据日志文件的内容将写指令从前到后执行一次以完成数据的恢复工作

Aof保存的是 appendonly.aof 文件

AOf

配置

aof 保存的文件是 appendonly.aof

默认是没有开启的 我们需要的话需要手动开启 把 appendonly no 改为 appendonly yes

如果Aof文件受损了Redis启动不起来 我们可以通过 redis-check-aof --fix 来修复aof文件

image-20210422091808551

  1. appendonly no   # 是否以append only模式作为持久化方式，默认使用的是rdb方式持久化，这
  2. 种方式在许多应用中已经足够用了
  3. appendfilename "appendonly.aof"   # appendfilename AOF 文件名称
  4. appendfsync everysec  # appendfsync aof持久化策略的配置
  5.     # no表示不执行fsync，由操作系统保证数据同步到磁盘，速度最快。
  6.     # always表示每次写入都执行fsync，以保证数据同步到磁盘。
  7.     # everysec表示每秒执行一次fsync，可能会导致丢失这1s数据。
  8. No-appendfsync-on-rewrite #重写时是否可以运用Appendfsync，用默认no即可，保证数据安
  9. 全性
  10. Auto-aof-rewrite-min-size # 设置重写的基准值
  11. Auto-aof-rewrite-percentage #设置重写的基准值

AOF 启动/修复/恢复

正常恢复：

  • 启动：设置Yes，修改默认的appendonly no，改为yes
  • 将有数据的aof文件复制一份保存到对应目录（config get dir）
  • 恢复：重启redis然后重新加载

异常恢复：

  • 启动：设置Yes
  • 故意破坏 appendonly.aof 文件！
  • 修复： redis-check-aof --fix appendonly.aof 进行修复
  • 恢复：重启 redis 然后重新加载
     

Rewrite

是什么

AOF 采用文件追加方式，文件会越来越大，为避免出现此种情况，新增了重写机制，当AOF文件的大小超过所设定的阈值时，Redis 就会启动

AOF 文件的内容压缩，只保留可以恢复数据的最小指令集，可以使用命令 bgrewriteaof ！
重写原理：

AOF 文件持续增长而过大时，会fork出一条新进程来将文件重写（也是先写临时文件最后再rename），遍历新进程的内存中数据，每条记录有一

条的Set语句。重写aof文件的操作，并没有读取旧的aof文件，这点和快照有点类似！

触发机制：

Redis会记录上次重写时的AOF大小，默认配置是当AOF文件大小是上次rewrite后大小的已被且文件大于64M的触发。
 

优点和缺点

优点

  1. 每一次修改都同步，appendfsync always 同步持久化，每次发生数据变更会被立即记录到磁盘，性能较差
    但数据完整性比较好
  2. 每秒同步一次， appendfsync everysec 异步操作，每秒记录 ，如果一秒内宕机，有数据丢失
  3. 从来不同步，效率最高

缺点

  1. 相对于数据文件来说，aof远远大于rdb，修复的速度也比rdb慢
  2. aof 运行效率也要比rdb慢，所以Redis默认的配置就是rdb持久化

小总结

 

 总结  

1、RDB 持久化方式能够在指定的时间间隔内对你的数据进行快照存储
2、AOF 持久化方式记录每次对服务器写的操作，当服务器重启的时候会重新执行这些命令来恢复原始的数据，AOF命令以Redis 协议追加保存每次写的操作到文件末尾，Redis还能对AOF文件进行后台重写，使得AOF文件的体积不至于过大。
3、只做缓存，如果你只希望你的数据在服务器运行的时候存在，你也可以不使用任何持久化
4、同时开启两种持久化方式

  • 在这种情况下，当redis重启的时候会优先载入AOF文件来恢复原始的数据，因为在通常情况下AOF文件保存的数据集要比RDB文件保存的数据集要完整。
  • RDB 的数据不实时，同时使用两者时服务器重启也只会找AOF文件，那要不要只使用AOF呢？作者建议不要，因为RDB更适合用于备份数据库（AOF在不断变化不好备份），快速重启，而且不会有AOF可能潜在的Bug，留着作为一个万一的手段。

5、性能建议

  • 因为RDB文件只用作后备用途，建议只在Slave上持久化RDB文件，而且只要15分钟备份一次就够了，只保留 save 900 1 这条规则。
  • 如果Enable AOF ，好处是在最恶劣情况下也只会丢失不超过两秒数据，启动脚本较简单只load自己的AOF文件就可以了，代价一是带来了持续的IO，二是AOF rewrite 的最后将 rewrite 过程中产生的新数据写到新文件造成的阻塞几乎是不可避免的。只要硬盘许可，应该尽量减少AOF rewrite 的频率，AOF重写的基础大小默认值64M太小了，可以设到5G以上，默认超过原大小100%大小重写可以改到适当的数值。
  • 如果不Enable AOF ，仅靠 Master-Slave Repllcation 实现高可用性也可以，能省掉一大笔IO，也减少了rewrite时带来的系统波动。代价是如果Master/Slave 同时倒掉，会丢失十几分钟的数据，启动脚本也要比较两个 Master/Slave 中的 RDB文件，载入较新的那个，微博就是这种架构。

Redis发布与订阅

Redis 发布订阅（pub/sub）是一种消息通信模式：发送者（pub）发送消息，订阅者（sub）接收消息 ——— > 微信 、微博的 关注系统

Redis 客户端可以订阅任意数量的频道

订阅/发布消息图：

  • 消息发布者
  • 频道
  • 消息订阅者

image-20210423090614975

下图是频道 channel1 ， 以及订阅这个频道的三个客户端 ——- cilent2，cilent5 和 cilent1 之间的关系

image-20210423091450391

当有消息通过Publish 命令发送给频道 channel1 时，这个消息就会被它发送给订阅它的三个客户端

image-20210423091506037

命令

redis 发布订阅常用命令：

序号命令及描述
1PSUBSCRIBE pattern [pattern …] 订阅一个或多个符合给定模式的频道。
2PUBSUB subcommand [argument [argument …]] 查看订阅与发布系统状态。
3PUBLISH channel message 将信息发送到指定的频道。
4PUNSUBSCRIBE [pattern [pattern …]] 退订所有给定模式的频道。
5SUBSCRIBE channel channel …] 订阅给定的一个或多个频道的信息。
6UNSUBSCRIBE [channel [channel …]] 指退订给定的频道。

订阅信息：

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

  1. redis 127.0.0.1:6379> SUBSCRIBE redisChat
  2. Reading messages... (press Ctrl-C to quit)
  3. 1) "subscribe"
  4. 2) "redisChat"
  5. 3) (integer) 1

现在，我们先重新开启个 redis 客户端，然后在同一个频道 redisChat 发布两次消息，订阅者就能接收
到消息。

  1.  redis 127.0.0.1:6379> PUBLISH redisChat "Hello,Redis"
  2. (integer) 1
  3. redis 127.0.0.1:6379> PUBLISH redisChat "Hello，Kuangshen"
  4. (integer) 1
  5. # 订阅者的客户端会显示如下消息
  6. 1) "message"
  7. 2) "redisChat"
  8. 3) "Hello,Redis"
  9. 1) "message"
  10. 2) "redisChat"
  11. 3) "Hello，Kuangshen"

原理

 Redis是使用C实现的，通过分析 Redis 源码里的 pubsub.c 文件，了解发布和订阅机制的底层实现，籍此加深对 Redis 的理解。

Redis 通过 PUBLISH 、SUBSCRIBE 和 PSUBSCRIBE 等命令实现发布和订阅功能。

通过 SUBSCRIBE 命令订阅某频道后，redis-server 里维护了一个字典，字典的键就是一个个 channel ，而字典的值则是一个链表，链表中保存了

所有订阅这个 channel 的客户端。SUBSCRIBE 命令的关键，就是将客户端添加到给定 channel 的订阅链表中。

通过 PUBLISH 命令向订阅者发送消息，redis-server 会使用给定的频道作为键，在它所维护的 channel 字典中查找记录了订阅这个频道的所有客

户端的链表，遍历这个链表，将消息发布给所有订阅者。Pub/Sub 从字面上理解就是发布（Publish）与订阅（Subscribe），在Redis中，你可以

设定对某一个key值进行消息发布及消息订阅，当一个key值上进行了消息发布后，所有订阅它的客户端都会收到相应的消息。这一功能最明显的

用法就是用作实时消息系统，比如普通的即时聊天，群聊等功能。

使用场景

Pub/Sub构建实时消息系统

Redis的Pub/Sub系统可以构建实时的消息系统 

比如很多用Pub/Sub构建的实时聊天系统的例子。

Redis主从复制

概念

一般来说，要将 Redis用于工程项目中，只使用一台 Redist是万万不能的，原因如下：

1、从结构上，单个 Redist服务器会发生单点故障，井且一台服务器需要处理所有的请求负載，压力较大

2、从容量上，单个 Redis服务器内存容量有限就算一台 Redis服务器内存容量为266，也不能将所有内存用作 Redis?存储内存一般来说，单台 Redist最大使用内存不应该超过206

电商网站上的商品，一般都是一次上传，无数次浏览的，说专业点也就是”多读少写”。
对于这种场景，我们可以使如下这种架构主从复制，息指将一台Reds3服的数据，复制他的Reds眼努，前者称为主节点 master/leade，后者称为从节点( slave/ follower);数据的复制是单向的，只能由主节点到从节点。 Master以写为主，Save以读为主。

认情况下，每台 Redish服务器都是主节点：且ー个主节点可以有多个从节点(或没有从节点)，但一个从节点只能有一个主节点
主从复制的作用主要包括：

  1. 数据元余：主从复制实现了数据的热备份，是持久化之外的一种数据冗余方式。
  2. 故障恢复：当主节点出现可题时，可以由从节点提供服务，实现快速的故障恢复；实际上是一种服务的冗余
  3. 负载均衡：在主从复制的基础上，配合读写分离，可以由主节点提供写服务，由从节点提供读服务(即写 Redisa效据时应用连接主节点，读Reds数据时应用连接从节点)，分担服务器负载;尤具是在写少读多的场景下，通过多个从节点分担读负载，可以大大提高 Redis服务器的并发量
  4. 高可用(集群)基石：除了上述作用以外，主从复制还是哨兵和集群能够实施的基础，因此说主从复制是Reds高可用的基础

一般来说，要将Redis运用于工程项目中，只使用一台Redis是万万不能的，原因如下：
1、从结构上，单个Redis服务器会发生单点故障，并且一台服务器需要处理所有的请求负载，压力较大；

2、从容量上，单个Redis服务器内存容量有限，就算一台Redis服务器内存容量为256G，也不能将所有内存用作Redis存储内存，一般来说，单台

Redis最大使用内存不应该超过20G。

电商网站上的商品，一般都是一次上传，无数次浏览的，说专业点也就是"多读少写"。

对于这种场景，我们可以使如下这种架构：
 

环境配置

只配置从库，不配置主库！

环境配置 

配从库不配主库，从库配置：
 

查看当前库的信息

  1. slaveof 主库ip 主库端口 # 配置主从
  2. Info replication # 查看信息
  1. 127.0.0.1：6379> info replication
  2. # Replication
  3. role：master // 角色
  4. connected_slaves：0 // 连接的丛机
  5. master_failover_state：no-failover
  6. master_replid：c52bb664e09e9e76e9c995fdd15215578e38250f
  7. master_replid2：0000000000000000000000000000000000000000
  8. master_repl_offset：0
  9. second_repl_offset：-1
  10. repl_backlog_active：0
  11. repl_backlog_size：1048576
  12. repl_backlog_first_byte_offset：0
  13. repl_backlog_histlen：0

image-20210424193553158

修改配置文件！

1.准备工作：我们配置主从复制，至少需要三个，一主二从！配置三个客户端！

 

 2.拷贝多个redis.conf 文件

然后修改配置文件：

2、指定端口 6379，依次类推
3、开启daemonize yes
4、Pid文件名字  pidfile /var/run/redis_6379.pid  , 依次类推
5、Log文件名字   logfile "6379.log"  , 依次类推
6、Dump.rdb 名字  dbfilename dump6379.rdb  , 依次类推

上面都配置完毕后，3个服务通过3个不同的配置文件开启，我们的准备环境就OK 了！

配置成功

启动3个redis

image-20210427152706030

一主二从

一主二从

1、环境初始化

默认三个都是Master 主节点   默认情况Redis每一个服务都是主节点

一般只配置从机 

查看Redis当前库信息

2、配置为一个Master 两个Slave

 

 

3、在主机设置值，在从机都可以取到！从机不能写值！  


 

 

 

测试

1、主机宕机了 从机状态

  1.  127.0.0.1:6310> SHUTDOWN
  2. not connected> exit
  3. [root@King bin]# redis-cli -p 6379
  4. Could not connect to Redis at 127.0.0.1:6379: Connection refused
  5. not connected> ping
  6. Could not connect to Redis at 127.0.0.1:6379: Connection refused

主机关闭

image-20210427160524806

image-20210427160413157

主机宕机不会影响从机的读取操作

2、主机从新工作

 
  1. [root@King bin]# redis-server KingConfig/redis-10.conf
  2. [root@King bin]# redis-cli -p 6379
  3. 127.0.0.1:6379> ping
  4. PONG
  5. 127.0.0.1:6379> set k2 v2
  6. OK
  7. 127.0.0.1:6379> get k2
  8. "v2"

从机状态

image-20210427160810556

也可以查询值

  1.  127.0.0.1:6320> get k2
  2. "v2"

 

测试从机断开 ：如果从机是使用命令连接的主机 那么从机断开之后 重新连接 他就会变为自己的主机，这样是取不到主机更新数据，但是可以取到以前的数据，我们重新让它成为从机 那么他还是可以读取到数据

层层链路

 上一个Slave 可以是下一个slave 和 Master，Slave 同样可以接收其他 slaves 的连接和同步请求，那么该 slave 作为了链条中下一个的master，可以有效减轻 master 的写压力！

测试：6379 设置值以后 6380 和 6381 都可以获取到！OK！

谋朝篡位  

一主二从的情况下，如果主机断了，从机可以使用命令  SLAVEOF NO ONE  将自己改为主机！这个时候其余的从机链接到这个节点。对一个从属

服务器执行命令 SLAVEOF NO ONE 将使得这个从属服务器关闭复制功能，并从从属服务器转变回主服务器，原来同步所得的数据集不会被丢

弃。

主机再回来，也只是一个光杆司令了，从机为了正常使用跑到了新的主机上！
 

 

复制原理

Slave启动成功连接到 master 后会发送一个sync命令

Master接到命令,启动后台的存盘进程,同时收集所有接收到的用于修改数据集命令,在后台进程执行完毕之后, master将传送整个数据文件到 slave,井完成一次完全同步

全量复制：而 slave服务在接收到数据库文件数据后,将其存盘井加载到内存中

增量复制：Master继续将新的所有收集到的修改命令依次传给 slave,完成同步

但是只要是重新连接 master,一次完全同步(全量复制)将被自动执行

主机宕机

如果主机宕机了，从机想要变成主机 我们可以通过命令 slaveof no noe 让自己变成主机！其他节点就可以手动连接，这个时候主机连接了 还想要 这个主机当老大 那么我们需要手动配置

哨兵模式

主从切换技术的方法是：当主服务器宕机后，需要手动把一台从服务器切换为主服务器，这就需要人工干预，费事费力，还会造成一段时间内服务不可用。这不是一种推荐的方式，更多时候，我们优先考虑哨兵模式。Redis从2.8开始正式提供了Sentinel（哨兵） 架构来解决这个问题。
谋朝篡位的自动版，能够后台监控主机是否故障，如果故障了根据投票数自动将从库转换为主库。
哨兵模式是一种特殊的模式，首先Redis提供了哨兵的命令，哨兵是一个独立的进程，作为进程，它会独立运行。其原理是哨兵通过发送命令，等待Redis服务器响应，从而监控运行的多个Redis实例。

主从切换技术的方法是：当主服务器宕机后，需要手动把一台从服务器切换为主服务器，这就需要人工干预，费事费力，还会造成一段时间内服务不可用。这不是一种推荐的方式，更多时候，我们优先考虑哨兵模式。

哨兵模式概述

哨兵模式是一种特殊的模式，首先Redis提供了哨兵的命令，哨兵是一个独立的进程，作为进程，它会独立运行。其原理是哨兵通过发送命令，等待Redis服务器响应，从而监控运行的多个Redis实例。

1

Redis哨兵

这里的哨兵有两个作用

  • 通过发送命令，让Redis服务器返回监控其运行状态，包括主服务器和从服务器。
  • 当哨兵监测到master宕机，会自动将slave切换成master，然后通过发布订阅模式通知其他的从服务器，修改配置文件，让它们切换主机。

然而一个哨兵进程对Redis服务器进行监控，可能会出现问题，为此，我们可以使用多个哨兵进行监控。各个哨兵之间还会进行监控，这样就形成了多哨兵模式。

用文字描述一下故障切换（failover）的过程。假设主服务器宕机，哨兵1先检测到这个结果，系统并不会马上进行failover过程，仅仅是哨兵1主观的认为主服务器不可用，这个现象成为主观下线。当后面的哨兵也检测到主服务器不可用，并且数量达到一定值时，那么哨兵之间就会进行一次投票，投票的结果由一个哨兵发起，进行failover操作。切换成功后，就会通过发布订阅模式，让各个哨兵把自己监控的从服务器实现切换主机，这个过程称为客观下线。这样对于客户端而言，一切都是透明的。

Redis配置哨兵模式

配置3个哨兵和1主2从的Redis服务器来演示这个过程。

服务类型是否是主服务器IP地址端口
Redis是192.168.11.1286379
Redis否192.168.11.1296379
Redis否192.168.11.1306379
Sentinel-192.168.11.12826379
Sentinel-192.168.11.12926379
Sentinel-192.168.11.13026379

2

多哨兵监控Redis

配置测试

 

1、调整结构，6379带着80、81

2、自定义的 /myredis 目录下新建 sentinel.conf 文件，名字千万不要错

3、配置哨兵，填写内容

  • sentinel monitor 被监控主机名字 127.0.0.1 6379 1
  • 上面最后一个数字1，表示主机挂掉后slave投票看让谁接替成为主机，得票数多少后成为主机

4、启动哨兵

  • Redis-sentinel   /myredis/sentinel.conf
  • 上述目录依照各自的实际情况配置，可能目录不同

5、正常主从演示

6、原有的Master 挂了

7、投票新选

8、重新主从继续开工，info replication 查查看

9、问题：如果之前的master 重启回来，会不会双master 冲突？ 之前的回来只能做小弟了

注意启动的顺序。首先是主机的Redis服务进程，然后启动从机的服务进程，最后启动3个哨兵的服务进程。

 

哨兵模式的其他配置项

配置项参数类型作用
port整数启动哨兵进程端口
dir文件夹目录哨兵进程服务临时文件夹，默认为/tmp，要保证有可写入的权限
sentinel down-after-milliseconds<服务名称><毫秒数（整数）>指定哨兵在监控Redis服务时，当Redis服务在一个默认毫秒数内都无法回答时，单个哨兵认为的主观下线时间，默认为30000（30秒）
sentinel parallel-syncs<服务名称><服务器数（整数）>指定可以有多少个Redis服务同步新的主机，一般而言，这个数字越小同步时间越长，而越大，则对网络资源要求越高
sentinel failover-timeout<服务名称><毫秒数（整数）>指定故障切换允许的毫秒数，超过这个时间，就认为故障切换失败，默认为3分钟
sentinel notification-script<服务名称><脚本路径>指定sentinel检测到该监控的redis实例指向的实例异常时，调用的报警脚本。该配置项可选，比较常用

sentinel down-after-milliseconds配置项只是一个哨兵在超过规定时间依旧没有得到响应后，会自己认为主机不可用。对于其他哨兵而言，并不是这样认为。哨兵会记录这个消息，当拥有认为主观下线的哨兵达到sentinel monitor所配置的数量时，就会发起一次投票，进行failover，此时哨兵会重写Redis的哨兵配置文件，以适应新场景的需要。

 

这个时候如果主机宕机了

image-20210427223236066

哨兵模式的优缺点

 优点

1. 哨兵集群模式是基于主从模式的，所有主从的优点，哨兵模式同样具有。

2. 主从可以切换，故障可以转移，系统可用性更好。

3. 哨兵模式是主从模式的升级，系统更健壮，可用性更高。
缺点

1. Redis较难支持在线扩容，在集群容量达到上限时在线扩容会变得很复杂。

2. 实现哨兵模式的配置也不简单，甚至可以说有些繁琐

哨兵配置说明

  1. # Example sentinel.conf
  2.  
  3. # 哨兵sentinel实例运行的端口 默认26379
  4. port 26379
  5.  
  6. # 哨兵sentinel的工作目录
  7. dir /tmp
  8.  
  9. # 哨兵sentinel监控的redis主节点的 ip port 
  10. # master-name  可以自己命名的主节点名字 只能由字母A-z、数字0-9 、这三个字符".-_"组成。
  11. # quorum 配置多少个sentinel哨兵统一认为master主节点失联 那么这时客观上认为主节点失联了
  12. # sentinel monitor <master-name> <ip> <redis-port> <quorum>
  13. sentinel monitor mymaster 127.0.0.1 6379 2
  14.  # 当在Redis实例中开启了requirepass foobared 授权密码 这样所有连接Redis实例的客户端都
  15. 要提供密码
  16. # 设置哨兵sentinel 连接主从的密码 注意必须为主从设置一样的验证密码
  17. # sentinel auth-pass <master-name> <password>
  18. sentinel auth-pass mymaster MySUPER--secret-0123passw0rd
  19. # 指定多少毫秒之后 主节点没有应答哨兵sentinel 此时 哨兵主观上认为主节点下线 默认30秒
  20. # sentinel down-after-milliseconds <master-name> <milliseconds>
  21. sentinel down-after-milliseconds mymaster 30000
  22.  
  23. # 这个配置项指定了在发生failover主备切换时最多可以有多少个slave同时对新的master进行 同
  24. 步，
  25. 这个数字越小，完成failover所需的时间就越长，
  26. 但是如果这个数字越大，就意味着越 多的slave因为replication而不可用。
  27. 可以通过将这个值设为 1 来保证每次只有一个slave 处于不能处理命令请求的状态。
  28. # sentinel parallel-syncs <master-name> <numslaves>
  29. sentinel parallel-syncs mymaster 1
  30. # 故障转移的超时时间 failover-timeout 可以用在以下这些方面： 
  31. #1. 同一个sentinel对同一个master两次failover之间的间隔时间。
  32. #2. 当一个slave从一个错误的master那里同步数据开始计算时间。直到slave被纠正为向正确的
  33. master那里同步数据时。
  34. #3.当想要取消一个正在进行的failover所需要的时间。  
  35. #4.当进行failover时，配置所有slaves指向新的master所需的最大时间。不过，即使过了这个超
  36. 时，slaves依然会被正确配置为指向master，但是就不按parallel-syncs所配置的规则来了
  37. # 默认三分钟
  38. # sentinel failover-timeout <master-name> <milliseconds>
  39. sentinel failover-timeout mymaster 180000
  40. # SCRIPTS EXECUTION
  41.  
  42. #配置当某一事件发生时所需要执行的脚本，可以通过脚本来通知管理员，例如当系统运行不正常时发邮
  43. 件通知相关人员。
  44. #对于脚本的运行结果有以下规则：
  45. #若脚本执行后返回1，那么该脚本稍后将会被再次执行，重复次数目前默认为10
  46. #若脚本执行后返回2，或者比2更高的一个返回值，脚本将不会重复执行。
  47. #如果脚本在执行过程中由于收到系统中断信号被终止了，则同返回值为1时的行为相同。
  48. #一个脚本的最大执行时间为60s，如果超过这个时间，脚本将会被一个SIGKILL信号终止，之后重新执
  49. 行。
  50.  
  51. #通知型脚本:当sentinel有任何警告级别的事件发生时（比如说redis实例的主观失效和客观失效等
  52. 等），将会去调用这个脚本，这时这个脚本应该通过邮件，SMS等方式去通知系统管理员关于系统不正常
  53. 运行的信息。调用该脚本时，将传给脚本两个参数，一个是事件的类型，一个是事件的描述。如果
  54. sentinel.conf配置文件中配置了这个脚本路径，那么必须保证这个脚本存在于这个路径，并且是可执
  55. 行的，否则sentinel无法正常启动成功。
  56. #通知脚本
  57. # sentinel notification-script <master-name> <script-path>
  58. sentinel notification-script mymaster /var/redis/notify.sh
  59.  
  60. # 客户端重新配置主节点参数脚本
  61. # 当一个master由于failover而发生改变时，这个脚本将会被调用，通知相关的客户端关于master
  62. 地址已经发生改变的信息。
  63. # 以下参数将会在调用脚本时传给脚本:
  64. # <master-name> <role> <state> <from-ip> <from-port> <to-ip> <to-port>
  65. # 目前<state>总是“failover”,
  66. # <role>是“leader”或者“observer”中的一个。 
  67. # 参数 from-ip, from-port, to-ip, to-port是用来和旧的master和新的master(即旧的
  68. slave)通信的
  69. # 这个脚本应该是通用的，能被多次调用，不是针对性的。
  70. # sentinel client-reconfig-script <master-name> <script-path>
  71. sentinel client-reconfig-script mymaster /var/redis/reconfig.sh

 

Redis缓存穿透和雪崩

缓存穿透 (查不到)

概念

缓存穿透的概念很简单，用户想要查询一个数据，发现redis内存数据库没有，也就是缓存没有命中，于是向持久层数据库查询。发现也没有，于是本次查询失败。当用户很多的时候，缓存都没有命中，于是都去请求了持久层数据库。这会给持久层数据库造成很大的压力，这时候就相当于出现了缓存穿透。

这里需要注意和缓存击穿的区别，缓存击穿，是指一个key非常热点，在不停的扛着大并发，大并发集中对这一个点进行访问，当这个key在失效的瞬间，持续的大并发就穿破缓存，直接请求数据库，就像在一个屏障上凿开了一个洞。

解决方案

布隆过滤器

布隆过滤器是一种数据结构，垃圾网站和正常网站加起来全世界据统计也有几十亿个。网警要过滤这些垃圾网站，总不能到数据库里面一个一个去比较吧，这就可以使用布隆过滤器。假设我们存储一亿个垃圾网站地址。

可以先有一亿个二进制比特，然后网警用八个不同的随机数产生器（F1,F2, …,F8） 产生八个信息指纹（f1, f2, …, f8）。接下来用一个随机数产生器 G 把这八个信息指纹映射到 1 到1亿中的八个自然数 g1, g2, …,g8。最后把这八个位置的二进制全部设置为一。过程如下：

3

有一天网警查到了一个可疑的网站，想判断一下是否是XX网站，首先将可疑网站通过哈希映射到1亿个比特数组上的8个点。如果8个点的其中有一个点不为1，则可以判断该元素一定不存在集合中。

那这个布隆过滤器是如何解决redis中的缓存穿透呢？很简单首先也是对所有可能查询的参数以hash形式存储，当用户想要查询的时候，使用布隆过滤器发现不在集合中，就直接丢弃，不再对持久层查询。

1

这个形式很简单。

缓存空对象

当存储层不命中后，即使返回的空对象也将其缓存起来，同时会设置一个过期时间，之后再访问这个数据将会从缓存中获取，保护了后端数据源；

2

但是这种方法会存在两个问题：

如果空值能够被缓存起来，这就意味着缓存需要更多的空间存储更多的键，因为这当中可能会有很多的空值的键；即使对空值设置了过期时间，还是会存在缓存层和存储层的数据会有一段时间窗口的不一致，这对于需要保持一致性的业务会有影响。

缓存击穿 (查询量太大，缓存过期）

描述

这里需要注意和缓存击穿的区别，缓存击穿，是指一个key非常热点，在不停的扛着大并发，大并发集中对这一个点进行访问，当这个key在失效

的瞬间，持续的大并发就穿破缓存，直接请求数据库，就像在一个屏障上凿开了一个洞。

当某个key在过期的瞬间，有大量的请求并发访问，这类数据一般是热点数据，由于缓存过期，会同时访问数据库来查询最新数据，并且回写缓

存，会导使数据库瞬间压力过大。

解决方案

  1. 设置热点数据永远不过期
  2. 接口限流与熔断，降级
  3. 加互斥锁

分布式锁：使用分布式锁，保证对于每个key同时只有一个线程去查询后端服务，其他线程没有获得分布式锁的权限，因此只需要等待即可。这种方式将高并发的压力转移到了分布式锁，因此对分布式锁的考验很大。

重要的接口一定要做好限流策略，防止用户恶意刷接口，同时要降级准备，当接口中的某些 服务 不可用时候，进行熔断，失败快速返回机制。

  1. 布隆过滤器

bloomfilter就类似于一个hash set，用于快速判某个元素是否存在于集合中，其典型的应用场景就是快速判断一个key是否存在于某容器，不存在就直接返回。布隆过滤器的关键就在于hash算法和容器大小

  1. 加互斥锁，互斥锁参考代码如下：

3

说明：

​ 1）缓存中有数据，直接走上述代码13行后就返回结果了

​ 2）缓存中没有数据，第1个进入的线程，获取锁并从数据库去取数据，没释放锁之前，其他并行进入的线程会等待100ms，再重新去缓存取数据。这样就防止都去数据库重复取数据，重复往缓存中更新数据情况出现。

​ 3）当然这是简化处理，理论上如果能根据key值加锁就更好了，就是线程A从数据库取key1的数据并不妨碍线程B取key2的数据，上面代码明显做不到这点。

缓存雪崩

概念

缓存雪崩，是指在某一个时间段，缓存集中过期失效。

产生雪崩的原因之一，比如在写本文的时候，马上就要到双十二零点，很快就会迎来一波抢购，这波商品时间比较集中的放入了缓存，假设缓存一

个小时。那么到了凌晨一点钟的时候，这批商品的缓存就都过期了。而对这批商品的访问查询，都落到了数据库上，对于数据库而言，就会产生周

期性的压力波峰。于是所有的请求都会达到存储层，存储层的调用量会暴增，造成存储层也会挂掉的情况。
4

解决方案

（1）redis高可用

这个思想的含义是，既然redis有可能挂掉，那我多增设几台redis，这样一台挂掉之后其他的还可以继续工作，其实就是搭建的集群。

（2）限流降级

这个解决方案的思想是，在缓存失效后，通过加锁或者队列来控制读数据库写缓存的线程数量。比如对某个key只允许一个线程查询数据和写缓存，其他线程等待。

（3）数据预热

数据加热的含义就是在正式部署之前，我先把可能的数据先预先访问一遍，这样部分可能大量访问的数据就会加载到缓存中。在即将发生大并发访问前手动触发加载缓存不同的key，设置不同的过期时间，让缓存失效的时间点尽量均匀。

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/IT小白/article/detail/673654
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号