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

Redis基础_redis下载安装

作者：我家自动化 | 2024-07-24 16:49:50

赞

踩

redis下载安装

导航：

【Java笔记+踩坑汇总】Java基础+JavaWeb+SSM+SpringBoot+SpringCloud+瑞吉外卖/谷粒商城/学成在线+设计模式+面试题汇总+性能调优/架构设计+源码解析

目录

1 简介 

1.1 环境准备

1.1.1 Redis下载和安装 

1.1.2 linux版启动redis

1.1.3 Windows版启动redis

1.2 Redis五种数据类型

1.3 Redis常用命令

通用命令

1.3.1 字符串类型string

1.3.2 哈希存储模型 hash

1.3.3 列表类型list

1.3.4 无序集合set

1.3.4 有序集合sorted set

2 springboot整合redis 

2.1 lettucs客户端技术操作Redis，默认

2.1.1 RedisTemplate对象

2.1.2 序列化器问题

2.1.3 StringRedisTemplate对象，命令行模式默认

2.2 切换jedis客户端技术

2.2.1 RedisTemplate或者StringRedisTemplate 

2.2.2 lettcus与jedis区别

3 Spring Cache

3.1 Spring Cache介绍

3.2 Spring Cache常用注解

3.2.1 依赖、 yml配置、开启缓存

3.2.2 key的命名方式 

3.2.3 注解实现缓存

3.3  Spring Cache使用各种缓存

3.3.1 SpringBoot内置缓存Simple

3.3.2 手机验证码模拟案例，@CachePut

3.3.3 Spring Cache使用Redis

1 简介 

Redis是一款c语言开发的、采用key-value数据存储格式的内存级NoSQL数据库，重点关注数据存储格式，是key-value格式，也就是键值对的存储形式。与MySQL数据库不同，MySQL数据库有表、有字段、有记录，Redis没有这些东西，就是一个名称对应一个值，并且数据以存储在内存中使用为主。 

什么叫以存储在内存中为主？其实Redis有它的数据持久化方案，分别是RDB和AOF，但是Redis自身并不是为了数据持久化而生的，主要是在内存中保存数据，加速数据访问的，所以说是一款内存级数据库。

Redis支持多种数据存储格式，比如可以直接存字符串，也可以存一个map集合，list集合。 

Redis优点：

  • 基于内存存储，性能高 
  • 适用于存储热点数据（例如热点咨询、商品、秒杀）

用途：

  • 数据库
  • 缓存
  • 任务队列
  • 消息队列
  • 分布式锁

nosql（not only SQL）：泛指非关系型数据库。

1.1 环境准备

1.1.1 Redis下载和安装 

下载

windows版安装包下载地址：Releases · tporadowski/redis · GitHub

linux版下载地址:Index of /releases/

安装

linux版安装

这里下的是4.4.0版本，直接上传到root路径下，分别输入下面命令：

  1. tar -zxvf redis-4.0.0.tar.gz -C /usr/local
  2. cd /usr/local/redis-4.0.0
  3. yum install gcc-c++ #安装redis的依赖环境gcc
  4. make
  5. cd src
  6. make install

命令对应步骤： 

​

windows版安装： 

下载的安装包有两种形式，这里采用的是msi一键安装的msi文件进行安装的。这里下msi，5.0.14版本。

啥是msi，其实就是一个文件安装包，不仅安装软件，还帮你把安装软件时需要的功能关联在一起，打包操作。比如如安装序列、创建和设置安装路径、设置系统依赖项、默认设定安装选项和控制安装过程的属性。说简单点就是一站式服务，安装过程一条龙操作一气呵成，就是为小白用户提供的软件安装程序。

安装时除了路径，其他配置都可以，直接一路next。

安装完毕后会得到如下文件，其中有两个文件对应两个命令，是启动Redis的核心命令，需要再CMD命令行模式执行。

​

1.1.2 linux版启动redis

启动服务器

  1. cd /usr/local/redis-4.0.0/src
  2. ./redis-server

.命令：表示执行的意思，就是执行这个文件。

./命令：表示执行当前目录下的某个文件，就比如当前目录有一个脚本a.sh，那么./a.sh就表示执行它。

​ 

新建一个finalshell窗口，启动客户端：

  1. cd /usr/local/redis-4.0.0/src
  2. ./redis-cli

​ 

修改配置： 

修改为后台运行服务器：

ctrl+c停止第一个窗口的服务器

  1. cd /usr/local/redis-4.0.0
  2. vim redis.conf

修改成后台运行（/dae回车查到后按i进入编辑模式）：

