Redis学习笔记——尚硅谷

Redis6

1.NoSQL数据库简介

1.1 技术发展

• 技术的分类

  • 解决功能性的问题：Java、Jsp、RDBMS、Tomcat、HTML、Linux、JDBC、SVN
  • 解决扩展性的问题：Struts、Spring、SpringMVC、Hibernate、Mybatis
  • 解决性能的问题：NoSQL、Java线程、Hadoop、Nginx、MQ、ElasticSearch

• Web1.0时代

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

  

• Web2.0时代

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

  

• 解决Web2.0问题

  • 解决CPU及内存压力

    

  • 解决IO压力

    

1.2 NoSQL数据库

• NoSQL数据库概述

  • NoSQL(Not Only SQL)，意即“不仅仅是SQL”，泛指非关系型的数据库。
  • NoSQL 不依赖业务逻辑方式存储，而以简单的key-value模式存储，因此大大的增加了数据库的扩展能力。
    • 不遵循SQL标准。
    • 不支持ACID(事务的四个特性)。
    • 远超于SQL的性能。

• NoSQL适用场景

  • 对数据高并发的读写
  • 海量数据的读写
  • 对数据高可扩展性的

• NoSQL不适用场景

  • 需要事务支持
  • 基于sql的结构化查询存储，处理复杂的关系，需要即席查询。
  • 用不着sql的和用了sql也不行的情况，请考虑用NoSql

• 常见的NoSQL数据库

  • Memcache

    

  • Redis

    

  • MongoDB

    

1.3 行式存储数据库（大数据时代）

• 行式数据库

  

• 列式数据库

  

  • Hbase

    • HBase是Hadoop项目中的数据库。
    • 它用于需要对大量的数据进行随机、实时的读写操作的场景中。
    • HBase的目标就是处理数据量非常庞大的表，可以用普通的计算机处理超过10亿行数据，还可处理有数百万列元素的数据表

  • Cassandra[kəˈsændrə]

    Apache Cassandra是一款免费的开源NoSQL数据库，其设计目的在于管理由大量商用服务器构建起来的庞大集群上的海量数据集(数据量通常达到PB级别)。在众多显著特性当中，Cassandra最为卓越的长处是对写入及读取操作进行规模调整，而且其不强调主集群的设计思路能够以相对直观的方式简化各集群的创建与扩展流程

• 图关系型数据库

  主要应用：社会关系，公共交通网络，地图及网络拓谱

  

2.Redis概述安装

2.0 概述

• Redis是一个开源的key-value存储系统。
• 和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。
• 这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。
• 在此基础上，Redis支持各种不同方式的排序。
• 与memcached一样，为了保证效率，数据都是缓存在内存中。
• 区别的是Redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件。并且在此基础上实现了master-slave(主从)同步

2.1 应用场景

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

  • 高频次，热门访问的数据，降低数据库IO
  • 分布式架构，做session共享

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

  

2.2 Redis安装

Redis官方网站	Redis中文官方网站
http://redis.io	http://redis.cn/

安装版本

• 6.2.1 for Linux（redis-6.2.1.tar.gz）
• 不用考虑在windows环境下对Redis的支持

安装步骤(Ubantu 安装gcc时失败)

1. 使用Ubantu，获得ip192.168.2.128

   sudo apt install net-tools
   ifconifg
   

2. Ubantu安装远程连接

   sudo apt-get install openssh-server
   #出现报错执行下面两个
   sudo apt-get update
   sudo /etc/init.d/ssh restart
   

3. 打开Linux系统，将压缩包放到先放在桌面，进入远程连接软件

   cd /home/duanyf/桌面
   sudo mv redis-6.2.1.tar.gz /opt/
   

4. 安装vim

   sudo apt-get install vim-gtk
   

5. 安装yum

   1. 备份source源文件

      sudo cp /etc/apt/sources.list /etc/apt/sources.list.bak
      

   2. 打开源文件

      sudo vim /etc/apt/sources.list
      

   3. 修改镜像源

      获取镜像源地址：清华大学开源镜像站

      

      将上述复制的镜像源地址复制到/etc/apt/sources.list此文件中，去除http后的s

      # 默认注释了源码镜像以提高 apt update 速度，如有需要可自行取消注释
      deb http://mirrors.tuna.tsinghua.edu.cn/ubuntu/ jammy main restricted universe multiverse
      # deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ jammy main restricted universe multiverse
      deb http://mirrors.tuna.tsinghua.edu.cn/ubuntu/ jammy-updates main restricted universe multiverse
      # deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ jammy-updates main restricted universe multiverse
      deb http://mirrors.tuna.tsinghua.edu.cn/ubuntu/ jammy-backports main restricted universe multiverse
      # deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ jammy-backports main restricted universe multiverse
      deb http://mirrors.tuna.tsinghua.edu.cn/ubuntu/ jammy-security main restricted universe multiverse
      # deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ jammy-security main restricted universe multiverse
      
      # 预发布软件源，不建议启用
      # deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ jammy-proposed main restricted universe multiverse
      # deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ jammy-proposed main restricted universe multiverse
      

      sudo apt-get update
      sudo apt-get install --reinstall ca-certificates
      

      添加如下镜像

      
      deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ bionic main restricted universe multiverse
      deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ bionic main restricted universe multiverse
      deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ bionic-updates main restricted universe multiverse
      deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ bionic-updates main restricted universe multiverse
      deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ bionic-backports main restricted universe multiverse
      deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ bionic-backports main restricted universe multiverse
      deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ bionic-security main restricted universe multiverse
      deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ bionic-security main restricted universe multiverse
      deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ bionic-proposed main restricted universe multiverse
      deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ bionic-proposed main restricted universe multiverse
      deb http://mirrors.aliyun.com/ubuntu/ bionic main restricted universe multiverse
      deb http://mirrors.aliyun.com/ubuntu/ bionic-security main restricted universe multiverse
      deb http://mirrors.aliyun.com/ubuntu/ bionic-updates main restricted universe multiverse
      deb http://mirrors.aliyun.com/ubuntu/ bionic-proposed main restricted universe multiverse
      deb http://mirrors.aliyun.com/ubuntu/ bionic-backports main restricted universe multiverse
      deb-src http://mirrors.aliyun.com/ubuntu/ bionic main restricted universe multiverse
      deb-src http://mirrors.aliyun.com/ubuntu/ bionic-security main restricted universe multiverse
      deb-src http://mirrors.aliyun.com/ubuntu/ bionic-updates main restricted universe multiverse
      deb-src http://mirrors.aliyun.com/ubuntu/ bionic-proposed main restricted universe multiverse
      deb-src http://mirrors.aliyun.com/ubuntu/ bionic-backports main restricted universe multiverse
      

      再次更新源

      sudo apt-get update
      

6. 安装yum

   sudo apt install yum
   

安装centos

1. 下载centos

   • 点击链接下载https://vault.centos.org/

   • 找到自己想要下载的版本，点击进入

     

   • 找到 isos/，点击进入

     

   • 点击x86_64/

     

   • 我们只需要选择DVD.iso

     

