redis补充

第一章 Redis概述

redis是一款高性能的NOSQL系列的非关系型数据库。

NoSQL(NoSQL = Not Only SQL)，意即“不仅仅是SQL”，是一项全新的数据库理念，泛指非关系型的数据库。
随着互联网web2.0网站的兴起，传统的关系数据库在应付web2.0网站，特别是超大规模和高并发的SNS类型的web2.0纯动态网站已经显得力不从心，暴露了很多难以克服的问题，而非关系型的数据库则由于其本身的特点得到了非常迅速的发展。NoSQL数据库的产生就是为了解决大规模数据集合多重数据种类带来的挑战，尤其是大数据应用难题。

1 NOSQL和关系型数据库比较

优点：
1）成本：nosql数据库简单易部署，基本都是开源软件，不需要像使用oracle那样花费大量成本购买使用，相比关系型数据库价格便宜。
2）查询速度：nosql数据库将数据存储于缓存之中，关系型数据库将数据存储在硬盘中，自然查询速度远不及nosql数据库。
3）存储数据的格式：nosql的存储格式是key,value形式、文档形式、图片形式等等，所以可以存储基础类型以及对象或者是集合等各种格式，而数据库则只支持基础类型。
4）扩展性：关系型数据库有类似join这样的多表查询机制的限制导致扩展很艰难。

缺点：
1）维护的工具和资料有限，因为nosql是属于新的技术，不能和关系型数据库10几年的技术同日而语。
2）不提供对sql的支持，如果不支持sql这样的工业标准，将产生一定用户的学习和使用成本。
3）不提供关系型数据库对事务的处理。

2 No-SQL主流数据库

1）键值(Key-Value)存储数据库
相关产品： Tokyo Cabinet/Tyrant、Redis、Voldemort、Berkeley DB
典型应用： 内容缓存，主要用于处理大量数据的高访问负载。
数据模型： 一系列键值对
优势： 快速查询
劣势： 存储的数据缺少结构化

2）列存储数据库
相关产品：Cassandra, HBase, Riak
典型应用：分布式的文件系统
数据模型：以列簇式存储，将同一列数据存在一起
优势：查找速度快，可扩展性强，更容易进行分布式扩展
劣势：功能相对局限
3）文档型数据库
相关产品：CouchDB、MongoDB
典型应用：Web应用（与Key-Value类似，Value是结构化的）
数据模型： 一系列键值对
优势：数据结构要求不严格
劣势： 查询性能不高，而且缺乏统一的查询语法
4）图形(Graph)数据库
相关数据库：Neo4J、InfoGrid、Infinite Graph
典型应用：社交网络
数据模型：图结构
优势：利用图结构相关算法。
劣势：需要对整个图做计算才能得出结果，不容易做分布式的集群方案。

3 Redis简介

1 介绍

Redis是一个开源，先进的key-value存储，并用于构建高性能，可扩展的Web应用程序的完美解决方案。

Redis从它的许多竞争继承来的三个主要特点：

• Redis数据库完全在内存中，使用磁盘仅用于持久性。
• 相比许多键值数据存储，Redis拥有一套较为丰富的数据类型。
• Redis可以将数据复制到任意数量的从服务器。

官方提供测试数据，50个并发执行100000个请求,读的速度是110000次/s,写的速度是81000次/s 。

2 支持的数据类型

Redis通过提供多种键值数据类型来适应不同场景下的存储需求：

• 字符串类型 string
• 哈希类型 hash
• 列表类型 list
• 集合类型 set
• 有序集合类型 sortedset

这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。

3 redis的应用场景

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

第二章 Redis安装

1 window安装Redis

1 下载

官网：http://www.redis.io

redis默认不提供window下安装，所以redis官网中没有相关的安装包，我们需要从github中下载安装包

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

打开页面找到 Redis-x64-3.2.100.zip，点击下载即可下载压缩包。

然后把压缩包解压出来即可以使用。

打开一个cmd窗口，使用cd命令切换目录到Redis-x64-3.2.100的根目录中D:\Program Files\Redis-x64-

3.2.100，运行命令：redis-server.exe redis.windows.conf

