学习目标

• 能够说出redis的常用数据类型

• 能够使用redis的string操作命令

• 能够使用redis的hash操作命令

• 能够使用redis的list操作命令

• 能够使用redis的set操作命令

• 能够使用redis的zset操作命令

• 能够使用jedis操作Redis

• 能够理解Redis持久化

第一章-Redis介绍和安装

知识点-Nosql概述

1.目标

• 能够理解nosql的概念

2.路径

• 什么是NOSQL
• 为什么需要NOSQL
• 主流的NOSQL产品
• NOSQL的特点

3.讲解

3.1 什么是NOSQL

​ MySQL：关系型数据库 ①表与表之间存在关系 ②表与实体存在关系

​ NoSQL(NoSQL = Not Only SQL)，意即“不仅仅是SQL”，是一项全新的数据库理念，泛指非关系型的数据库。

​ 非关系型数据库只是关系型数据库的一个补充，并不是关系型数据库的替代品。

3.2.为什么需要学习NOSQL （三高）

​ 随着互联网的高速崛起，网站的用户群的增加，访问量的上升，传统(关系型)数据库上都开始出现了性能瓶颈，web程序不再仅仅专注在功能上，同时也在追求性能。所以NOSQL数据库应运而上，具体表现为对如下三高问题的解决：

• High performance - 对数据库高并发读写的需求

  ​ web2.0网站要根据用户个性化信息来实时生成动态页面和提供动态信息，所以基本上无法使用动态页面静态化技术，因此数据库并发负载非常高，往往要达到每秒上万次读写请求。关系数据库应付上万次SQL查询还勉强顶得住，但是应付上万次SQL写数据请求，硬盘IO就已经无法承受了。其实对于普通的BBS网站，往往也存在对高并发写请求的需求，例如网站的实时统计在线用户状态，记录热门帖子的点击次数，投票计数等，因此这是一个相当普遍的需求。(微博 ：明星曝光恋情)

• Huge Storage - 对海量数据的高效率存储和访问的需求

  ​ 类似Facebook，twitter，Friendfeed这样的SNS网站，每天用户产生海量的用户动态，以Friendfeed为例，一个月就达到了2.5亿条用户动态，对于关系数据库来说，在一张2.5亿条记录的表里面进行SQL查询，效率是极其低下乃至不可忍受的。再例如大型web网站的用户登录系统，例如腾讯，盛大，动辄数以亿计的帐号，关系数据库也很难应付。

• High Scalability && High Availability- 对数据库的高可扩展性和高可用性的需求

  ​ 在基于web的架构当中，数据库是最难进行横向扩展的，当一个应用系统的用户量和访问量与日俱增的时候，你的数据库却没有办法像web server和app server那样简单的通过添加更多的硬件和服务节点来扩展性能和负载能力。对于很多需要提供24小时不间断服务的网站来说，对数据库系统进行升级和扩展是非常痛苦的事情，往往需要停机维护和数据迁移，为什么数据库不能通过不断的添加服务器节点来实现扩展呢？

3.3 主流的NOSQL产品

• 键值(Key-Value)存储数据库 Redis key-value

• 列存储数据库(分布式) Hbase

• 文档型数据库 (Web应用与Key-Value类似，Value是结构化的） mongoDB

• 图形(Graph)数据库(图结构)

3.4NOSQL的特点

​ 在大数据存取上具备关系型数据库无法比拟的性能优势，例如：

• 易扩展

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

• 大数据量，高性能

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

• 灵活的数据模型

  ​ NoSQL无需事先为要存储的数据建立字段，随时可以存储自定义的数据格式。而在关系数据库里，增删字段是一件非常麻烦的事情。如果是非常大数据量的表，增加字段简直就是一个噩梦。这点在大数据量的Web2.0时代尤其明显。

• 高可用

  ​ NoSQL在不太影响性能的情况，就可以方便的实现高可用的架构。比如Cassandra，HBase模型，通过复制模型也能实现高可用。

4.小结

1. NoSQL：非关系型数据库 是关系型数据库的一个补充。
2. 为什么要使用NOSQL
   1. 高并发读写需求
   2. 高效率存储和访问的需求
   3. 高扩展性和高可用性需求
3. 主流的NoSQL
   1. redis
   2. MongoDB

知识点-Redis概述

1.目标

• 知道什么是Redis以及Redis的应用场景

2.路径

• 什么是Redis
• redis的应用场景

3.讲解

3.1.什么是Redis

​ Redis是用C语言开发的一个开源的高性能键值对（key-value）数据库，数据是保存在内存里面的. 官方提供测试数据，50个并发执行100000个请求,读的速度是110000次/s,写的速度是81000次/s ，且Redis通过提供多种键值数据类型来适应不同场景下的存储需求，目前为止Redis支持的键值数据类型如下：

​ key是string类型，value可以是下面这五种类型

• 字符串类型 string
• 散列类型 hash java-hashmap
• 列表类型 list java-linkedlist
• 集合类型 set java-hashset
• 有序集合类型 sortedset 简称：zset 有序且唯一

​ Redis支持的数据类型有五种：string、hash、list、set、zset

3.2 redis的应用场景

• 缓存（数据查询、短连接、新闻内容、商品内容、首页等等）
• 任务队列。（秒杀、抢购、12306等等）
• 数据过期处理（可以精确到毫秒, 短信验证码)
• 分布式集群架构中 session共享
• 分布式锁实现
• 聊天室的在线好友列表
• 应用排行榜
• 网站访问统计

