Redis
Redis入门
Redis is an open source (BSD licensed), in-memory data structure store, used as a database, cache, and message broker. 翻译为:Redis是一个开源的内存中的数据结构存储系统,它可以用作:数据库、缓存和消息中间件。
Redis是用C语言开发的一个开源的高性能键值对(key-value)数据库,官方提供的数据是可以达到100000+的QPS(每秒内查询次数)。它存储的value类型比较丰富,也被称为结构化的NoSql数据库。
NoSql(Not Only SQL),不仅仅是SQL,泛指非关系型数据库。NoSql数据库并不是要取代关系型数据库,而是关系型数据库的补充。
关系型数据库(RDBMS):
-
Mysql
-
Oracle
-
DB2
-
SQLServer
非关系型数据库(NoSql):
-
Redis
-
Mongo db
-
MemCached
DB-Engines - Knowledge Base of Relational and NoSQL Database Management Systems (数据库排行榜)
redis下载与安装
Redis下载
Redis安装包分为windows版和Linux版:
-
Windows版下载地址:Releases · microsoftarchive/redis · GitHub
-
Linux版下载地址: Index of /releases/
下载后得到下面安装包:
Redis安装
1)在Linux中安装Redis
在Linux系统安装Redis步骤:
-
将Redis安装包上传到Linux
-
解压安装包,命令:tar -zxvf redis-4.0.0.tar.gz -C /usr/local
-
安装Redis的依赖环境gcc,命令:yum install gcc-c++
-
进入/usr/local/redis-4.0.0,进行编译,命令:make
-
进入redis的src目录进行安装,命令:make install
安装后重点文件说明:
/usr/local/redis-4.0.0/src/redis-server:Redis服务启动脚本
/usr/local/redis-4.0.0/src/redis-cli:Redis客户端脚本
/usr/local/redis-4.0.0/redis.conf:Redis配置文件
2)在Windows中安装Redis
Redis的Windows版属于绿色软件,直接解压即可使用,解压后目录结构如下:
Redis服务启动与停止
1)Linux系统中启动和停止Redis
执行Redis服务启动脚本文件redis-server:
通过启动日志可以看到,Redis默认端口号为6379。
Ctrl + C停止Redis服务
通过redis-cli可以连接到本地的Redis服务,默认情况下不需要认证即可连接成功。
退出客户端可以输入exit或者quit命令。
Windows系统中启动和停止Redis**
Windows系统中启动Redis,直接双击redis-server.exe即可启动Redis服务,redis服务默认端口号为6379
Ctrl + C停止Redis服务
双击redis-cli.exe即可启动Redis客户端,默认连接的是本地的Redis服务,而且不需要认证即可连接成功。
退出客户端可以输入exit或者quit命令。
Redis配置文件
前面我们已经启动了Redis服务,默认情况下Redis启动后是在前台运行,而且客户端不需要密码就可以连接到Redis服务。如果我们希望Redis服务启动后是在后台运行,同时希望客户端认证通过后才能连接到Redis服务,应该如果做呢?
此时就需要修改Redis的配置文件:
-
Linux系统中Redis配置文件:REDIS_HOME/redis.conf
-
Windows系统中Redis配置文件:REDIS_HOME/redis.windows.conf
通过修改Redis配置文件可以进行如下配置:**
1)设置Redis服务后台运行(就是运行时无需界面)
将配置文件中的daemonize配置项改为yes,默认值为no。
注意:Windows版的Redis不支持后台运行。
./redis-server ../redis.conf
运行服务端读取配置文件(注意: 配置文件在服务端的上一级目录)
2)设置Redis服务密码
将配置文件中的 # requirepass foobared 配置项取消注释,默认为注释状态。foobared为密码,可以根据情况自己指定。
一般不需要
3)设置允许客户端远程连接Redis服务(windows客户端可以连接linux的redis)
Redis服务默认只能客户端本地连接,不允许客户端远程连接。将配置文件中的 bind 127.0.0.1 配置项注释掉。
修改redis.conf配置文件的 69行 bind 0.0.0.0
解释说明:
Redis配置文件中 # 表示注释
Redis配置文件中的配置项前面不能有空格,需要顶格写
daemonize:用来指定redis是否要用守护线程的方式启动,设置成yes时,代表开启守护进程模式。在该模式下,redis会在后台运行
requirepass:设置Redis的连接密码
bind:如果指定了bind,则说明只允许来自指定网卡的Redis请求。如果没有指定,就说明可以接受来自任意一个网卡的Redis请求。
注意:修改配置文件后需要重启Redis服务配置才能生效,并且启动Redis服务时需要显示的指定配置文件:
注意要开启防火墙允许6379远程访问
firewall-cmd --zone=public --add-port=6379/tcp --permanent
firewall-cmd --reload
1)Linux中启动Redis服务
# 进入Redis安装目录 cd /usr/local/redis-4.0.0 # 启动Redis服务,指定使用的配置文件 ./src/redis-server ./redis.conf
2)Windows中启动Redis服务
由于Redis配置文件中开启了认证校验,即客户端连接时需要提供密码,此时客户端连接方式变为:
解释说明:
-h:指定连接的Redis服务的ip地址
-p:指定连接的Redis服务的端口号
-a:指定连接的Redis服务的密码
NoSQL
NoSQL(NoSQL = Not Only SQL),意即“不仅 仅是SQL”,是一项全新的数据库理念,泛指非关系 型的数据库。NoSql数据库并不是要取代关系型数据 库,而是关系型数据库的补充。
Redis是一个基于内存的key-value结构数据库。
Redis能做什么?
-
缓存(热门数据、短链接、新闻首页、商品首页等等)
-
应用排行榜(武力排行榜,输出排行榜DPS)
-
任务队列。(秒杀、抢购、12306等等)
-
聊天室的在线好友列表
-
网站访问统计、签到统计(量大、频次)
-
数据过期处理(可以精确到毫秒)
-
分布式集群架构中的session分离
-
分布式锁
-
分布式计数器
快的原因
redis
Redis数据类型
3.1 介绍
Redis存储的是key-value结构的数据,其中key是字符串类型,value有5种常用的数据类型:
-
字符串 string
-
哈希 hash
-
列表 list
-
集合 set
-
有序集合 sorted set / zset
3.2 Redis 5种常用数据类型
解释说明:
字符串(string):普通字符串,常用
哈希(hash):适合存储对象
列表(list):按照插入顺序排序,可以有重复元素
集合(set):无序集合,没有重复元素
有序集合(sorted set / zset):集合中每个元素关联一个分数(score),根据分数升序排序,没有重复元素
Redis常用命令
更多命令可以参考Redis中文网:https://www.redis.net.cn
4.1 字符串string操作命令
Redis 中字符串类型常用命令:
-
SET key value 设置指定key的值
-
GET key 获取指定key的值
-
SETEX key seconds value 设置指定key的值,并将 key 的过期时间设为 seconds 秒
-
SETNX key value 只有在 key不存在时设置 key 的值
-
-
del key 删除指定的key
4.2 哈希hash操作命令
Redis hash 是一个string类型的 field 和 value 的映射表,hash特别适合用于存储对象,常用命令:
-
HSET key field value 将哈希表 key 中的字段 field 的值设为 value
-
HMSET key field1 value1 filed2 value2... 批量添加 (multi 多)
-
HGET key field 获取存储在哈希表中指定字段的值
-
HDEL key field 删除存储在哈希表中的指定字段,可以批量删
-
HKEYS key 获取哈希表中所有字段
-
HVALS key 获取哈希表中所有值
-
HGETALL key 获取在哈希表中指定 key 的所有字段和值
列表list操作命令
Redis 列表是简单的字符串列表,按照插入顺序排序,常用命令:
-
LPUSH key value1 [value2] 将一个或多个值插入到列表头部(left)
-
LRANGE key start stop 获取列表指定范围内的元素
lrange 0 -1 查看所有的元素
-
RPOP key 移除并获取列表最后一个元素
-
LLEN key 获取列表长度
-
BRPOP key1 [key2 ] timeout 移出并获取列表的最后一个元素, 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止
集合set操作命令
Redis set 是string类型的无序集合。集合成员是唯一的,这就意味着集合中不能出现重复的数据,常用命令:
-
SADD key member1 [member2] 向集合添加一个或多个成员
-
SMEMBERS key 返回集合中的所有成员
-
SCARD key 获取集合的成员数
-
SINTER key1 [key2] 返回给定所有集合的交集
-
SUNION key1 [key2] 返回所有给定集合的并集
-
SDIFF key1 [key2] 返回给定所有集合的差集
-
SREM key member1 [member2] 移除集合中一个或多个成员
有序集合sorted set操作命令
Redis sorted set (别名zset)有序集合是 string 类型元素的集合,且不允许重复的成员。每个元素都会关联一个double类型的分数(score) 。redis正是通过分数来为集合中的成员进行从小到大排序。有序集合的成员是唯一的,但分数却可以重复。
常用命令:
-
ZADD key score1 member1 [score2 member2] 向有序集合添加一个或多个成员,或者更新已存在成员的 分数
-
ZRANGE key start stop [WITHSCORES] 通过索引区间返回有序集合中指定区间内的成员
-
ZINCRBY key increment member 有序集合中对指定成员的分数加上增量 increment
-
ZREM key member [member ...] 移除有序集合中的一个或多个成员
通用命令
Redis中的通用命令,主要是针对key进行操作的相关命令:
-
KEYS pattern 查找所有符合给定模式( pattern)的 key
-
EXISTS key 检查给定 key 是否存在(1为true,0为false)
-
TYPE key 返回 key 所储存的值的类型
-
TTL key 返回给定 key 的剩余生存时间(TTL, time to live),以秒为单位
-1表示没有设置超时时间
-2表示已超时
-
DEL key 该命令用于在 key 存在是删除 key
Redis的五种类型使用场景
String 字符串
-
setnx 只有key不存在时,才能设置key的值
-
可以实现分布式锁。
-
但是只通过这一个命令没有办法实现一个完美的分布式锁
-
如果想要详细了解,可以找一些相关的分布式锁知识
-
-
incr 自增
-
使用场景
-
朋友圈点赞
-
统计点击数量
-
-
-
decr 自减
-
使用场景
-
扣减库存
-
-
-
setbit 操作二进制位
-
使用方式
-
setbit key offset value 设置该key中,对应的offset位的value,只能设置为0或者1
-
-
使用场景
-
签到
-
-
-
getbit 获取key的offset位的value
-
使用方式
-
getbit key offset
-
-
-
bitcount key [start end] 统计key中出现value为1的二进制位的数量
-
需要注意 其中start和end是按8位=1计算,也就是一个字节来计算的。
-
如果要统计24二进制位(3字节),那么命令就是 getbit key 0 2
-
-
hash 哈希
-
使用场景
-
常见于保存对象类型的数据。例如用户信息
-
-
hkeys key 获取哈希表中所有字段
-
hvals key 获取哈希表中所有的值
-
hgetall key 获取在哈希表中指定key的所有字段和值
list 列表
-
使用场景
-
评价列表&评论列表
-
使用商品id作为key,使用lpush添加评论,那么每次最新的评论都会在最前面
-
-
set 不可重复集合
-
使用场景
-
好友关系
-
交集 sinter
-
并集 sunion
-
差集 sdiff
-
返回差集的key前后顺序会导致返回不同的结果
-
返回在前的key的数据
-
-
-
-
-
sismember 判断集合中是否存在某成员
-
黑白名单
-
数据量特别大的情况下,可以考虑把黑名单或者是白名单的数据保存到redis中
-
-
srandmember 返回集合中任意成员(随机)
zset 不可重复的有序集合
-
通过分数来进行排序
-
可以正序输出也可以倒序输出
-
zrange 正序 0->10
-
zrevrange 倒序 10->0
-
-
使用场景
-
排行榜
-
Redis中Bit的使用
-
SETBIT key offset value 设置Key,对应的Value第N个二进制位,标记0或1
-
当设置的offset超出字节长度时,会在后面再追加字节(8位)
-
-
GETBIT key offset 获取Key,对应的Value第N个二进制位的状态
-
BITCOUNT key [start end] 统计Key,对应的Value对应的第N个字节的二进制数量,1为有效
-
统计的数量是按字节的数量统计的。
-
即start为0 end 为 2时,统计的就是从第0个字节开始到第二个字节中出现的1的数量
-
-
-
使用场景
-
当有大批量的,需要统计是或者否(1或者0)这种情况时,很适合使用bit位来统计,这会节省大量的redis的内存占用
-
最常见的场景业务:统计签到
-
在Java中操作Redis
介绍
前面我们讲解了Redis的常用命令,这些命令是我们操作Redis的基础,那么我们在java程序中应该如何操作Redis呢?这就需要使用Redis的Java客户端,就如同我们使用JDBC操作MySQL数据库一样。
Redis 的 Java 客户端很多,官方推荐的有三种:
-
Jedis (入门)
-
Lettuce
-
Redisson (使用)
Spring 对 Redis 客户端进行了整合,提供了 Spring Data Redis,在Spring Boot项目中还提供了对应的Starter,即 spring-boot-starter-data-redis。
5.2 Jedis
Jedis 是 Redis 的 Java 版本的客户端实现。
maven坐标:
<dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>2.8.0</version> </dependency>
使用 Jedis 操作 Redis 的步骤:
-
获取连接
-
执行操作
-
关闭连接
示例代码:
package com.itheima.test; import org.junit.Test; import redis.clients.jedis.Jedis; import redis.clients.jedis.JedisPool; import redis.clients.jedis.JedisPoolConfig; public class JedisDemo { @Test public void method01(){ //1. 创建连接 String host = "192.168.47.111"; int port = 6379; Jedis jedis = new Jedis(host, port); //2. 操作redis数据库(增删改查) //往redis中存一个string类型的数据 jedis.set("dance","tianelake"); //3. 释放连接 jedis.close(); } @Test public void method02(){ /* * 连接池: 管理连接的容器 * 1). 没有连接池,就会需要连接去创建,不需要就销毁,这样频繁创建和销毁连接会给系统性能造成很大的负担 * 2). 连接池的原理: 初始化的时候会预先创建一些连接存到容器中,需要访问redis的时候从容器中获取连接,用完放回去 * * */ //1. 创建连接池 JedisPoolConfig config = new JedisPoolConfig(); config.setMaxIdle(5); // 最大空闲连接数量 config.setMaxTotal(10); // 最大连接数量 config.setMaxWaitMillis(2000); // 最长等待时间 String host = "192.168.47.111"; int port = 6379; JedisPool jedisPool = new JedisPool(config, host, port); //2. 从连接池获取连接 Jedis jedis = jedisPool.getResource(); //3. 操作redis数据库(增删改查) String value = jedis.get("dance"); System.out.println(value); //4. 将连接还给连接池 jedis.close(); } }
5.3 Spring Data Redis
5.3.1 介绍
Spring Data Redis 是 Spring 的一部分,提供了在 Spring 应用中通过简单的配置就可以访问 Redis 服务,对 Redis 底层开发包进行了高度封装。在 Spring 项目中,可以使用Spring Data Redis来简化 Redis 操作。
maven坐标:
<dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-redis</artifactId> <version>2.4.8</version> </dependency>
Spring Boot提供了对应的Starter,maven坐标:
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency>
Spring Data Redis中提供了一个高度封装的类:RedisTemplate,针对 Jedis 客户端中大量api进行了归类封装,将同一类型操作封装为operation接口,具体分类如下:
-
ValueOperations:简单K-V操作
-
SetOperations:set类型数据操作
-
ZSetOperations:zset类型数据操作
-
HashOperations:针对hash类型的数据操作
-
ListOperations:针对list类型的数据操作
5.3.2 使用方式
5.3.2.1 环境搭建
第一步:创建maven项目springdataredis_demo,配置pom.xml文件
<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.4.5</version> <relativePath/> </parent> <groupId>com.itheima</groupId> <artifactId>springdataredis_demo</artifactId> <version>1.0-SNAPSHOT</version> <properties> <java.version>1.8</java.version> </properties> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <version>2.4.5</version> </plugin> </plugins> </build> </project>
第二步:编写启动类
package com.itheima; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication public class App { public static void main(String[] args) { SpringApplication.run(App.class,args); } }
以上两步用springboot模板代替
第三步:配置application.yml
spring: #Redis相关配置 redis: host: localhost port: 6379 #password: 123456 database: 0 #操作的是0号数据库 jedis: #Redis连接池配置 pool: max-active: 8 #最大连接数 max-wait: 1ms #连接池最大阻塞等待时间 max-idle: 4 #连接池中的最大空闲连接 min-idle: 0 #连接池中的最小空闲连接
解释说明:
spring.redis.database:指定使用Redis的哪个数据库,Redis服务启动后默认有16个数据库,编号分别是从0到15。
可以通过修改Redis配置文件来指定数据库的数量。
第四步:提供配置类
package com.itheima.config; import org.springframework.cache.annotation.CachingConfigurerSupport; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.data.redis.connection.RedisConnectionFactory; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.data.redis.serializer.StringRedisSerializer; /** * Redis配置类 */ @Configuration public class RedisConfig extends CachingConfigurerSupport { @Bean public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) { RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>(); //默认的Key序列化器为:JdkSerializationRedisSerializer redisTemplate.setKeySerializer(new StringRedisSerializer()); redisTemplate.setHashKeySerializer(new StringRedisSerializer()); redisTemplate.setConnectionFactory(connectionFactory); return redisTemplate; } }
解释说明:
当前配置类不是必须的,因为 Spring Boot 框架会自动装配 RedisTemplate 对象,但是默认的key序列化器为JdkSerializationRedisSerializer,导致我们存到Redis中后的数据和原始数据有差别
第五步:提供测试类
package com.itheima.test; import org.junit.jupiter.api.Test; import org.springframework.boot.test.context.SpringBootTest; @SpringBootTest public class SpringDataRedisTest { @Autowired private RedisTemplate redisTemplate; }
5.3.2.2 操作字符串类型数据
/** * 操作String类型数据 */ @Test public void testString(){ //存值 redisTemplate.opsForValue().set("city123","beijing"); //取值 String value = (String) redisTemplate.opsForValue().get("city123"); System.out.println(value); //存值,同时设置过期时间 redisTemplate.opsForValue().set("key1","value1",10l, TimeUnit.SECONDS); //存值,如果存在则不执行任何操作 Boolean aBoolean = redisTemplate.opsForValue().setIfAbsent("city1234", "nanjing"); System.out.println(aBoolean); }
5.3.2.3 操作哈希类型数据
/** * 操作Hash类型数据 */ @Test public void testHash(){ HashOperations hashOperations = redisTemplate.opsForHash(); //存值 hashOperations.put("002","name","xiaoming"); hashOperations.put("002","age","20"); hashOperations.put("002","address","bj"); //取值 String age = (String) hashOperations.get("002", "age"); System.out.println(age); //获得hash结构中的所有字段 Set keys = hashOperations.keys("002"); for (Object key : keys) { System.out.println(key); } //获得hash结构中的所有值 List values = hashOperations.values("002"); for (Object value : values) { System.out.println(value); } }
5.3.2.4 操作列表类型数据
/** * 操作List类型的数据 */ @Test public void testList(){ ListOperations listOperations = redisTemplate.opsForList(); //存值 listOperations.leftPush("mylist","a"); listOperations.leftPushAll("mylist","b","c","d"); //取值 List<String> mylist = listOperations.range("mylist", 0, -1); for (String value : mylist) { System.out.println(value); } //获得列表长度 llen Long size = listOperations.size("mylist"); int lSize = size.intValue(); for (int i = 0; i < lSize; i++) { //出队列 String element = (String) listOperations.rightPop("mylist"); System.out.println(element); } }
5.3.2.5 操作集合类型数据
/** * 操作Set类型的数据 */ @Test public void testSet(){ SetOperations setOperations = redisTemplate.opsForSet(); //存值 setOperations.add("myset","a","b","c","a"); //取值 Set<String> myset = setOperations.members("myset"); for (String o : myset) { System.out.println(o); } //删除成员 setOperations.remove("myset","a","b"); //取值 myset = setOperations.members("myset"); for (String o : myset) { System.out.println(o); } }
5.3.2.6 操作有序集合类型数据
/** * 操作ZSet类型的数据 */ @Test public void testZset(){ ZSetOperations zSetOperations = redisTemplate.opsForZSet(); //存值 zSetOperations.add("myZset","a",10.0); zSetOperations.add("myZset","b",11.0); zSetOperations.add("myZset","c",12.0); zSetOperations.add("myZset","a",13.0); //取值 Set<String> myZset = zSetOperations.range("myZset", 0, -1); for (String s : myZset) { System.out.println(s); } //修改分数 zSetOperations.incrementScore("myZset","b",20.0); //取值 myZset = zSetOperations.range("myZset", 0, -1); for (String s : myZset) { System.out.println(s); } //删除成员 zSetOperations.remove("myZset","a","b"); //取值 myZset = zSetOperations.range("myZset", 0, -1); for (String s : myZset) { System.out.println(s); } }
5.3.2.7 通用操作
/** * 通用操作,针对不同的数据类型都可以操作 */ @Test public void testCommon(){ //获取Redis中所有的key Set<String> keys = redisTemplate.keys("*"); for (String key : keys) { System.out.println(key); } //判断某个key是否存在 Boolean itcast = redisTemplate.hasKey("itcast"); System.out.println(itcast); //删除指定key redisTemplate.delete("myZset"); //获取指定key对应的value的数据类型 DataType dataType = redisTemplate.type("myset"); System.out.println(dataType.name()); }
前言
当前系统存在的问题
之前我们已经实现了移动端菜品展示、点餐、购物车、下单等功能,但是由于移动端是面向所有的消费者的,请求压力相对比较大,而我们当前所有的数据查询都是从数据库MySQL中直接查询的,那么可能就存在如下问题: 频繁访问数据库,数据库访问压力大,系统性能下降,用户体验较差。
2). 解决该问题的方法
要解决我们上述提到的问题,就可以使用我们前面学习的一个技术:Redis,通过Redis来做缓存,从而降低数据库的访问压力,提高系统的访问性能,从而提升用户体验。加入Redis做缓存之后,我们在进行数据查询时,就需要先查询缓存,如果缓存中有数据,直接返回,如果缓存中没有数据,则需要查询数据库,再将数据库查询的结果,缓存在redis中。
业务修改
短信业务
环境准备
1). 在项目的pom.xml文件中导入spring data redis的maven坐标
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-cache</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> </dependencies>
2). 在项目的application.yml中加入redis相关配置
redis: host: 192.168.200.200 port: 6379 password: root@123456 database: 0
注意: 引入上述依赖时,需要注意yml文件前面的缩进,上述配置应该配置在spring层级下面。
3). 编写Redis的配置类RedisConfig,定义RedisTemplate
import org.springframework.cache.annotation.CachingConfigurerSupport; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.data.redis.connection.RedisConnectionFactory; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.data.redis.serializer.StringRedisSerializer; @Configuration public class RedisConfig extends CachingConfigurerSupport { @Bean public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) { RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>(); redisTemplate.setDefaultSerializer(new Jackson2JsonRedisSerializer<>(Object.class)); // 序列化构造器 redisTemplate.setKeySerializer(new StringRedisSerializer()); redisTemplate.setConnectionFactory(connectionFactory); return redisTemplate; } }
解释说明:
1). 在SpringBoot工程启动时, 会加载一个自动配置类 RedisAutoConfiguration, 在里面已经声明了RedisTemplate这个bean
上述框架默认声明的RedisTemplate用的key和value的序列化方式是默认的 JdkSerializationRedisSerializer,如果key采用这种方式序列化,最终我们在测试时通过redis的图形化界面查询不是很方便,如下形式:
2). 如果使用我们自定义的RedisTemplate, key的序列化方式使用的是StringRedisSerializer, 也就是字符串形式, 最终效果如下:
3). 定义了两个bean会不会出现冲突呢? 答案是不会, 因为源码如下:
代码改造
1). 在UserController中注入RedisTemplate对象,用于操作Redis
@Autowired private RedisTemplate redisTemplate;
2). 在UserController的sendMsg方法中,将生成的验证码保存到Redis
//需要将生成的验证码保存到Redis,设置过期时间 redisTemplate.opsForValue().set(phone, code, 5, TimeUnit.MINUTES);
3). 在UserController的login方法中,从Redis中获取生成的验证码,如果登录成功则删除Redis中缓存的验证码
//从Redis中获取缓存的验证码 Object codeInSession = redisTemplate.opsForValue().get(phone);
//从Redis中删除缓存的验证码 redisTemplate.delete(phone);
缓存菜品信息
具体的实现思路如下:
1). 改造DishController的list方法,先从Redis中获取分类对应的菜品数据,如果有则直接返回,无需查询数据库;如果没有则查询数据库,并将查询到的菜品数据存入Redis。
2). 改造DishController的save和update方法,加入清理缓存的逻辑。
注意:
在使用缓存过程中,要注意保证数据库中的数据和缓存中的数据一致,如果数据库中的数据发生变化,需要及时清理缓存数据。否则就会造成缓存数据与数据库数据不一致的情况。
1). 在DishController中注入RedisTemplate
@Autowired private RedisTemplate redisTemplate;
2). 在list方法中,查询数据库之前,先查询缓存, 缓存中有数据, 直接返回
List<DishDto> dishDtoList = null; //动态构造key String key = "dish_" + dish.getCategoryId() + "_" + dish.getStatus();//dish_1397844391040167938_1 //先从redis中获取缓存数据 dishDtoList = (List<DishDto>) redisTemplate.opsForValue().get(key); if(dishDtoList != null){ //如果存在,直接返回,无需查询数据库 return R.success(dishDtoList); }
3). 如果redis不存在,查询数据库,并将数据库查询结果,缓存在redis,并设置过期时间
//如果不存在,需要查询数据库,将查询到的菜品数据缓存到Redis redisTemplate.opsForValue().set(key,dishDtoList,60, TimeUnit.MINUTES);
清理菜品缓存
为了保证数据库中的数据和缓存中的数据一致,如果数据库中的数据发生变化,需要及时清理缓存数据。所以,我们需要在添加菜品、更新菜品时清空缓存数据。
1). 保存菜品,清空缓存
在保存菜品的方法save中,当菜品数据保存完毕之后,需要清空菜品的缓存。那么这里清理菜品缓存的方式存在两种:
A. 清理所有分类下的菜品缓存
//清理所有菜品的缓存数据 Set keys = redisTemplate.keys("dish_*"); //获取所有以dish_xxx开头的key redisTemplate.delete(keys); //删除这些key
B. 清理当前添加菜品分类下的缓存
//清理某个分类下面的菜品缓存数据 String key = "dish_" + dishDto.getCategoryId() + "_1"; redisTemplate.delete(key);
此处, 我们推荐使用第二种清理的方式, 只清理当前菜品关联的分类下的菜品数据。
更新菜品,清空缓存**
在更新菜品的方法update中,当菜品数据更新完毕之后,需要清空菜品的缓存。这里清理缓存的方式和上述基本一致。
A. 清理所有分类下的菜品缓存
//清理所有菜品的缓存数据 Set keys = redisTemplate.keys("dish_*"); //获取所有以dish_xxx开头的key redisTemplate.delete(keys); //删除这些key
B. 清理当前添加菜品分类下的缓存
//清理某个分类下面的菜品缓存数据 String key = "dish_" + dishDto.getCategoryId() + "_1"; redisTemplate.delete(key);
注意: 在这里我们推荐使用第一种方式进行清理,这样逻辑更加严谨。 因为对于修改操作,用户是可以修改菜品的分类的,如果用户修改了菜品的分类,那么原来分类下将少一个菜品,新的分类下将多一个菜品,这样的话,两个分类下的菜品列表数据都发生了变化。
SpringCache
4.1 介绍
Spring Cache是一个框架,实现了基于注解的缓存功能,只需要简单地加一个注解,就能实现缓存功能,大大简化我们在业务中操作缓存的代码。
Spring Cache只是提供了一层抽象,底层可以切换不同的cache实现。具体就是通过CacheManager接口来统一不同的缓存技术。CacheManager是Spring提供的各种缓存技术抽象接口。
针对不同的缓存技术需要实现不同的CacheManager:
CacheManager | 描述 |
---|---|
EhCacheCacheManager | 使用EhCache作为缓存技术 |
GuavaCacheManager | 使用Google的GuavaCache作为缓存技术 |
RedisCacheManager | 使用Redis作为缓存技术 |
4.2 注解
在SpringCache中提供了很多缓存操作的注解,常见的是以下的几个:
注解 | 说明 |
---|---|
@EnableCaching | 开启缓存注解功能 |
@Cacheable | 在方法执行前spring先查看缓存中是否有数据,如果有数据,则直接返回缓存数据;若没有数据,调用方法并将方法返回值放到缓存中 |
@CachePut | 将方法的返回值放到缓存中 |
@CacheEvict | 将一条或多条数据从缓存中删除 |
在spring boot项目中,使用缓存技术只需在项目中导入相关缓存技术的依赖包,并在启动类上使用@EnableCaching开启缓存支持即可。
例如,使用Redis作为缓存技术,只需要导入Spring data Redis的maven坐标即可。
1)注入CacheManager
我们可以在UserController注入一个CacheManager,在Debug时,我们可以通过CacheManager跟踪缓存中数据的变化。
我们可以看到CacheManager是一个接口,默认的实现有以下几种 ;
而在上述的这几个实现中,默认使用的是 ConcurrentMapCacheManager。稍后我们可以通过断点的形式跟踪缓存数据的变化。
4). 引导类上加@EnableCaching
在引导类上加该注解,就代表当前项目开启缓存注解功能。
注意: 上述的演示,最终的数据,实际上是缓存在ConcurrentHashMap中,那么当我们的服务器重启之后,缓存中的数据就会丢失。 我们后面使用了Redis来缓存就不存在这样的问题了。
@CachePut注解
@CachePut 说明:
作用: 将方法返回值,放入缓存
value: 缓存的名称, 每个缓存名称下面可以有很多key
key: 缓存的key ----------> 支持Spring的表达式语言SPEL语法
在save方法上加注解@CachePut
/** * CachePut:将方法返回值放入缓存 * value:缓存的名称,每个缓存名称下面可以有多个key * key:缓存的key */ @CachePut(value = "userCache", key = "#user.id") @PostMapping public User save(User user){ userService.save(user); return user; }
@CacheEvict注解
@CacheEvict 说明:
作用: 清理指定缓存
value: 缓存的名称,每个缓存名称下面可以有多个key
key: 缓存的key ----------> 支持Spring的表达式语言SPEL语法
在 delete 方法上加注解@CacheEvict
当我们在删除数据库user表的数据的时候,我们需要删除缓存中对应的数据,此时就可以使用@CacheEvict注解, 具体的使用方式如下:
/** * CacheEvict:清理指定缓存 * value:缓存的名称,每个缓存名称下面可以有多个key * key:缓存的key */ @CacheEvict(value = "userCache",key = "#p0") //#p0 代表第一个参数 //@CacheEvict(value = "userCache",key = "#root.args[0]") //#root.args[0] 代表第一个参数 //@CacheEvict(value = "userCache",key = "#id") //#id 代表变量名为id的参数 @DeleteMapping("/{id}") public void delete(@PathVariable Long id){ userService.removeById(id); }
@Cacheable注解
@Cacheable 说明:
作用: 在方法执行前,spring先查看缓存中是否有数据,如果有数据,则直接返回缓存数据;若没有数据,调用方法并将方法返回值放到缓存中
value: 缓存的名称,每个缓存名称下面可以有多个key
key: 缓存的key ----------> 支持Spring的表达式语言SPEL语法
1). 在getById上加注解@Cacheable
/** * Cacheable:在方法执行前spring先查看缓存中是否有数据,如果有数据,则直接返回缓存数据;若没有数据,调用方法并将方法返回值放到缓存中 * value:缓存的名称,每个缓存名称下面可以有多个key * key:缓存的key */ @Cacheable(value = "userCache",key = "#id") @GetMapping("/{id}") public User getById(@PathVariable Long id){ User user = userService.getById(id); return user; }
2)缓存非null值
在@Cacheable注解中,提供了两个属性分别为: condition, unless 。
condition : 表示满足什么条件, 再进行缓存 ;
unless : 表示满足条件则不缓存 ; 与上述的condition是反向的 ;
具体实现方式如下:
/** * Cacheable:在方法执行前spring先查看缓存中是否有数据,如果有数据,则直接返回缓存数据;若没有数据,调用方法并将方法返回值放到缓存中 * value:缓存的名称,每个缓存名称下面可以有多个key * key:缓存的key * condition:条件,满足条件时才缓存数据 * unless:满足条件则不缓存 */ @Cacheable(value = "userCache",key = "#id", unless = "#result == null") @GetMapping("/{id}") public User getById(@PathVariable Long id){ User user = userService.getById(id); return user; }
注意: 此处,我们使用的时候只能够使用 unless, 因为在condition中,我们是无法获取到结果 #result的。
3). 在list方法上加注解@Cacheable
在list方法中进行查询时,有两个查询条件,如果传递了id,根据id查询; 如果传递了name, 根据name查询,那么我们缓存的key在设计的时候,就需要既包含id,又包含name。 具体的代码实现如下:
@Cacheable(value = "userCache",key = "#user.id + '_' + #user.name") @GetMapping("/list") public List<User> list(User user){ LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>(); queryWrapper.eq(user.getId() != null,User::getId,user.getId()); queryWrapper.eq(user.getName() != null,User::getName,user.getName()); List<User> list = userService.list(queryWrapper); return list; }
集成Redis
在使用上述默认的ConcurrentHashMap做缓存时,服务重启之后,之前缓存的数据就全部丢失了,操作起来并不友好。在项目中使用,我们会选择使用redis来做缓存,主要需要操作以下几步:
1). pom.xml
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-cache</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency>
2). application.yml
spring: redis: host: 192.168.200.200 port: 6379 password: root@123456 database: 0 cache: redis: time-to-live: 1800000 #设置缓存过期时间,可选
缓存套餐数据
具体的实现思路如下:
1). 导入Spring Cache和Redis相关maven坐标
2). 在application.yml中配置缓存数据的过期时间
3). 在启动类上加入@EnableCaching注解,开启缓存注解功能
4). 在SetmealController的list方法上加入@Cacheable注解
5). 在SetmealController的save和delete方法上加入CacheEvict注解
启动类上加入@EnableCaching注解
SetmealController的list方法上加入@Cacheable注解
/** * 根据条件查询套餐数据 * @param setmeal * @return */ @GetMapping("/list") @Cacheable(value = "setmealCache",key = "#setmeal.categoryId + '_' + #setmeal.status") public R<List<Setmeal>> list(Setmeal setmeal){ LambdaQueryWrapper<Setmeal> queryWrapper = new LambdaQueryWrapper<>(); queryWrapper.eq(setmeal.getCategoryId() != null,Setmeal::getCategoryId,setmeal.getCategoryId()); queryWrapper.eq(setmeal.getStatus() != null,Setmeal::getStatus,setmeal.getStatus()); queryWrapper.orderByDesc(Setmeal::getUpdateTime); List<Setmeal> list = setmealService.list(queryWrapper); return R.success(list); }
为什么会报出这个错误呢?
因为 @Cacheable 会将方法的返回值R缓存在Redis中,而在Redis中存储对象,该对象是需要被序列化的,而对象要想被成功的序列化,就必须得实现 Serializable 接口。而当前我们定义的R,并未实现 Serializable 接口。所以,要解决该异常,只需要让R实现 Serializable 接口即可。如下:
清理套餐数据
代码实现
为了保证数据库中数据与缓存数据的一致性,在我们添加套餐或者删除套餐数据之后,需要清空当前套餐缓存的全部数据。那么@CacheEvict注解如何清除某一份缓存下所有的数据呢,这里我们可以指定@CacheEvict中的一个属性 allEnties,将其设置为true即可。
1). 在delete方法上加注解@CacheEvict
/** * 删除套餐 * @param ids * @return */ @DeleteMapping @CacheEvict(value = "setmealCache",allEntries = true) //清除setmealCache名称下,所有的缓存数据 public R<String> delete(@RequestParam List<Long> ids){ log.info("ids:{}",ids); setmealService.removeWithDish(ids); return R.success("套餐数据删除成功"); }
2). 在delete方法上加注解@CacheEvict
/** * 新增套餐 * @param setmealDto * @return */ @PostMapping @CacheEvict(value = "setmealCache",allEntries = true) //清除setmealCache名称下,所有的缓存数据 public R<String> save(@RequestBody SetmealDto setmealDto){ log.info("套餐信息:{}",setmealDto); setmealService.saveWithDish(setmealDto); return R.success("新增套餐成功"); }