​ 

esc后:wq退出vim编辑器。

如果想设置密码校验， 就在redis.conf里取消注释：

​

登录客户端方式 ​

设置允许远程连接 

将这行注释掉：​

远程连接： 

在Windows的redis安装目录下：

.\redis-cli.exe -h 虚拟机ip地址 -p 6379 -a 123456 

​ 

后台运行服务器：

  1.  
  2. cd /usr/local/redis-4.0.0
  3. src/redis-server ./redis.conf

​ 

杀掉后台运行的Redis服务器进程：

  1. #查看进程号
  2. ps -ef | grep redis	
  3. kill -9 进程号

1.1.3 Windows版启动redis

启动服务器

进入安装文件夹下cmd，命令行启动redis-server.exe并指定配置

redis-server.exe redis.windows.conf

初学者无需调整服务器对外服务端口，默认6379。

报错：

​

 解决：要先双击启动客户端redis-cli.exe，然后执行命令shutdown停止客户端、exit回车，再次启动服务器就可以了。

如果提示下图，则是Redis已经默认启动了：

，可以直接尝试下文的启动客户端。

​

启动客户端

打开另一个cmd窗口： 

redis-cli.exe

 也可以直接双击redis-cli.exe这个文件：

如果启动redis服务器失败，可以先启动客户端，然后执行shutdown停止客户端操作后退出，此时redis服务器就可以正常执行了。

服务器启动后，使用客户端就可以连接服务器，类似于启动完MySQL数据库，然后启动SQL命令行操作数据库。

1.2 Redis五种数据类型

1.3 Redis常用命令

通用命令

​

查看所有

keys * 

删除所有key：

FLUSHALL

1.3.1 字符串类型string

常用命令

​ 更多命令请看官网。 

举例： 

放置一个字符串数据到redis中，先为数据定义一个名称，比如name,age等，然后使用命令set设置数据到redis服务器中即可

  1. set name itheima
  2. set age 12

 从redis中取出已经放入的数据，根据名称取，就可以得到对应数据。如果没有对应数据就会得到(nil)

  1. get name
  2. get age

​ 

1.3.2 哈希存储模型 hash

哈希模型适合存储对象。 

 string的数据存储是一个名称对应一个值，如果要维护的数据过多，可以使用hash哈希存储模型，它一个名称下可以存储多个数据，每个数据也可以有自己的二级存储名称。 

常用命令：

​ 

举例：

  1. hset a a1 aa1		#对外key名称是a，在名称为哈希存储模型a中，a1这个key中保存了数据aa1
  2. hset a a2 aa2

这里a可以理解成一个对象，它有a1、a2两个属性。

获取hash结构中的数据命令如下

  1. hget a a1			#得到aa1
  2. hget a a2			#得到aa2

有关redis的基础操作就普及到这里，需要全面掌握redis技术，请参看相关教程学习。

​

1.3.3 列表类型list

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

常用命令：

​​ 

lpush意思是从左边头部插入 ，rpop意思是从右边尾部删除。

  • 在头部插入和遍历，在尾部删除。对比队列是在队头删除，队尾插入。
  • 最后插入的元素在遍历时候排第一个。

举例： 

​ 

1.3.4 无序集合set

概念：

​ 

常用命令：

​

举例：

​ 

1.3.4 有序集合sorted set

​ 举例：

​ 

zset（有序集合） ：元素有序不可重复，每个元素关联一个可重复的double类型的分数，Redis是通过这个分数对元素排序的。分数可重复，元素

zset底层存储结构：ziplist（压缩列表）或skiplist（跳跃表）。

元素数量小于128个，且每个元素长度小于64字节时使用压缩列表，其他情况使用跳跃表。

  • 压缩列表：本质是一个数组，数组首部存长度、偏移量、元素个数，尾部存结束标识。每个元素使用两个紧挨在一起的压缩列表节点来保存，第一个节点保存元素的成员，第二个节点保存元素的分值。
  • 跳跃表：单向链表按序保存元素及分值，使用哈希表dict来保存元素和分值的映射关系。链表增加了多级索引，先从最上层索引跳跃查，再渐渐往下层到链表地查询，实现了快速查找元素，时间复杂度O(logn)，这种查询算法类似于链表版二分查找，是基于有序的。

zset底层不使用红黑树的原因：

  • 范围查找：因为红黑树范围查找效率低，而跳跃表范围查找效率高，因为是链表结构。zset可以用zrange命令查指定范围内元素。
  • 实现难度：跳跃表实现比红黑树简单。

压缩列表：