2. 安装CentOS

   • 打开你的VMware Workstation Pro，并点击“创建新的虚拟机”

   • 点选自定义(推荐)(T)，并点击“下一步”

   • 点选稍后安装操作系统(S)，并点击“下一步”

   • 点选Linux(L)，因为我们之前下载的 CentOS-7-x86_64-DVD-1708.iso 是64位 7.4版本的，所以这里我们选择CentOS 7 64位，并点击“下一步”

     

   • 点击“下一步”

   • 指定内存

     

   • 默认为NAT 模式(N)：用于共享主机的IP地址即可

   • 一直下一步，完成

   • 选择iso

     

   • 开启虚拟机，选择Install CentOS 7，最后按下“Enter 键”回车。

     

     

   • 选择“中文”，点击“继续”。

     

   • 点击“安装位置”，进去后再点击“完成”。

     

   • 点击“软件选择”

     

   • 选择“GNUOME桌面”，再勾选“GNOME应用程序”“开发工具”“安全性工具”，最后点击“完成(D)”

     

   • 卡一会，点击“开始安装”。

   • 设置root密码，并且创建一个管理员账户

     

   • 等待安装，安装成功后点击"重启®"。

     

   • 接受许可协议并设置网络(打开)

     

     

     

   • 登录账户，CentOS 7安装完成

安装步骤(centos)

• 获得ip192.168.2.134

• 关闭ipv6(不知道哪一步成功)

  1. 编辑/etc/sysctl.conf配置

     sudo vim /etc/sysctl.conf
     

     增加

     net.ipv6.conf.all.disable_ipv6 =1
     net.ipv6.conf.default.disable_ipv6 =1
     

     注意：确保文件/etc/ssh/sshd_config 包含AddressFamily inet行，以避免在使用sysctl方法时破坏SSHXforwarding

     将AddressFamily行添加到sshd_config：

     

     重新启动sshd以获得更改以获得生效：

     systemctl restart sshd
     

  2. 编辑/etc/sysconfig/network配置，增加 NETWORKING_IPV6=no，保存并退出

     sudo vim /etc/sysconfig/network
     

     

  3. 编辑/etc/sysconfig/network-scripts/ifcfg-eno16777736，ifcfg-eno16777736是根据自己机器的，实际网卡信息来看，不是固定的

     sudo vim /etc/sysconfig/network-scripts/ifcfg-ens33
     

     

  4. 关闭防火墙的开机自启动(centos7没有ip6tables.service)

     systemctl disable ip6tables.service
     

  5. 编辑/etc/default/grub，在GRUB_CMDLINE_LINUX的句首加上ipv6.disable=1(无用)

     sudo vim /etc/default/grub
     

     修改后

     [root@localhost Desktop]# cat /etc/default/grub 
     GRUB_TIMEOUT=5
     GRUB_DISTRIBUTOR="$(sed 's, release .*$,,g' /etc/system-release)"
     GRUB_DEFAULT=saved
     GRUB_DISABLE_SUBMENU=true
     GRUB_TERMINAL_OUTPUT="console"
     GRUB_CMDLINE_LINUX="ipv6.disable=1 rd.lvm.lv=centos/root rd.lvm.lv=centos/swap rhgb quiet"
     GRUB_DISABLE_RECOVERY="true"
     

     修改完毕后保存，运行grub2-mkconfig -o /boot/grub2/grub.cfg重新生成grub.cfg文件。

     sudo grub2-mkconfig -o /boot/grub2/grub.cfg
     

  6. 重启

     sysctl -p
     

• 关闭防火墙

  1. 命令行界面输入命令systemctl status firewalld.service并按下回车键

     

     在下方可以查看得到active(running)，此时说明防火墙已经被打开了

  2. 在命令行中输入systemctl stop firewalld.service命令，进行关闭防火墙

     

  3. 再使用命令systemctl status firewalld.service，在下方出现inavtive（dead），这权样就说明防火墙已经关闭

     

  4. 再在命令行中输入命令systemctl disable firewalld.service命令，即可永久关闭防火墙

     

• 远程连接

  1. 报错/usr/bin/xauth: file /home/dunayf/.Xauthority does not exist

     chown dunayf:dunayf -R /home/dunayf
     

• 将用户加入到sudoers文件中

  1. 切换至root用户

     su - root
     

  2. 给root用户添加可写权限

     chmod 640 /etc/sudoers
     

  3. 修改sudoers文件

     vim /etc/sudoers
     

     如下图所示位置加上duanyf ALL=(ALL) ALL

  4. 查看是否修改成功

     cat /etc/sudoers
     

  5. 修改sudoers文件：只读权限（原有权限）

     chmod 440 /etc/sudoers
     

  6. 返回普通用户

     exit
     

• 将压缩包放到通过mobaxterm先放在桌面，进入远程连接软件

  cd /home/duanyf/桌面
  sudo mv redis-6.2.1.tar.gz /opt/
  

• 安装gcc

  yum install gcc
  #测试
  gcc --version
  

• 解压redis

  tar -zxvf redis-6.2.1.tar.gz
  

• 解压完成后进入目录

  cd redis-6.2.1
  

• 在redis-6.2.1目录下再次执行make命令（只是编译好）

  sudo make
  

  

• 跳过make test 继续执行: make install

  sudo make install
  

  

• 默认安装目录：/usr/local/bin

  redis-benchmark:性能测试工具，可以在自己本子运行，看看自己本子性能如何
  redis-check-aof：修复有问题的AOF文件，rdb和aof后面讲
  redis-check-dump：修复有问题的dump.rdb文件
  redis-sentinel：Redis集群使用
  redis-server：Redis服务器启动命令
  redis-cli：客户端，操作入口
  

启动

• 前台启动

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

  redis-server
  

  

• 后台启动

  1. 拷贝一份redis.conf到其他目录

     cd /usr/local/bin
     sudo cp /opt/redis-6.2.1/redis.conf /etc/redis.conf
     

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

     sudo vim /etc/redis.conf
     

  3. Redis启动

     cd /usr/local/bin
     redis-server /etc/redis.conf
     #查看进程
     ps -ef | grep redis
     

  4. 用客户端访问

     单个端口

     redis-cli
     

     多个端口

     redis-cli -p6379
     

  5. Redis关闭

     • 进入终端后再关闭

       

     • 单实例关闭：redis-cli shutdown

     • 实例关闭，指定端口关闭：redis-cli -p 6379 shutdown

     • 杀死进程

       kill -9 [pid]
       

解决关闭错误

1. 首先先在redis-cli的同级目录下创建一个redis的日志文件，然后把此文件的权限更改为，对所有的用户都可以进行读写操作

   sudo touch redis-log.log
   sudo chmod 777 redis-log.log
   sudo chmod 777 /user/local/bin
   

   

2. 去redis的配置文件中指明redis的日志文件的位置，如下图：

   sudo vim /etc/redis.conf
   

   

3. 把redis-server服务的进程号杀死，然后重新启动redis-server服务，去日志查看报错

   cd /usr/local/bin
   
   #查看进程
   ps -ef | grep redis
   
   #杀死进程
   sudo kill -9 [pid]
   
   #启动
   redis-server /etc/redis.conf
   
   #关闭
   redis-cli shutdown
   
   #查看日志
   vim redis-log.log
   

   

4. 报错信息：主要是权限问题

   21201:M 23 Sep 2022 00:40:26.944 # User requested shutdown...
   21201:M 23 Sep 2022 00:40:26.944 * Saving the final RDB snapshot before exiting.
   21201:M 23 Sep 2022 00:40:26.944 # Failed opening the RDB file dump.rdb (in server root dir /usr/local/bin) for saving: Permission denied
   21201:M 23 Sep 2022 00:40:26.944 # Error trying to save the DB, can't exit.
   

   解决：

   #设置权限
   sudo chmod 777 /etc/redis.conf
   sudo chmod 777 /etc
   #查看进程
   ps -ef | grep redis
   
   #杀死进程
   sudo kill -9 [pid]
   
   #启动
   redis-server /etc/redis.conf
   
   #关闭
   redis-cli shutdown
   

解决IP自动变化问题

sudo vim /etc/sysconfig/network-scripts/ifcfg-ens33