输入之后，会显示如下界面：显示端口号6379

如果想方便的话，可以把redis的路径加到系统的Path环境变量里，这样就省得再输路径了

后面的那个redis.windows.conf可以省略，如果省略，会启用默认的配置文件。

2 安装测试

这时候另启一个cmd窗口，原来的不要关闭，不然就无法访问服务端了。

运行命令：redis-cli.exe -h 127.0.0.1 -p 6379，其中的-h和-p是可以省略的，保持默认。

也可以直接输入命令：redis-cli.exe

D:\Program Files\Redis-x64-3.2.100>redis-cli.exe
127.0.0.1:6379> set a aa
OK
127.0.0.1:6379> get a
"aa"
127.0.0.1:6379>

3 安装RedisDesktopManager

和mysql的navicat一样，redis也提供可视化工具RedisDesktopManager

2 Docker安装Redis

1 获取 redis 镜像

$ docker pull redis 

不加版本号默认获取最新版本，也可以使用 docker search redis 查看镜像来源

使用以下命令来查看是否已安装了 redis：

$ docker images

2 官网获取redis.conf配置文件

修改默认配置文件：

• bind 127.0.0.1 #注释掉这部分，这是限制redis只能本地访问
• protected-mode no #默认yes，开启保护模式，限制为本地访问
• daemonize no#默认no，改为yes意为以守护进程方式启动，可后台运行，除非kill进程（可选），改为yes会使配置文件方式启动redis失败
• dir ./ #输入本地redis数据库存放文件夹（可选）
• appendonly yes #yes就是打开了redis的AOF持久化（可选）

​ Redis的持久化存储提供两种方式：RDB(Redis DataBase)和AOF(Append Only File)。RDB是默认配置。AOF需要手动开启。
​ 现在Redis的配置中默认是关闭AOF模式的。

3 启动Redis

命令：

docker run -d --name redis  -p 6379:6379   -v /usr/local/redis/redis.conf:/etc/redis/redis.conf  -v /usr/local/redis/data:/data  redis redis-server   --appendonly   yes  --requirepass 'test'

即：

docker run -d 
    --name redis 
    -p 6379:6379 
    -v /usr/local/redis/redis.conf:/etc/redis/redis.conf 
    -v /usr/local/redis/data:/data
    redis redis-server /etc/redis/redis.conf 
    --appendonly yes 
    --requirepass 'test'

参数说明：

-d	后台运行容器
–name redis	设置容器名为 redis
-p 6379:6379	将宿主机 6379 端口映射到容器的 6379 端口
-v /usr/local/redis/redis.conf:/etc/redis/redis.conf	将宿主机redis.conf映射到容器内
-v /usr/local/redis/data:/data	将宿主机 /usr/local/redis/data 映射到容器 /data , 方便备份持久数据
redis-server /etc/redis/redis.conf	redis 服务以容器内的 redis.conf 配置启动
–appendonly yes	redis 数据持久化
–requirepass ‘test’	连接密码

4 日常启动Redis

docker -ps -a

启动

docker start redis

第三章 Redis基本命令

redis的数据结构

redis存储的是：key,value格式的数据，其中key都是字符串，value有5种不同的数据结构

• value的数据结构：
  1. 字符串类型 string
  2. 哈希类型 hash ： map格式
  3. 列表类型 list ： linkedlist格式。支持重复元素
  4. 集合类型 set ： 不允许重复元素

5. 有序集合类型 sortedset：不允许重复元素，且元素有顺序

1 字符串类型 string

string类型数据结构如下：

基本操作

• set：存数据

SET key value
set name zhangsan

• get：取数据

GET key

get name

• del：删除数据

DEL key [key ...]

del name

• mset：一次性存储多个key

MSET key value [key value ...]

mset a zhangsan b lisi c wangwu

• mget：一次性取多个key

MGET key [key ...]

mget a b c

• strlen：获取字符个数

STRLEN key
strlen a

• append：追加字符串（如果没有则新增）

APPEND key value
append a 88

string扩展操作

• 自增

incr key				# 自增1

set num 10
incr num

incrby key increment	# 自增increment

