package com.panzhihua.sangeshenbian.aspectj;
|
|
import com.panzhihua.sangeshenbian.annotation.DistributedLock;
|
import lombok.extern.slf4j.Slf4j;
|
import org.apache.commons.lang3.StringUtils;
|
import org.aspectj.lang.ProceedingJoinPoint;
|
import org.aspectj.lang.annotation.Around;
|
import org.aspectj.lang.annotation.Aspect;
|
import org.aspectj.lang.annotation.Pointcut;
|
import org.aspectj.lang.reflect.MethodSignature;
|
import org.redisson.api.RLock;
|
import org.redisson.api.RedissonClient;
|
import org.springframework.core.LocalVariableTableParameterNameDiscoverer;
|
import org.springframework.expression.ExpressionParser;
|
import org.springframework.expression.spel.standard.SpelExpressionParser;
|
import org.springframework.expression.spel.support.StandardEvaluationContext;
|
import org.springframework.stereotype.Component;
|
|
import javax.annotation.Resource;
|
import java.lang.reflect.Method;
|
import java.util.Objects;
|
|
/**
|
* @Desecription: 分布式锁切面
|
* 注意！！！分布式锁不能加在事务方法当中：因为当锁释放，事务还没有提交
|
*/
|
|
@Aspect
|
@Component
|
@Slf4j
|
public class DistributedLockAspect {
|
@Resource
|
private RedissonClient redissonClient;
|
|
/**
|
* @Descreption: 定义切面：以注解为切面
|
*/
|
@Pointcut("@annotation(com.panzhihua.sangeshenbian.annotation.DistributedLock)")
|
public void distributedLockAspect() {
|
}
|
|
|
@Around(value = "distributedLockAspect()")
|
public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
|
|
//切点所在的类
|
MethodSignature methodSignature = (MethodSignature) pjp.getSignature();
|
Method method = methodSignature.getMethod();
|
//
|
DistributedLock annotation = method.getAnnotation(DistributedLock.class);
|
String lockName = getLockName(annotation, pjp.getArgs(), method);
|
//log.info("lockName:"+lockName);
|
RLock lock = redissonClient.getLock(lockName);
|
lock.lock();
|
try {
|
return pjp.proceed();
|
} finally {
|
if (lock.isLocked() && lock.isHeldByCurrentThread()) {
|
//释放锁
|
lock.unlock();
|
}
|
}
|
}
|
|
/**
|
* @Descreption: 获取锁名字，优先获取注解中锁名
|
*/
|
private String getLockName(DistributedLock distributedLock, Object[] args, Method method) {
|
//优先获取注解名称
|
if (StringUtils.isNotBlank(distributedLock.lockName())) {
|
return distributedLock.lockName();
|
}
|
//根据参数匹配有参数就使用动态参数，没有就使用定义参数
|
String lockNamePre = distributedLock.lockNamePre();
|
String lockNamePost = distributedLock.lockNamePost();
|
String separator = distributedLock.separator();
|
|
String preExpression = parseExpression(lockNamePre, method, args);
|
String postExpression = parseExpression(lockNamePost, method, args);
|
StringBuilder sb = new StringBuilder();
|
if (StringUtils.isNotBlank(preExpression)) {
|
sb.append(preExpression);
|
} else {
|
sb.append(lockNamePre);
|
}
|
sb.append(separator);
|
if (StringUtils.isNotBlank(postExpression)) {
|
sb.append(postExpression);
|
} else {
|
sb.append(lockNamePost);
|
}
|
return sb.toString();
|
}
|
|
/**
|
* el表达式解析
|
*
|
* @param expressionString 解析值
|
* @param method 方法
|
* @param args 参数
|
* @return
|
*/
|
private String parseExpression(String expressionString, Method method, Object[] args) {
|
//获取被拦截方法参数名列表
|
LocalVariableTableParameterNameDiscoverer discoverer = new LocalVariableTableParameterNameDiscoverer();
|
String[] paramNameArr = discoverer.getParameterNames(method);
|
//SPEL解析
|
ExpressionParser parser = new SpelExpressionParser();
|
StandardEvaluationContext context = new StandardEvaluationContext();
|
for (int i = 0; i < Objects.requireNonNull(paramNameArr).length; i++) {
|
context.setVariable(paramNameArr[i], args[i]);
|
}
|
return parser.parseExpression(expressionString).getValue(context, String.class);
|
}
|
|
// ==========================示例=============================
|
|
// //固定静态参数锁:product_lock
|
// @DistributedLock(lockName = "product_lock")
|
// @GetMapping(value = "/test1")
|
// public void test1() {
|
// System.out.println("执行事务");
|
// }
|
//
|
// //未匹配到参数，因此仍然是静态参数锁:#param1_#param2
|
// @DistributedLock(lockNamePre = "#param1", lockNamePost = "#param2")
|
// @GetMapping(value = "/test2")
|
// public void test2() {
|
// System.out.println("执行事务");
|
// }
|
//
|
//匹配到参数，动态参数锁:hello_world
|
// @DistributedLock(lockNamePre = "#order", lockNamePost = "#param2")
|
// @GetMapping(value = "/test3")
|
public void test3(String param1, String param2) {
|
System.out.println("执行事务");
|
}
|
}
|