4.小结

1. Redis：由C语言开发 高性能键值对存储的数据库，数据存储在内存中。
2. Redis数据类型：string、hash、list、set、zset
3. Redis的应用场景
   1. 缓存
   2. 任务队列
   3. 过期数据处理
   4. 分布式集群架构下的session共享
   5. 分布式锁实现
   6. ...

实操-window版Redis的安装

1.目标

• 掌握window版Redis的安装与使用

2.路径

1. Redis的下载

2. Redis的安装

3. 启动

3.讲解

3.1.windows版Redis的下载

​ 官方提倡使用Linux版的Redis，所以官网只提供了Linux版的Redis下载，我们可以从GitHub上下载window版的Redis，具体链接地址如下：

• 官网下载地址：http://redis.io/download

• github下载地址：https://github.com/MSOpenTech/redis/tags

在今天的课程资料中提供的下载完毕的window版本的Redis：

3.2 Redis的安装

解压Redis压缩包后，见到如下目录机构：

3.3 启动

​ 先启动服务端，再启动客户端！

• 安装:window版的安装及其简单，解压Redis压缩包完成即安装完毕
• 启动与关闭: 双击Redis目录中redis-server.exe可以启动redis服务，Redis服务占用的端口是6379

![](

• 点击redis-cli

)

4.小结

1. redis目录结构

2. 启动
   1. 先启动服务端 redis-server.exe
   2. 再启动客户端 redis-cli.exe
3. 注意：
   1. redis默认端口号6379
   2. redis默认连接不需要密码

实操-Redis的客户端安装

1.目标

​ 装Redis的客户端

2.步骤

• 双击, 下一步 ...
• 安装没有中文和空格目录

注意：

​ 1.使用客户端连接redis时，Redis服务端一定要开启

​ 2.我们一般不在Redis客户端下进行操作，主要就是通过Redis客户端方便查看我们存储哪些key

第二章-Redis的数据类型【重点】

知识点-redis中数据结构/类型

1.目标

• 能够说出Redis中的数据类型

2.路径

• Redis的数据类型类型介绍
• Redis中的key

3.讲解

3.1Redis的数据类型【面试】

​ redis中存储的数据是以key-value的形式存在的.key是string类型，其中value支持5种数据类型 .在日常开发中主要使用比较多的有字符串string、哈希hash、字符串列表list、字符串集合set 四种类型，其中最为常用的是字符串类型。

​ 字符串(String)

​ 哈希(hash) 类似HashMap 适合存储对象(属性，属性值)

​ 字符串列表(list) 类似LinkedList

​ 字符串集合(set) 类似HashSet

​ 有序的字符串集合(sorted-set或者叫zset) 有序且唯一

3.2key

• key不要太长(不能>1024个字节)

• 也不要太短 . 可读性差.

  现在有一个jd项目，项目中有用户模块，需要存储一个用户名name
  项目名_模块_key  eg: jd_user_name
  项目名:模块:key  eg：jd:user:name   [推荐]
  

4.小结

1. Redis数据类型
   1. string 字符串类型
   2. hash 类似java中的HashMap
   3. list 类似java中的LinkedList
   4. set 无序唯一 java中hashset
   5. zset 有序且唯一
2. key的命名规则：项目:模块:key

知识点-Redis字符串(String)

1.目标

• 能够使用redis的string操作命令

2.路径

1. Redis字符串(String)概述
2. 应用场景
3. 常见命令
4. 应用举例

2.讲解

2.1概述

​ string是redis最基本的类型,用的也是最多的，一个key对应一个value。 一个键最大能存储512MB.

2.2应用场景

1. 缓存功能：字符串最经典的使用场景，redis作为缓存层，MySQL作为存储层，绝大部分请求数据都是在redis中操作，由于redis具有支撑高并发特性，所以缓存通常能起到加速读写和降低后端MySQL压力的作用。
2. 计数器功能：比如视频播放次数，点赞次数。

2.3常见命令

2.4应用举例

商品编号、订单号采用string的递增数字特性生成。

定义商品编号key：items:id
192.168.101.3:7003> INCR items:id
(integer) 2
192.168.101.3:7003> INCR items:id
(integer) 3

4.小结

4.1string

1. string类型：是Redis中使用最多的数据类型，经常使用在缓存处理，计数，数据过期处理这些场景中。
2. set key value
3. get key
4. del key
5. setex key seconds value
6. setnx key value
7. incr key

4.2使用string的问题