incrby key 20

incrbyfloat key increment	# 自增小数

set num2 0.5
incrbyfloat key 0.5			# 只能对小数自增小数

• 自减

decr key
decr num

decrby key incremnet
decr num 10

string类型的注意事项

• 数据操作不成功的反馈与数据正常操作之间的差异
  • 1）： 表示运行结果是否成功
    • (integer) 0 -> false 失败
    • (integer) 1-> true 成功
  • 2）：表示运行结果值
    • (integer) 3 -> 3 3个
    • (integer) 1 -> 1 1个
• 数据未获取到
  • (nil)等同于null

2 列表类型 list

在Redis中，List类型是按照插入顺序排序的字符串链表。和数据结构中的普通链表一样，我们可以在其头部(left)和尾部(right)添加新的元素。在插入时，如果该键并不存在，Redis将为该键创建一个新的链表。与此相反，如果链表中所有的元素均被移除，那么该键也将会被从数据库中删除。Redis中的list类型采用的是双向链表。

redis存储结构如下：

基本操作

• 添加/修改数据

LPUSH key value [value ...]		# 添加到队列左侧
RPUSH key value [value ...]		# 添加到队列右侧

lpush fruits apple pear
rpush fruits banana tomato

• 获取数据

LRANGE key start stop		# 从左边开始读取数据,从start索引查询到stop索引
lrange fruits 0 3			# 从0开始查询到3索引
lrange fruits 0 -2			# 从0开始查询到-2索引
lrange fruits 0 -1			# 从0开始查询到-1索引(倒数第二),通常用此命令来查询全部数据


LINDEX key index			# 根据指定的索引查询,从0开始
lindex fruits 3

• 获取并移除数据

LPOP key		# 从队列左边移除一个元素并返回
lpop fruits

RPOP key		# 从队列右边移除一个元素并返回
rpop fruits

list扩展操作

• 规定时间内获取并移除数据

BLPOP key [key ...] timeout		# 在timeout时间内取出key中的值
BRPOP key [key ...] timeout

blpop fruits 5				# 5秒内取出fruits中的值并删除,如果没取到则一直处于等待状态

• 规定时间内移除list左边的一个元素到另一个list中，并将此元素返回

BRPOPLPUSH source destination timeout

brpoplpush fruits temp 5

• 移除指定数据

LREM key count value		# 从list左边开始移除元素

# count:移除多少个  value:移除什么元素

rpush data a b c d e a b c k o;
lrem data 2 a		# 移除两个a

3 集合类型 set

在Redis中，我们可以将Set类型看作为没有排序的字符集合，和List类型一样，我们也可以在该类型的数据值上执行添加、删除或判断某一元素是否存在等操作。需要说明的是，这些操作的时间是常量时间。Set可包含的最大元素数是4294967295。

和List类型不同的是，Set集合中不允许出现重复的元素。和List类型相比，Set类 型在功能上还存在着一个非常重要的特性，即在服务器端完成多个Sets之间的聚合计算操作，如unions、intersections和differences。由于这些操作均在服务端完成， 因此效率极高，而且也节省了大量的网络IO开销

基本操作

• 添加数据

SADD key member [member ...]

sadd nums 1 2 3 4 5 6 7

• 读取全部数据

SMEMBERS key

smembers nums

• 删除数据

SREM key member [member ...]

srem nums 1 3 5 7

• 获取集合中元素的个数

SCARD key

scard nums

• 判断集合中是否包含指定的数据

SISMEMBER key member

sismember nums 1

扩展操作

• 在指定的key中随机获取几个个值

SRANDMEMBER key [count]

srandmember nums 3

• 在指定的key中随机获取几个值，并将这几个值移除

SPOP key [count]

spop nums 3

• 获取两个集合的交、并、差集

sinter key [key ...]			# 交集
sunion key [key ...]			# 并集
sdiff key [key ...]				# 差集

4 有序集合类型sortedset

Sorted-Sets和Sets类型极为相似，它们都是字符串的集合，都不允许重复的成员出现，在一个Set中。它们之间的主要差别是Sorted-Sets中的每一个成员都会有一个分数(score)与之关联，Redis正是通过分数来为集合中的成员进行从小到大的排序。然而需要额外指出的是，尽管Sorted-Sets中的成员必须是唯一的，但是分数(score) 却是可以重复的。

