SpringBoot教程（十四） | SpringBoot之集成Redis

一、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"?><projectxmlns="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:6379password:123456database:0

如果有其他配置放到一起：

server:port:19191spring:datasource:driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/springboot_learning?serverTimezone=Asia/Shanghai&characterEncoding=utf-8username: root
    password: root
  redis:host: localhost
    port:6379password:123456database:0lettuce:pool:max-idle:16max-active:32min-idle:8devtools:restart:enable:truethird:weather:url: http://www.baidu.com
    port:8080username: test
    cities:- 北京
      - 上海
      - 广州
    list[0]: aaa
    list[1]: bbb
    list[2]: ccc

这样我们就可以直接在项目当中操作redis了。如果使用的是集群，那么使用如下配置方式：

spring:redis:password:123456cluster: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:7006max-redirects:3

但是有的时候我们想要给我们的redis客户端配置上连接池。
就像我们连接mysql的时候，也会配置连接池一样，目的就是增加对于数据连接的管理，提升访问的效率，也保证了对资源的合理利用。那么我们如何配置连接池呢，这里大家一定要注意了，很多网上的文章中，介绍的方法可能由于版本太低，都不是特别的准确。
比如很多人使用spring.redis.pool来配置，这个是不对的（不清楚是不是老版本是这样的配置的，但是在springboot-starter-data-redis中这种写法不对）。首先是配置文件，由于我们使用的lettuce客户端，所以配置的时候，在spring.redis下加上lettuce再加上pool来配置，具体如下；

spring:redis:host: 10.255.144.111
    port:6379password:123456database:0lettuce:pool:max-idle:16max-active:32min-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）。

packagecom.lsqingfeng.springboot.controller;importcom.lsqingfeng.springboot.base.Result;importorg.springframework.data.redis.core.RedisTemplate;importorg.springframework.web.bind.annotation.GetMapping;importorg.springframework.web.bind.annotation.RequestMapping;importorg.springframework.web.bind.annotation.RestController;/**
 * @className: RedisController
 * @description:
 * @author: sh.Liu
 * @date: 2022-03-08 14:28
 */@RestController@RequestMapping("redis")publicclassRedisController{privatefinalRedisTemplate redisTemplate;publicRedisController(RedisTemplate redisTemplate){this.redisTemplate = redisTemplate;}@GetMapping("save")publicResultsave(String key,String value){
        redisTemplate.opsForValue().set(key, value);returnResult.success();}}

三、工具类封装