IPADDR=192.168.2.152 #你想要的IP
NETMASK=255.255.255.0
GATEWAY=192.168.2.2
DNS1=8.8.8.8

2.3 Redis介绍相关知识

• Redis中默认16个数据库，类似数组下标从0开始，初始默认使用0号库

• 使用命令 select 来切换数据库。如: select 8

• 统一密码管理，所有库同样密码

• 操作指令：

  dbsize 查看当前数据库的key的数量
  flushdb 清空当前库
  flushall 通杀全部库
  

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

  • 多路复用是指使用一个线程来检查多个文件描述符（Socket）的就绪状态，比如调用select和poll函数，传入多个文件描述符，如果有一个文件描述符就绪，则返回，否则阻塞直到超时。

  • 得到就绪状态后进行真正的操作可以在同一个线程里执行，也可以启动线程执行（比如使用线程池）。

  • 实例讲解

    

    1，2，3都让黄牛帮忙卖票，然后去做自己的事情

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

  与Memcache三点不同: 支持多数据类型，支持持久化，单线程+多路IO复用

3.常用五大数据类型

指的是key-value中，value的类型

3.1 Redis键(key)

进入客户端redis-cli可使用一下命令

keys *					查看当前库所有key (匹配：keys *1)
exists key				判断某个key是否存在
type key				查看你的key是什么类型
del key       			删除指定的key数据
unlink key   			根据value选择非阻塞删除
						仅将keys从keyspace元数据中删除，真正的删除会在后续异步操作。
expire key 10   		10秒钟：为给定的key设置过期时间
ttl key 				查看还有多少秒过期，-1表示永不过期，-2表示已过期

select					命令切换数据库
dbsize					查看当前数据库的key的数量
flushdb					清空当前库
flushall				通杀全部库

• keys *:查看当前库所有key (匹配：keys *1)

  

• exists key:判断某个key是否存在

  

• type key:查看你的key是什么类型

  

• del key:删除指定的key数据

  

• unlink key:根据value选择非阻塞删除，仅将keys从keyspace元数据中删除，真正的删除会在后续异步操作

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

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

  

• select:命令切换数据库

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

• flushdb:清空当前库

• flushall:通杀全部库

3.2 Redis字符串(String)

• 简介

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

• 常用命令

  1. set :添加键值对

     

     *NX：当数据库中key不存在时，可以将key-value添加数据库
     *XX：当数据库中key存在时，可以将key-value添加数据库，与NX参数互斥
     *EX：key的超时秒数
     *PX：key的超时毫秒数，与EX互斥
     

  2. get :查询对应键值

  3. append :将给定的 追加到原值的末尾

  4. strlen:获得值的长度

  5. setnx :只有在 key 不存在时，设置 key 的值

  6. incr ：将 key 中储存的数字值增1；只能对数字值操作，如果为空，新增值为1，具有原子性

  7. decr :将 key 中储存的数字值减1；只能对数字值操作，如果为空，新增值为-1

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

  9. mset ..... :同时设置一个或多个 key-value对

  10. mget .....:同时获取一个或多个 value

  11. msetnx ..... :同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在。具有原子性，有一个失败则都失败

  12. getrange <起始位置><结束位置>:获得值的范围，类似java中的substring，前包，后包

  13. setrange <起始位置>:用 覆写所储存的字符串值，从<起始位置>开始(索引从0开始)。

      

  14. setex <过期时间>:设置键值的同时，设置过期时间，单位秒。

  15. getset :以新换旧，设置了新值同时获得旧值。

• 数据结构

  • String的数据结构为简单动态字符串(Simple Dynamic String,缩写SDS)。

  • 是可以修改的字符串，内部结构实现上类似于Java的ArrayList，采用预分配冗余空间的方式来减少内存的频繁分配.

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

    

3.3 Redis列表(List)

• 简介

  • 单键多值

  • Redis 列表是简单的字符串列表，按照插入顺序排序。

  • 你可以添加一个元素到列表的头部（左边）或者尾部（右边）。

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

    

• 常用命令

  1. lpush/rpush .... :从左边/右边插入一个或多个值。

     

  2. lpop/rpop :从左边/右边吐出一个值。值在键在，值光键亡。

     

  3. rpoplpush :从列表右边吐出一个值，插到列表左边。

     

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

  5. lrange 0-1: 0左边第一个，-1右边第一个，（0-1表示获取所有）

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

  7. llen :获得列表长度

  8. linsert before/after "" "":在的 后面/前面 插入插入值

  9. lrem "":从左边删除n个value(从左到右)

     

  10. lset :将列表key下标为index的值替换成value

• 数据结构

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

  • 首先在列表元素较少的情况下会使用一块连续的内存存储，这个结构是ziplist，也即是压缩列表。它将所有的元素紧挨着一起存储，分配的是一块连续的内存。

  • 当数据量比较多的时候才会改成quicklist，因为普通的链表需要的附加指针空间太大，会比较浪费空间。比如这个列表里存的只是int类型的数据，结构上还需要两个额外的指针prev和next。

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

    

3.4 Redis集合(Set)

• 简介
  • Redis set对外提供的功能与list类似是一个列表的功能，特殊之处在于set是可以自动排重的
  • 当你需要存储一个列表数据，又不希望出现重复数据时，set是一个很好的选择，并且set提供了判断某个成员是否在一个set集合内的重要接口，这个也是list所不能提供的。
  • Redis的Set是string类型的无序集合。它底层其实是一个value为null的hash表，所以添加，删除，查找的复杂度都是O(1)。
  • 一个算法，随着数据的增加，执行时间的长短，如果是O(1)，数据增加，查找数据的时间不变
• 常用命令
  1. sadd ..... :将一个或多个 member 元素加入到集合 key 中，已经存在的 member 元素将被忽略
  2. smembers :取出该集合的所有值。
  3. sismember :判断集合是否为含有该值，有1，没有0
  4. scard:返回该集合的元素个数。
  5. srem ....: 删除集合中的某个元素。
  6. spop :随机从该集合中吐出一个值，会从集合中删除。
  7. srandmember :随机从该集合中取出n个值。不会从集合中删除 。
  8. smove :把集合中一个值从一个集合移动到另一个集合
  9. sinter :返回两个集合的交集元素。
  10. sunion :返回两个集合的并集元素。
  11. sdiff :两个集合的差集元素(在key1中不包含key2中的)
• 数据结构
  • Set数据结构是dict字典，字典是用哈希表实现的。
  • Java中HashSet的内部实现使用的是HashMap，只不过所有的value都指向同一个对象。
  • Redis的set结构也是一样，它的内部也使用hash结构，所有的value都指向同一个内部值。

3.4 Redis哈希(Hash)

• 简介

  • Redis hash 是一个键值对集合。

  • Redis hash是一个string类型的field和value的映射表，hash特别适合用于存储对象，类似Java里面的Map

  • 用户ID为查找的key，存储的value用户对象包含姓名，年龄，生日等信息

    • 如果用普通的key/value结构来存储，主要有以下2种存储方式：

      

    • 通过 key(用户ID) + field(属性标签) 就可以操作对应属性数据了，既不需要重复存储数据，也不会带来序列化和并发修改控制的问题

      

• 常用命令

  1. hset :给集合中的 键赋值

     

  2. hget :从集合取出

     

  3. hmset ... :批量设置hash的值

  4. hexists :查看哈希表 key 中，给定域 field 是否存在。

  5. hkeys :列出该hash集合的所有field

  6. hvals :列出该hash集合的所有value

  7. hincrby 为哈希表 key 中的域 field 的值加上增量

  8. hsetnx :将哈希表 key 中的域 field 的值设置为 value ，当且仅当域 field 不存在 .