在Sorted-Set中添加、删除或更新一个成员都是非常快速的操作，其时间复杂度为集合中成员数量的对数。由于Sorted-Sets中的成员在集合中的位置是有序的，因此，即便是访问位于集合中部的成员也仍然是非常高效的。事实上，Redis所具有的这一特征在很多其它类型的数据库中是很难实现的，换句话说，在该点上要想达到和Redis 同样的高效，在其它数据库中进行建模是非常困难的。

基本操作

• 添加数据

zadd key score1 member1 [score2 member2]

• 实例：

127.0.0.1:6379> zadd students 90 zs
(integer) 1
127.0.0.1:6379> zadd students 80 ls 85 ww 60 zl 70 tq
(integer) 4

• 读取数据

zrange key start stop [WITHSCORES]
zrevrange key start stop [WITHSCORES]		

• withscores：是否显示分值
• zrevrange：将查询结果反转

示例：

127.0.0.1:6379> zrange students 0 -1
1) "zl"
2) "tq"
3) "ls"
4) "ww"
5) "zs"
127.0.0.1:6379> zrevrange students 0 -1 withscores
 1) "zs"
 2) "90"
 3) "ww"
 4) "85"
 5) "ls"
 6) "80"
 7) "tq"
 8) "70"
 9) "zl"
10) "60"

• 删除数据

zrem key member [member ...]

• 实例：

127.0.0.1:6379> zrem students zs zl
(integer) 2
127.0.0.1:6379> zrevrange students 0 -1 withscores
1) "ww"
2) "85"
3) "ls"
4) "80"
5) "tq"
6) "70"

• 根据分值筛选

zrangebyscore key min max [WITHSCORES] [LIMIT offset count]
zrevrangebyscore key max min [WITHSCORES] [LIMIT offset count]

• min：最小分值（包含）
• max：最大分值（包含）
• limit：限定查询结果（分页查询）
  • offset：起始索引（从0开始）
  • count：查询几条数据
• zrevrangebyscore：根据分值反转查询

示例：

127.0.0.1:6379> zadd students 90 zs 80 ls 95 ww 60 zl 75 tq
(integer) 5
127.0.0.1:6379> zrange students 0 -1 withscores
 1) "zl"
 2) "60"
 3) "tq"
 4) "75"
 5) "ls"
 6) "80"
 7) "zs"
 8) "90"
 9) "ww"
10) "95"
127.0.0.1:6379> zrangebyscore students 60 95 withscores
 1) "zl"
 2) "60"
 3) "tq"
 4) "75"
 5) "ls"
 6) "80"
 7) "zs"
 8) "90"
 9) "ww"
10) "95"

• 查询集合总数量

zcard key

zcard students

• 根据分值范围查询集合总数量

zcount key min max

zcount student 60 80

• 取多个集合中的交集、并集

zinterstore destination numkeys key [key ...]
zunionstore destination numkeys key [key ...]

示例：

127.0.0.1:6379> zadd num1 1 a 4 b 7 c
(integer) 3
127.0.0.1:6379> zadd num2 2 a 5 b 8 c
(integer) 3
127.0.0.1:6379> zadd num3 3 a 6 b 9 c
(integer) 3
127.0.0.1:6379> zinterstore temp1 3 num1 num2 num3
(integer) 3
127.0.0.1:6379> zrange temp1 0 -1 withscores
1) "a"
2) "6"
3) "b"
4) "15"
5) "c"
6) "24"

zinterstore首先取并集，然后把分数累加。

总结：不允许重复元素，且元素有顺序。每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。

5 哈希类型 hash

hash类型的存储结构如下：

hash类型的数据结构，底层采用hash表存储。

基本操作

• hset：添加/修改数据

HSET key field value

hset user username zs
hset user password admin

• hget：取数据

HGET key field

hget user username

• hdel：删除数据

HDEL key field [field ...]

hdel user password

• hmset：一次性添加/修改多个字段

