网站改版的费用,ui设计零基础好学吗,wordpress 翻译 _e,做网站 多少钱SpringBoot教程#xff08;十四#xff09; | SpringBoot之集成Redis
一、Redis集成简介二、集成步骤 2.1 添加依赖2.2 添加配置2.3 项目中使用之简单使用 #xff08;举例讲解#xff09;2.4 项目中使用之工具类封装 #xff08;正式用这个#xff09;2.5 序列化 …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依赖 --
dependencygroupIdorg.springframework.boot/groupIdartifactIdspring-boot-starter-data-redis/artifactId
/dependency完整pom.xml
?xml version1.0 encodingUTF-8?
project xmlnshttp://maven.apache.org/POM/4.0.0xmlns:xsihttp://www.w3.org/2001/XMLSchema-instancexsi:schemaLocationhttp://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsdmodelVersion4.0.0/modelVersiongroupIdcom.lsqingfeng.springboot/groupIdartifactIdspringboot-learning/artifactIdversion1.0.0/versionpropertiesmaven.compiler.source8/maven.compiler.sourcemaven.compiler.target8/maven.compiler.target/propertiesdependencyManagementdependenciesdependencygroupIdorg.springframework.boot/groupIdartifactIdspring-boot-dependencies/artifactIdversion2.6.2/versiontypepom/typescopeimport/scope/dependency/dependencies/dependencyManagementdependenciesdependencygroupIdorg.springframework.boot/groupIdartifactIdspring-boot-starter-web/artifactId/dependency!-- https://mvnrepository.com/artifact/org.projectlombok/lombok --dependencygroupIdorg.projectlombok/groupIdartifactIdlombok/artifactIdversion1.18.22/versionscopeprovided/scope/dependency!-- mybatis-plus 所需依赖 --dependencygroupIdcom.baomidou/groupIdartifactIdmybatis-plus-boot-starter/artifactIdversion3.5.1/version/dependencydependencygroupIdcom.baomidou/groupIdartifactIdmybatis-plus-generator/artifactIdversion3.5.1/version/dependencydependencygroupIdorg.freemarker/groupIdartifactIdfreemarker/artifactIdversion2.3.31/version/dependency!-- 开发热启动 --dependencygroupIdorg.springframework.boot/groupIdartifactIdspring-boot-devtools/artifactIdoptionaltrue/optional/dependency!-- MySQL连接 --dependencygroupIdmysql/groupIdartifactIdmysql-connector-java/artifactIdscoperuntime/scope/dependency!-- 集成redis依赖 --dependencygroupIdorg.springframework.boot/groupIdartifactIdspring-boot-starter-data-redis/artifactId/dependency/dependencies
/project注意点如果我们想要使用jedis客户端怎么办呢就需要排除lettuce这个依赖再引入jedis的相关依赖就可以了。
dependency groupIdorg.springframework.boot/groupId artifactIdspring-boot-starter-data-redis/artifactId exclusions exclusion groupIdio.lettuce/groupId artifactIdlettuce-core/artifactId /exclusion /exclusions
/dependencydependency groupIdredis.clients/groupId artifactIdjedis/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: localhostport: 6379password: 123456database: 0如果有其他配置放到一起
server:port: 19191spring:datasource:driver-class-name: com.mysql.cj.jdbc.Driverurl: jdbc:mysql://localhost:3306/springboot_learning?serverTimezoneAsia/ShanghaicharacterEncodingutf-8username: rootpassword: rootredis:host: localhostport: 6379password: 123456database: 0lettuce:pool:max-idle: 16max-active: 32min-idle: 8devtools:restart:enable: truethird:weather:url: http://www.baidu.comport: 8080username: testcities:- 北京- 上海- 广州list[0]: aaalist[1]: bbblist[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.111port: 6379password: 123456database: 0lettuce:pool:max-idle: 16max-active: 32min-idle: 8如果使用的是jedis,就把lettuce换成jedis同时要注意依赖也是要换的。
但是仅仅这在配置文件中加入其实连接池是不会生效的。这里大家一定要注意很多同学在配置文件上加上了这段就以为连接池已经配置好了其实并没有还少了最关键的一步就是要导入一个依赖不导入的话这么配置也没有用。
dependencygroupIdorg.apache.commons/groupIdartifactIdcommons-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 {Autowiredprivate 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(MapString, String keyAndValue) {redisTemplate.opsForValue().multiSet(keyAndValue);}/*** 批量添加 key-value 只有在键不存在时,才添加* map 中只要有一个key存在,则全部不添加** param keyAndValue*/public void batchSetIfAbsent(MapString, 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 SetObject 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 SetSet difference(String key, String destKey) {return redisTemplate.opsForSet().difference(key, destKey);}//- - - - - - - - - - - - - - - - - - - - - hash类型 - - - - - - - - - - - - - - - - - - - -/*** 加入缓存** param key 键* param map 键* return*/public void add(String key, MapString, String map) {redisTemplate.opsForHash().putAll(key, map);}/*** 获取 key 下的 所有 hashkey 和 value** param key 键* return*/public MapObject, 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 SetObject 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 ListObject 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返回类型为RedisTemplateString, Object Bean(name redisTemplate) public RedisTemplateString, Object getRedisTemplate(RedisConnectionFactory factory) { // 创建一个新的RedisTemplate实例用于操作Redis RedisTemplateString, Object redisTemplate new RedisTemplateString, 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 {AutowiredStringRedisTemplate template;RequestMapping(/buy1)public String index(){// 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模拟高并发场景测试结果如下 测试结果出现多个用户购买同一商品发生了数据不一致问题
解决办法单体应用的情况下对并发的操作进行加锁操作保证对数据的操作具有原子性
synchronizedReentrantLock
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();AutowiredStringRedisTemplate 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;AutowiredStringRedisTemplate template;RequestMapping(/buy7)public String index(){// 每个人进来先要进行加锁key值为lockString 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);
// ListObject list template.exec();
// if(list null){
// continue;
// }
// }
// template.unwatch();
// break;
// }}}
}二 Redisson去实现
先引入maven依赖redisson和springboot的集成包
!-- 添加Redisson依赖 --
dependencygroupIdorg.redisson/groupIdartifactIdredisson-spring-boot-starter/artifactIdversion3.15.0/versionexclusionsexclusiongroupIdorg.redisson/groupId!-- 默认是 Spring Data Redis v.2.3.x ,所以排除掉--artifactIdredisson-spring-data-23/artifactId/exclusion/exclusions
/dependency网上其他的有可能是引入
dependencygroupIdorg.redisson/groupIdartifactIdredisson/artifactIdversion3.6.1/version
/dependency根据以上例子用redisson去实现分布式锁更加nice 使用Redisson的getLock方法时你实际上是在使用RedLock红锁算法来获取分布式锁
RestController
public class IndexController8 {public static final String REDIS_LOCK lock;AutowiredStringRedisTemplate template;AutowiredRedisson 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分布式锁
