AOP+自定义注解+Redis实现分布式锁(亲测)

亦凉 2024-02-22 09:51 64阅读 0赞

文章目录  
1、背景  
2、目标  
3、方案  
4、实战编码  
4.1、环境准备  
4.2、pom依赖  
4.3、自定义注解  
4.4、切面处理类  
4.5、工具类  
4.6、配置类  
4.7、yml配置  
4.8、表相关  
4.9、使用  
4.10、测试  
总结  
1、背景  
分布式系统开发中常常用到分布式锁，比如防止多个用户同时购买同一个商品，传统的synchronized就无法实现了，而基于数据库的乐观锁实现又可能会对数据库产生较大的压力  
而分布式锁相对较轻量，对性能影响也较小  
目前主流的分布式锁都是基于Redis或者Zookeeper实现  
使用分布式锁的流程一般如下：

![9b9556892c0e4d79a7f6bd9a81c20025.png][]

思考：

如果需要使用分布式锁的场景有多处，那么就需要写多个类似的代码片段了，就会形成很多冗余的代码了，那怎么办呢？

解决方案：

我们可以使用 AOP技术 把这段逻辑抽象出来，这样就避免了重复代码，极大减少了工作量

2、目标  
我们希望这把分布式锁能帮我们达到这样的目标：

对业务代码无侵入(或侵入性较小)  
使用起来非常方便，最好是打一个注解就可以了，可插拔式的  
对性能影响尽可能的小  
要便于后期维护  
3、方案  
此处我们选择的方案就是：AOP+自定义注解+Redis锁

自定义一个注解，声明锁的相关参数，如：锁存Redis的key值、锁的有效期、提示信息、是否自动释放等等  
使用Spring AOP的环绕通知增强被自定义注解修饰的方法，把加锁和释放锁的代码片段抽取到这个切面中，这样就公用了  
那么需要用到分布式锁的接口，只需要打一个注解即可，这样才灵活优雅  
4、实战编码  
4.1、环境准备  
首先我们需要一个简单的SpringBoot项目环境，这里我写了一个基础Demo版本，地址如下：

https://gitee.com/colinWu\_java/spring-boot-base.git

大家可以先下载下来，本文就是基于这份主干代码进行修改的

4.2、pom依赖  
pom.xml中需要新增以下依赖：

<dependency> 
<groupId>cn.hutool</groupId> 
<artifactId>hutool-all</artifactId> 
<version>5.7.8</version> 
</dependency>

<dependency> 
<groupId>org.springframework.boot</groupId> 
<artifactId>spring-boot-starter-aop</artifactId> 
</dependency>

<dependency> 
<groupId>org.redisson</groupId> 
<artifactId>redisson</artifactId> 
<version>3.5.0</version> 
</dependency> 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 
11 
12 
13 
14 
15 
16 
17 
18 
4.3、自定义注解 
package org.wujiangbo.annotation;

import org.wujiangbo.constants.LockType;  
import java.lang.annotation.\*;  
import java.util.concurrent.TimeUnit;

/\*\*  
\* @desc 用于标记Redis锁的自定义注解  
\* @author 波波老师(微信：javabobo0513)  
\*/  
@Target(\{ElementType.TYPE, ElementType.METHOD\})  
@Retention(RetentionPolicy.RUNTIME)  
@Documented  
public @interface RedisLock \{

/\*\*  
\* 防止redis的key发生冲突，所以会对key加上一些统一的前缀，例如：insertXxx, DeleteXxx  
\*/  
String lockName() default "redisson\_distributed\_lock:";

/\*\*  
\* 锁自动释放时间(默认30秒)  
\*\*/  
int leaseTime() default 30000;

/\*\*  
\* 获取锁等待时间(默认3秒)  
\*\*/  
int waitTime() default 3000;

/\*\*  
\* 尝试获取锁的次数  
\*\*/  
int tryNum() default 5;

/\*\*  
\* 时间单位  
\*\*/  
TimeUnit timeUnit() default TimeUnit.MILLISECONDS;

/\*\*  
\* 锁类型  
\*\*/  
LockType LockType() default LockType.REENTRANT\_LOCK;  
\}  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
32  
33  
34  
35  
36  
37  
38  
39  
40  
41  
42  
43  
44  
45  
4.4、切面处理类  
package org.wujiangbo.aspect;

