其实我们在前面已经演示过使用redisson来实现分布式锁了，详情见：《Spring Cloud微服务项目模板系列（十）Redisson分布式锁》。由于最近在编写秒杀的演示项目，里面也会使用到分布式锁，这里我们想着使用简单一点，因此这里我们使用注解的方式实现一个分布式锁的案例，这样子使用起来比较简单。
利用redisson来实现分布式锁的时候，其实主要有几个核心的类，分别是：
声明注解 实现注解逻辑 redisson分布式锁
所以基于这几个主类，我们来演示下代码：
一、声明一个注解
这里我们声明注解的时候比较简单，示例代码如下：
package com.redisson.aop; import java.lang.annotation.Documented; import java.lang.annotation.ElementType; import java.lang.annotation.Inherited; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; @Documented @Inherited @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.METHOD}) public @interface RedisDistributedLock { String key() default ""; int leaseTime() default 10; boolean autoRelease() default true; String errorDesc() default "系统正在处理，请稍后重试"; int waitTime() default 1; }
二、实现注解逻辑
接着我们就来实现注解的逻辑，这个逻辑比较简单，就是我们日常使用redisson加锁解锁的逻辑，示例代码如下：
package com.redisson.aop; import java.lang.reflect.Method; import org.aspectj.lang.ProceedingJoinPoint; 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.core.DefaultParameterNameDiscoverer; import org.springframework.expression.Expression; import org.springframework.expression.spel.standard.SpelExpressionParser; import org.springframework.expression.spel.support.StandardEvaluationContext; import org.springframework.stereotype.Component; import org.springframework.util.StringUtils; import com.redisson.redis.RedissonLock; import lombok.extern.slf4j.Slf4j; @Aspect @Component @Slf4j public class RedisDistributedLockHandler { @Autowired RedissonLock redissonLock; public RedisDistributedLockHandler() { } @Around("@annotation(distributedLock)") public Object around(ProceedingJoinPoint joinPoint, RedisDistributedLock distributedLock) throws Throwable { String lockName = this.getRedisKey(joinPoint, distributedLock); int leaseTime = distributedLock.leaseTime(); String errorDesc = distributedLock.errorDesc(); int waitTime = distributedLock.waitTime(); Object var8; try { boolean lock = this.redissonLock.tryLock(lockName, (long)leaseTime, (long)waitTime); if (!lock) { throw new RuntimeException(errorDesc); } var8 = joinPoint.proceed(); } catch (Throwable var12) { log.error("执行业务方法异常", var12); throw var12; } finally { this.redissonLock.isHeldByCurrentThread(lockName); } return var8; } /** * 获取加锁的key * @param joinPoint * @param distributedLock * @return */ private String getRedisKey(ProceedingJoinPoint joinPoint, RedisDistributedLock distributedLock) { String key = distributedLock.key(); Object[] parameterValues = joinPoint.getArgs(); MethodSignature signature = (MethodSignature)joinPoint.getSignature(); Method method = signature.getMethod(); DefaultParameterNameDiscoverer nameDiscoverer = new DefaultParameterNameDiscoverer(); String[] parameterNames = nameDiscoverer.getParameterNames(method); if (StringUtils.isEmpty(key)) { if (parameterNames != null && parameterNames.length > 0) { StringBuffer sb = new StringBuffer(); int i = 0; for(int len = parameterNames.length; i < len; ++i) { sb.append(parameterNames[i]).append(" = ").append(parameterValues[i]); } key = sb.toString(); } else { key = "redissionLock"; } return key; } else { SpelExpressionParser parser = new SpelExpressionParser(); Expression expression = parser.parseExpression(key); if (parameterNames != null && parameterNames.length != 0) { StandardEvaluationContext evaluationContext = new StandardEvaluationContext(); for(int i = 0; i < parameterNames.length; ++i) { evaluationContext.setVariable(parameterNames[i], parameterValues[i]); } try { Object expressionValue = expression.getValue(evaluationContext); return expressionValue != null && !"".equals(expressionValue.toString()) ? expressionValue.toString() : key; } catch (Exception var13) { return key; } } else { return key; } } } }
三、实现redisson的锁
最后就是redisson工具类加锁，示例代码如下：
package com.redisson.redis;
import java.util.concurrent.TimeUnit;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import lombok.extern.slf4j.Slf4j;
@Component
@Slf4j
public class RedissonLock {
@Autowired
private RedissonClient redissonClient;
public boolean tryLock(String lockName, long leaseTime, long waitTime) {
try {
RLock rLock = redissonClient.getLock(lockName);
boolean isLockSuccess = rLock.tryLock(waitTime, leaseTime, TimeUnit.SECONDS);
log.info("{} get lock result:{}", lockName, isLockSuccess);
return isLockSuccess;
} catch (Exception e) {
log.error(e.getMessage(),e);
}
return false;
}
/**
* 释放锁
*
* @param lockName
*/
public void isHeldByCurrentThread(String lockName) {
RLock lock = redissonClient.getLock(lockName);
if (lock.isLocked()) { // 是否还是锁定状态
if (lock.isHeldByCurrentThread()) { // 时候是当前执行线程的锁
lock.unlock(); // 释放锁
}
}
}
}最后我们在使用的时候，直接添加上对应的@RedisDistributedLock注解即可，示例代码如下：
@PostMapping("/reduceStock")
@RedisDistributedLock(key = "'lock_good_'+#request.goodId", errorDesc = "当前请求频繁，请稍后重试")
public String reduceStock(@RequestBody GoodRequest request) {
Integer stock = goodDao.getGoodStock(request.getGoodId());
if (stock > 0) {
goodDao.reduceGoodStock(request.getGoodId());
}
return "成功";
}到这里我们的代码就编写完了，接着我们把项目打包放到服务器上去：
备注：
1、这里我们部署多个，主要是根据实际的环境来进行并发测试，验证并发测试下这个分布式锁有没有问题。
接着我们使用apipost进行并发测试，来看看效果，请求示例如下：
我们在这里进行一键压测
首先我们把数据库的库存设置为10
这里我们的并发数设置为100，压测10轮次，看看最后这个库存会不会存在超卖：
然后再看看数据库的库存：
可以看到库存为0了，也就是差不多1000个请求，成功买到的只有10个人。说明咱们这个分布式锁的编写是没问题的。
备注：
1、在并发测试里面成功请求数比较多，这是因为我们如果没抢到的话，返回的http statu code还是200，apipost会认为是成功的。 2、如果大家编写多线程代码，在日志中输出返回结果就可以看到提示库存不足或者其他的提示了。 3、这里失败请求数有一些，是由于当前服务器的配置较低，CPU撑满了，导致请求直接错误了。 4、在实际的环境中如果使用redis做分布式锁的载体的时候要注意下：使用redis单机是没问题的，使用redis单分片（无副本）集群没有问题，但是涉及到主从的话做分布式锁可能会出现问题，主要是由于主从同步可能出现问题。
最后按照惯例，附上本案例的源码，登录后即可下载。
还没有评论，来说两句吧...