• 数据结构

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

3.5 Redis有序集合Zset(sorted set)

• 简介

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

• 常用命令

  1. zadd …:将一个或多个 member 元素及其 score 值加入到有序集 key 当中。

  2. zrange [WITHSCORES]:返回有序集 key 中，下标在之间的元素
     带WITHSCORES，可以让分数一起和值返回到结果集。

     

  3. zrangebyscore key min max [withscores] [limit offset count]:返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从小到大)次序排列。

     

  4. zrevrangebyscore key max min [withscores] [limit offset count]:同上，改为从大到小排列。

  5. zincrby :为元素的score加上增量increment

  6. zrem :删除该集合下，指定值的元素

  7. zcount :统计该集合，分数区间内的元素个数

  8. zrank :返回该值在集合中的排名，从0开始。

• 数据结构

  • SortedSet(zset)是Redis提供的一个非常特别的数据结构

    • 一方面它等价于Java的数据结构Map，可以给每一个元素value赋予一个权重score

    • 一方面它又类似于TreeSet，内部的元素会按照权重score进行排序，可以得到每个元素的名次，还可以通过score的范围来获取元素的列表。

  • zset底层使用了两个数据结构

    1. hash作用就是关联元素value和权重score，保障元素value的唯一性，可以通过元素value找到相应的score值。
    2. 跳跃表，跳跃表的目的在于给元素value排序，根据score的范围获取元素列表。

4.Redis配置文件介绍

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

4.1 Units单位

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

# Redis configuration file example.
#
# Note that in order to read the configuration file, Redis must be
# started with the file path as first argument:
#
# ./redis-server /path/to/redis.conf

# Note on units: when memory size is needed, it is possible to specify
# it in the usual form of 1k 5GB 4M and so forth:
#
# 1k => 1000 bytes
# 1kb => 1024 bytes
# 1m => 1000000 bytes
# 1mb => 1024*1024 bytes
# 1g => 1000000000 bytes
# 1gb => 1024*1024*1024 bytes
#
# units are case insensitive so 1GB 1Gb 1gB are all the same.

4.2 INCLUDES包含

• 类似jsp中的include(包含其他页面)
• 多实例的情况可以把公用的配置文件提取出来

################################## INCLUDES ###################################

# Include one or more other config files here.  This is useful if you
# have a standard template that goes to all Redis servers but also need
# to customize a few per-server settings.  Include files can include
# other files, so use this wisely.
#
# Note that option "include" won't be rewritten by command "CONFIG REWRITE"
# from admin or Redis Sentinel. Since Redis always uses the last processed
# line as value of a configuration directive, you'd better put includes
# at the beginning of this file to avoid overwriting config change at runtime.
#
# If instead you are interested in using includes to override configuration
# options, it is better to use include as the last line.
#
# include /path/to/local.conf
# include /path/to/other.conf

4.3 网络相关配置

4.3.1 bind

• 默认情况bind=127.0.0.1只能接受本机的访问请求

  

• 不写的情况下，无限制接受任何ip地址的访问

• 生产环境肯定要写你应用服务器的地址；服务器是需要远程访问的，所以需要将其注释掉

• 如果开启了protected-mode，那么在没有设定bind ip且没有设密码的情况下，Redis只允许接受本机的响应

• 当bind=127.0.0.1不写、protected-mode=no时，保存配置，停止服务，重启启动查看进程，不再是本机访问了

  

4.3.2 protected-mode

• 如果开启了protected-mode，那么在没有设定bind ip且没有设密码的情况下，Redis只允许接受本机的响应
• 将本机访问保护模式设置no

4.3.3 Port

端口号，默认 6379

4.3.4 tcp-backlog

• 设置tcp的backlog，backlog其实是一个连接队列

• backlog队列总和=未完成三次握手队列 + 已经完成三次握手队列。

• 在高并发环境下你需要一个高backlog值来避免慢客户端连接问题

• Linux内核会将这个值减小到/proc/sys/net/core/somaxconn的值128，所以需要确认增大/proc/sys/net/core/somaxconn和/proc/sys/net/ipv4/tcp_max_syn_backlog（128）两个值来达到想要的效果

  

4.3.5 timeout

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

4.3.6 tcp-keepalive

• 对访问客户端的一种心跳检测，每个n秒检测一次。

• 单位为秒，如果设置为0，则不会进行Keepalive检测，建议设置成60

  

4.4 GENERAL通用

4.4.1 daemonize

• 是否为后台进程，设置为yes
• 守护进程，后台启动

4.4.2 pidfile

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

4.4.3 loglevel

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

4.4.4 logfile

日志文件名称

4.4.5 databases 16

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

4.5 SECURITY安全

• 设置密码

  

• 在命令中设置密码，只是临时的。重启redis服务器，密码就还原了。

• 永久设置，需要再配置文件中进行设置。

  

4.6 CLIENTS

maxclients

• 设置redis同时可以与多少个客户端进行连接。

• 默认情况下为10000个客户端。

• 如果达到了此限制，redis则会拒绝新的连接请求，并且向这些连接请求方发出max number of clients reached以作回应。

  

4.7 MEMORY MANAGEMENT

4.6.1 maxmemory

• 建议必须设置，否则，将内存占满，造成服务器宕机

• 设置redis可以使用的内存量。一旦到达内存使用上限，redis将会试图移除内部数据，移除规则可以通过maxmemory-policy来指定。

• 如果redis无法根据移除规则来移除内存中的数据，或者设置了“不允许移除”，那么redis则会针对那些需要申请内存的指令返回错误信息，比如SET、LPUSH等。

• 但是对于无内存申请的指令，仍然会正常响应，比如GET等。如果你的redis是主redis（说明你的redis有从redis），那么在设置内存使用上限时，需要在系统中留出一些内存空间给同步队列缓存，只有在你设置的是“不移除”的情况下，才不用考虑这个因素。

  

4.6.2 maxmemory-policy

• volatile-lru：使用LRU算法移除key，只对设置了过期时间的键（最近最少使用）

• allkeys-lru：在所有集合key中，使用LRU算法移除key

• volatile-random：在过期集合中移除随机的key，只对设置了过期时间的键

• allkeys-random：在所有集合key中，移除随机的key

• volatile-ttl：移除那些TTL值最小的key，即那些最近要过期的key

• noeviction：不进行移除。针对写操作，只是返回错误信息

  

4.6.4 maxmemory-samples

• 设置样本数量，LRU算法和最小TTL算法都并非是精确的算法，而是估算值，所以你可以设置样本的大小，redis默认会检查这么多个key并选择其中LRU的那个。

• 一般设置3到7的数字，数值越小样本越不准确，但性能消耗越小。

  

5.Redis的发布和订阅

5.1 什么是发布和订阅

• Redis 发布订阅 (pub/sub) 是一种消息通信模式：发送者 (pub) 发送消息，订阅者 (sub) 接收消息。

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

5.2 Redis的发布和订阅

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

   

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

   

5.3 发布订阅命令行实现

1. 打开一个客户端订阅频道一(channel1)

   #打开客户端
   /usr/local/bin/redis-cli
   #订阅频道
   SUBSCRIBE channel1
   

   

2. 打开另一个客户端，给channel1发布消息hello

   #打开客户端
   /usr/local/bin/redis-cli
   #给channel1发布消息hello
   PUBLISH channel1 hello
   

   

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

   

6.Redis新数据类型

6.1 Bitmaps