跳跃表zrange： 

  1. #将a和b两个元素插入到名称为myzset的有序集合中，并为它们分别设置了分值为10和9
  2. zset myzset 10.0 a 9.0 b    
  3. #返回所有元素，并按照它们的分值从小到大排列。结果为b和a。0表示第一个元素，-1表示最后一个元素
  4. zrange myzset 0 -1

2 springboot整合redis 

2.1 lettucs客户端技术操作Redis，默认

2.1.1 RedisTemplate对象

在进行整合之前先梳理一下整合的思想，springboot整合任何技术其实就是在springboot中使用对应技术的API。如果两个技术没有交集，就不存在整合的概念了。所谓整合其实就是使用springboot技术去管理其他技术，几个问题是躲不掉的。

第一，需要先导入对应技术的坐标，而整合之后，这些坐标都有了一些变化

第二，任何技术通常都会有一些相关的设置信息，整合之后，这些信息如何写，写在哪是一个问题

第三，没有整合之前操作如果是模式A的话，整合之后如果没有给开发者带来一些便捷操作，那整合将毫无意义，所以整合后操作肯定要简化一些，那对应的操作方式自然也有所不同

按照上面的三个问题去思考springboot整合所有技术是一种通用思想，在整合的过程中会逐步摸索出整合的套路，而且适用性非常强，经过若干种技术的整合后基本上可以总结出一套固定思维。

springboot整合redis步骤：

步骤①：导入springboot整合redis的starter坐标

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

上述坐标可以在创建模块的时候通过勾选的形式进行选择，归属NoSQL分类中

​

tip:第二行spring data reactive redis包含了第一行Redis的驱动和访问，现在阶段只用第一行就够了。

步骤②：进行基础配置

默认配置： 

  1. spring:
  2.   data:
  3.     redis:
  4.       host: localhost
  5.       port: 6379

操作redis，最基本的信息就是操作哪一台redis服务器，所以服务器地址属于基础配置信息，不可缺少。但是即便你不配置，目前也是可以用的。因为以上两组信息都是默认配置值，刚好就是上述配置值。

更丰富配置：

小贴士:

  • 这里database: 0的意思是使用0号数据库，在redis服务器启动后默认提供了16个数据库，不同数据库内容不互通，默认使用0号数据库。
  • 修改Redis提供数据库数量：

conf文件：

  • 切换成数据库1：

客户端命令行

select 1

步骤③：确保之前启动服务器后，自动注入Redis模板对象，获取值操作对象对数据增删改查。

此处使用的是注入Redis模板对象RedisTemplate的opsForValue()方法获取值操作对象ValueOperations ，通过ValueOperations对象的get和set方法操作数据库。

  1. @SpringBootTest
  2. class Springboot16RedisApplicationTests {
  3.     //自动注入RedisTemplate对象
  4.     @Autowired
  5.     private RedisTemplate redisTemplate;
  6.     //注意ValueOperations 添加是set，HashOperations 添加是put
  7.     @Test
  8.     void set() {
  9.         //获取值简单k-v操作对象ValueOperations。如果想获取hash操作对象要用opsForHash()方法。
  10.         ValueOperations ops = redisTemplate.opsForValue();
  11.         ops.set("age",41);
  12.     }
  13.     @Test
  14.     void get() {
  15.         ValueOperations ops = redisTemplate.opsForValue();
  16.         Object age = ops.get("name");
  17.         System.out.println(age);
  18.     }
  19.     @Test
  20.     void hset() {
  21.         //获取hash类型操作对象HashOperations 
  22.         HashOperations ops = redisTemplate.opsForHash();
  23.         ops.put("info","b","bb");
  24.     }
  25.     @Test
  26.     void hget() {
  27.         HashOperations ops = redisTemplate.opsForHash();
  28.         //hash操作对象的get返回值类型是Object，可以强转为String
  29.         Object val = ops.get("info", "b");
  30.         System.out.println(val);
  31.         //获取keys
  32.         System.out.println(ops.keys("*"));
  33.         System.out.println(ops.keys("info"));
  34.     }
  35.

操作list类型数据：

 操作set类型数据：

 

操作zset类型数据：

 

通用命令：

 

在操作redis时，需要先确认操作何种数据，根据数据种类得到操作接口。例如使用opsForValue()获取string类型的数据操作接口，使用opsForHash()获取hash类型的数据操作接口，剩下的就是调用对应api操作了。各种类型的数据操作接口如下：

​

2.1.2 序列化器问题

RedisTemplate是以对象为操作的基本单元，存到数据库的实际内容是序列化后的。

通过命令行看到是乱码的：

​

修改key的序列化器，由jdk序列化器修改为字符串序列化器：

方法一，配置类：

  1. package com.jq.config;
  2.  
  3. import org.springframework.cache.annotation.CachingConfigurerSupport;
  4. import org.springframework.context.annotation.Bean;
  5. import org.springframework.context.annotation.Configuration;
  6. import org.springframework.data.redis.connection.RedisConnectionFactory;
  7. import org.springframework.data.redis.core.RedisTemplate;
  8. import org.springframework.data.redis.serializer.StringRedisSerializer;
  9. /**
  10.  * Redis配置类
  11.  */
  12. @Configuration
  13. public class RedisConfig extends CachingConfigurerSupport{
  14.     
  15.     @Bean
  16.     public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
  17.  
  18.         RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
  19.  
  20.         //默认的Key序列化器为：JdkSerializationRedisSerializer
  21.         redisTemplate.setKeySerializer(new StringRedisSerializer());
  22.         redisTemplate.setHashKeySerializer(new StringRedisSerializer());
  23.  
  24.         redisTemplate.setConnectionFactory(connectionFactory);
  25.  
  26.         return redisTemplate;
  27.     }
  28.  
  29. }
  30.

 测试后可以发现key已经成字符串序列化，而value依然还是jdk序列化，这里就不改了，不影响使用：

 方法二：使用下一节的StringRedisTemplate

