前言
来啦老铁！
笔者学习Spring Boot有一段时间了，附上Spring Boot系列学习文章，欢迎取阅、赐教：
- 5分钟入手Spring Boot;
- Spring Boot数据库交互之Spring Data JPA;
- Spring Boot数据库交互之Mybatis;
- Spring Boot视图技术;
- Spring Boot之整合Swagger;
- Spring Boot之junit单元测试踩坑;
- 如何在Spring Boot中使用TestNG;
- Spring Boot之整合logback日志;
- Spring Boot之整合Spring Batch：批处理与任务调度;
- Spring Boot之整合Spring Security: 访问认证;
- Spring Boot之整合Spring Security: 授权管理;
- Spring Boot之多数据库源：极简方案;
- Spring Boot之使用MongoDB数据库源;
- Spring Boot之多线程、异步：@Async;
- Spring Boot之前后端分离（一）：Vue前端;
- Spring Boot之前后端分离（二）：后端、前后端集成;
- Spring Boot之前后端分离（三）：登录、登出、页面认证;
- Spring Boot之面向切面编程：Spring AOP;
- Spring Boot之集成Redis（一）：Redis初入门;
在上一篇文章Spring Boot之集成Redis（一）：Redis初入门中，我们初步入门了Redis，熟悉了Redis的安装、配置、本数据类型以及基本操作。今天，我们一起来尝试在Spring Boot项目中集成Redis，一起在Spring Boot完成一些Redis基本操作吧！
项目代码已上传Git Hub仓库，欢迎取阅：
基本步骤
- 安装Redis依赖；
- 配置application.properties；
- 使用StringRedisTemplate操作Redis；
1. 安装Redis依赖；
在项目的pom.xml文件内的dependencies节点内添加redis依赖：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
记得安装一下依赖：
mvn install -Dmaven.test.skip=true -Dmaven.wagon.http.ssl.insecure=true -Dmaven.wagon.http.ssl.allowall=true
2. 配置application.properties；
这里作用主要是配置Redis服务端的连接，配置如下：
#Redis服务端的host和port
spring.redis.host=127.0.0.1
spring.redis.port=6379
#Redis服务端的密码
spring.redis.password=Redis!123
#Redis最大连接数
spring.redis.pool.max-active=8
#Redis连接超时时间，单位 ms（毫秒）
spring.redis.timeout=5000
其中spring.redis.pool.max-active指定了Spring Boot应用的最大连接数，若设置为0，则表示无限制。
3. 使用StringRedisTemplate操作Redis；
我的思路是创建一个API，在该API内使用Redis的基本命令，进而演示在Spring Boot项目中与Redis的交互过程。
（我们先来演示Redis数据类型为String的）
1). 创建controller包，并在包内创建RedisStringController类；
2). 创建domain包，并创建实体类RedisStringCache，用于声明Redis String缓存对象格式;
代码如下：
package com.github.dylanz666.domain;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.stereotype.Component;
import java.io.Serializable;
/**
* @author : dylanz
* @since : 10/28/2020
*/
@NoArgsConstructor
@AllArgsConstructor
@Data
@Component
public class RedisStringCache implements Serializable {
private static final long serialVersionUID = 1L;
private String key;
private String value;
@Override
public String toString() {
return "{" +
"\"key\":\"" + key + "\"," +
"\"value\":" + value + "" +
"}";
}
}
3). 在RedisStringController类内添加演示用的API，代码如下：
package com.github.dylanz666.controller;
import com.github.dylanz666.domain.RedisStringCache;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.*;
/**
* @author : dylanz
* @since : 10/28/2020
*/
@RestController
@RequestMapping("/api/cache")
public class RedisStringController {
@Autowired
private StringRedisTemplate stringRedisTemplate;
@PostMapping("/string")
public @ResponseBody RedisStringCache redisStringCache(@RequestBody RedisStringCache redisStringCache) {
String key = redisStringCache.getKey();
String value = redisStringCache.getValue();
stringRedisTemplate.opsForValue().set(key, value);
String cachedValue = stringRedisTemplate.opsForValue().get(key);
RedisStringCache cached = new RedisStringCache();
cached.setKey(key);
cached.setValue(cachedValue);
return cached;
}
}
项目整体结构：
项目整体结构
上述步骤完成后，我们开始来做演示：
(1). 启动Redis服务端；
启动Redis服务端
(2). 启动Spring Boot应用；
启动Spring Boot应用
(3). 调用API进行Redis交互演示；
请求API：http://127.0.0.1:8080/api/cache/string
请求API
(4). 通过redis-cli方式，再次验证是否缓存成功；
再次验证是否缓存成功
可见，我们已在Spring Boot项目中与Redis服务端交互成功啦！
stringRedisTemplate.opsForValue().set(key, value);
上面这一行代码，相当于redis-cli连接Redis服务端方式的 set key value 操作；
stringRedisTemplate.opsForValue().get(key);
上面这一行代码，相当于redis-cli连接Redis服务端方式的 get key 操作；
接下来，我们一起来尝试在Spring Boot项目中做更多的Redis基本操作！
（演示Redis数据类型为hash的）
1). domain包内创建RedisHashCache实体类，用于声明Redis hash缓存对象格式;
package com.github.dylanz666.domain;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.stereotype.Component;
import java.io.Serializable;
/**
* @author : dylanz
* @since : 10/28/2020
*/
@NoArgsConstructor
@AllArgsConstructor
@Data
@Component
public class RedisHashCache implements Serializable {
private static final long serialVersionUID = 1L;
private String key;
private String field;
private String value;
@Override
public String toString() {
return "{" +
"\"key\":\"" + key + "\"," +
"\"field\":\"" + field + "\"," +
"\"value\":" + value + "" +
"}";
}
}
2). RedisStringController内编写演示API：
@PostMapping("/hash")
public @ResponseBody RedisHashCache redisHashCache(@RequestBody RedisHashCache redisHashCache) {
String key = redisHashCache.getKey();
String field = redisHashCache.getField();
String value = redisHashCache.getValue();
stringRedisTemplate.opsForHash().put(key, field, value);
String cachedValue = Objects.requireNonNull(stringRedisTemplate.opsForHash().get(key, field)).toString();
RedisHashCache cached = new RedisHashCache();
cached.setKey(key);
cached.setField(field);
cached.setValue(cachedValue);
return cached;
}
stringRedisTemplate.opsForHash().put(key, field, value);
上面这行代码等同于redis-cli中使用命令：hset key field value；
stringRedisTemplate.opsForHash().get(key, field);
上面这行代码等同于redis-cli中使用命令：hget key field；
(3). 调用API进行Redis交互演示；
请求API：http://127.0.0.1:8080/api/cache/hash
请求API
（演示Redis数据类型为list的）
1). domain包内创建RedisListCache实体类，用于声明Redis list缓存对象格式;
package com.github.dylanz666.domain;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.stereotype.Component;
import java.io.Serializable;
import java.util.List;
/**
* @author : dylanz
* @since : 10/28/2020
*/
@NoArgsConstructor
@AllArgsConstructor
@Data
@Component
public class RedisListCache implements Serializable {
private static final long serialVersionUID = 1L;
private String key;
private List<String> list;
@Override
public String toString() {
return "{" +
"\"key\":\"" + key + "\"," +
"\"list\":" + list + "" +
"}";
}
}
2). RedisStringController内编写演示API：
@PostMapping("/list")
public @ResponseBody RedisListCache redisListCache(@RequestBody RedisListCache redisListCache) {
String key = redisListCache.getKey();
List<String> list = redisListCache.getList();
stringRedisTemplate.opsForList().leftPushAll(key, list);
List<String> cachedList = stringRedisTemplate.opsForList().range(key, 0, -1);
RedisListCache cached = new RedisListCache();
cached.setKey(key);
cached.setList(cachedList);
return cached;
}
stringRedisTemplate.opsForList().leftPushAll(key, list);
上面这行代码等同于redis-cli中使用命令：lpush key value...；
stringRedisTemplate.opsForList().range(key, 0, -1);
上面这行代码等同于redis-cli中使用命令：lrange key 0 -1；
(3). 调用API进行Redis交互演示；
请求API：http://127.0.0.1:8080/api/cache/list
请求API
（演示Redis数据类型为set的）
1). domain包内创建RedisSetCache实体类，用于声明Redis set缓存对象格式;
package com.github.dylanz666.domain;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.stereotype.Component;
import java.io.Serializable;
import java.util.Arrays;
/**
* @author : dylanz
* @since : 10/28/2020
*/
@NoArgsConstructor
@AllArgsConstructor
@Data
@Component
public class RedisSetCache implements Serializable {
private static final long serialVersionUID = 1L;
private String key;
private String[] sets;
@Override
public String toString() {
return "{" +
"\"key\":\"" + key + "\"," +
"\"sets\":" + Arrays.toString(sets) + "" +
"}";
}
}
2). RedisStringController内编写演示API：
@PostMapping("/set")
public @ResponseBody RedisSetCache redisSetCache(@RequestBody RedisSetCache redisSetCache) {
String key = redisSetCache.getKey();
String[] sets = redisSetCache.getSets();
stringRedisTemplate.opsForSet().add(key, sets);
Set<String> cacheSets = stringRedisTemplate.opsForSet().members(key);
RedisSetCache cached = new RedisSetCache();
cached.setKey(key);
assert cacheSets != null;
cached.setSets(cacheSets.toArray(sets));
return cached;
}
stringRedisTemplate.opsForSet().add(key, sets);
上面这行代码等同于redis-cli中使用命令：sadd key value...；
stringRedisTemplate.opsForSet().members(key);
上面这行代码等同于redis-cli中使用命令：smembers key；
(3). 调用API进行Redis交互演示；
请求API：http://127.0.0.1:8080/api/cache/set
请求API
（演示Redis数据类型为zset的）
1). domain包内创建RedisZsetCache实体类，用于声明Redis zset缓存对象格式;
package com.github.dylanz666.domain;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.stereotype.Component;
import java.io.Serializable;
import java.util.Set;
/**
* @author : dylanz
* @since : 10/28/2020
*/
@NoArgsConstructor
@AllArgsConstructor
@Data
@Component
public class RedisZsetCache implements Serializable {
private static final long serialVersionUID = 1L;
private String key;
private String value;
private double score;
private Set<String> zset;
@Override
public String toString() {
return "{" +
"\"key\":\"" + key + "\"," +
"\"value\":\"" + value + "\"," +
"\"score\":\"" + score + "\"," +
"\"zset\":" + zset + "" +
"}";
}
}
2). RedisStringController内编写演示API：
@PostMapping("/zset")
public @ResponseBody RedisZsetCache redisZsetCache(@RequestBody RedisZsetCache redisZsetCache) {
String key = redisZsetCache.getKey();
String value = redisZsetCache.getValue();
double score = redisZsetCache.getScore();
stringRedisTemplate.opsForZSet().add(key, value, score);
Set<String> cachedZset = stringRedisTemplate.opsForZSet().rangeByScore(key, score, score);
RedisZsetCache cached = new RedisZsetCache();
cached.setKey(key);
cached.setValue(value);
cached.setScore(score);
cached.setZset(cachedZset);
return cached;
}
stringRedisTemplate.opsForZSet().add(key, value, score);
上面这行代码等同于redis-cli中使用命令：zadd key score value；
stringRedisTemplate.opsForZSet().rangeByScore(key, score, score);
上面这行代码等同于redis-cli中使用命令：zrangebyscore key min max；
(3). 调用API进行Redis交互演示；
请求API：http://127.0.0.1:8080/api/cache/zset
请求API
最后，来演示设置一个会过期的Redis缓存(演示缓存2分钟）：
@PostMapping("/expire/string")
public @ResponseBody RedisStringCache redisStringCacheWithExpireTime(@RequestBody RedisStringCache redisStringCache) {
String key = redisStringCache.getKey();
String value = redisStringCache.getValue();
stringRedisTemplate.opsForValue().set(key, value, Duration.ofMinutes(2));
String cachedValue = stringRedisTemplate.opsForValue().get(key);
RedisStringCache cached = new RedisStringCache();
cached.setKey(key);
cached.setValue(cachedValue);
return cached;
}
缓存2分钟
通过这样的Redis操作，我们设置了一个2分钟后失效的String类型的Redis缓存，并且的确2分钟后缓存失效了！
更多操作和redis接口，可直接使用stringRedisTemplate，获取代码建议：
redis接口
以上是我们使用StringRedisTemplate来与Redis进行交互的过程，涉及存、取数据，读者可自行根据StringRedisTemplate提供的接口，对Redis进行增删改查。
实际使用场景中，通常是在第一次存到其他数据库时，会缓存到Redis，并设置一定的缓存过期时间，而后续的请求会先从Redis缓存中获取，减少数据库访问次数，降低数据库服务器的压力！
使用StringRedisTemplate来与Redis进行交互的过程是正确、灵活的，这一点毋庸置疑，但整体代码还是比较多的，略显臃肿，其实有更简约的方式来操作Redis，这里剧透一下：
下一篇文章我将介绍基于Spring Cache方式操作Redis，操作Redis缓存也能用注解的方式，敬请期待！
如果本文对您有帮助，麻烦点赞、关注！
谢谢！