​ 假设有User对象以JSON序列化的形式存储到Redis中，User对象有id，username、password、age、nickname等属性，存储的过程如下：
​ 保存： User对象 ==> json(string) ==>redis

​ 更新：redis == >json(string) ==> user对象 ==>修改age ==> json == >再存进去

​ 如果业务只想更新用户年龄age，这个时候按正常，就需要取出json字符串，转为user对象，重新设置age属性值，然后再将User对象==> json(string) ==>redis ，优化？hash存储 就可以直接修改age即可 不需要转来转去

但是：实际开发中，基本不会在redis中修改数据，redis主要负责存储数据作缓存处理，等待获取。如果数据发生改变，则会直接删除redis中存储的原有数据，等待下一次查询之后再加入到redis中。

知识点-Redis 哈希(Hash)

1.目标

• 能够使用redis的hash操作命令

2.路径

1. Redis 哈希(Hash)概述
2. 应用场景
3. 常见命令
4. 应用举例

3.讲解

3.1 概述

​ Redis中hash 是一个键值对集合。 类似于java中的hashmap

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

​ Redis存储hash可以看成是String key 和String value的map容器. 也就是说把值看成map集合.

​ hash特别适合存储对象相比较而言，将一个对象类型存储在Hash类型里要比存储在String类型里占用更少的内存空间并方便存取整个对象

3.2应用场景

​ 用一个对象来存储用户信息，商品信息，订单信息等等。 存储对象

3.3常见命令

3.4应用举例 存对象

存储商品信息

• 商品字段【商品id、商品名称、商品价格】
• 定义商品信息的key, 商品1001的信息在 Redis中的key为：[items:1001]
• 存储商品信息

HMSET items:1001 id 3 name apple price 999.9 

4.小结

​ 1. hash类型适合存储对象，类似于java中hashMap 是一个键值对的存储 key可以存对象属性，value可以存属性值

知识点-Redis 列表(List)

1.目标

• 能够使用redis的list操作命令

2.路径

1. List类型
2. Redis 列表(List)概述
3. 应用场景
4. 常见命令
5. 应用举例

3.讲解

3.1List类型

​ ArrayList使用数组方式存储数据，所以根据索引查询数据速度快，而新增或者删除元素时需要设计到位移操作，所以比较慢。

​ LinkedList使用双向链表方式存储数据，每个元素都记录前后元素的指针，所以插入、删除数据时只是更改前后元素的指针指向即可，速度非常快。然后通过下标查询元素时需要从头开始索引，所以比较慢，但是如果查询前几个元素或后几个元素速度比较快。

3.2概述

​ 列表类型（list）可以存储一个有序的字符串列表(链表)，常用的操作是向列表两端添加元素，或者获得列表的某一个片段。
​ 列表类型内部是使用双向链表（double linked list）实现的，所以向列表两端添加元素的时间复杂度为O(1)，获取越接近两端的元素速度就越快。这意味着即使是一个有几千万个元素的列表，获取头部或尾部的10条记录也是极快的。

衡量一个程序的好坏：时间复杂度、空间复杂度

衡量一个程序是否合格高效，主要有两个维度：运行时间(程序的效率)、运行空间

时间复杂度：衡量程序运行是否高效

空间复杂度：衡量程序运行占用空间大小

eg：现在老师布置了一个作业，要求张三和李四去设计程序完成，张三写的程序运行时间50ms，占用空间5000M，李四写的程序运行时间5s，占用空间500M。

java程序：空间换时间，宁肯牺牲空间(+内存 +主机)，也要保证时间

https://blog.csdn.net/qq_41523096/article/details/82142747

3.2应用场景

​ 如好友列表，粉丝列表，消息队列，最新消息排行等。

​ lpush/rpush方法就相当于将消息放入到队列中，lpop/rpop就相当于从队列中拿出消息进行消费

​ list列表底层采用双向链表实现，但是功能上又接近于队列。

3.3.常见命令

3.4应用举例

商品评论列表

• 思路: 在Redis中创建商品评论列表,用户发布商品评论，将评论信息转成json存储到list中。用户在页面查询评论列表，从redis中取出json数据展示到页面。

4.小结

1. List是一个字符串链表，可以当作队列使用，通过lpush、rpush向队列中添加数据，通过lpop、rpop从队列中获取数据消费

知识点-Redis 集合(Set)

1.目标

• 能够使用redis的set操作命令

2.路径

1. Redis 集合(Set)概述
2. 应用场景
3. 常见命令
4. 应用举例

3.讲解

3.1概述

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

​ Redis 中 集合是通过哈希表实现的，所以添加，删除，查找的时间复杂度都是O(1)。集合中最大的成员数为 2的32次方 -1 (4294967295, 每个集合可存储40多亿个成员)。

​ Redis还提供了多个集合之间的交集、并集、差集的运算

​ 特点:无序+唯一

3.2应用场景

​ 投票记录

​ 共同好友、共同兴趣、好友推荐【A有这些好友 而你没有】

3.3.常见命令