总结

  1. springboot整合redis步骤

    1. 导入springboot整合redis的starter坐标
    2. 进行基础配置
    3. 使用springboot整合redis的专用客户端接口RedisTemplate操作

2.1.3 StringRedisTemplate对象，命令行模式默认

 RedisTemplate是以对象为操作的基本单元，存到数据库的实际内容是序列化后的。StringRedisTemplate是以字符串为操作的基本单元。两个类创建的对象获取数据是不通用的，命令行客户端redis-cli.exe默认使用StringRedisTemplate。

​

由于redis内部不提供java对象的存储格式，因此当操作的数据以对象的形式存在时，会进行转码，转换成字符串格式后进行操作。为了方便开发者使用基于字符串为数据的操作，springboot整合redis时提供了专用的API接口StringRedisTemplate，你可以理解为这是RedisTemplate的一种指定数据泛型的操作API。

  1. @SpringBootTest
  2. public class StringRedisTemplateTest {
  3.     @Autowired
  4.     private StringRedisTemplate stringRedisTemplate;
  5.     @Test
  6.     void get(){
  7.         ValueOperations<String, String> ops = stringRedisTemplate.opsForValue();
  8.         String name = ops.get("name");
  9.         System.out.println(name);
  10.     }
  11. }

2.2 切换jedis客户端技术

2.2.1 RedisTemplate或者StringRedisTemplate 

springboot整合redis技术提供了多种客户端兼容模式，默认提供的是lettucs客户端技术，也可以根据需要切换成指定客户端技术，例如jedis客户端技术。jedis是Redis传统的客户端技术。

从默认客户端技术lettucs切换成jedis客户端技术：
步骤①：导入jedis坐标。不用加版本号，该坐标被springboot管理。

  1. <dependency>
  2.     <groupId>redis.clients</groupId>
  3.     <artifactId>jedis</artifactId>
  4. </dependency>

先确保导入了redis的starter坐标：

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

jedis坐标受springboot管理，无需提供版本号

步骤②：配置客户端技术类型，设置为jedis

  1. spring:
  2.   redis:
  3.     host: localhost
  4.     port: 6379
  5.     client-type: jedis

也可以根据需要设置对应的配置

  1. spring:
  2.   redis:
  3.     host: localhost
  4.     port: 6379
  5.     client-type: jedis
  6.     lettuce:
  7.       pool:
  8.         max-active: 16
  9.     jedis:
  10.       pool:
  11.         max-active: 16

步骤③： 整合方法和lettucs一样

使用RedisTemplate对象或者StringRedisTemplate对象。

  1. @SpringBootTest
  2. class Springboot16RedisApplicationTests {
  3.     //自动注入RedisTemplate对象
  4.     @Autowired
  5.     private RedisTemplate redisTemplate;
  6.     //注意ValueOperations 添加是set，HashOperations 添加是put
  7.     @Test
  8.     void set() {
  9.         //获取值操作对象。如果想获取hash操作对象要用opsForHash()方法。
  10.         ValueOperations ops = redisTemplate.opsForValue();
  11.         ops.set("age",41);
  12.     }
  13.     @Test
  14.     void get() {
  15.         ValueOperations ops = redisTemplate.opsForValue();
  16.         Object age = ops.get("name");
  17.         System.out.println(age);
  18.     }
  19.     @Test
  20.     void hset() {
  21.         HashOperations ops = redisTemplate.opsForHash();
  22.         ops.put("info","b","bb");
  23.     }
  24.     @Test
  25.     void hget() {
  26.         HashOperations ops = redisTemplate.opsForHash();
  27.         Object val = ops.get("info", "b");
  28.         System.out.println(val);
  29.     }
  30. }