import lombok.extern.slf4j.Slf4j;  
import org.aspectj.lang.ProceedingJoinPoint;  
import org.aspectj.lang.Signature;  
import org.aspectj.lang.annotation.Around;  
import org.aspectj.lang.annotation.Aspect;  
import org.aspectj.lang.reflect.MethodSignature;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.stereotype.Component;  
import org.wujiangbo.annotation.RedisLock;  
import org.wujiangbo.utils.RedissonUtil;  
import java.lang.reflect.Method;

/\*\* 
\* 切面类 
\* 被 @RedisLock 所注解的方法，会被 RedisLockAspect 进行切面管理 
\* 
\* @author 波波老师(微信 ： javabobo0513) 
\*/ 
@Slf4j 
@Aspect 
@Component 
public class RedisLockAspect \{

@Autowired  
private RedissonUtil redissonUtil;

/\*\*  
\* 环绕通知  
\*/  
@Around(value = "@annotation(redisLock)", argNames = "joinPoint,redisLock")  
public Object around(ProceedingJoinPoint joinPoint, RedisLock redisLock) throws Throwable \{  
log.info("线程\{\}，进入切面", Thread.currentThread().getName());

//获取锁的名称key  
String lockKey = getRedisName(joinPoint, redisLock.lockName());

Object result = null;  
try \{  
//尝试获取锁的次数  
int tryNum = redisLock.tryNum();  
// 尝试获取锁，等待5秒，自己获得锁后一直不解锁则在指定时间后自动解锁  
while (tryNum > 0) \{  
/\*\*  
\* 开始尝试获取锁了，返回true表示当前线程获取到了锁，返回false表示没有获取到锁  
\*/  
boolean lock = redissonUtil.tryLock(redisLock.LockType(), lockKey, redisLock.timeUnit(), redisLock.waitTime(), redisLock.leaseTime());  
if (lock) \{  
log.info("线程：\{\}，获取到了锁，开始处理业务", Thread.currentThread().getName());  
//执行业务逻辑  
result = joinPoint.proceed();  
//代码运行到这，业务做完，需要释放锁了  
redissonUtil.unlock(lockKey); //释放锁  
log.info("线程：\{\}，业务代码处理完毕，锁已释放", Thread.currentThread().getName());  
break;  
\}  
log.info("XXXXX - 线程：\{\}，没有获取到锁，开始自旋", Thread.currentThread().getName());  
/\*\*  
\* 睡眠500毫秒，休息一小会，给其他拿到锁的线程一点时间去处理业务逻辑代码，再自旋  
\*/  
Thread.sleep(500);  
tryNum --;  
\}  
\} catch (Exception e) \{  
e.printStackTrace();  
\}  
return result;  
\}

/\*\*  
\* 获取Redis名称  
\*  
\* @param joinPoint 切点  
\* @param lockName 锁名称  
\* @return redisKey  
\*/  
private String getRedisName(ProceedingJoinPoint joinPoint, String lockName) \{  
Signature signature = joinPoint.getSignature();  
MethodSignature methodSignature = (MethodSignature) signature;  
Method targetMethod = methodSignature.getMethod();  
return lockName + targetMethod.getName();  
\}  
\}  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
32  
33  
34  
35  
36  
37  
38  
39  
40  
41  
42  
43  
44  
45  
46  
47  
48  
49  
50  
51  
52  
53  
54  
55  
56  
57  
58  
59  
60  
61  
62  
63  
64  
65  
66  
67  
68  
69  
70  
71  
72  
73  
74  
75  
76  
77  
78  
79  
80  
81  
82  
83  
84  
4.5、工具类  
RedissonUtil工具类：

package org.wujiangbo.utils;

import org.redisson.api.RLock;  
import org.redisson.api.RedissonClient;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.stereotype.Component;  
import org.wujiangbo.constants.LockType;  
import org.wujiangbo.exception.MyException;  
import java.util.concurrent.TimeUnit;

