一个基于 Redisson 实现分布式锁的库存 AOP 切面处理逻辑

一个基于 Redisson 实现分布式锁的库存扣减场景，包含了具体的业务接口和对应的 AOP 切面处理逻辑

🛒 库存扣减业务接口

该接口演示了如何利用自定义注解 @RedissonLock 实现分布式锁，并包含库存检查、模拟耗时操作、幂等性校验及库存扣减逻辑。

/**
库存扣减
@param stockDeductDto
@return
*/
@PostMapping(value = "/test/deduct/stock")
@ResponseBody
@RedissonLock(key = "'lock:' + #stockDeductDto.transactionId", fairLock = true)
public Result deductStock(@RequestBody StockDeductDto stockDeductDto) {

int deductStock = stockDeductDto.getDeductStock();

// 1. 库存预检查
if (deductStock > inventory.get()) {
return Result.failure("库存不足");
}

// 2. 模拟业务处理耗时 (等待5s)
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}

// 3. 幂等性判断：检查 transactionMap 是否已存在 transactionId
Integer status = trxMap.get(stockDeductDto.getTransactionId());

// 状态 2：已回滚处理
if (status != null && status == 2) {
return Result.successWithErrorCode(
ResultStatus.Already_Processed.code + "",
ResultStatus.Already_Processed.name,
"已回滚处理，无法再操作"
);
}

// 状态 1：已处理
if (status != null && status == 1) {
return Result.successWithErrorCode(
ResultStatus.Already_Processed.code + "",
ResultStatus.Already_Processed.name,
"已处理，无法再操作"
);
}

// 4. 执行扣减
inventory.addAndGet(-deductStock);
trxMap.put(stockDeductDto.getTransactionId(), 1);

log.info("库存扣减成功，TransactionId：{}", stockDeductDto.getTransactionId());
return Result.success();
}

🔒 Redisson 分布式锁切面实现

该切面类负责拦截带有 @RedissonLock 注解的方法，解析 SpEL 表达式生成锁键，并处理锁的获取（包括公平锁和等待超时机制）与释放。

import java.util.concurrent.TimeUnit;

@Aspect
@Component
@Slf4j
public class RedissonLockAspect {

@Autowired
private RedissonLockerUtil redissonLockerUtil;

/**
环绕通知：处理分布式锁逻辑
*/
@Around("@annotation(redissonLock)")
public Object around(ProceedingJoinPoint joinPoint, RedissonLock redissonLock) throws Throwable {
String lockKey = parseSpel(redissonLock.key(), joinPoint); // 解析 SpEL 表达式
long waitTime = redissonLock.waitTime();
long leaseTime = redissonLock.leaseTime();
boolean fairLock = redissonLock.fairLock();
RLock lock = null;

try {
// 尝试获取锁逻辑
if (waitTime > 0) {
// 带超时时间的尝试获取锁
lock = redissonLockerUtil.tryLock(lockKey, TimeUnit.SECONDS, waitTime, leaseTime);
if (lock == null) {
return Result.failure("系统繁忙，请稍后再试");
}
} else {
// 无限等待排队锁 (公平锁/非公平锁)
log.info("尝试获取无限等待排队锁，key: {}", lockKey);
lock = fairLock ? redissonLockerUtil.fairlock(lockKey) : redissonLockerUtil.lock(lockKey);
if (lock == null) {
log.warn("获取锁失败: {}", lockKey);
return Result.failure("系统繁忙，请稍后再试");
}
}

log.info("成功获取锁: {}", lockKey);

// 执行业务逻辑
return joinPoint.proceed();

} finally {
// 释放锁
if (lock != null) {
redissonLockerUtil.unlock(lock);
log.info("锁已释放: {}", lockKey);
}
}
}

/**
解析 SpEL 表达式
*/
private String parseSpel(String spel, ProceedingJoinPoint joinPoint) {
// 获取方法参数名和值
MethodSignature signature = (MethodSignature) joinPoint.getSignature();
String[] parameterNames = signature.getParameterNames();
Object[] args = joinPoint.getArgs();

// 构建 SpEL 上下文
EvaluationContext context = new StandardEvaluationContext();
for (int i = 0; i < parameterNames.length; i++) {
context.setVariable(parameterNames[i], args[i]);
}

// 解析并获取表达式值
ExpressionParser parser = new SpelExpressionParser();
return parser.parseExpression(spel).getValue(context, String.class);
}
}