HMSET key field value [field value ...]

hmset user username zs password admin age 20

• hmget

HMGET key field [field ...]

hmget user username password age

• 获取指定key的field的数量

HLEN key

hlen user

• hexists：判断指定的key中是否包含有指定的field（返回1[有]或0[没有]）

HEXISTS key field

hexists user username
hexists user aa

• hgetall：获取指定key中所有的field以及value值

HGETALL key

hgetall user

扩展操作

• hkeys：获取key中所有的field

HKEYS key

hkeys key

• hvals：获取key中所有的value

HVALS key

hvals key

• 给指定key中的指定field增加指定范围的值

HINCRBY key field increment
HINCRBYFLOAT key field increment

hincrby user age 2
hincrbyfloat user age 0.5

• hsetnx：如果指定key中有对应的field则返回0（false），如果没有则存对应的值进去

HSETNX key field value

hsetnx user flag 1

6 通用命令

key基本操作

• 删除key

del key

• 判断key是否存在

exists key

• 获取key的类型

type key

控制key的时效性

setex key seconds value		# 秒
setex name 5 zhangsan

psetex key milliseconds value		# 毫秒
psetex name 5000 zhangsan

• 为指定key设置有效期

expire key seconds
pexpire key milliseconds
expireat key timestamp
pexpireat key milliseconds-timestamp

• 获取key的有效时间

ttl key			# 返回key的有效时间，单位秒
pttl key		# 返回key的有效时间，单位毫秒

如果key没有设置有效期(永久存在)，返回-1，如果key不存在返回-2，如果key存在返回key的有效时间

• 切换key从时效性转换为永久性

persist key

key的查询操作

• 查询key

keys pattern 

查询匹配规则：

• *：匹配任意数量的任意符号
• ?：匹配任意一个符号
• []匹配一个指定符号

keys * 查询所有
keys java* 查询所有以java开头
keys *java 查询所有以java结尾
keys ??java 查询所有前面两个字符任意，后面以java结尾
keys user:? 查询所有以user:开头，最后一个字符任意
keys j[av]a:1 查询所有以j开头，以a:1结尾，中间包含一个字母，a或v

key的其他操作

• key改名

rename key newkey
renamenx key newkey

rename：如果改名的时候newkey已经存在了，则会把key中的值覆盖newkey中的值。

renamenx：如果newkey已经存在，则不允许修改名称

• 对所有key排序：只能对集合进行排序list、sort、sorted-set

SORT key [BY pattern] [LIMIT offset count] [ASC|DESC] [ALPHA] [STORE destination]

• 关于key的其他操作在帮助文档中的@generic组中可以查询到

help @generic

数据库通用操作

在一个redis中会有16个数据库，分别为db0、db1、db2…

• 切换数据库

select num

select 0 		# 切换到0数据库
select 1		# 切换到1数据库

• 数据清除

dbsize			# 查看当前数据库共有多少个key
flushdb			# 清除当前数据库的所有数据
flushall		# 清除所有数据库的所有数据

第四章 Java客户端Jedis(了解)

Jedis是Redis官方推荐的Java连接开发工具。

增加依赖

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.5.0</version>
</dependency>

连接使用

//1. 获取连接
Jedis jedis = new Jedis("localhost",6379);
//2. 操作
jedis.set("username","zhangsan");
//3. 关闭连接
jedis.close();

1 Jedis操作字符串string

get、set、setex

//1. 获取连接
Jedis jedis = new Jedis();//如果使用空参构造，默认值 "localhost",6379端口
//2. 操作
//存储
jedis.set("username","zhangsan");
//获取
String username = jedis.get("username");
System.out.println(username);

//可以使用setex()方法存储可以指定过期时间的 key value
jedis.setex("activecode",20,"hehe");//将activecode：hehe键值对存入redis，并且20秒后自动删除该键值对

//3. 关闭连接
jedis.close();

2 哈希类型 hash

hset、hget、hgetAll

//1. 获取连接
Jedis jedis = new Jedis();//如果使用空参构造，默认值 "localhost",6379端口
//2. 操作
// 存储hash
jedis.hset("user","name","lisi");
jedis.hset("user","age","23");
jedis.hset("user","gender","female");