/\*\* 
\* Redisson工具类：加锁解锁 
\* 
\* @author 波波老师(微信 ： javabobo0513) 
\*/ 
@Component 
public class RedissonUtil \{

// RedissonClient已经由配置类生成，这里自动装配即可  
@Autowired  
private RedissonClient redissonClient;

/\*\*  
\* 锁住不设置超时时间(拿不到lock就不罢休，不然线程就一直block)  
\* @param lockKey  
\* @return org.redisson.api.RLock  
\*/  
public RLock lock(String lockKey) \{  
RLock lock = redissonClient.getLock(lockKey);  
lock.lock();  
return lock;  
\}

/\*\*  
\* leaseTime为加锁时间，单位为秒  
\* @param lockKey  
\* @param leaseTime  
\* @return org.redisson.api.RLock  
\*/  
public RLock lock(String lockKey, long leaseTime) \{  
RLock lock = redissonClient.getLock(lockKey);  
lock.lock(leaseTime, TimeUnit.SECONDS);  
return null;  
\}

/\*\*  
\* timeout为加锁时间，时间单位由unit确定  
\* @param lockKey  
\* @param unit  
\* @param timeout  
\* @return org.redisson.api.RLock  
\*/  
public RLock lock(String lockKey, TimeUnit unit, long timeout) \{  
RLock lock = redissonClient.getLock(lockKey);  
lock.lock(timeout, unit);  
return lock;  
\}

/\*\*  
\* 尝试获取锁  
\* @param lockType 锁的类型  
\* @param lockKey 锁的key  
\* @param unit 锁的单位  
\* @param waitTime 获取锁等待时间  
\* @param leaseTime 锁自动释放时间  
\* @return boolean  
\*/  
public boolean tryLock(LockType lockType, String lockKey, TimeUnit unit, long waitTime, long leaseTime) \{  
RLock lock = null;  
switch (lockType)\{  
case REENTRANT\_LOCK:  
lock= redissonClient.getLock(lockKey);  
break;  
case FAIR\_LOCK:  
lock= redissonClient.getFairLock(lockKey);  
break;  
case READ\_LOCK:  
lock= redissonClient.getReadWriteLock(lockKey).readLock();  
break;  
case WRITE\_LOCK:  
lock= redissonClient.getReadWriteLock(lockKey).writeLock();  
break;  
default:  
throw new MyException("do not support lock type：" + lockType);  
\}  
try \{  
return lock.tryLock(waitTime, leaseTime, unit);  
\} catch (InterruptedException e) \{  
return false;  
\}  
\}

/\*\*  
\* 通过lockKey解锁  
\* @param lockKey  
\* @return void  
\*/  
public void unlock(String lockKey) \{  
RLock lock = redissonClient.getLock(lockKey);  
lock.unlock();  
\}

/\*\*  
\* 直接通过锁解锁  
\* @param lock  
\* @return void  
\*/  
public void unlock(RLock lock) \{  
lock.unlock();  
\}  
\}  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
32  
33  
34  
35  
36  
37  
38  
39  
40  
41  
42  
43  
44  
45  
46  
47  
48  
49  
50  
51  
52  
53  
54  
55  
56  
57  
58  
59  
60  
61  
62  
63  
64  
65  
66  
67  
68  
69  
70  
71  
72  
73  
74  
75  
76  
77  
78  
79  
80  
81  
82  
83  
84  
85  
86  
87  
88  
89  
90  
91  
92  
93  
94  
95  
96  
97  
98  
99  
100  
101  
102  
103  
104  
105  
106  
107  
108  
109  
110  
111  
LockType枚举类：

package org.wujiangbo.constants;

/\*\*  
\* @desc 锁类型  
\* @author 波波老师(微信：javabobo0513)  
\*/  
public enum LockType \{  
REENTRANT\_LOCK, //可重入锁  
FAIR\_LOCK, //公平锁  
READ\_LOCK, //读锁  
WRITE\_LOCK; //写锁  
\}  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
4.6、配置类  
package org.wujiangbo.config;

import org.redisson.Redisson;  
import org.redisson.api.RedissonClient;  
import org.redisson.config.Config;  
import org.springframework.beans.factory.annotation.Value;  
import org.springframework.context.annotation.Bean;  
import org.springframework.context.annotation.Configuration;