3.4应用举例

共同好友

• A的好友
• B的好友
• A和B的共同好友 SINTER

4.小结

1. Redis中的set是无序唯一，类似java中的hashset
2. 使用场景：
   1. 投票 唯一
   2. 抽奖 spop
   3. 共同好友 sinter
   4. 好友推荐 sdiff

知识点-Redis 有序集合(sorted set | zset)

1.目标

• 能够使用redis的sorted set操作命令

2.路径

1. sorted set介绍
2. sorted set 应用场景
3. sorted set 命令
4. sorted set 具体示例

3.讲解

3.1概述

Redis 有序集合zset和集合set一样也是string类型元素的集合,且不允许重复的成员。

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

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

集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是O(1)。 集合中最大的成员数为 232 - 1 (4294967295, 每个集合可存储40多亿个成员)。

特点: 有序(根据分数排序)+唯一

3.2应用场景

排行榜：例如音乐排行榜 今年最流行十首华语歌曲 视频排行榜 元素：视频名称 score： 点击量

3.3.常见命令

3.4应用举例

商品销售排行榜

• 需求：根据商品销售量对商品进行排行显示
• 思路：定义商品销售排行榜（sorted set集合），Key为items:sellsort，分数为商品销售量 元素是商品编号
• 实现

--商品编号1001的销量是9，商品编号1002的销量是10 ，商品编号1003的销量是15
127.0.0.1:6379> zadd items:sellsort 9 1001 10 1002 15 1003
--商品编号1001的销量加1
127.0.0.1:6379> zincrby items:sellsort 1 1001
--商品销量前10名
127.0.0.1:6379> zrevrange items:sellsort 0 9

4.小结

1. ZSET：有序集合(有序+唯一) 有序的实现是为每个元素添加一个double类型的分数，实现排序
2. 使用场合：排行榜

第三章-Redis通用的操作,发布订阅和持久化【了解】

知识点-Redis通用的操作

1.目标

• 掌握Redis通用的操作命令

2.路径

• 通用操作
• 多数据库性

3.讲解

3.1 通用操作

• keys *: 查询所有的key

• exists key:判断是否有指定的key 若有返回1,否则返回0

• expire key 秒数:设置这个key在缓存中的存活时间

• ttl key:展示指定key的剩余时间

  ​ 若返回值为 -1:永不过期

  ​ 若返回值为 -2:已过期或者不存在

• del key:删除指定key

• rename key 新key:重命名

• type key:判断一个key的类型

• ping :测试连接是否连接

3.2多数据库性

​ redis默认是16个数据库, 编号是从0~15. 【默认是0号库】

• select index:切换库
• move key index: 把key移动到几号库(index是库的编号)
• flushdb:清空当前数据库
• flushall:清空当前实例下所有的数据库

4.小结

1. exists key 判断是否有这个key
2. expire key 秒数 设置这个key在缓存中的存活时间
3. ttl key 展示指定key的剩余时间(-1：永不过期 -2：已过期或不存在)
4. select index 切换库

知识点-订阅发布机制 【了解】

1.目标

• 了解Redis订阅发布机制

2.路径

1. 什么是Redis订阅发布机制
2. 相关的命令
3. 订阅发布实操

3.讲解

3.1什么是Redis订阅发布机制

​ Redis 发布订阅(pub/sub)是进程间一种消息通信模式：发送者(pub)发送消息，订阅者(sub)接收消息。(用户收听广播)

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

3.2相关的命令

3.3订阅发布实操

• 开启两个客户端
• A客户端

SUBSCRIBE nba

• B客户端

PUBLISH  nba aaa

4.小结

1. Redis 发布订阅(pub/sub)是进程间一种消息通信模式, 工作里面一般使用MQ【消息中间件 rabbitMQ kafaka RocketMQ】

知识点-Redis的持久化【面试】

1.目标

​ Redis的高性能是由于其将所有数据都存储在了内存中，为了使Redis在重启之后仍能保证数据不丢失，需要将数据从内存中同步到硬盘(文件)中，这一过程就是持久化。

​ Redis支持两种方式的持久化，一种是RDB方式，一种是AOF方式。可以单独使用其中一种或将二者结合使用。

2.路径

• RDB持久化机制
• AOF持久化机制
• 两种持久化机制比较

3.讲解

3.1RDB持久化机制

3.1.1概述

​ RDB持久化是指在指定的时间间隔内将内存中的数据集快照写入磁盘。这种方式是就是将内存中数据以快照的方式写入到二进制文件中,默认的文件名为dump.rdb。 这种方式是默认已经开启了,不需要配置.

3.1.2 RDB持久化机制的配置

• 在redis.windows.conf配置文件中有如下配置：

其中，上面配置的是RDB方式数据持久化时机：

3.2 AOF持久化机制

3.2.1概述

​ AOF持久化机制会将每一个收到的写命令都通过write函数追加到文件中,默认的文件名是appendonly.aof。 这种方式默认是没有开启的,要使用时候需要配置.【一旦手动开启AOF持久化之后，将不再使用RDB持久化了】