// 获取hash
String name = jedis.hget("user", "name");
System.out.println(name);

 // 获取hash的所有map中的数据
Map<String, String> user = jedis.hgetAll("user");

// keyset
Set<String> keySet = user.keySet();
for (String key : keySet) {
	//获取value
	String value = user.get(key);
	System.out.println(key + ":" + value);
}

//3. 关闭连接
jedis.close();

3 列表类型list

linkedlist格式。支持重复元素。

lpush / rpush、lpop / rpop、lrange start end : 范围获取

//1. 获取连接
Jedis jedis = new Jedis();//如果使用空参构造，默认值 "localhost",6379端口
//2. 操作
// list 存储
jedis.lpush("mylist","a","b","c");//从左边存
jedis.rpush("mylist","a","b","c");//从右边存

// list 范围获取
List<String> mylist = jedis.lrange("mylist", 0, -1);
System.out.println(mylist);

// list 弹出
String element1 = jedis.lpop("mylist");//c
System.out.println(element1);

String element2 = jedis.rpop("mylist");//c
System.out.println(element2);

// list 范围获取
List<String> mylist2 = jedis.lrange("mylist", 0, -1);
System.out.println(mylist2);

//3. 关闭连接
jedis.close();

4 集合类型 set

不允许重复元素

sadd、smembers:获取所有元素

//1. 获取连接
Jedis jedis = new Jedis();//如果使用空参构造，默认值 "localhost",6379端口
//2. 操作
// set 存储
jedis.sadd("myset","java","php","c++");

// set 获取
Set<String> myset = jedis.smembers("myset");
System.out.println(myset);

//3. 关闭连接
jedis.close();

5 有序集合类型sortedset

不允许重复元素，且元素有顺序

zadd、zrange

//1. 获取连接
Jedis jedis = new Jedis();//如果使用空参构造，默认值 "localhost",6379端口
//2. 操作
// sortedset 存储
jedis.zadd("mysortedset",3,"亚瑟");
jedis.zadd("mysortedset",30,"后裔");
jedis.zadd("mysortedset",55,"孙悟空");

// sortedset 获取
Set<String> mysortedset = jedis.zrange("mysortedset", 0, -1);

System.out.println(mysortedset);
 //3. 关闭连接
jedis.close();

6 jedis连接池 JedisPool

jedisPool 是 Jedis 内部管理到 redis 的连接资源，内部的实例是 Jedis，通过连接池策略来优化对 redis 的访问。

//1创建一个配置对象
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxTotal(50);
config.setMaxIdle(10);

//2.创建Jedis连接池对象
JedisPool jedisPool = new JedisPool(config,"localhost",6379);

//3.获取连接
Jedis jedis = jedisPool.getResource();
//4. 使用
jedis.set("hehe","heihei");
 //5. 关闭 归还到连接池中
jedis.close();

创建配置文件

#最大活动对象数     
redis.pool.maxTotal=1000    
#最大能够保持idel状态的对象数      
redis.pool.maxIdle=100  
#最小能够保持idel状态的对象数   
redis.pool.minIdle=50    
#当池内没有返回对象时，最大等待时间    
redis.pool.maxWaitMillis=10000    
#当调用borrow Object方法时，是否进行有效性检查    
redis.pool.testOnBorrow=true    
#当调用return Object方法时，是否进行有效性检查    
redis.pool.testOnReturn=true  
#“空闲链接”检测线程，检测的周期，毫秒数。如果为负值，表示不运行“检测线程”。默认为-1.  
redis.pool.timeBetweenEvictionRunsMillis=30000  
#向调用者输出“链接”对象时，是否检测它的空闲超时；  
redis.pool.testWhileIdle=true  
# 对于“空闲链接”检测线程而言，每次检测的链接资源的个数。默认为3.  
redis.pool.numTestsPerEvictionRun=50  
#redis服务器的IP    
redis.ip=127.0.0.1
#redis服务器的Port    
redis1.port=6379   

创建连接池工具类JedisPoolUtils