/\*\* 
\* Redisson配置类 
\* 
\* @author 波波老师(微信 ： javabobo0513) 
\*/ 
@Configuration 
public class RedissonConfig \{

@Value("$\{redisson.address\}")  
private String addressUrl;

@Value("$\{redisson.password\}")  
private String password;

/\*\*  
\* 将 RedissonClient 对象注入Spring容器中  
\* @return  
\* @throws Exception  
\*/  
@Bean  
public RedissonClient getRedisson() throws Exception\{  
Config config = new Config();  
config.useSingleServer().setAddress(addressUrl);  
config.useSingleServer().setPassword(password);  
return Redisson.create(config);  
\}  
\}  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
32  
33  
34  
35  
36  
4.7、yml配置  
server:  
port: 8001  
spring:  
\#配置数据库链接信息  
datasource:  
url: jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true&rewriteBatchedStatements=true  
username: root  
password: 123456  
driver-class-name: com.mysql.jdbc.Driver  
type: com.alibaba.druid.pool.DruidDataSource  
application:  
name: springboot \#服务名

\#MyBatis-Plus相关配置  
mybatis-plus:  
\#指定Mapper.xml路径，如果与Mapper路径相同的话，可省略  
mapper-locations: classpath:org/wujiangbo/mapper/\*Mapper.xml  
configuration:  
map-underscore-to-camel-case: true \#开启驼峰大小写自动转换  
\# log-impl: org.apache.ibatis.logging.stdout.StdOutImpl \#开启控制台sql输出

\#redisson配置  
redisson:  
address: redis://127.0.0.1:6379  
password: 123456  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
4.8、表相关  
数据库新建一张商品信息表：