• 简介

  • 现代计算机用二进制（位） 作为信息的基础单位， 1个字节等于8位

  • 例如“abc”字符串是由3个字节组成， 但实际在计算机存储时将其用二进制表示， “abc”分别对应的ASCII码分别是97、 98、 99， 对应的二进制分别是01100001、 01100010和01100011，如下图

    

  • 合理地使用操作位能够有效地提高内存使用率和开发效率

  • Redis提供了Bitmaps这个“数据类型”可以实现对位的操作

    1. Bitmaps本身不是一种数据类型， 实际上它就是字符串（key-value） ， 但是它可以对字符串的位进行操作

    2. Bitmaps单独提供了一套命令， 所以在Redis中使用Bitmaps和使用字符串的方法不太相同。 可以把Bitmaps想象成一个以位为单位的数组， 数组的每个单元只能存储0和1， 数组的下标在Bitmaps中叫做偏移量

       

• 命令

  1. setbit

     • 格式

       setbit:设置Bitmaps中某个偏移量的值（0或1）

       注：*offset:偏移量从0开始

     • 实例

       - 题目：每个独立用户是否访问过网站存放在Bitmaps中， 将访问的用户记做1， 没有访问的用户记做0， 用偏移量作为用户的id

       - 解释：设置键的第offset个位的值（从0算起） ， 假设现在有20个用户，userid=1， 6， 11， 15， 19的用户对网站进行了访问， 那么当前Bitmaps初始化结果如图

       

       - 实例：unique:users:20201106代表2020-11-06这天的独立访问用户的Bitmaps

       

       - 注意：很多应用的用户id以一个指定数字（例如10000） 开头， 直接将用户id和Bitmaps的偏移量对应势必会造成一定的浪费， 通常的做法是每次做setbit操作时将用户id减去这个指定数字。在第一次初始化Bitmaps时， 假如偏移量非常大， 那么整个初始化过程执行会比较慢， 可能会造成Redis的阻塞

  2. getbit

     • 格式：

       getbit:获取Bitmaps中某个偏移量的值

     • 实例

       获取id=8的用户是否在2020-11-06这天访问过， 返回0说明没有访问过

       

       注：因为100根本不存在，所以也是返回0

  3. bitcount

     • 格式：

       bitcount[start end]:统计字符串从start字节到end字节比特值为1的数量

     • 实例1:

       计算2022-11-06这天的独立访问用户数量

       

     • 实例2:

       start和end代表起始和结束字节数， 下面操作计算用户id在第1个字节到第3个字节之间的独立访问用户数， 对应的用户id是11， 15， 19。

       

     • 实例3:

       情景：K1 【01000001 01000000 00000000 00100001】，对应【0，1，2，3】

       ①bitcount K1 1 2: 统计下标1、2字节组中bit=1的个数，即01000000 00000000中1的个数

       ②bitcount K1 1 3:统计下标1、2、3字节组中bit=1的个数，即01000000 00000000 00100001中1的个数

       ③bitcount K1 0 -2 :统计下标0到2(下标倒数第2)，字节组中bit=1的个数，即01000001 01000000 00000000中1的个数

     • 注意：

       - redis的setbit设置或清除的是bit位置，而bitcount计算的是byte位置

       - start 和 end 参数的设置，都可以使用负数值：比如 -1 表示最后一个位，而 -2 表示倒数第二个位

  4. bitop

     • 格式:

       bitop and(or/not/xor) [key…]

     • 作用：

       bitop是一个复合操作， 它可以做多个Bitmaps的and（交集） 、 or（并集） 、 not（非） 、 xor（异或） 操作并将结果保存在destkey中

     • 实例1

       #2020-11-04 日访问网站的userid=1,2,5,9。
       setbit unique:users:20201104 1 1
       setbit unique:users:20201104 2 1
       setbit unique:users:20201104 5 1
       setbit unique:users:20201104 9 1
       
       
       
       #2020-11-03 日访问网站的userid=0,1,4,9。
       setbit unique:users:20201103 0 1
       setbit unique:users:20201103 1 1
       setbit unique:users:20201103 4 1
       setbit unique:users:20201103 9 1
       

       计算出两天都访问过网站的用户数量

       bitop and unique:users:and:20201104_03 unique:users:20201103 unique:users:20201104
       

       

       

     • 计算出任意一天都访问过网站的用户数量（例如月活跃就是类似这种） ， 可以使用or求并集

       

• Bitmaps与set对比

  假设网站有1亿用户， 每天独立访问的用户有5千万， 如果每天用集合类型和Bitmaps分别存储活跃用户可以得到表

  数据类型	每个用户id占用空间	需要存储的用户量	全部内存量
  集合类型	64位	50000000	64位*50000000 = 400MB
  Bitmaps	1位	100000000	1位*100000000 = 12.5MB

  很明显， 这种情况下使用Bitmaps能节省很多的内存空间， 尤其是随着时间推移节省的内存还是非常可观的

  数据类型	一天	一个月	一年
  集合类型	400MB	12GB	144GB
  Bitmaps	12.5MB	375MB	4.5GB

  但Bitmaps并不是万金油， 假如该网站每天的独立访问用户很少， 例如只有10万（大量的僵尸用户） ， 那么两者的对比如下表所示

  数据类型	每个userid占用空间	需要存储的用户量	全部内存量
  集合类型	64位	100000	64位*100000 = 800KB
  Bitmaps	1位	100000000	1位*100000000 = 12.5MB

  很显然， 这时候使用Bitmaps就不太合适了， 因为基本上大部分位都是0，虽然只有10w用户，但是10w用户中可能 有人的id是1000w，因此必须要分配1000w位

​

6.2 HyperLogLog

• 简介

  • 工作当中，我们经常会遇到与统计相关的功能需求，比如统计网站PV（PageView页面访问量）,可以使用Redis的incr、incrby轻松实现。

  • 像UV（UniqueVisitor，独立访客）、独立IP数、搜索记录数等需要去重和计数的问题如何解决？

    • 这种求集合中不重复元素个数的问题称为基数问题。
    • 解决基数问题有很多种方案：
      （1）数据存储在MySQL表中，使用distinct count计算不重复个数
      （2）使用Redis提供的hash、set、bitmaps等数据结构来处理

  • 以上的方案结果精确，但随着数据不断增加，导致占用空间越来越大，对于非常大的数据集是不切实际的。

  • 能否能够降低一定的精度来平衡存储空间？Redis推出了HyperLogLog

  • Redis HyperLogLog 是用来做基数统计的算法

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

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

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

  • 什么是基数?
    比如数据集 {1, 3, 5, 7, 5, 7, 8}， 那么这个数据集的基数集为 {1, 3, 5 ,7, 8}, 基数(不重复元素的个数)为5。

  • 基数估计就是在误差可接受的范围内，快速计算基数。

• 命令

  1. pfadd

     • 格式

       pfadd < element> [element ...]:添加指定元素到 HyperLogLog 中

     • 实例

       

       将所有元素添加到指定HyperLogLog数据结构中。如果执行命令后hll估计的近似基数发生变化，则返回1，否则返回0(加入的数据重复就不加入)

  2. pfcount

     • 格式

       pfcount [key ...] 计算HLL的近似基数，可以计算多个HLL，比如用HLL存储每天的UV，计算一周的UV可以使用7天的UV合并计算即可

     • 实例

       

       hll1和hll2都有redis，并集只算一个，所以总共是3

  3. pfmerge

     • 格式

       pfmerge [sourcekey ...]:将一个或多个HLL()合并后的结果存储在另一个HLL()中，比如每月活跃用户可以使用每天的活跃用户来合并计算可得

     • 实例

       

6.3 Geospatial

• 简介

  • Redis 3.2 中增加了对GEO类型的支持。
  • GEO，Geographic，地理信息的缩写。
  • 该类型，就是元素的2维坐标，在地图上就是经纬度。
  • redis基于该类型，提供了经纬度设置，查询，范围查询，距离查询，经纬度Hash等常见操作。