public class JedisPoolUtils {
    private static JedisPool jedisPool;
    static {
        //读取配置文件
        InputStream is = JedisPoolUtils.class.getClassLoader().getResourceAsStream("jedis.properties");
        //创建Properties对象
        Properties pro = new Properties();
        //关联文件
        try {
            pro.load(is);
        } catch (IOException e) {
            e.printStackTrace();
        }
        //获取数据，设置到JedisPoolConfig中
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(Integer.parseInt(pro.getProperty("maxTotal")));
        config.setMaxIdle(Integer.parseInt(pro.getProperty("maxIdle")));

        //初始化JedisPool
        jedisPool = new JedisPool(config, pro.getProperty("host"), Integer.parseInt(pro.getProperty("port")));
    }

    /**
     * 获取连接方法
     */
    public static Jedis getJedis() {
        return jedisPool.getResource();
    }
}

第五章 SpringBoot中使用Redis

基本逻辑

1. 先读缓存，缓存有则直接返回。
2. 缓存没有，则读数据库。
3. 读取后，缓存数据，且设置数据的超时时间。

1 增加依赖

 		<!-- redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-redis</artifactId>
            <version>1.3.3.RELEASE</version>
        </dependency>

2 redis配置文件

application.properties增加配置

#
#redis 单机配置
spring.redis.host=127.0.0.1
spring.redis.port=6379
spring.redis.password=
#
spring.redis.jedis.pool.min-idle=100
spring.redis.jedis.pool.max-idle=300
spring.redis.jedis.pool.max-active=500

新增RedisConfig

package com.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.time.Duration;

/**
 * @auth admin
 * @date
 * @Description redis的操作组件自定义注入配置
 */
@Configuration
//@EnableCaching：开启缓存（注解生效的）
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {

    //注入connectionFactory
    @Autowired
    private RedisConnectionFactory connectionFactory;

    @Bean
    public RedisTemplate redisTemplate() {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(connectionFactory);
        //设置序列化策略
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());

        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    @Bean
    public StringRedisTemplate stringRedisTemplate() {
        StringRedisTemplate stringRedisTemplate = new StringRedisTemplate();
        stringRedisTemplate.setConnectionFactory(connectionFactory);
        return stringRedisTemplate;
    }


    //缓存cache管理器
    @Override
    public CacheManager cacheManager() {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofSeconds(120)).disableCachingNullValues();
        return RedisCacheManager.builder(connectionFactory).cacheDefaults(config)
                .transactionAware().build();
    }
}

3 测试

controller

// 通过id查询用户
@GetMapping("getById")
@ResponseBody
public User getById(Integer id) {
   return userService.getById(id);
}    

//通过id修改用户
@GetMapping("update")
@ResponseBody
public void update(User user) {
    userService.update(user);
}

UserService

/**
 * @auth admin
 * @date
 * @Description
 */
@Service
public class UserService {

    @Resource
    private UserDao userDao;

    //从spring容器中获取RedisTemplate实例
    @Autowired
    private RedisTemplate redisTemplate;

    //通过id查询
    public User getById(Integer id) {
        User user = null;

        ValueOperations valueOperations = redisTemplate.opsForValue();

        String key = "SpringBootRedis:String:" + id;

        if (id != null) {
            //判断key是否存在，如果存在则从redis中取出数据，如果不存在直接从数据库中查
            if (redisTemplate.hasKey(key)) {
                Object obj = valueOperations.get(key);
                if (obj != null) {
                    user = (User) obj;
                }
            } else {
                //从数据库中查询，然后把结果再放入redis中
                user = userDao.getById(id);
                if (user != null) {
                    valueOperations.set(key, user);
                    //设置过期时间
                    redisTemplate.expire(key,60*30,TimeUnit.SECONDS);
                }
            }
        }
        return user;
    }

    //修改
    public void update(User user) {
        int result = userDao.update(user);

        if (result > 0) {
            String key = "SpringBootRedis:String:" + user.getId();
            ValueOperations valueOperations = redisTemplate.opsForValue();
            //修改实体数据库的同时需要修改redis中的数据
            //方式1：直接删除key
            //redisTemplate.delete(key);

            //方式2：更新redis中的数据
            valueOperations.set(key, user);
        }
    }
}