DROP TABLE IF EXISTS \`t\_goods\`;  
CREATE TABLE \`t\_goods\` (  
\`id\` bigint(20) NOT NULL AUTO\_INCREMENT COMMENT '商品ID',  
\`name\` varchar(255) CHARACTER SET utf8 COLLATE utf8\_general\_ci NULL DEFAULT NULL COMMENT '商品名称',  
\`count\` int(11) NULL DEFAULT NULL COMMENT '库存剩余数量',  
\`version\` bigint(20) NULL DEFAULT 0 COMMENT '版本',  
PRIMARY KEY (\`id\`) USING BTREE  
) ENGINE = InnoDB AUTO\_INCREMENT = 2 CHARACTER SET = utf8 COLLATE = utf8\_general\_ci COMMENT = '商品表' ROW\_FORMAT = Dynamic;

INSERT INTO \`t\_goods\` VALUES (1, 'IPhoneX', 3, 1);  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
里面只有一条数据，有一个商品【IPhoneX】，库存数量只有3个了

然后新建实体类对象：

package org.wujiangbo.domain;

import com.baomidou.mybatisplus.annotations.TableName;  
import lombok.AllArgsConstructor;  
import lombok.Data;  
import lombok.NoArgsConstructor;  
import lombok.ToString;

/\*\* 
\* 商品表对应实体类 
\* 
\* @author 波波老师(微信 ： javabobo0513) 
\*/ 
@Data 
@AllArgsConstructor 
@NoArgsConstructor 
@ToString 
@TableName("t\_goods") 
public class Goods \{

private Long id;  
private String name;  
private Integer count;  
private Long version;  
\}  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
然后新建GoodsMapper类：

package org.wujiangbo.mapper;

import com.baomidou.mybatisplus.mapper.BaseMapper;  
import org.wujiangbo.domain.Goods;

/\*\* 
\* 商品表的Mapper 
\* 
\* @author 波波老师(微信 ： javabobo0513) 
\*/ 
public interface GoodsMapper extends BaseMapper<Goods> \{ 
\} 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 
11 
12 
然后新建GoodsMapper.xml

<?xml version="1.0" encoding="UTF-8"?> 
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> 
<mapper namespace="org.wujiangbo.mapper.GoodsMapper">

</mapper> 
1 
2 
3 
4 
5 
4.9、使用 
新建一个OrderController，写一个下单接口做测试：

package org.wujiangbo.controller;

import lombok.extern.slf4j.Slf4j;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.web.bind.annotation.PostMapping;  
import org.springframework.web.bind.annotation.RequestMapping;  
import org.springframework.web.bind.annotation.RestController;  
import org.wujiangbo.annotation.RedisLock;  
import org.wujiangbo.domain.Goods;  
import org.wujiangbo.mapper.GoodsMapper;  
import org.wujiangbo.result.JSONResult;

/\*\*  
\* @desc 订单接口  
\* @author 波波老师(微信：javabobo0513)  
\*/  
@RestController  
@RequestMapping("/order")  
@Slf4j  
public class OrderController \{

@Autowired  
private GoodsMapper goodsMapper;

//测试Redis分布式锁  
@PostMapping("/insertOrder")  
@RedisLock()  
public JSONResult insertOrder()\{  
log.info("线程\{\}，开始下单...", Thread.currentThread().getName());  
/\*\*  
\* 开始做业务  
\* 现在我们假设每个请求过来都只买一个  
\*/  
Goods goods = goodsMapper.selectById(1);  
if(goods.getCount() > 0)\{  
//如果还有库存的话，就进行库存扣减操作  
goods.setCount(goods.getCount() - 1);  
goodsMapper.updateById(goods);  
log.info("线程\{\}，下单成功", Thread.currentThread().getName());  
return JSONResult.success("insertOrder success");  
\}  
else\{  
log.info("线程\{\}，下单失败，库存不足", Thread.currentThread().getName());  
return JSONResult.error("insertOrder fail");  
\}  
\}  
\}  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
32  
33  
34  
35  
36  
37  
38  
39  
40  
41  
42  
43  
44  
45  
46  
47  
4.10、测试  
测试场景是这样的：

目前商品数量只剩3个了，但是现在有5个人同时发请求要买这个商品，假设每个人每次只能买一个，那结果必然是有三个人买到了，有两个人是买不到商品的（有点类似于秒杀场景，或者抢湖北消费券的场景）

我这里会使用JMeter压测工具进行测试，模拟1秒钟发5个请求

好，现在我们启动项目，然后用JMeter发请求：

![72f76858ae294a43aa01cdd2d8be83d3.png][]

然后运行，结果如下：

![5c7e90e585604c1eab664870e6db1b46.png][]

![8b86a4b196184beca25094786f7ec696.png][]

然后我们再看下控制台核心打印语句：

INFO 2022-10-21 15:51:28.851 \[http-nio-8001-exec-1\] org.wujiangbo.aspect.RedisLockAspect.around：34：线程http-nio-8001-exec-1，进入切面  
INFO 2022-10-21 15:51:28.851 \[http-nio-8001-exec-5\] org.wujiangbo.aspect.RedisLockAspect.around：34：线程http-nio-8001-exec-5，进入切面  
INFO 2022-10-21 15:51:28.851 \[http-nio-8001-exec-3\] org.wujiangbo.aspect.RedisLockAspect.around：34：线程http-nio-8001-exec-3，进入切面  
INFO 2022-10-21 15:51:28.851 \[http-nio-8001-exec-2\] org.wujiangbo.aspect.RedisLockAspect.around：34：线程http-nio-8001-exec-2，进入切面  
INFO 2022-10-21 15:51:28.851 \[http-nio-8001-exec-4\] org.wujiangbo.aspect.RedisLockAspect.around：34：线程http-nio-8001-exec-4，进入切面  
INFO 2022-10-21 15:51:28.864 \[http-nio-8001-exec-4\] org.wujiangbo.aspect.RedisLockAspect.around：50：线程：http-nio-8001-exec-4，获取到了锁，开始处理业务  
INFO 2022-10-21 15:51:28.868 \[http-nio-8001-exec-4\] org.wujiangbo.controller.OrderController.insertOrder：29：线程http-nio-8001-exec-4，开始下单...  
INFO 2022-10-21 15:51:28.920 \[http-nio-8001-exec-4\] org.wujiangbo.controller.OrderController.insertOrder：39：线程http-nio-8001-exec-4，下单成功  
INFO 2022-10-21 15:51:28.922 \[http-nio-8001-exec-4\] org.wujiangbo.aspect.RedisLockAspect.around：55：线程：http-nio-8001-exec-4，业务代码处理完毕，锁已释放  
INFO 2022-10-21 15:51:28.925 \[http-nio-8001-exec-5\] org.wujiangbo.aspect.RedisLockAspect.around：50：线程：http-nio-8001-exec-5，获取到了锁，开始处理业务  
INFO 2022-10-21 15:51:28.925 \[http-nio-8001-exec-5\] org.wujiangbo.controller.OrderController.insertOrder：29：线程http-nio-8001-exec-5，开始下单...  
INFO 2022-10-21 15:51:28.931 \[http-nio-8001-exec-5\] org.wujiangbo.controller.OrderController.insertOrder：39：线程http-nio-8001-exec-5，下单成功  
INFO 2022-10-21 15:51:28.946 \[http-nio-8001-exec-5\] org.wujiangbo.aspect.RedisLockAspect.around：55：线程：http-nio-8001-exec-5，业务代码处理完毕，锁已释放  
INFO 2022-10-21 15:51:28.948 \[http-nio-8001-exec-2\] org.wujiangbo.aspect.RedisLockAspect.around：50：线程：http-nio-8001-exec-2，获取到了锁，开始处理业务  
INFO 2022-10-21 15:51:28.949 \[http-nio-8001-exec-2\] org.wujiangbo.controller.OrderController.insertOrder：29：线程http-nio-8001-exec-2，开始下单...  
INFO 2022-10-21 15:51:28.954 \[http-nio-8001-exec-2\] org.wujiangbo.controller.OrderController.insertOrder：39：线程http-nio-8001-exec-2，下单成功  
INFO 2022-10-21 15:51:28.955 \[http-nio-8001-exec-2\] org.wujiangbo.aspect.RedisLockAspect.around：55：线程：http-nio-8001-exec-2，业务代码处理完毕，锁已释放  
INFO 2022-10-21 15:51:28.956 \[http-nio-8001-exec-3\] org.wujiangbo.aspect.RedisLockAspect.around：50：线程：http-nio-8001-exec-3，获取到了锁，开始处理业务  
INFO 2022-10-21 15:51:28.957 \[http-nio-8001-exec-3\] org.wujiangbo.controller.OrderController.insertOrder：29：线程http-nio-8001-exec-3，开始下单...  
INFO 2022-10-21 15:51:28.958 \[http-nio-8001-exec-3\] org.wujiangbo.controller.OrderController.insertOrder：43：线程http-nio-8001-exec-3，下单失败，库存不足  
INFO 2022-10-21 15:51:28.959 \[http-nio-8001-exec-3\] org.wujiangbo.aspect.RedisLockAspect.around：55：线程：http-nio-8001-exec-3，业务代码处理完毕，锁已释放  
INFO 2022-10-21 15:51:28.964 \[http-nio-8001-exec-1\] org.wujiangbo.aspect.RedisLockAspect.around：50：线程：http-nio-8001-exec-1，获取到了锁，开始处理业务  
INFO 2022-10-21 15:51:28.967 \[http-nio-8001-exec-1\] org.wujiangbo.controller.OrderController.insertOrder：29：线程http-nio-8001-exec-1，开始下单...  
INFO 2022-10-21 15:51:28.970 \[http-nio-8001-exec-1\] org.wujiangbo.controller.OrderController.insertOrder：43：线程http-nio-8001-exec-1，下单失败，库存不足  
INFO 2022-10-21 15:51:28.971 \[http-nio-8001-exec-1\] org.wujiangbo.aspect.RedisLockAspect.around：55：线程：http-nio-8001-exec-1，业务代码处理完毕，锁已释放  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
从上面结果我们梳理一下现象：

首先可以看到确实有5个线程进入切面类了，分别是：http-nio-8001-exec-1、http-nio-8001-exec-2、http-nio-8001-exec-3、http-nio-8001-exec-4、http-nio-8001-exec-5  
首先是http-nio-8001-exec-4获取到了锁，开始扣减库存，其次是：http-nio-8001-exec-5和http-nio-8001-exec-2  
最后线程http-nio-8001-exec-3和http-nio-8001-exec-1虽然拿到了锁，但是库存已经不足了，所以没有抢到商品  
完全符合预期，测试成功

总结  
本文主要是介绍了分布式锁利用注解的方式处理，方便使用和扩展  
具体使用了AOP+自定义注解+Redis实现了基于注解实现分布式锁的目的  
希望对大家有所帮助  
最后本案例代码已全部提交到gitee中了，地址如下：

https://gitee.com/colinWu\_java/spring-boot-base.git

本文新增的代码在RedisDistributedLock分支中  
————————————————  
版权声明：本文为CSDN博主「小学生波波」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。  
原文链接：https://blog.csdn.net/wujiangbo520/article/details/127509897

[9b9556892c0e4d79a7f6bd9a81c20025.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/f17d89be73f5482ab9c501e1593a1346.png
[72f76858ae294a43aa01cdd2d8be83d3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/965459a673af418d85a4c7b16b6eacf3.png
[5c7e90e585604c1eab664870e6db1b46.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/bbfa5e81a5ea4f2b981a7998b024394f.png
[8b86a4b196184beca25094786f7ec696.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/c9aa78e90c4147dfaf1a76fe4ef9707f.png