• 命令

  1. geoadd

     • 格式

       geoadd< longitude> [longitude latitude member...]:添加地理位置（经度，纬度，名称

     • 实例

       #添加上海
       geoadd china:city 121.47 31.23 shanghai
       #添加重庆，深圳，北京
       geoadd china:city 106.50 29.53 chongqing 114.05 22.52 shenzhen 116.38 39.90 beijing
       

     • 注意

       - 两极无法直接添加，一般会下载城市数据，直接通过 Java 程序一次性导入。
       - 有效的经度从 -180 度到 180 度。有效的纬度从 -85.05112878 度到 85.05112878 度。
       - 当坐标位置超出指定范围时，该命令将会返回一个错误。
       - 已经添加的数据，是无法再次往里面添加的

  2. geopos

     • 格式

       geopos [member...]:获得指定地区的坐标值

     • 实例

       

  3. geodist

     • 格式

       geodist [m|km|ft|mi ]:获取两个位置之间的直线距离

     • 实例

       

     • 注意

       • 单位：
         m 表示单位为米[默认值]。
         km 表示单位为千米。
         mi 表示单位为英里。
         ft 表示单位为英尺。
       • 如果用户没有显式地指定单位参数， 那么 GEODIST 默认使用米作为单位

  4. georadius

     • 格式

       georadius< longitude>radius m|km|ft|mi 以给定的经纬度为中心，找出某一半径内的元素

     • 实例

       

7.Redis_Jedis_测试

7.1 Jedis所需要的jar包

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

7.2 连接Redis注意事项

• 禁用Linux的防火墙：Linux(CentOS7)里执行命令

  systemctl stop firewalld.service 
  systemctl disable firewalld.service  
  

• redis.conf中注释掉bind 127.0.0.1 ,然后 protected-mode no

7.3 Jedis常用操作

• 创建动态的工程

  1. 创建maven项目

     

     

     

  2. 引入依赖

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

• 创建测试程序

  创建com/duanyf/jedis/JedisDemo1.java，进行测试

  public class JedisDemo1 {
  
    public static void main(String[] args) {
      //创建Jedis对象
      Jedis jedis=new Jedis("192.168.2.135",6379);
  
      //测试
      String value = jedis.ping();
      System.out.println(value);//PONG
    }
  }
  

7.4 测试相关数据类型

Jedis-API: Key

  @Test
  public void demo1(){
    //创建Jedis对象
    Jedis jedis=new Jedis("192.168.2.135",6379);

    //添加数据
    jedis.set("name","lucy");

    //获取
    String name = jedis.get("name");
    System.out.println("name:"+name);

    //打印所有key
    Set<String> keys = jedis.keys("*");
    for (String key : keys) {
      System.out.println(key);
    }

    //判断key值是否存在
    System.out.println(jedis.exists("name"));

    //查看还有多少秒过期
    System.out.println(jedis.ttl("name"));
  }

Jedis-API: String

  @Test
  public void demo2(){
    //创建Jedis对象
    Jedis jedis=new Jedis("192.168.2.135",6379);

    //设置多个key-value
    jedis.mset("str1","v1","str2","v2","str3","v3");

    //获取多个key的value
    System.out.println(jedis.mget("str1","str2","str3"));
  }

Jedis-API: List

  @Test
  public void demo3(){
    //创建Jedis对象
    Jedis jedis=new Jedis("192.168.2.135",6379);

    //加入数据
    jedis.lpush("key1","v1","v2","v3");

    //获取数据
    List<String> list = jedis.lrange("key1",0,-1);
    for (String element : list) {
      System.out.println(element);
    }
  }

Jedis-API: set

  @Test
  public void demo4(){
    //创建Jedis对象
    Jedis jedis=new Jedis("192.168.2.135",6379);

    //加入数据
    jedis.sadd("orders", "order01");
    jedis.sadd("orders", "order02");
    jedis.sadd("orders", "order03");
    jedis.sadd("orders", "order04");

    //获取数据
    Set<String> smembers = jedis.smembers("orders");
    for (String order : smembers) {
      System.out.println(order);
    }

    //删除元素
    jedis.srem("orders", "order02");

    //判断元素是否还存在
    System.out.println(jedis.sismember("orders", "order02"));
  }

Jedis-API: hash

  @Test
  public void demo5(){
    //创建Jedis对象
    Jedis jedis=new Jedis("192.168.2.135",6379);

    //加入数据
    jedis.hset("hash1","userName","lisi");

    Map<String,String> map = new HashMap<String,String>();
    map.put("telphone","13810169999");
    map.put("address","atguigu");
    map.put("email","[email protected]");
    jedis.hmset("hash2",map);

    //获取数据
    System.out.println(jedis.hget("hash1","userName"));

    List<String> result = jedis.hmget("hash2", "telphone","email");
    for (String element : result) {
      System.out.println(element);
    }
  }

Jedis-API: zset

  @Test
  public void demo6(){
    //创建Jedis对象
    Jedis jedis=new Jedis("192.168.2.135",6379);

    //加入数据
    jedis.zadd("zset01", 100d, "z3");
    jedis.zadd("zset01", 90d, "l4");
    jedis.zadd("zset01", 80d, "w5");
    jedis.zadd("zset01", 70d, "z6");

    //获取数据
    Set<String> zrange = jedis.zrange("zset01", 0, -1);
    for (String e : zrange) {
      System.out.println(e);
    }
  }

8.Redis_Jedis_实例

完成一个手机验证码功能
要求：
1、输入手机号，点击发送后随机生成6位数字码，2分钟有效
2、输入验证码，点击验证，返回成功或失败
3、每个手机号每天只能输入3次

• 思路

  • 随机生成6位数字码：使用Random类
  • 2分钟有效：将验证码放入redis，设置过期时间120s
  • 验证：从redis中取出数字码和输入内容的进行比较
  • 每天只能输入3次：
    1. incr每次发送+1
    2. 大于3时，提醒不能发送了

• 代码实现

  package com.duanyf.jedis;
  
  import java.util.Random;
  import redis.clients.jedis.Jedis;
  
  /**
   * @Description:
   * @Author: duanyf
   * @DateTime: 2022/9/24 0024 0:01
   */
  public class PhoneCode {
  
    public static void main(String[] args) {
      String phone="123343256";
      //模拟验证码的发送
      verifyCode(phone);
  
      //getRedisCode(phone,"428476");
    }
  
    //1.生成6位数字验证码
    public static String getCode() {
      Random random = new Random();
      String code = "";
      for (int i = 0; i < 6; i++) {
        int rand = random.nextInt(10);
        code += rand;
      }
      return code;
    }
  
    //2.让每个手机每天只能发送三次，验证码放到redis中，设置过期时间
    public static void verifyCode(String phone){
      //创建Jedis对象
      Jedis jedis=new Jedis("192.168.2.135",6379);
  
      //拼接key
      //手机发送次数
      String phone_sendCount_key="VerifyCode"+phone+":count";
      //验证码key
      String codeKey="VerifyCode"+phone+":code";
  
      //每个手机每天只能发送三次
      String count=jedis.get(phone_sendCount_key);
      if (count==null){
        //没有发送次数，第一次发送，设置发送次数为1
        //这个发送次数需要持续一天
        jedis.setex(phone_sendCount_key,24*60*60,"1");
      }else if (Integer.parseInt(count)<=2){
        //第一次 为1进入if 第二次还是为1进入此elseif变成2出去 第三次为2还是进入此elseif
        //发送次数+1
        jedis.incr(phone_sendCount_key);
      }else {
        System.out.println("今天发送次数已经超过三次");
        jedis.close();
        return;
      }
  
      //随机生成验证码放到redis中
      String vcode = getCode();
      jedis.setex(codeKey,120,vcode);
      jedis.close();
    }
  
    //3.验证码校验
    public static void getRedisCode(String phone,String code){
      //从redis中获取验证码
      Jedis jedis=new Jedis("192.168.2.135",6379);
      String codeKey="VerifyCode"+phone+":code";
      String redisCode = jedis.get(codeKey);
      //判断
      if (redisCode.equals(code)){
        System.out.println("成功");
      }else {
        System.out.println("失败");
      }
      jedis.close();
    }
  }
  