非Maven项目使用jedis的方法：

jedis以字符串为操作的基本单元，代码里添加的数据，在命令行模式也能查到。

2.2.2 lettcus与jedis区别

  • jedis连接Redis服务器是直连模式，当多线程模式下使用jedis会存在线程安全问题，解决方案可以通过配置连接池使每个连接专用，这样整体性能就大受影响
  • lettcus基于Netty框架进行与Redis服务器连接，底层设计中采用StatefulRedisConnection。 StatefulRedisConnection自身是线程安全的，可以保障并发访问安全问题，所以一个连接可以被多线程复用。当然lettcus也支持多连接实例一起工作

总结

  1. springboot整合redis提供了StringRedisTemplate对象，以字符串的数据格式操作redis
  2. 如果需要切换redis客户端实现技术，可以通过配置的形式进行

3 Spring Cache

3.1 Spring Cache介绍

Spring Cache是一个框架，实现了基于注解的缓存功能，只需要简单地加一个注解，就能实现缓存功能。

Spring Cache提供了一层抽象，底层可以切换不同的cache实现。具体就是通过CacheManager接口来统一不同的缓存技术。 CacheManager是Spring提供的各种缓存技术抽象接口。

前面学springboot3开发篇时候有简单讲过整合各种缓存技术：

【黑马Java笔记】SpringBoot基础3——开发_vincewm的博客-CSDN博客_site:csdn.net

3.2 Spring Cache常用注解

在这里插入图片描述

3.2.1 依赖、 yml配置、开启缓存

环境准备

导入坐标：

  1.  <dependency>
  2.      <groupId>org.springframework.boot</groupId>
  3.      <artifactId>spring-boot-starter-data-redis</artifactId>
  4.  </dependency>
  5.  <dependency>
  6.      <groupId>org.springframework.boot</groupId>
  7.      <artifactId>spring-boot-starter-cache</artifactId>
  8.  </dependency>

yml配置端口：

  1. spring:
  2.   redis:
  3.     host: localhost
  4.     port: 6379
  5.   cache:
  6.     type: redis
  7.     redis:
  8. #默认带缓存空间名前缀，例如"ssmCode::12345678"，不加前缀重复可能大，如"12345678"
  9.       use-key-prefix: true
  10. #指定前缀，默认是缓存空间名
  11.       key-prefix: sms_
  12. #是否缓存空值，防止缓存穿透。这个是全局的，也可以在@Cacheable的属性unless="#result==null"局部排除
  13.       cache-null-values: false
  14. #生存时间
  15.       time-to-live: 10s

主启动类开启缓存：

  1. @SpringBootApplication
  2. //开启过滤器。在SpringBootApplication上使用@ServletComponentScan注解后，Servlet、Filter、Listener可以直接通过@WebServlet、@WebFilter、@WebListener注解自动注册，无需其他代码。
  3. @ServletComponentScan
  4. @EnableTransactionManagement
  5. //开启缓存
  6. @EnableCaching
  7. @Slf4j
  8. public class ReggieApplication {
  9.  
  10.     public static void main(String[] args) {
  11.  
  12.         SpringApplication.run(ReggieApplication.class, args);
  13.         log.info("引导类已经启动。。。。");
  14.     }
  15.  
  16. }

在spring boot项目中，使用缓存技术只需在项目中导入相关缓存技术的依赖包，并在启动类上使用@EnableCaching开启缓存支持即可。 例如，使用Redis作为缓存技术，只需要导入Spring data Redis的maven坐标即可。

3.2.2 key的命名方式 

示例 

  1.     //value是缓存名称，一个value下有多个key
  2.     //key是缓存的key，key="#tele"是将方法返回值存到key里。
  3.     @CachePut(value = "smsCode", key = "#tele")

固定key：

  1. @Cacheable(value="users", key="'key'")    
  2.  
  3.    public User find(Integer id) {
  4.  
  5.       returnnull;
  6.  
  7.    }

变量key：