测试流程：

第一次调用getById()，打一个断点进行调试，发现直接查询的是数据库

第二次调用getById()，发现直接查询的是redis，不会再从数据库中查询，这样可以减轻数据库的压力

当对同一条数据修改时，需要同步更新redis中的数据。

缓存常见问题

缓存最常见的3个问题：

1. 缓存穿透

2. 缓存雪崩

3. 缓存击穿

缓存穿透是指查询一个不存在的数据，由于缓存无法命中，将去查询数据库，但是数据库也无此记录，并且出于容错考虑，我们没有将这次查询的null写入缓存，这将导致这个不存在的数据每次请求都要到存储层去查询，失去了缓存的意义。在流量大时，可能DB就挂掉了，要是有人利用不存在的key频繁攻击我们的应用，这就是漏洞。

解决：空结果也进行缓存，但它的过期时间会很短，最长不超过五分钟。

缓存雪崩是指在我们设置缓存时采用了相同的过期时间，导致缓存在某一时刻同时失效，请求全部转发到DB，DB瞬时压力过重雪崩。

解决：原有的失效时间基础上增加一个随机值，比如1-5分钟随机，这样每一个缓存的过期时间的重复率就会降低，就很难引发集体失效的事件。

缓存击穿是指对于一些设置了过期时间的key，如果这些key可能会在某些时间点被超高并发地访问，是一种非常“热点”的数据。这个时候，需要考虑一个问题：如果这个key在大量请求同时进来之前正好失效，那么所有对这个key的数据查询都落到db，我们称为缓存击穿。

与缓存雪崩的区别：

1. 击穿是一个热点key失效

2. 雪崩是很多key集体失效
   (user != null) {
   valueOperations.set(key, user);
   //设置过期时间
   redisTemplate.expire(key,60*30,TimeUnit.SECONDS);
   }
   }
   }
   return user;
   }

   //修改
   public void update(User user) {
   int result = userDao.update(user);

    if (result > 0) {
        String key = "SpringBootRedis:String:" + user.getId();
        ValueOperations valueOperations = redisTemplate.opsForValue();
        //修改实体数据库的同时需要修改redis中的数据
        //方式1：直接删除key
        //redisTemplate.delete(key);
   
        //方式2：更新redis中的数据
        valueOperations.set(key, user);
    }
   

   }
   }

测试流程：

第一次调用getById()，打一个断点进行调试，发现直接查询的是数据库

第二次调用getById()，发现直接查询的是redis，不会再从数据库中查询，这样可以减轻数据库的压力

当对同一条数据修改时，需要同步更新redis中的数据。



**缓存常见问题**

缓存最常见的3个问题：

1. 缓存穿透

2. 缓存雪崩

3. 缓存击穿



**缓存穿透**是指查询一个**不存在的数据**，由于缓存无法命中，将去查询数据库，但是数据库也无此记录，并且出于容错考虑，我们没有将这次查询的null写入缓存，这将导致这个不存在的数据每次请求都要到存储层去查询，失去了缓存的意义。在流量大时，可能DB就挂掉了，要是有人利用不存在的key频繁攻击我们的应用，这就是**漏洞**。

解决：空结果也进行缓存，但它的过期时间会很短，最长不超过五分钟。



**缓存雪崩**是指在我们设置缓存时采用了**相同的过期时间**，导致缓存在某一时刻同时失效，请求全部转发到DB，DB瞬时压力过重雪崩。

解决：原有的失效时间基础上增加一个随机值，比如1-5分钟随机，这样每一个缓存的过期时间的重复率就会降低，就很难引发集体失效的事件。



**缓存击穿**是指对于一些设置了过期时间的key，如果这些key可能会在某些时间点被超高并发地访问，是一种非常“热点”的数据。这个时候，需要考虑一个问题：如果这个key在大量请求同时进来之前正好失效，那么所有对这个key的数据查询都落到db，我们称为缓存击穿。

与缓存雪崩的区别：

1. 击穿是一个热点key失效
2. 雪崩是很多key集体失效