9.Redis与Spring Boot整合

1. 创建Springboot项目

   

2. 配置maven(同上)

3. 引入依赖

   
   <dependency>
       <groupId>org.springframework.bootgroupId>
       <artifactId>spring-boot-starter-data-redisartifactId>
   dependency>
   
   
   <dependency>
       <groupId>org.apache.commonsgroupId>
       <artifactId>commons-pool2artifactId>
       <version>2.6.0version>
   dependency>
   

4. 修改pom.xml

   

5. application.properties配置redis配置

   #Redis服务器地址
   spring.redis.host=192.168.3.135
   #Redis服务器连接端口
   spring.redis.port=6379
   #Redis数据库索引（默认为0）
   spring.redis.database= 0
   #连接超时时间（毫秒）
   spring.redis.timeout=1800000
   #连接池最大连接数（使用负值表示没有限制）
   spring.redis.lettuce.pool.max-active=20
   #最大阻塞等待时间(负数表示没限制)
   spring.redis.lettuce.pool.max-wait=-1
   #连接池中的最大空闲连接
   spring.redis.lettuce.pool.max-idle=5
   #连接池中的最小空闲连接
   spring.redis.lettuce.pool.min-idle=0
   
   

6. 添加redis配置类com/duanyf/redis_springboot/config/RedisConfig.java

   @EnableCaching
   @Configuration
   public class RedisConfig extends CachingConfigurerSupport {
   
       @Bean
       public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
           RedisTemplate<String, Object> template = new RedisTemplate<>();
           RedisSerializer<String> redisSerializer = new StringRedisSerializer();
           Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
           ObjectMapper om = new ObjectMapper();
           om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
           om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
           jackson2JsonRedisSerializer.setObjectMapper(om);
           template.setConnectionFactory(factory);
   //key序列化方式
           template.setKeySerializer(redisSerializer);
   //value序列化
           template.setValueSerializer(jackson2JsonRedisSerializer);
   //value hashmap序列化
           template.setHashValueSerializer(jackson2JsonRedisSerializer);
           return template;
       }
   
       @Bean
       public CacheManager cacheManager(RedisConnectionFactory factory) {
           RedisSerializer<String> redisSerializer = new StringRedisSerializer();
           Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
   //解决查询缓存转换异常的问题
           ObjectMapper om = new ObjectMapper();
           om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
           om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
           jackson2JsonRedisSerializer.setObjectMapper(om);
   // 配置序列化（解决乱码的问题）,过期时间600秒
           RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                   .entryTtl(Duration.ofSeconds(600))
                   .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
                   .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
                   .disableCachingNullValues();
           RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
                   .cacheDefaults(config)
                   .build();
           return cacheManager;
       }
   }
   

7. 创建com/duanyf/redis_springboot/controller/RedisTestController.java

   @RestController
   @RequestMapping("/redisTest")
   public class RedisTestController {
   
     @Autowired
     private RedisTemplate redisTemplate;
   
     @GetMapping
     public String testRedis(){
       //设置值到redis中
       redisTemplate.opsForValue().set("name","lucy");
       //从redis中获取值
       String name = (String) redisTemplate.opsForValue().get("name");
       return name;
     }
   }
   

10.Redis事务锁机制_秒杀

10.1 Redis的事务定义

• Redis事务是一个单独的隔离操作：事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。
• Redis事务的主要作用就是串联多个命令防止别的命令插队。

10.2 Multi、Exec、discard

• 从输入Multi命令开始，输入的命令都会依次进入命令队列中，但不会执行，直到输入Exec后，Redis会将之前的命令队列中的命令依次执行，组队的过程中可以通过discard来放弃组队。

  

• 实例

  • 组队成功，提交成功

    

  • 组队成功，放弃组队

    

10.3 事务的错误处理

• 组队中某个命令出现了报告错误，执行时整个的所有队列都会被取消。

  

  

• 如果执行阶段某个命令报出了错误，则只有报错的命令不会被执行，而其他的命令都会执行，不会回滚。

  

  

10.4 事务冲突的问题

10.4.1 例子

模拟一个场景：有很多人能使用你的账户支付,同时去参加双十一抢购，账户中有1w元

• 一个请求想给金额减8000
• 一个请求想给金额减5000
• 一个请求想给金额减1000

10.4.2 悲观锁

• 悲观锁(Pessimistic Lock), 顾名思义，就是很悲观

• 每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会block直到它拿到锁。

• 传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁

• 实例

  

10.4.3 乐观锁

• 乐观锁(Optimistic Lock), 顾名思义，就是很乐观

• 每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。

• 乐观锁适用于多读的应用类型，这样可以提高吞吐量。

• Redis就是利用这种check-and-set机制实现事务的。

• 实例

  

10.4.4 WATCH key [key …]

在执行multi之前，先执行watch key1 [key2],可以监视一个(或多个) key ，如果在事务执行之前这个(或这些) key 被其他命令所改动，那么事务将被打断。(乐观锁)

• 开启终端一

  

• 开启终端二

  

10.4.4 unwatch

• 取消 WATCH 命令对所有 key 的监视。
• 如果在执行 WATCH 命令之后，EXEC 命令或DISCARD 命令先被执行了的话，那么就不需要再执行UNWATCH 了。

10.5 Redis事务三特性

• 单独的隔离操作

  事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。

• 没有隔离级别的概念

  队列中的命令没有提交之前都不会实际被执行，因为事务提交前任何指令都不会被实际执行

• 不保证原子性

  事务中如果有一条命令执行失败，其后的命令仍然会被执行，没有回滚

11.Redis事务秒杀案例

11.1 案例分析

11.2 环境配置

1. 创建一个web项目

   

   

   

   

   

2. 配置tomcat

3. 导入依赖

   
   <dependency>
       <groupId>redis.clientsgroupId>
       <artifactId>jedisartifactId>
       <version>2.9.0version>
   dependency>
   
   <dependency>
       <groupId>org.apache.commonsgroupId>
       <artifactId>commons-pool2artifactId>
       <version>2.4.2version>
   dependency>
   
   
   <dependency>
       <groupId>org.codehaus.janinogroupId>
       <artifactId>janinoartifactId>
       <version>2.7.8version>
   dependency>
   
   
   
   <dependency>
       <groupId>org.codehaus.janinogroupId>
       <artifactId>commons-compilerartifactId>
       <version>2.7.8version>
   dependency>
   
   
   
   <dependency>
       <groupId>org.slf4jgroupId>
       <artifactId>slf4j-apiartifactId>
       <version>1.7.25version>
   dependency>
   
   
   <dependency>
       <groupId>ch.qos.logbackgroupId>
       <artifactId>logback-classicartifactId>
       <version>1.2.4-groovylessversion>
       <scope>testscope>
   dependency>
   
   <dependency>
       <groupId>ch.qos.logbackgroupId>
       <artifactId>logback-coreartifactId>
       <version>1.2.4-groovylessversion>
       <scope>compilescope>
   dependency>
   
   
   <dependency>
       <groupId>ch.qos.logbackgroupId>
       <artifactId>logback-accessartifactId>
       <version>1.2.3version>
   dependency>
   
   
   <dependency>
       <groupId>log4jgroupId>
       <artifactId>log4jartifactId>
       <version>1.2.17version>
   dependency>
   
   
   <dependency>
       <groupId>javax.servletgroupId>
       <artifactId>javax.servlet-apiartifactId>
       <version>3.1.0version>
       <scope>providedscope>
   dependency>
   

   出现找不到类 clean一下