1.直接使用“#参数名”或者“#p参数index”：

  1. @Cacheable(value="users", key="#id")    //也可以是key="#p0"
  2.  
  3.    public User find(Integer id) {
  4.  
  5.       returnnull;
  6.  
  7.    }
  8.  
  9.  
  10.    @Cacheable(value="users", key="#user.id")    //也可以是key="#p0.id"
  11.  
  12.    public User find(User user) {
  13.  
  14.       returnnull;
  15.  
  16.    }

2.root对象可以用来生成key 

当我们要使用root对象的属性作为key时我们也可以将“#root”省略，因为Spring默认使用的就是root对象的属性。如：

  1.    @Cacheable(value={"users", "xxx"}, key="caches[1].name")
  2.  
  3.    public User find(User user) {
  4.  
  5.       returnnull;
  6.  
  7.    }

3.key="#result.tele"是将返回值存到key里，result.是默认可省略。 

3.2.3 注解实现缓存

在这里插入图片描述

  1.     @PostMapping
  2.     //allEntries 属性是删除此命名空间下所有的key
  3.     @CacheEvict(value = "setmealCache",allEntries = true)
  4.     public R<String> save(@RequestBody SetmealDto setmealDto) {
  5.         Setmeal setmeal = new Setmeal();
  6.         if (setmealService.saveWithDish(setmealDto)) return R.success("保存成功");
  7.         else return R.error("保存失败");
  8.     }

注意：

  • @Cacheable和@CachePut都是方法注解，缓存的是返回值
  • @CachePut只存不取

3.3  Spring Cache使用各种缓存

在导入对应坐标后，通过配置可以切换缓存方法。

springboot提供了缓存的统一整合接口，方便缓存技术的开发和管理：

3.3.1 SpringBoot内置缓存Simple

springboot技术提供有内置的缓存解决方案，可以帮助开发者快速开启缓存技术，并使用缓存技术进行数据的快速操作，例如读取缓存数据和写入数据到缓存。

步骤①：导入springboot提供的缓存技术对应的starter

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

步骤②：开启缓存功能，在引导类上方标注注解@EnableCaching配置springboot程序中可以使用缓存

  1. @SpringBootApplication
  2. //开启缓存功能
  3. @EnableCaching
  4. public class Springboot19CacheApplication {
  5.     public static void main(String[] args) {
  6.         SpringApplication.run(Springboot19CacheApplication.class, args);
  7.     }
  8. }

步骤③：设置操作的数据是否使用缓存

  1. @Service
  2. public class BookServiceImpl implements BookService {
  3.     @Autowired
  4.     private BookDao bookDao;
  5.     //Cacheable译为可缓存的，可缓冲的。@Cacheable的value属性是存储空间名，key属性是此方法返回值在存储空间内的键名。
  6.     //key属性名必须和形参名一样才能缓存，别忘了#号
  7.     @Cacheable(value="cacheSpace",key="#id")
  8.     public Book getById(Integer id) {
  9.         return bookDao.selectById(id);
  10.     }
  11. }

注意：

  • 一定一定别忘了#号
  • 缓存的key属性名必须方法的形参名一样才能缓存。 只要此key对应的缓存已存在，下次不管查询出什么数据，返回的结果都是直接从缓存的这个key里取。
  • 被注解@Cacheable声明的方法不能被本类中其他方法调用，原因是spring容器管理问题。

在业务方法上面使用注解@Cacheable声明当前方法的返回值放入缓存中，其中要指定缓存的存储位置，以及缓存中保存当前方法返回值对应的名称。上例中value属性描述缓存的存储位置，可以理解为是一个存储空间名，key属性描述了缓存中保存数据的名称，使用#id读取形参中的id值作为缓存名称。

使用@Cacheable注解后，执行当前操作，如果发现对应名称在缓存中没有数据，就正常读取数据，然后放入缓存；如果对应名称在缓存中有数据，就终止当前业务方法执行，直接返回缓存中的数据。

测试缓存已经实现：

使用postman根据id查询：

 查询多次同一个id，会发现控制台只会输出第一次数据库查询日志：

3.3.2 手机验证码模拟案例，@CachePut

为了便于下面演示各种各样的缓存技术，我们创建一个手机验证码的案例环境，模拟使用缓存保存手机验证码的过程。

手机验证码案例需求如下：

  • 输入手机号获取验证码，组织文档以短信形式发送给用户（页面模拟）
  • 输入手机号和验证码验证结果

为了描述上述操作，我们制作两个表现层接口，一个用来模拟发送短信的过程，其实就是根据用户提供的手机号生成一个验证码，然后放入缓存，另一个用来模拟验证码校验的过程，其实就是使用传入的手机号和验证码进行匹配，并返回最终匹配结果。下面直接制作本案例的模拟代码，先以上例中springboot提供的内置缓存技术来完成当前案例的制作。

