SpringBoot教程（十四） | SpringBoot之集成Redis
- 一、Redis集成简介
- 二、集成步骤
-
- 2.1 添加依赖
- 2.2 添加配置
- 2.3 项目中使用之简单使用 （举例讲解）
- 2.4 项目中使用之工具类封装 （正式用这个）
- 2.5 序列化 （正常都需要自定义序列化）
- 三、分布式锁
-
- （一）RedisTemplate 去实现
-
- 场景一：单体应用
- 场景二：分布式架构部署
- （二） Redisson去实现
- 总结
一、Redis集成简介
Redis是我们Java开发中，使用频次非常高的一个nosql数据库，数据以key-value键值对的形式存储在内存中。redis的常用使用场景，可以做缓存，分布式锁，自增序列等，使用redis的方式和我们使用数据库的方式差不多，首先我们要在自己的本机电脑或者服务器上安装一个redis的服务器，通过我们的java客户端在程序中进行集成，然后通过客户端完成对redis的增删改查操作。
redis的Java客户端类型还是很多的，常见的有jedis, redission,lettuce等，
所以我们在集成的时候，我们可以选择直接集成这些原生客户端。
但是在springBoot中更常见的方式是集成spring-data-redis，这是spring提供的一个专门用来操作redis的项目，封装了对redis的常用操作，里边主要封装了jedis和lettuce两个客户端。相当于是在他们的基础上加了一层门面。
二、集成步骤
2.1 添加依赖
添加redis所需依赖：（在 Spring Boot 2.x及以后的版本中，spring-boot-starter-data-redis 默认使用的就是lettuce这个客户端）
<!-- 集成redis依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
完整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>
<groupId>com.lsqingfeng.springboot</groupId>
<artifactId>springboot-learning</artifactId>
<version>1.0.0</version>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>2.6.2</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.22</version>
<scope>provided</scope>
</dependency>
<!-- mybatis-plus 所需依赖 -->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.5.1</version>
</dependency>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-generator</artifactId>
<version>3.5.1</version>
</dependency>
<dependency>
<groupId>org.freemarker</groupId>
<artifactId>freemarker</artifactId>
<version>2.3.31</version>
</dependency>
<!-- 开发热启动 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<optional>true</optional>
</dependency>
<!-- MySQL连接 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
<!-- 集成redis依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
</dependencies>
</project>
注意点：如果我们想要使用jedis客户端怎么办呢？就需要排除lettuce这个依赖，再引入jedis的相关依赖就可以了。
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
<exclusions>
<exclusion>
<groupId>io.lettuce</groupId>
<artifactId>lettuce-core</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>你的Jedis版本号</version>
</dependency>
两者的区别
Lettuce更适合需要异步处理、线程安全以及支持哨兵和集群模式的场景（线程安全）；
Jedis则更适合简单的同步操作，以及在不需要哨兵和集群模式的场景中使用（线程不安全）。
2.2 添加配置
然后我们需要配置连接redis所需的账号密码等信息，这里大家要提前安装好redis,保证我们的本机程序可以连接到我们的redis， 如果不知道redis如何安装，可以参考文章: [Linux系统安装redis6.0.5] blog.csdn.net/lsqingfeng/…
常规配置如下： 在application.yml配置文件中配置 redis的连接信息
spring:
redis:
host: localhost
port: 6379
password: 123456
database: 0
如果有其他配置放到一起：
server:
port: 19191
spring:
datasource:
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://localhost:3306/springboot_learning?serverTimezone=Asia/Shanghai&characterEncoding=utf-8
username: root
password: root
redis:
host: localhost
port: 6379
password: 123456
database: 0
lettuce:
pool:
max-idle: 16
max-active: 32
min-idle: 8
devtools:
restart:
enable: true
third:
weather:
url: http://www.baidu.com
port: 8080
username: test
cities:
- 北京
- 上海
- 广州
list[0]: aaa
list[1]: bbb
list[2]: ccc
这样我们就可以直接在项目当中操作redis了。如果使用的是集群，那么使用如下配置方式：
spring:
redis:
password: 123456
cluster:
nodes: 10.255.144.115:7001,10.255.144.115:7002,10.255.144.115:7003,10.255.144.115:7004,10.255.144.115:7005,10.255.144.115:7006
max-redirects: 3
但是有的时候我们想要给我们的redis客户端配置上连接池。
就像我们连接mysql的时候，也会配置连接池一样，目的就是增加对于数据连接的管理，提升访问的效率，也保证了对资源的合理利用。那么我们如何配置连接池呢，这里大家一定要注意了，很多网上的文章中，介绍的方法可能由于版本太低，都不是特别的准确。
比如很多人使用spring.redis.pool来配置，这个是不对的（不清楚是不是老版本是这样的配置的，但是在springboot-starter-data-redis中这种写法不对）。首先是配置文件，由于我们使用的lettuce客户端，所以配置的时候，在spring.redis下加上lettuce再加上pool来配置，具体如下；
spring:
redis:
host: 10.255.144.111
port: 6379
password: 123456
database: 0
lettuce:
pool:
max-idle: 16
max-active: 32
min-idle: 8
如果使用的是jedis,就把lettuce换成jedis（同时要注意依赖也是要换的）。
但是仅仅这在配置文件中加入，其实连接池是不会生效的。这里大家一定要注意，很多同学在配置文件上加上了这段就以为连接池已经配置好了，其实并没有，还少了最关键的一步，就是要导入一个依赖，不导入的话，这么配置也没有用。
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
</dependency>
之后，连接池才会生效。我们可以做一个对比。 在导包前后，观察RedisTemplate对象的值就可以看出来。
导入之前：
导入之后：
导入之后，我们的连接池信息才有值，这也印证了我们上面的结论。
具体的配置信息我们可以看一下源代码，源码中使用RedisProperties 这个类来接收redis的配置参数。
2.3 项目中使用之简单使用 （举例讲解）
我们的配置工作准备就绪以后，我们就可以在项目中操作redis了，操作的话，使用spring-data-redis中为我们提供的 RedisTemplate 这个类，就可以操作了。我们先举个简单的例子，插入一个键值对（值为string）。
package com.lsqingfeng.springboot.controller;
import com.lsqingfeng.springboot.base.Result;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* @className: RedisController
* @description:
* @author: sh.Liu
* @date: 2022-03-08 14:28
*/
@RestController
@RequestMapping("redis")
public class RedisController {
private final RedisTemplate redisTemplate;
public RedisController(RedisTemplate redisTemplate) {
this.redisTemplate = redisTemplate;
}
@GetMapping("save")
public Result save(String key, String value){
redisTemplate.opsForValue().set(key, value);
return Result.success();
}
}
2.4 项目中使用之工具类封装 （正式用这个）
package com.lsqingfeng.springboot.utils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
/**
* @className: RedisUtil
* @description:
* @author: sh.Liu
* @date: 2022-03-09 14:07
*/
@Component
public class RedisUtil {
@Autowired
private RedisTemplate redisTemplate;
/**
* 给一个指定的 key 值附加过期时间
*
* @param key
* @param time
* @return
*/
public boolean expire(String key, long time) {
return redisTemplate.expire(key, time, TimeUnit.SECONDS);
}
/**
* 根据key 获取过期时间
*
* @param key
* @return
*/
public long getTime(String key) {
return redisTemplate.getExpire(key, TimeUnit.SECONDS);
}
/**
* 根据key 获取过期时间
*
* @param key
* @return
*/
public boolean hasKey(String key) {
return redisTemplate.hasKey(key);
}
/**
* 移除指定key 的过期时间
*
* @param key
* @return
*/
public boolean persist(String key) {
return redisTemplate.boundValueOps(key).persist();
}
//- - - - - - - - - - - - - - - - - - - - - String类型 - - - - - - - - - - - - - - - - - - - -
/**
* 根据key获取值
*
* @param key 键
* @return 值
*/
public Object get(String key) {
return key == null ? null : redisTemplate.opsForValue().get(key);
}
/**
* 将值放入缓存
*
* @param key 键
* @param value 值
* @return true成功 false 失败
*/
public void set(String key, String value) {
redisTemplate.opsForValue().set(key, value);
}
/**
* 将值放入缓存并设置时间
*
* @param key 键
* @param value 值
* @param time 时间(秒) -1为无期限
* @return true成功 false 失败
*/
public void set(String key, String value, long time) {
if (time > 0) {
redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
} else {
redisTemplate.opsForValue().set(key, value);
}
}
/**
* 批量添加 key (重复的键会覆盖)
*
* @param keyAndValue
*/
public void batchSet(Map<String, String> keyAndValue) {
redisTemplate.opsForValue().multiSet(keyAndValue);
}
/**
* 批量添加 key-value 只有在键不存在时,才添加
* map 中只要有一个key存在,则全部不添加
*
* @param keyAndValue
*/
public void batchSetIfAbsent(Map<String, String> keyAndValue) {
redisTemplate.opsForValue().multiSetIfAbsent(keyAndValue);
}
/**
* 对一个 key-value 的值进行加减操作,
* 如果该 key 不存在 将创建一个key 并赋值该 number
* 如果 key 存在,但 value 不是长整型 ,将报错
*
* @param key
* @param number
*/
public Long increment(String key, long number) {
return redisTemplate.opsForValue().increment(key, number);
}
/**
* 对一个 key-value 的值进行加减操作,
* 如果该 key 不存在 将创建一个key 并赋值该 number
* 如果 key 存在,但 value 不是 纯数字 ,将报错
*
* @param key
* @param number
*/
public Double increment(String key, double number) {
return redisTemplate.opsForValue().increment(key, number);
}
//- - - - - - - - - - - - - - - - - - - - - set类型 - - - - - - - - - - - - - - - - - - - -
/**
* 将数据放入set缓存
*
* @param key 键
* @return
*/
public void sSet(String key, String value) {
redisTemplate.opsForSet().add(key, value);
}
/**
* 获取变量中的值
*
* @param key 键
* @return
*/
public Set<Object> members(String key) {
return redisTemplate.opsForSet().members(key);
}
/**
* 随机获取变量中指定个数的元素
*
* @param key 键
* @param count 值
* @return
*/
public void randomMembers(String key, long count) {
redisTemplate.opsForSet().randomMembers(key, count);
}
/**
* 随机获取变量中的元素
*
* @param key 键
* @return
*/
public Object randomMember(String key) {
return redisTemplate.opsForSet().randomMember(key);
}
/**
* 弹出变量中的元素
*
* @param key 键
* @return
*/
public Object pop(String key) {
return redisTemplate.opsForSet().pop("setValue");
}
/**
* 获取变量中值的长度
*
* @param key 键
* @return
*/
public long size(String key) {
return redisTemplate.opsForSet().size(key);
}
/**
* 根据value从一个set中查询,是否存在
*
* @param key 键
* @param value 值
* @return true 存在 false不存在
*/
public boolean sHasKey(String key, Object value) {
return redisTemplate.opsForSet().isMember(key, value);
}
/**
* 检查给定的元素是否在变量中。
*
* @param key 键
* @param obj 元素对象
* @return
*/
public boolean isMember(String key, Object obj) {
return redisTemplate.opsForSet().isMember(key, obj);
}
/**
* 转移变量的元素值到目的变量。
*
* @param key 键
* @param value 元素对象
* @param destKey 元素对象
* @return
*/
public boolean move(String key, String value, String destKey) {
return redisTemplate.opsForSet().move(key, value, destKey);
}
/**
* 批量移除set缓存中元素
*
* @param key 键
* @param values 值
* @return
*/
public void remove(String key, Object... values) {
redisTemplate.opsForSet().remove(key, values);
}
/**
* 通过给定的key求2个set变量的差值
*
* @param key 键
* @param destKey 键
* @return
*/
public Set<Set> difference(String key, String destKey) {
return redisTemplate.opsForSet().difference(key, destKey);
}
//- - - - - - - - - - - - - - - - - - - - - hash类型 - - - - - - - - - - - - - - - - - - - -
/**
* 加入缓存
*
* @param key 键
* @param map 键
* @return
*/
public void add(String key, Map<String, String> map) {
redisTemplate.opsForHash().putAll(key, map);
}
/**
* 获取 key 下的 所有 hashkey 和 value
*
* @param key 键
* @return
*/
public Map<Object, Object> getHashEntries(String key) {
return redisTemplate.opsForHash().entries(key);
}
/**
* 验证指定 key 下 有没有指定的 hashkey
*
* @param key
* @param hashKey
* @return
*/
public boolean hashKey(String key, String hashKey) {
return redisTemplate.opsForHash().hasKey(key, hashKey);
}
/**
* 获取指定key的值string
*
* @param key 键
* @param key2 键
* @return
*/
public String getMapString(String key, String key2) {
return redisTemplate.opsForHash().get("map1", "key1").toString();
}
/**
* 获取指定的值Int
*
* @param key 键
* @param key2 键
* @return
*/
public Integer getMapInt(String key, String key2) {
return (Integer) redisTemplate.opsForHash().get("map1", "key1");
}
/**
* 弹出元素并删除
*
* @param key 键
* @return
*/
public String popValue(String key) {
return redisTemplate.opsForSet().pop(key).toString();
}
/**
* 删除指定 hash 的 HashKey
*
* @param key
* @param hashKeys
* @return 删除成功的 数量
*/
public Long delete(String key, String... hashKeys) {
return redisTemplate.opsForHash().delete(key, hashKeys);
}
/**
* 给指定 hash 的 hashkey 做增减操作
*
* @param key
* @param hashKey
* @param number
* @return
*/
public Long increment(String key, String hashKey, long number) {
return redisTemplate.opsForHash().increment(key, hashKey, number);
}
/**
* 给指定 hash 的 hashkey 做增减操作
*
* @param key
* @param hashKey
* @param number
* @return
*/
public Double increment(String key, String hashKey, Double number) {
return redisTemplate.opsForHash().increment(key, hashKey, number);
}
/**
* 获取 key 下的 所有 hashkey 字段
*
* @param key
* @return
*/
public Set<Object> hashKeys(String key) {
return redisTemplate.opsForHash().keys(key);
}
/**
* 获取指定 hash 下面的 键值对 数量
*
* @param key
* @return
*/
public Long hashSize(String key) {
return redisTemplate.opsForHash().size(key);
}
//- - - - - - - - - - - - - - - - - - - - - list类型 - - - - - - - - - - - - - - - - - - - -
/**
* 在变量左边添加元素值
*
* @param key
* @param value
* @return
*/
public void leftPush(String key, Object value) {
redisTemplate.opsForList().leftPush(key, value);
}
/**
* 获取集合指定位置的值。
*
* @param key
* @param index
* @return
*/
public Object index(String key, long index) {
return redisTemplate.opsForList().index("list", 1);
}
/**
* 获取指定区间的值。
*
* @param key
* @param start
* @param end
* @return
*/
public List<Object> range(String key, long start, long end) {
return redisTemplate.opsForList().range(key, start, end);
}
/**
* 把最后一个参数值放到指定集合的第一个出现中间参数的前面，
* 如果中间参数值存在的话。
*
* @param key
* @param pivot
* @param value
* @return
*/
public void leftPush(String key, String pivot, String value) {
redisTemplate.opsForList().leftPush(key, pivot, value);
}
/**
* 向左边批量添加参数元素。
*
* @param key
* @param values
* @return
*/
public void leftPushAll(String key, String... values) {
// redisTemplate.opsForList().leftPushAll(key,"w","x","y");
redisTemplate.opsForList().leftPushAll(key, values);
}
/**
* 向集合最右边添加元素。
*
* @param key
* @param value
* @return
*/
public void leftPushAll(String key, String value) {
redisTemplate.opsForList().rightPush(key, value);
}
/**
* 向左边批量添加参数元素。
*
* @param key
* @param values
* @return
*/
public void rightPushAll(String key, String... values) {
//redisTemplate.opsForList().leftPushAll(key,"w","x","y");
redisTemplate.opsForList().rightPushAll(key, values);
}
/**
* 向已存在的集合中添加元素。
*
* @param key
* @param value
* @return
*/
public void rightPushIfPresent(String key, Object value) {
redisTemplate.opsForList().rightPushIfPresent(key, value);
}
/**
* 向已存在的集合中添加元素。
*
* @param key
* @return
*/
public long listLength(String key) {
return redisTemplate.opsForList().size(key);
}
/**
* 移除集合中的左边第一个元素。
*
* @param key
* @return
*/
public void leftPop(String key) {
redisTemplate.opsForList().leftPop(key);
}
/**
* 移除集合中左边的元素在等待的时间里，如果超过等待的时间仍没有元素则退出。
*
* @param key
* @return
*/
public void leftPop(String key, long timeout, TimeUnit unit) {
redisTemplate.opsForList().leftPop(key, timeout, unit);
}
/**
* 移除集合中右边的元素。
*
* @param key
* @return
*/
public void rightPop(String key) {
redisTemplate.opsForList().rightPop(key);
}
/**
* 移除集合中右边的元素在等待的时间里，如果超过等待的时间仍没有元素则退出。
*
* @param key
* @return
*/
public void rightPop(String key, long timeout, TimeUnit unit) {
redisTemplate.opsForList().rightPop(key, timeout, unit);
}
}
2.5 序列化 （正常都需要自定义序列化）
Redis本身提供了一下一种序列化的方式：
- GenericToStringSerializer: 可以将任何对象泛化为字符串并序列化
- Jackson2JsonRedisSerializer: 跟JacksonJsonRedisSerializer实际上是一样的
- JacksonJsonRedisSerializer: 序列化object对象为json字符串
- JdkSerializationRedisSerializer: 序列化java对象
- StringRedisSerializer: 简单的字符串序列化
如果我们存储的是String类型，默认使用的是StringRedisSerializer 这种序列化方式。
如果我们存储的是对象，默认使用的是 JdkSerializationRedisSerializer，也就是Jdk的序列化方式（通过ObjectOutputStream和ObjectInputStream实现，缺点是我们无法直观看到存储的对象内容）。
通过观察RedisTemplate的源码我们就可以看出来，默认使用的是JdkSerializationRedisSerializer. 这种序列化最大的问题就是存入对象后，我们很难直观看到存储的内容，很不方便我们排查问题：
而一般我们最经常使用的对象序列化方式是： Jackson2JsonRedisSerializer
设置序列化方式的主要方法就是我们在配置类中，自己来创建RedisTemplate对象，并在创建的过程中指定对应的序列化方式。
@Configuration
public class RedisConfig {
// 定义一个Bean，名称为"redisTemplate"，返回类型为RedisTemplate<String, Object>
@Bean(name = "redisTemplate")
public RedisTemplate<String, Object> getRedisTemplate(RedisConnectionFactory factory) {
// 创建一个新的RedisTemplate实例，用于操作Redis
RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
// 设置RedisTemplate使用的连接工厂，以便它能够连接到Redis服务器
redisTemplate.setConnectionFactory(factory);
// 创建一个StringRedisSerializer实例，用于序列化Redis的key为字符串
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
// 创建一个ObjectMapper实例，用于处理JSON的序列化和反序列化
ObjectMapper objectMapper = new ObjectMapper();
// 设置ObjectMapper的属性访问级别，以便能够序列化对象的所有属性
objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
// 启用默认的类型信息，以便在反序列化时能够知道对象的实际类型
// 注意：这里使用了新的方法替换了过期的enableDefaultTyping方法
// 方法过期，改为下面代码
// objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,
ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
// 创建一个Jackson2JsonRedisSerializer实例，用于序列化Redis的value为JSON格式
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
// 设置Jackson2JsonRedisSerializer使用的ObjectMapper
jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
// 设置RedisTemplate的key序列化器为stringRedisSerializer
redisTemplate.setKeySerializer(stringRedisSerializer); // key的序列化类型
// 设置RedisTemplate的value序列化器为jackson2JsonRedisSerializer
redisTemplate.setValueSerializer(jackson2JsonRedisSerializer); // value的序列化类型
// 设置RedisTemplate的hash key序列化器为stringRedisSerializer
redisTemplate.setHashKeySerializer(stringRedisSerializer); // key的序列化类型
// 设置RedisTemplate的hash value序列化器为jackson2JsonRedisSerializer
redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer); // value的序列化类型
// 调用RedisTemplate的afterPropertiesSet方法，该方法会执行一些初始化操作，比如检查序列化器是否设置等
redisTemplate.afterPropertiesSet();
// 返回配置好的RedisTemplate实例
return redisTemplate;
}
}
当出现以下报错时
setObjectMapper(com.fasterxml.jackson.databind.ObjectMapper)' is deprecated since version 3.0 and marked for removal
官方给出的解释为该接口已弃用，如果要使用原接口功能对Jackson2JsonRedisSerializer配置对象映射器，则使用对应的构造函数。
说明你的 Spring Data Redis 版本是3+了，redis设置序列化的操作就要换成以下
把上面的这两行代码
// 创建一个Jackson2JsonRedisSerializer实例，用于序列化Redis的value为JSON格式
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
// 设置Jackson2JsonRedisSerializer使用的ObjectMapper
jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
换成以下这一行代码
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(objectMapper, Object.class);
这样使用的时候，就会按照我们设置的json序列化方式进行存储，我们也可以在redis中查看内容的时候方便的查看到属性值。
三、分布式锁
（一）RedisTemplate 去实现
场景一：单体应用
单机数据一致性架构如下图所示：多个可客户访问同一个服务器，连接同一个数据库。
场景描述：客户端模拟购买商品过程，在Redis中设定库存总数剩100个，多个客户端同时并发购买。
@RestController
public class IndexController1 {
@Autowired
StringRedisTemplate template;
@RequestMapping("/buy1")
public String index(){
// Redis中存有goods:001号商品，数量为100
String result = template.opsForValue().get("goods:001");
// 获取到剩余商品数
int total = result == null ? 0 : Integer.parseInt(result);
if( total > 0 ){
// 剩余商品数大于0 ，则进行扣减
int realTotal = total -1;
// 将商品数回写数据库
template.opsForValue().set("goods:001",String.valueOf(realTotal));
System.out.println("购买商品成功，库存还剩："+realTotal +"件， 服务端口为8001");
return "购买商品成功，库存还剩："+realTotal +"件， 服务端口为8001";
}else{
System.out.println("购买商品失败，服务端口为8001");
}
return "购买商品失败，服务端口为8001";
}
}
使用Jmeter模拟高并发场景，测试结果如下
测试结果出现多个用户购买同一商品，发生了数据不一致问题！
解决办法：单体应用的情况下，对并发的操作进行加锁操作，保证对数据的操作具有原子性
- synchronized
- ReentrantLock
synchronized （自动获取锁，并在退出时自动释放锁）去实现如下
@RestController
public class IndexController2 {
@Autowired
StringRedisTemplate template;
@RequestMapping("/buy2")
public synchronized String index() {
String result = template.opsForValue().get("goods:001");
int total = result == null ? 0 : Integer.parseInt(result);
if (total > 0) {
int realTotal = total - 1;
template.opsForValue().set("goods:001", String.valueOf(realTotal));
System.out.println("购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001");
return "购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001";
} else {
System.out.println("购买商品失败，服务端口为8001");
}
return "购买商品失败，服务端口为8001";
}
}
ReentrantLock（需要手动获取锁，并在退出时手动释放锁） 去实现
在针对单体应用时的操作（ReentrantLock去实现相对来说好一点，因为颗粒度更细）
@RestController
public class IndexController2 {
// 使用ReentrantLock锁解决单体应用的并发问题
Lock lock = new ReentrantLock();
@Autowired
StringRedisTemplate template;
@RequestMapping("/buy2")
public String index() {
lock.lock();
try {
String result = template.opsForValue().get("goods:001");
int total = result == null ? 0 : Integer.parseInt(result);
if (total > 0) {
int realTotal = total - 1;
template.opsForValue().set("goods:001", String.valueOf(realTotal));
System.out.println("购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001");
return "购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001";
} else {
System.out.println("购买商品失败，服务端口为8001");
}
} catch (Exception e) {
lock.unlock();
} finally {
lock.unlock();
}
return "购买商品失败，服务端口为8001";
}
}
100个商品100个人买最后剩余为0
场景二：分布式架构部署
提供两个服务，端口分别为8001、8002，连接同一个Redis服务，在服务前面有一台Nginx作为负载均衡
两台服务代码相同，只是端口不同
将8001、8002两个服务启动，每个服务依然用ReentrantLock加锁，用Jmeter做并发测试，发现会出现数据一致性问题！
我这边直接写最终版本（存粹的只用redis）
要求：
1.保证自己加的锁，自己删自己的（由以下的uuid生成value去控制，以防止其他的线程把自己的删除了或者自己删除了别人的）
- REDIS_LOCK: 这是你想要设置的Redis键（Key）。在分布式锁的场景中，它通常是一个唯一的字符串，用于标识某个资源或操作。
- value: 这是你想要设置的Redis值（Value）。在分布式锁的场景中，这通常是一个表示锁持有者的唯一标识，例如线程ID或进程ID。
- 10L: 这是锁的过期时间，单位是秒。这意味着如果持有锁的客户端在这个时间内没有释放锁（例如，由于崩溃或网络问题），那么锁将自动过期，其他客户端可以获取它。这是一个重要的安全机制，可以防止死锁。
- TimeUnit.SECONDS: 这是时间单位。TimeUnit是一个枚举类型，表示时间的单位，如毫秒、秒、分钟等。在这里，我们使用SECONDS表示过期时间是以秒为单位的。
redis事务或lua脚本（lua脚本的执行是原子的）,如下
@RestController
public class IndexController7 {
public static final String REDIS_LOCK = "lock";
@Autowired
StringRedisTemplate template;
@RequestMapping("/buy7")
public String index(){
// 每个人进来先要进行加锁，key值为"lock"
String value = UUID.randomUUID().toString().replace("-","");
try{
// 为key加一个过期时间
Boolean flag = template.opsForValue().setIfAbsent(REDIS_LOCK, value,10L,TimeUnit.SECONDS);
// 加锁失败
if(!flag){
return "抢锁失败！";
}
System.out.println( value+ " 抢锁成功");
String result = template.opsForValue().get("goods:001");
int total = result == null ? 0 : Integer.parseInt(result);
if (total > 0) {
// 如果在此处需要调用其他微服务，处理时间较长。。。
int realTotal = total - 1;
template.opsForValue().set("goods:001", String.valueOf(realTotal));
System.out.println("购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001");
return "购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001";
} else {
System.out.println("购买商品失败，服务端口为8001");
}
return "购买商品失败，服务端口为8001";
}finally {
// 谁加的锁，谁才能删除
// 也可以使用redis事务
// https://redis.io/commands/set
// 使用Lua脚本，进行锁的删除
Jedis jedis = null;
try{
jedis = RedisUtils.getJedis();
String script = "if redis.call('get',KEYS[1]) == ARGV[1] " +
"then " +
"return redis.call('del',KEYS[1]) " +
"else " +
" return 0 " +
"end";
Object eval = jedis.eval(script, Collections.singletonList(REDIS_LOCK), Collections.singletonList(value));
if("1".equals(eval.toString())){
System.out.println("-----del redis lock ok....");
}else{
System.out.println("-----del redis lock error ....");
}
}catch (Exception e){
}finally {
if(null != jedis){
jedis.close();
}
}
// redis事务
// while(true){
// template.watch(REDIS_LOCK);
// if(template.opsForValue().get(REDIS_LOCK).equalsIgnoreCase(value)){
// template.setEnableTransactionSupport(true);
// template.multi();
// template.delete(REDIS_LOCK);
// List<Object> list = template.exec();
// if(list == null){
// continue;
// }
// }
// template.unwatch();
// break;
// }
}
}
}
（二） Redisson去实现
先引入maven依赖（redisson和springboot的集成包）
<!-- 添加Redisson依赖 -->
<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson-spring-boot-starter</artifactId>
<version>3.15.0</version>
<exclusions>
<exclusion>
<groupId>org.redisson</groupId>
<!-- 默认是 Spring Data Redis v.2.3.x ,所以排除掉-->
<artifactId>redisson-spring-data-23</artifactId>
</exclusion>
</exclusions>
</dependency>
网上其他的有可能是引入
<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson</artifactId>
<version>3.6.1</version>
</dependency>
根据以上例子用redisson去实现分布式锁，更加nice
使用Redisson的getLock方法时，你实际上是在使用RedLock（红锁）算法来获取分布式锁
@RestController
public class IndexController8 {
public static final String REDIS_LOCK = "lock";
@Autowired
StringRedisTemplate template;
@Autowired
Redisson redisson;
@RequestMapping("/buy8")
public String index(){
//创建锁“lock”
RLock lock = redisson.getLock(REDIS_LOCK);
//加锁
lock.lock();
try{
String result = template.opsForValue().get("goods:001");
int total = result == null ? 0 : Integer.parseInt(result);
if (total > 0) {
// 如果在此处需要调用其他微服务，处理时间较长。。。
int realTotal = total - 1;
template.opsForValue().set("goods:001", String.valueOf(realTotal));
System.out.println("购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001");
return "购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001";
} else {
System.out.println("购买商品失败，服务端口为8001");
}
return "购买商品失败，服务端口为8001";
}finally {
//避免竞态条件，不要if判断检查锁的状态。需直接使用 lock.unlock();
// if(lock.isLocked() && lock.isHeldByCurrentThread()){
// lock.unlock();
// }
lock.unlock();
}
}
}
总结
实际为了保证redis高可用，redis一般会集群部署。
redis集群解决方案,使用redlock解决（redlock的特点如下）:
- 顺序向5个节点请求加锁（5个节点相互独立，没任何关系）
- 根据超时时间来判断是否要跳过该节点
- 如果大于等于3节点加锁成功，并且使用时间小于锁有效期，则加锁成功，否则获取锁失败，解锁
参考文章
【1】SpringBoot教程(十四) | SpringBoot集成Redis(全网最全)
【2】Redis实现分布式锁方法详细
【3】Redis实现分布式锁
【4】陪你一起学redis(十一)——redis分布式锁