3.2.2AOF持久化机制配置

3.2.2.1开启配置

• 在redis.windows.conf配置文件中有如下配置：

• 将appendonly修改为yes， 但是启动redis的时候需要指定该文件,也就是意味着不能直接点击了, 需要输入命令启动:

• 开启aof持久化机制后，默认会在目录下产生一个appendonly.aof文件

3.2.2.2配置详解

• 上述配置为aof持久化的时机，解释如下：(在redis.windows.conf配置)

4,小结

Redis持久化：表示将redis在内存中存储的数据 同步保存到硬盘上，进行一个永久保存。

Redis持久化有两种方式：RDB【默认 二进制文件 有一定的时间间隔】、AOF【需要打开 命令文件 默认每秒】

一台Redis服务器主机RDB和AOF只能使用一种，如果设置了AOF持久化方式，就关闭了RDB方式持久化。

4.1RDB

优点

• RDB 是一个非常紧凑（compact）的文件，它保存了 Redis 在某个时间点上的数据集。 这种文件非常适合用于进行备份
• RDB 在恢复大数据集时的速度比 AOF 的恢复速度要快(因为其文件要比AOF的小)
• RDB的性能要比AOF更好

缺点

• RDB的持久化不够及时(一定时间间隔),可能会存在数据丢失
• RDB持久化时如果文件过大可能会造成服务器的阻塞,停止接收客户端请求

4.2AOF

优点

• AOF的持久性更加的耐久(可以每秒 或 每次操作保存一次)
• AOF 文件有序地保存了对数据库执行的所有写入操作， 这些写入操作以 Redis 协议的格式保存， 因此 AOF 文件的内容非常容易被人读懂， 对文件进行分析（parse）也很轻松。
• AOF是增量操作

缺点

• 对于相同的数据集来说，AOF 文件的体积通常要大于 RDB 文件的体积
• 根据所使用的 fsync 策略，AOF 的速度可能会慢于 RDB.

4.3选择

• 如果你非常关心你的数据， 但仍然可以承受数分钟以内的数据丢失，选择RDB 持久化。

• 如果对数据的完整性要求比较高, 选择AOF

  RDB：是redis默认开启的，在一定时间间隔内对redis内存中的数据进行持久化操作，将数据保存在一个二进制文件中，文件体积小，恢复快，性能好，但是容易出现数据丢失。
  AOF：需要手动开启，默认每秒进行持久化，将数据保存在一个增量文件中，数据保存的方式是以redis协议命令方式保存，容易阅读和解析，但是文件体积大，恢复慢，性能稍差。可是数据完整性好，不容易出现数据丢失。
  

第四章-Jedis 【重点】

案例-Jedis的快速入门

1.目标

• 掌握什么是Jedis

2.路径

1. jedis的介绍

2. Jedis的入门

3.讲解

3.1 jedis的介绍

​ Redis不仅是使用命令来操作，现在基本上主流的语言都有客户端支持，比如java、C、C#、C++、php、Node.js、Go等。 在官方网站里列一些Java的客户端，有Jedis、Redisson、lettuce、JDBC-Redis、等其中官方推荐使用Jedis和Redisson。 在企业中用的最多的就是Jedis，Jedis同样也是托管在github上.

说白了Jedis就是使用Java操作Redis的客户端(工具包) jedis=JDBC+驱动

地址：https://github.com/xetorthio/jedis。

文档地址:http://xetorthio.github.io/jedis/

3.2 Jedis的入门

需求: 使用java代码操作Redis 进行增(改)删查

步骤:

1. 创建项目，添加jedis jar包
2. 创建jedis对象
3. 调用方法操作redis
4. 关闭jedis对象 释放资源

• 基本操作

package com.itheima.test;

import redis.clients.jedis.Jedis;

import java.util.Set;

public class Demo01 {
    public static void main(String[] args) {

        //1.创建jedis对象
        Jedis jedis = new Jedis("localhost",6379);
        //2.调用方法
        //2.1：string类型操作
        //获取value
        String akey = jedis.get("akey");
        System.out.println("akey = " + akey);
        //判断key是否存在
        Boolean flag = jedis.exists("akey");
        System.out.println("akey是否存在："+flag);
        //jedis.del("akey");  删除key
        //存储key-value
        jedis.set("dkey","ddd");

        //2.2：hash类型
        jedis.hset("user1","name","zs");
        String name = jedis.hget("user1", "name");
        System.out.println("name = " + name);

        //2.3:list类型
        jedis.rpush("list1","a","b","c");
        System.out.println(jedis.lindex("list1", 2));

        //2.4:set类型
        jedis.sadd("set1","a","b","c");
        Set<String> set1 = jedis.smembers("set1");
        for (String s : set1) {
            System.out.println(s);
        }

        //3.关闭对象
        jedis.close();
    }
}

4.小结