步骤①：导入springboot提供的缓存技术对应的starter

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

步骤②：启用缓存，在引导类上方标注注解@EnableCaching配置springboot程序中可以使用缓存

  1. @SpringBootApplication
  2. //开启缓存功能
  3. @EnableCaching
  4. public class Springboot19CacheApplication {
  5.     public static void main(String[] args) {
  6.         SpringApplication.run(Springboot19CacheApplication.class, args);
  7.     }
  8. }

步骤③：定义验证码对应的实体类，封装手机号与验证码两个属性

  1. @Data
  2. public class SMSCode {
  3.     private String tele;
  4.     private String code;
  5. }

步骤④：定义验证码功能的业务层接口与实现类

这里是要新建另外一个工具类，把验证码的生成和获取写在工具类中，并加上缓存注解，然后通过service调用，从而实现缓存。注意不能直接给service的获取和检查方法设置缓存注解，因为检查时候它不能直接调用本类的获取方法，spring管理bean的问题。

  1. public interface SMSCodeService {
  2.     public String sendCodeToSMS(String tele);
  3.     public boolean checkCode(SMSCode smsCode);
  4. }
  5.  
  6. @Service
  7. public class SMSCodeServiceImpl implements SMSCodeService {
  8.     @Autowired
  9.     private CodeUtils codeUtils;
  10.     
  11.  
  12.     public String sendCodeToSMS(String tele) {
  13.         //使用工具类是为了使用后面的检查方法
  14.         String code = codeUtils.generator(tele);
  15.         return code;
  16.     }
  17.     //取出内存中的验证码与传递过来的验证码比对，如果相同，返回true。
  18.     //参数是包括手机号和验证码的实体类
  19.     public boolean checkCode(SMSCode smsCode) {
  20.         //获取controller传来实体对象的验证码
  21.         String code = smsCode.getCode();
  22.         //获取缓存中的验证码，注意这里必须要使用工具类调用get方法，如果只设置service，直接调用本service里的get方法不是spring容器管理的。
  23.         String cacheCode = codeUtils.get(smsCode.getTele());
  24.         return code.equals(cacheCode);
  25.     }
  26. }

获取验证码后，当验证码失效时必须重新获取验证码，因此在获取验证码的功能上不能使用@Cacheable注解，@Cacheable注解是缓存中没有值则放入值，缓存中有值则取值。此处的功能仅仅是生成验证码并放入缓存，并不具有从缓存中取值的功能，因此不能使用@Cacheable注解，应该使用仅具有向缓存中保存数据的功能，使用@CachePut注解即可。

对于校验验证码的功能建议放入工具类中进行。

步骤⑤：定义验证码的生成策略与根据手机号读取验证码的功能

不能只用service就实现所检查验证码功能 ，因为被注解@Cacheable声明的方法不能被本类中其他方法调用，原因是spring容器管理问题。

  1. @Component
  2. public class CodeUtils {
  3.     //补0，防止最终生成验证码转字符串后前几位是0
  4.     private String [] patch = {"000000","00000","0000","000","00","0",""};
  5.     //加密算法生成验证码
  6.     //注解@CachePut是仅把返回值放到缓存里，而不自己取。如果还用@Cacheable多次发验证码，内存值都是第一次的缓存值。
  7.     @CachePut(value = "smsCode", key = "#tele")
  8.     public String generator(String tele){
  9.         //获取手机号字符串的哈希码
  10.         int hash = tele.hashCode();
  11.         //定义加密码
  12.         int encryption = 20206666;
  13.         //哈希码加密码、时间戳分别异或，进行加密
  14.         long result = hash ^ encryption;
  15.         long nowTime = System.currentTimeMillis();
  16.         result = result ^ nowTime;
  17.         long code = result % 1000000;
  18.         code = code < 0 ? -code : code;
  19.         String codeStr = code + "";
  20.         int len = codeStr.length();
  21.         //防止验证码不到6位，补0
  22.         return patch[len] + codeStr;
  23.     }
  24.     //获取缓存中的验证码。
  25.     @Cacheable(value = "smsCode",key="#tele")
  26.     //这里形参名必须和@Cacheable的key名一致。当缓存中对应key有值时，不管返回值是什么都会返回缓存中的值
  27.     public String get(String tele){
  28.         return null;
  29.     }
  30. }