4. 配置web.xml

   <servlet>
       <description>description>
       <display-name>doseckilldisplay-name>
       <servlet-name>doseckillservlet-name>
       <servlet-class>SecKillServletservlet-class>
   servlet>
   <servlet-mapping>
       <servlet-name>doseckillservlet-name>
       <url-pattern>/doseckillurl-pattern>
   servlet-mapping>
   

11.3 并发秒杀模拟

• 模拟测试工具ab安装

  • 联网

    sudo yum install httpd-tools
    

  • 无网络

    cd  /run/media/root/CentOS 7 x86_64/Packages
    #顺序安装
    apr-1.4.8-3.el7.x86_64.rpm
    apr-util-1.5.2-6.el7.x86_64.rpm
    httpd-tools-2.4.6-67.el7.centos.x86_64.rpm
    

• ab参数讲解

  #请求数量
  -n requests     Number of requests to perform
  #并发数量
  -c concurrency  Number of multiple requests to make at a time
  #提交参数
  -p postfile     File containing data to POST. Remember also to set -T
  #参数类型
  -T content-type Content-type header to use for POST/PUT data, eg.
                      'application/x-www-form-urlencoded'
                      Default is 'text/plain'
  

• 实例测试

  1. 创建postfile，postfile中写有参数

     vim postfile
     

     

  2. 设置reids

     /usr/local/bin/redis-cli
     del sk:0101:user
     set sk:0101:qt 10
     

  3. 使用ab

     #“~/”表示当前路径
     #ip填的不是虚拟机 而是本机ip
     ab -n 1000 -c 100 -p ~/postfile -T application/x-www-form-urlencoded http://10.211.161.108:8080/seckill/doseckill
     

  4. 查看问题

     • idea中

       

     • redis中，库存为负数

       

11.4 连接池解决连接超时问题

• 为什么会连接超时

  当向redis发送多个请求，redis处理不过来时，可能会出现连接超时问题

  

• 连接池

  • 作用：

    节省每次连接redis服务带来的消耗，把连接好的实例反复利用，通过参数管理连接的行为。

  • 参数

    • MaxTotal：控制一个pool可分配多少个jedis实例，通过pool.getResource()来获取；如果赋值为-1，则表示不限制；如果pool已经分配了MaxTotal个jedis实例，则此时pool的状态为exhausted。
    • maxIdle：控制一个pool最多有多少个状态为idle(空闲)的jedis实例
    • MaxWaitMillis：表示当borrow一个jedis实例时，最大的等待毫秒数，如果超过等待时间，则直接抛JedisConnectionException
    • testOnBorrow：获得一个jedis实例的时候是否检查连接可用性（ping()）；如果为true，则得到的jedis实例均是可用的

11.5 超卖问题及解决

• 超卖问题

  

• 利用乐观锁淘汰用户，解决超卖问题

  

11.6 库存遗留问题

• 产生原因：
  • 使用乐观锁，当一个请求购买了一个茶品后，版本号更新，剩余请求版本号与其不匹配无法购买
  • 有的请求可以成功是在当前请求结束后，库存更新了，版本号自然更新，所以此请求和版本号匹配可以购买
  • 有的请求失败是因为当一个请求未完成时，它也请求，此时版本号没有更新，此请求版本号与其不匹配无法购买
• Lua
  • 介绍
    • Lua 是一个小巧的脚本语言，Lua脚本可以很容易的被C/C++ 代码调用，也可以反过来调用C/C++的函数
    • Lua并没有提供强大的库，一个完整的Lua解释器不过200k，所以Lua不适合作为开发独立应用程序的语言，而是作为嵌入式脚本语言。
    • 很多应用程序、游戏使用LUA作为自己的嵌入式脚本语言，以此来实现可配置性、可扩展性。这其中包括魔兽争霸地图、魔兽世界、博德之门、愤怒的小鸟等众多游戏插件或外挂
  • LUA脚本在Redis中的优势
    • 将复杂的或者多步的redis操作写为一个脚本，一次提交给redis执行，减少反复连接redis的次数，提升性能。
    • LUA脚本是类似redis事务，有一定的原子性，不会被其他命令插队，可以完成一些redis事务性的操作。
    • 注意redis的lua脚本功能，只有在Redis 2.6以上的版本才可以使用。
    • 利用lua脚本淘汰用户，解决超卖问题。
    • redis 2.6版本以后，通过lua脚本解决争抢问题，实际上是redis 利用其单线程的特性，用任务队列的方式解决多任务并发问题。

11.8 代码编写

index.jsp页面

<%@ page language="java" contentType="text/html; charset=UTF-8"
         pageEncoding="UTF-8"%>



  
  


iPhone 13 Pro !!!  1元秒杀！！！




  
  

单人秒杀

• SecKill_redis

  import java.io.IOException;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Set;
  
  import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
  
  import ch.qos.logback.core.rolling.helper.IntegerTokenConverter;
  import redis.clients.jedis.HostAndPort;
  import redis.clients.jedis.Jedis;
  import redis.clients.jedis.JedisCluster;
  import redis.clients.jedis.JedisPool;
  import redis.clients.jedis.JedisPoolConfig;
  import redis.clients.jedis.ShardedJedisPool;
  import redis.clients.jedis.Transaction;
  
  public class SecKill_redis {
  	/**
  	 * 秒杀过程
  	 * @param uid 用户id
  	 * @param prodid 产品id
  	 * @return
  	 * @throws IOException
  	 */
  	public static boolean doSecKill(String uid,String prodid) throws IOException {
  		//1 uid和prodid非空判断
  		if(uid == null || prodid == null) {
  			return false;
  		}
  
  		//2 连接redis
  		Jedis jedis = new Jedis("192.168.2.140",6379);
  		//通过连接池得到jedis对象
  		//JedisPool jedisPoolInstance = JedisPoolUtil.getJedisPoolInstance();
  		//Jedis jedis = jedisPoolInstance.getResource();
  
  		//3 拼接key
  		//3.1 库存key
  		String kcKey = "sk:"+prodid+":qt";
  		//3.2 秒杀成功用户key
  		String userKey = "sk:"+prodid+":user";
  
  		//监视库存
  		//jedis.watch(kcKey);
  
  		//4.获取库存，如果库存null，秒杀还没有开始
  		String kc = jedis.get(kcKey);
  		if(kc == null) {
  			System.out.println("秒杀还没有开始，请等待");
  			jedis.close();
  			return false;
  		}
  
  		// 5.判断用户是否重复秒杀操作
  		if(jedis.sismember(userKey, uid)) {
  			System.out.println("已经秒杀成功了，不能重复秒杀");
  			jedis.close();
  			return false;
  		}
  
  		//6.判断如果商品数量，库存数量小于1，秒杀结束
  		if(Integer.parseInt(kc)<=0) {
  			System.out.println("秒杀已经结束了");
  			jedis.close();
  			return false;
  		}
  
  		//7.秒杀过程
  		//使用事务
  		//Transaction multi = jedis.multi();
  		//
  		组队操作
  		//multi.decr(kcKey);
  		//multi.sadd(userKey,uid);
  		//
  		执行
  		//List