1. Jedis: java操作Redis的客户端, 工具包(等价于 JDBC+数据库驱动)，操作redis，也就是把之前redis的命令封装成了方法。
2. 使用步骤
   • 导入jar包
   • 创建jedis对象
   • 调用方法
   • 关闭对象

知识点-Jedis进阶

1.目标

• 掌握Jedis连接池的使用

2.路径

1. jedis连接池介绍
2. jedis连接池的使用
3. 工具类的抽取

3.讲解

连接池：存放连接对象的容器 避免连接对象的频繁创建销毁，造成资源浪费，提高系统性能

3.1 jedis连接池的基本概念

​ jedis连接资源的创建与销毁是很消耗程序性能，所以jedis为我们提供了jedis的池化技术，jedisPool在创建时初始化一些连接资源存储到连接池中，使用jedis连接资源时不需要创建，而是从连接池中获取一个资源进行redis的操作，使用完毕后，不需要销毁该jedis连接资源，而是将该资源归还给连接池，供其他请求使用。

3.2jedis连接池的使用

需求: 从Jedis的连接池里面获得jedis对象使用

步骤:

1. 创建JedisPoolConfig对象
2. 创建JedisPool对象
3. 获取Jedis对象
4. 调用方法
5. 归还连接对象

• 基本使用

public class Demo02 {
    public static void main(String[] args) {
        //1. 创建JedisPoolConfig对象
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(5);
        config.setMaxWaitMillis(5000);
        //2. 创建JedisPool对象
        JedisPool jedisPool = new JedisPool(config, "localhost", 6379);
        //3. 获取jedis对象
        Jedis jedis = jedisPool.getResource();
        //4. 调用方法  需求：如果akey存在 获取akey的值  ; 如果akey不存在 创建一个akey=aaa存入redis中
        if(jedis.exists("akey")){
            System.out.println(jedis.get("akey"));
        }else{
            jedis.set("akey","aaa");
        }
        //5. 归还jedis对象到Jedis连接池
        jedis.close();
    }
}

3.3Jedis工具类的抽取

目的: 1.保证池子只有一个 2.获得jedis对象 3.归还

步骤:

1. 创建JedisUtils工具类
2. 获取jedis对象
3. 归还jedis对象
4. 保证池子只有一个 使用静态代码块创建连接池对象

package com.itheima.utils;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

/**
 * Jedis工具类
 *  1.提供获取jedis对象的方法  getJedis();
 *  2.提供归还jedis对象的方法  close(Jedis jedis);
 *  优化：让jedisPool对象只有一个  采用单例模式  声明一个静态变量JedisPool对象  然后使用静态代码块初始化JedisPool对象
 */
public class JedisUtils {

    private static JedisPool jedisPool;

    static{
        //1. 创建JedisPoolConfig对象
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(5);
        config.setMaxWaitMillis(3000);
        //2. 创建JedisPool对象
        jedisPool = new JedisPool(config,"127.0.0.1",6379);
    }

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

    /**
     * 归还jedis对象
     * @param jedis
     */
    public static void close(Jedis jedis){
        if(jedis!=null){
            jedis.close();
        }
    }
}

3.4.3 作业

把JedisUtils里面配置信息(eg：host和port) 抽取到 jedis.properties里面

4.小结

1. 使用JedisPool目的: 为了jedis对象复用，使用了池化技术。

案例-使用Redis优化省份的展示

1.需求

​ 访问index.html页面，使用ajax请求加载省份列表 前端(vue 发送ajax请求) 后台(Servlet 响应json)

• 先从Redis里面获得
  • 有 就直接返回
  • 没有 从Mysql获得,再存到Redis

2.分析

2.1直接从MySQL获得

1. 创建数据库；创建项目，创建包结构，javabean；jar包、工具类、配置文件；页面

2. 前端|html 在index.html中发送ajax请求 在生命周期函数created时发送

   data:{
       provinces:[]
   },
   created:function(){
       axios.get("请求地址").then(response=>{
           if(response.data.flag){
              this.provinces = response.data.result;
              }else{
                  alert(response.data.message);
              }
       });
   }
   
   //使用v-for遍历省份列表数据 显示到下拉列表中
   

3. 后台|Servlet

   //1.获取请求参数  没有
   
   /* 判断redis中是否存储的有省份列表数据 有 就从redis中获取响应  没有 从MySQL中查询 存入redis一份*/
   //redis中省份列表数据的key为 province_list
   if(jedis.exists("province_list")){
       //从redis中获取响应
   }else{
       //从MySQL中查询 存入redis一份
       //2.调用业务处理  【Service返回省份列表集合数据  List<Province>】
   	//3.响应json数据
   	//3.1:封装list到result对象
   	//3.2:将result对象以json格式响应给客户端浏览器
   }
   
   

3.代码实现

3.1准备工作

• 数据库

create database day32;
use day32;

CREATE TABLE `province` (
  `pid` int NOT NULL AUTO_INCREMENT,
  `pname` varchar(40) DEFAULT NULL,
  PRIMARY KEY (`pid`)
) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8;