步骤⑥：定义验证码功能的web层接口，一个方法用于提供手机号获取验证码，一个方法用于提供手机号和验证码进行校验

  1. @RestController
  2. @RequestMapping("/sms")
  3. public class SMSCodeController {
  4.     @Autowired
  5.     private SMSCodeService smsCodeService;
  6.     
  7.     @GetMapping
  8.     public String getCode(String tele){
  9.         String code = smsCodeService.sendCodeToSMS(tele);
  10.         return code;
  11.     }
  12.     
  13.     @PostMapping
  14.     public boolean checkCode(SMSCode smsCode){
  15.         return smsCodeService.checkCode(smsCode);
  16.     }
  17. }

3.3.3 Spring Cache使用Redis

引入maven依赖

使用Redis作为缓存技术，只需要导入Spring data Redis的maven

  1.  <dependency>
  2.      <groupId>org.springframework.boot</groupId>
  3.      <artifactId>spring-boot-starter-cache</artifactId>
  4.  </dependency>
  5.  
  6.  <dependency>
  7.      <groupId>org.springframework.boot</groupId>
  8.      <artifactId>spring-boot-starter-data-redis</artifactId>
  9.  </dependency>

配置：

  1. spring:
  2.   redis:
  3.     host: localhost
  4.     port: 6379
  5.   cache:
  6.     type: redis
  7.     redis:
  8. #默认带缓存空间名前缀，例如"ssmCode::12345678"，不加前缀重复可能大，如"12345678"
  9.       use-key-prefix: true
  10. #指定前缀，默认是缓存空间名
  11.       key-prefix: sms_
  12. #是否缓存空值，防止缓存穿透。这个是全局的，也可以在@Cacheable的属性unless="#result==null"局部排除
  13.       cache-null-values: false
  14. #生存时间
  15.       time-to-live: 10s

Java代码

  1. @RestController
  2. @RequestMapping("/user")
  3. @Slf4j
  4. public class UserController {
  5.  
  6.     @Autowired
  7.     private CacheManager cacheManager;
  8.  
  9.     @Autowired
  10.     private UserService userService;
  11.  
  12.     /**
  13.       CachePut：将方法返回值放入缓存
  14.       value：缓存的名称，每个缓存名称下面可以有多个key
  15.       key：缓存的key
  16.      /
  17.     @CachePut(value = "userCache",key = "#user.id")
  18.     @PostMapping
  19.     public User save(User user){
  20.         userService.save(user);
  21.         return user;
  22.     }
  24.     /**
  25.       CacheEvict：清理指定缓存
  26.       value：缓存的名称，每个缓存名称下面可以有多个key
  27.       key：缓存的key
  28.      /
  29.     @CacheEvict(value = "userCache",key = "#p0")
  30.     //@CacheEvict(value = "userCache",key = "#root.args[0]")
  31.     //@CacheEvict(value = "userCache",key = "#id")
  32.     @DeleteMapping("/{id}")
  33.     public void delete(@PathVariable Long id){
  34.         userService.removeById(id);
  35.     }
  37.     //@CacheEvict(value = "userCache",key = "#p0.id")
  38.     //@CacheEvict(value = "userCache",key = "#user.id")
  39.     //@CacheEvict(value = "userCache",key = "#root.args[0].id")
  40.     @CacheEvict(value = "userCache",key = "#result.id")
  41.     @PutMapping
  42.     public User update(User user){
  43.         userService.updateById(user);
  44.         return user;
  45.     }
  47.     /**
  48.       Cacheable：在方法执行前spring先查看缓存中是否有数据，如果有数据，则直接返回缓存数据；若没有数据，调用方法并将方法返回值放到缓存中
  49.       value：缓存的名称，每个缓存名称下面可以有多个key
  50.       key：缓存的key
  51.       condition：条件，满足条件时才缓存数据
  52.       unless：满足条件则不缓存
  53.      */
  54.     @Cacheable(value = "userCache",key = "#id",unless = "#result == null")
  55.     @GetMapping("/{id}")
  56.     public User getById(@PathVariable Long id){
  57.         User user = userService.getById(id);
  58.         return user;
  59.     }
  60.  
  61.     @Cacheable(value = "userCache",key = "#user.id + '_' + #user.name")
  62.     @GetMapping("/list")
  63.     public List<User> list(User user){
  64.         LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
  65.         queryWrapper.eq(user.getId() != null,User::getId,user.getId());
  66.         queryWrapper.eq(user.getName() != null,User::getName,user.getName());
  67.         List<User> list = userService.list(queryWrapper);
  68.         return list;
  69.     }
  70. }

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

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

  

闽ICP备14008679号