packagecom.lsqingfeng.springboot.utils;importorg.springframework.beans.factory.annotation.Autowired;importorg.springframework.data.redis.core.RedisTemplate;importorg.springframework.stereotype.Component;importjava.util.List;importjava.util.Map;importjava.util.Set;importjava.util.concurrent.TimeUnit;/**
 * @className: RedisUtil
 * @description:
 * @author: sh.Liu
 * @date: 2022-03-09 14:07
 */@ComponentpublicclassRedisUtil{@AutowiredprivateRedisTemplate redisTemplate;/**
     * 给一个指定的 key 值附加过期时间
     *
     * @param key
     * @param time
     * @return
     */publicbooleanexpire(String key,long time){return redisTemplate.expire(key, time,TimeUnit.SECONDS);}/**
     * 根据key 获取过期时间
     *
     * @param key
     * @return
     */publiclonggetTime(String key){return redisTemplate.getExpire(key,TimeUnit.SECONDS);}/**
     * 根据key 获取过期时间
     *
     * @param key
     * @return
     */publicbooleanhasKey(String key){return redisTemplate.hasKey(key);}/**
     * 移除指定key 的过期时间
     *
     * @param key
     * @return
     */publicbooleanpersist(String key){return redisTemplate.boundValueOps(key).persist();}//- - - - - - - - - - - - - - - - - - - - -  String类型 - - - - - - - - - - - - - - - - - - - -/**
     * 根据key获取值
     *
     * @param key 键
     * @return 值
     */publicObjectget(String key){return key ==null?null: redisTemplate.opsForValue().get(key);}/**
     * 将值放入缓存
     *
     * @param key   键
     * @param value 值
     * @return true成功 false 失败
     */publicvoidset(String key,String value){
        redisTemplate.opsForValue().set(key, value);}/**
     * 将值放入缓存并设置时间
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒) -1为无期限
     * @return true成功 false 失败
     */publicvoidset(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
     */publicvoidbatchSet(Map<String,String> keyAndValue){
        redisTemplate.opsForValue().multiSet(keyAndValue);}/**
     * 批量添加 key-value 只有在键不存在时,才添加
     * map 中只要有一个key存在,则全部不添加
     *
     * @param keyAndValue
     */publicvoidbatchSetIfAbsent(Map<String,String> keyAndValue){
        redisTemplate.opsForValue().multiSetIfAbsent(keyAndValue);}/**
     * 对一个 key-value 的值进行加减操作,
     * 如果该 key 不存在 将创建一个key 并赋值该 number
     * 如果 key 存在,但 value 不是长整型 ,将报错
     *
     * @param key
     * @param number
     */publicLongincrement(String key,long number){return redisTemplate.opsForValue().increment(key, number);}/**
     * 对一个 key-value 的值进行加减操作,
     * 如果该 key 不存在 将创建一个key 并赋值该 number
     * 如果 key 存在,但 value 不是 纯数字 ,将报错
     *
     * @param key
     * @param number
     */publicDoubleincrement(String key,double number){return redisTemplate.opsForValue().increment(key, number);}//- - - - - - - - - - - - - - - - - - - - -  set类型 - - - - - - - - - - - - - - - - - - - -/**
     * 将数据放入set缓存
     *
     * @param key 键
     * @return
     */publicvoidsSet(String key,String value){
        redisTemplate.opsForSet().add(key, value);}/**
     * 获取变量中的值
     *
     * @param key 键
     * @return
     */publicSet<Object>members(String key){return redisTemplate.opsForSet().members(key);}/**
     * 随机获取变量中指定个数的元素
     *
     * @param key   键
     * @param count 值
     * @return
     */publicvoidrandomMembers(String key,long count){
        redisTemplate.opsForSet().randomMembers(key, count);}/**
     * 随机获取变量中的元素
     *
     * @param key 键
     * @return
     */publicObjectrandomMember(String key){return redisTemplate.opsForSet().randomMember(key);}/**
     * 弹出变量中的元素
     *
     * @param key 键
     * @return
     */publicObjectpop(String key){return redisTemplate.opsForSet().pop("setValue");}/**
     * 获取变量中值的长度
     *
     * @param key 键
     * @return
     */publiclongsize(String key){return redisTemplate.opsForSet().size(key);}/**
     * 根据value从一个set中查询,是否存在
     *
     * @param key   键
     * @param value 值
     * @return true 存在 false不存在
     */publicbooleansHasKey(String key,Object value){return redisTemplate.opsForSet().isMember(key, value);}/**
     * 检查给定的元素是否在变量中。
     *
     * @param key 键
     * @param obj 元素对象
     * @return
     */publicbooleanisMember(String key,Object obj){return redisTemplate.opsForSet().isMember(key, obj);}/**
     * 转移变量的元素值到目的变量。
     *
     * @param key     键
     * @param value   元素对象
     * @param destKey 元素对象
     * @return
     */publicbooleanmove(String key,String value,String destKey){return redisTemplate.opsForSet().move(key, value, destKey);}/**
     * 批量移除set缓存中元素
     *
     * @param key    键
     * @param values 值
     * @return
     */publicvoidremove(String key,Object... values){
        redisTemplate.opsForSet().remove(key, values);}/**
     * 通过给定的key求2个set变量的差值
     *
     * @param key     键
     * @param destKey 键
     * @return
     */publicSet<Set>difference(String key,String destKey){return redisTemplate.opsForSet().difference(key, destKey);}//- - - - - - - - - - - - - - - - - - - - -  hash类型 - - - - - - - - - - - - - - - - - - - -/**
     * 加入缓存
     *
     * @param key 键
     * @param map 键
     * @return
     */publicvoidadd(String key,Map<String,String> map){
        redisTemplate.opsForHash().putAll(key, map);}/**
     * 获取 key 下的 所有  hashkey 和 value
     *
     * @param key 键
     * @return
     */publicMap<Object,Object>getHashEntries(String key){return redisTemplate.opsForHash().entries(key);}/**
     * 验证指定 key 下 有没有指定的 hashkey
     *
     * @param key
     * @param hashKey
     * @return
     */publicbooleanhashKey(String key,String hashKey){return redisTemplate.opsForHash().hasKey(key, hashKey);}/**
     * 获取指定key的值string
     *
     * @param key  键
     * @param key2 键
     * @return
     */publicStringgetMapString(String key,String key2){return redisTemplate.opsForHash().get("map1","key1").toString();}/**
     * 获取指定的值Int
     *
     * @param key  键
     * @param key2 键
     * @return
     */publicIntegergetMapInt(String key,String key2){return(Integer) redisTemplate.opsForHash().get("map1","key1");}/**
     * 弹出元素并删除
     *
     * @param key 键
     * @return
     */publicStringpopValue(String key){return redisTemplate.opsForSet().pop(key).toString();}/**
     * 删除指定 hash 的 HashKey
     *
     * @param key
     * @param hashKeys
     * @return 删除成功的 数量
     */publicLongdelete(String key,String... hashKeys){return redisTemplate.opsForHash().delete(key, hashKeys);}/**
     * 给指定 hash 的 hashkey 做增减操作
     *
     * @param key
     * @param hashKey
     * @param number
     * @return
     */publicLongincrement(String key,String hashKey,long number){return redisTemplate.opsForHash().increment(key, hashKey, number);}/**
     * 给指定 hash 的 hashkey 做增减操作
     *
     * @param key
     * @param hashKey
     * @param number
     * @return
     */publicDoubleincrement(String key,String hashKey,Double number){return redisTemplate.opsForHash().increment(key, hashKey, number);}/**
     * 获取 key 下的 所有 hashkey 字段
     *
     * @param key
     * @return
     */publicSet<Object>hashKeys(String key){return redisTemplate.opsForHash().keys(key);}/**
     * 获取指定 hash 下面的 键值对 数量
     *
     * @param key
     * @return
     */publicLonghashSize(String key){return redisTemplate.opsForHash().size(key);}//- - - - - - - - - - - - - - - - - - - - -  list类型 - - - - - - - - - - - - - - - - - - - -/**
     * 在变量左边添加元素值
     *
     * @param key
     * @param value
     * @return
     */publicvoidleftPush(String key,Object value){
        redisTemplate.opsForList().leftPush(key, value);}/**
     * 获取集合指定位置的值。
     *
     * @param key
     * @param index
     * @return
     */publicObjectindex(String key,long index){return redisTemplate.opsForList().index("list",1);}/**
     * 获取指定区间的值。
     *
     * @param key
     * @param start
     * @param end
     * @return
     */publicList<Object>range(String key,long start,long end){return redisTemplate.opsForList().range(key, start, end);}/**
     * 把最后一个参数值放到指定集合的第一个出现中间参数的前面，
     * 如果中间参数值存在的话。
     *
     * @param key
     * @param pivot
     * @param value
     * @return
     */publicvoidleftPush(String key,String pivot,String value){
        redisTemplate.opsForList().leftPush(key, pivot, value);}/**
     * 向左边批量添加参数元素。
     *
     * @param key
     * @param values
     * @return
     */publicvoidleftPushAll(String key,String... values){//        redisTemplate.opsForList().leftPushAll(key,"w","x","y");
        redisTemplate.opsForList().leftPushAll(key, values);}/**
     * 向集合最右边添加元素。
     *
     * @param key
     * @param value
     * @return
     */publicvoidleftPushAll(String key,String value){
        redisTemplate.opsForList().rightPush(key, value);}/**
     * 向左边批量添加参数元素。
     *
     * @param key
     * @param values
     * @return
     */publicvoidrightPushAll(String key,String... values){//redisTemplate.opsForList().leftPushAll(key,"w","x","y");
        redisTemplate.opsForList().rightPushAll(key, values);}/**
     * 向已存在的集合中添加元素。
     *
     * @param key
     * @param value
     * @return
     */publicvoidrightPushIfPresent(String key,Object value){
        redisTemplate.opsForList().rightPushIfPresent(key, value);}/**
     * 向已存在的集合中添加元素。
     *
     * @param key
     * @return
     */publiclonglistLength(String key){return redisTemplate.opsForList().size(key);}/**
     * 移除集合中的左边第一个元素。
     *
     * @param key
     * @return
     */publicvoidleftPop(String key){
        redisTemplate.opsForList().leftPop(key);}/**
     * 移除集合中左边的元素在等待的时间里，如果超过等待的时间仍没有元素则退出。
     *
     * @param key
     * @return
     */publicvoidleftPop(String key,long timeout,TimeUnit unit){
        redisTemplate.opsForList().leftPop(key, timeout, unit);}/**
     * 移除集合中右边的元素。
     *
     * @param key
     * @return
     */publicvoidrightPop(String key){
        redisTemplate.opsForList().rightPop(key);}/**
     * 移除集合中右边的元素在等待的时间里，如果超过等待的时间仍没有元素则退出。
     *
     * @param key
     * @return
     */publicvoidrightPop(String key,long timeout,TimeUnit unit){
        redisTemplate.opsForList().rightPop(key, timeout, unit);}}

四、序列化（正常都需要自定义序列化）

Redis本身提供了一下一种序列化的方式：

GenericToStringSerializer: 可以将任何对象泛化为字符串并序列化
Jackson2JsonRedisSerializer: 跟JacksonJsonRedisSerializer实际上是一样的
JacksonJsonRedisSerializer: 序列化object对象为json字符串
JdkSerializationRedisSerializer: 序列化java对象
StringRedisSerializer: 简单的字符串序列化

如果我们存储的是String类型，默认使用的是StringRedisSerializer 这种序列化方式。
如果我们存储的是对象，默认使用的是 JdkSerializationRedisSerializer，也就是Jdk的序列化方式（通过ObjectOutputStream和ObjectInputStream实现，缺点是我们无法直观看到存储的对象内容）。

通过观察RedisTemplate的源码我们就可以看出来，默认使用的是JdkSerializationRedisSerializer. 这种序列化最大的问题就是存入对象后，我们很难直观看到存储的内容，很不方便我们排查问题：

而一般我们最经常使用的对象序列化方式是： Jackson2JsonRedisSerializer

设置序列化方式的主要方法就是我们在配置类中，自己来创建RedisTemplate对象，并在创建的过程中指定对应的序列化方式。

@ConfigurationpublicclassRedisConfig{// 定义一个Bean，名称为"redisTemplate"，返回类型为RedisTemplate<String, Object>  @Bean(name ="redisTemplate")publicRedisTemplate<String,Object>getRedisTemplate(RedisConnectionFactory factory){// 创建一个新的RedisTemplate实例，用于操作Redis  RedisTemplate<String,Object> redisTemplate =newRedisTemplate<String,Object>();// 设置RedisTemplate使用的连接工厂，以便它能够连接到Redis服务器  
        redisTemplate.setConnectionFactory(factory);// 创建一个StringRedisSerializer实例，用于序列化Redis的key为字符串  StringRedisSerializer stringRedisSerializer =newStringRedisSerializer();// 创建一个Jackson2JsonRedisSerializer实例，用于序列化Redis的value为JSON格式  Jackson2JsonRedisSerializer jackson2JsonRedisSerializer =newJackson2JsonRedisSerializer(Object.class);// 创建一个ObjectMapper实例，用于处理JSON的序列化和反序列化  ObjectMapper objectMapper =newObjectMapper();// 设置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使用的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;}}

这样使用的时候，就会按照我们设置的json序列化方式进行存储，我们也可以在redis中查看内容的时候方便的查看到属性值。

五、分布式锁

（一）RedisTemplate 去实现

场景一：单体应用

单机数据一致性架构如下图所示：多个可客户访问同一个服务器，连接同一个数据库。

在这里插入图片描述
场景描述：客户端模拟购买商品过程，在Redis中设定库存总数剩100个，多个客户端同时并发购买。

@RestControllerpublicclassIndexController1{@AutowiredStringRedisTemplate template;@RequestMapping("/buy1")publicStringindex(){// Redis中存有goods:001号商品，数量为100String 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 （自动获取锁，并在退出时自动释放锁）去实现如下

@RestControllerpublicclassIndexController2{@AutowiredStringRedisTemplate template;@RequestMapping("/buy2")publicsynchronizedStringindex(){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去实现相对来说好一点，因为颗粒度更细）

@RestControllerpublicclassIndexController2{// 使用ReentrantLock锁解决单体应用的并发问题Lock lock =newReentrantLock();@AutowiredStringRedisTemplate template;@RequestMapping("/buy2")publicStringindex(){
 
        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脚本的执行是原子的）,如下

@RestControllerpublicclassIndexController7{publicstaticfinalStringREDIS_LOCK="lock";@AutowiredStringRedisTemplate template;@RequestMapping("/buy7")publicStringindex(){// 每个人进来先要进行加锁，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（红锁）算法来获取分布式锁

@RestControllerpublicclassIndexController8{publicstaticfinalStringREDIS_LOCK="lock";@AutowiredStringRedisTemplate template;@AutowiredRedisson redisson;@RequestMapping("/buy8")publicStringindex(){//创建锁“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分布式锁

标签： spring boot redis 后端

本文转载自: https://blog.csdn.net/qq_20236937/article/details/137561788
版权归原作者 Slow菜鸟 所有，如有侵权，请联系我们删除。

SpringBoot教程（十四） | SpringBoot之集成Redis

SpringBoot教程（十四） | SpringBoot之集成Redis

一、Redis集成简介

二、集成步骤

2.1 添加依赖

2.2 添加配置

2.3 项目中使用

三、工具类封装

四、序列化（正常都需要自定义序列化）

五、分布式锁

（一）RedisTemplate 去实现

场景一：单体应用

场景二：分布式架构部署

（二） Redisson去实现

总结

发表评论