INSERT INTO `province` VALUES ('1', '广东');
INSERT INTO `province` VALUES ('2', '湖北');
INSERT INTO `province` VALUES ('3', '湖南');
INSERT INTO `province` VALUES ('4', '四川');
INSERT INTO `province` VALUES ('5', '山东');
INSERT INTO `province` VALUES ('6', '山西');
INSERT INTO `province` VALUES ('7', '广西');

• 创建工程(web)
• 导入jar包, 导入配置文件, 导入工具类,导入页面
• Province.java

package com.itheima.bean;

import java.io.Serializable;

public class Province implements Serializable {
	
	private Integer pid;
	private String pname;
	public Integer getPid() {
		return pid;
	}
	public void setPid(Integer pid) {
		this.pid = pid;
	}
	public String getPname() {
		return pname;
	}
	public void setPname(String pname) {
		this.pname = pname;
	}
	@Override
	public String toString() {
		return "Province [pid=" + pid + ", pname=" + pname + "]";
	}
}

3.2代码实现

• 页面

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script src="js/vuejs-2.5.16.js"></script>
    <script src="js/axios-0.18.0.js"></script>
</head>
<body>
    <div id="app">
        省: <select id="pSelect">
                  <option>请选择</option>
                  <option v-for="(province,index) in provinces">{{province.pname}}</option>
           </select>
    </div>

    <script>
    	var vm = new Vue({
    		//指定vue使用的区域  不可以指定为body
    		el:"#app",
    		//声明数据  1.可以封装请求参数  2.接收响应数据
    		data:{
                provinces:[]
    		},
    		//声明函数
    		methods: {

    		},
            created:function () {
                //1.获取请求参数 【没有】
                //2.发送ajax请求
                axios.get("ProvinceServlet").then(response=>{
                    //3.根据响应数据 进行处理
                    if(response.data.flag){
                        //请求处理成功 数据绑定
                        //response：响应信息  response.data=result对象   response.data.result=result对象中的result属性 用于封装查询返回的数据
                        this.provinces = response.data.result;
                    }else{
                        //请求处理失败  弹窗提示
                        alert(response.data.message);
                    }
                });
            }
    	});
    </script>
</body>
</html>

• ProvinceServlet

package com.itheima.web;

import com.alibaba.fastjson.JSON;
import com.itheima.bean.Province;
import com.itheima.bean.Result;
import com.itheima.service.ProvinceService;
import com.itheima.utils.JedisUtils;
import com.itheima.utils.JsonUtils;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;

@WebServlet("/ProvinceServlet")
public class ProvinceServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        try {
            //1.获取请求参数  【没有】
            /*判断Redis中是否存储province_list这个键  存在表示redis中有省份列表数据  不存在表示没有 需要去MySQL数据库中查询*/
            //2.1：获取jedis对象
            Jedis jedis = JedisUtils.getJedis();
            //2.2：判断province_list键是否存在
            if(jedis.exists("province_list")){
                //true 存在 从redis中获取省份列表数据响应
                System.out.println("从redis中获取");

                //注意：此时返回的是json数据字符串形式  在进行响应给前台时 需要将其转为list集合再封装
                //如果将一个字符串再转为json数据  就会变成普通字符串 就不再是json数据格式了，会导致前端无法正常解析
                //Result result = new Result(true, "查询成功！",province_list);

                String province_list = jedis.get("province_list");
                Result result = new Result(true, "查询成功！",JSON.parse(province_list));
                JsonUtils.printResult(response,result);
            }else{
                //false 不存在  从MySQL中获取省份列表数据响应
                System.out.println("从MySQL中获取");
                //2.调用业务处理 返回省份列表List<Province>
                ProvinceService provinceService = new ProvinceService();
                List<Province> list = provinceService.getList();

                /*第一次查询 redis中时没有省份列表数据的  需要从MySQL数据库中查询出来后存入redis一份*/
                jedis.set("province_list", JSON.toJSONString(list));

                //3.封装响应数据到result对象以json格式响应给前台
                Result result = new Result(true, "查询成功！", list);
                JsonUtils.printResult(response,result);
            }

        } catch (Exception e) {
            e.printStackTrace();
            Result result = new Result(false, "服务器异常！");
            JsonUtils.printResult(response,result);
        }
    }

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doPost(request, response);
    }
}

• ProvinceService

package com.itheima.service;

import com.itheima.bean.Province;
import com.itheima.dao.ProvinceDao;

import java.sql.SQLException;
import java.util.List;

public class ProvinceService {

    /**
     * 查询所有省份列表信息
     * @return
     */
    public List<Province> findList() throws SQLException {
        //调用dao
        ProvinceDao provinceDao = new ProvinceDao();
        return provinceDao.findList();
    }
}

• ProvinceDao

package com.itheima.dao;

import com.itheima.bean.Province;
import com.itheima.utils.C3P0Utils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanListHandler;

import java.sql.SQLException;
import java.util.List;

public class ProvinceDao {

    //查询所有省份列表信息
    public List<Province> findList() throws SQLException {
        //操作数据库
        QueryRunner queryRunner = new QueryRunner(C3P0Utils.getDataSource());
        String sql = "select * from province";
        return queryRunner.query(sql,new BeanListHandler<>(Province.class));
    }
}

4.小结

1. 优化

   • 先判断redis中是否存储省份列表数据 jedis.exists("province_list");

   • 存在：直接从redis中获取 注意：redis中存的String类型 所以取出后需要转换一下

     //注意2：存入redis的是json字符串 存进去之后又变成了普通String  需要转回来，不转的话前端无法正常解析
     Result result = new Result(true,"从redis中查询成功！", JSON.parse(province_list));
     

   • 不存在：从MySQL中查询，查询之后存入redis，然后响应

     //注意1:在将数据存入redis中时  需要转成json字符串存入
     jedis.set("province_list",JSON.toJSONString(list));
     

案例-使用Redis完成邮箱验证码的校验

1.需求

• 输入邮箱, 发送激活邮件, 完成校验

2.分析

2.1发送邮件思路

1. 填写邮箱地址，发送激活链接(附加邮箱地址和激活码)
2. 将生成的激活码存入redis，24h
3. 发送激活邮件到用户邮箱

2.2验证思路

1. 创建一个激活Servlet activeServlet
2. 获取redis中的验证码与激活链接的验证码进行比对
3. 激活成功(更新账号状态status为1，表示启用 删除redis中存储的该验证码)

3.代码实现

3.1发送邮件代码

• RegisterServlet添加发送邮件代码

  /******************************注册时发送激活邮件***************************************/
//2.1：生成激活码   UUID 
String code = UUIDUtils.generateUUID();
// 2.2：将激活码存redis中 key-value   ("邮箱地址","激活码")
// 2.3：设置过期时间24h
Jedis jedis = JedisUtils.getJedis();
jedis.setex(user.getEmail(),60*60*24,code);
// 2.4：发送激活链接到用户邮箱   active?email=?&code=?
MailUtil.sendMail(user.getEmail(),"账户激活","尊敬的用户，您好，请点击<a href='http://localhost:8080"+request.getContextPath()+"/active?email="+user.getEmail()+"&code="+code+"'>该链接</a>进行账户激活使用。");
/******************************注册时发送激活邮件***************************************/

3.2验证代码

• ActiveServlet

package com.itheima.web;

import com.itheima.utils.JedisUtils;
import redis.clients.jedis.Jedis;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet(value = "/active")
public class ActiveServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1.获取请求参数
        String email = request.getParameter("email");
        String activeCode = request.getParameter("activeCode");
        //1.1:获取redis中存储的用户激活信息  key：用户邮箱 value：激活码
        Jedis jedis = JedisUtils.getJedis();
        Boolean flag = jedis.exists(email);
        if(flag){
            String code = jedis.get(email);
            if(code.equals(activeCode)){
                //激活成功  1.修改用户status=1       2.删除redis中存储的验证码
                response.getWriter().print("active success");
            }else{
                //激活失败
                response.getWriter().print("active fail");
            }
        }else{
            //激活失败
            response.getWriter().print("active fail");
        }
    }

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doPost(request, response);
    }
}

4.小结

• 注册时 发送激活链接邮件到邮箱 注意：要将激活码存入redis，并且设置过期时间
• 编写激活Servlet 在其中获取激活链接传递的激活码和redis中存储的激活码进行比对，一致就说明激活成功！
• 练习：下去之后 自己完成激活成功后 1.更新账号状态status=1 2.删除对应的redis的key

总结

1. 概念

   1. NoSQL：泛指非关系型数据库
   2. Redis：是一个由C语言开发的高性能键值对数据库，数据存储在内存中。
   3. Redis的安装和使用
      1. 先启动服务端 redis-server.exe
      2. 再启动客户端 redis-cli.exe

2. Redis的数据类型

   1. key为string类型，value有五种类型：string、hash、list、set、zset
   2. string
      1. set key value
      2. get key
      3. del key
      4. exists key
      5. setex key seconds value
      6. setnx key value
      7. incr key

3. Redis通用操作

   1. expire key
   2. ttl key
      1. 正数：表示key的剩余时间
      2. -1：永不过期
      3. -2：不存在或已删除
   3. select index：切换库

4. Redis持久化

   1. RDB
   2. AOF

5. Jedis

   1. 使用jedis在java中操作redis
      1. 导入jar包
      2. 创建jedis对象
      3. 调用方法
      4. 关闭对象
   2. 使用jedis连接池
      1. 创建JedisPoolConfig对象
      2. 创建JedisPool对象
      3. 获取jedis对象
      4. 调用方法
      5. 归还jedis对象
   3. 抽取jedis工具类

6. 练习

   1. Redis的数据类型练习【重点是String】

   2. 使用Jedis操作Redis

   3. 案例一

   4. 理解持久化【先记忆一下 RDB和AOF的区别】

   5. 案例二