1. 自定义注解实现分布式锁
利用自定义注解实现分布式锁,最麻烦的地方就是,加锁的key,怎么获取，之前项目中,对key的处理是：在调用需要加分布式锁方法前，就把key拼装完毕,然后在需要加锁的方法的第一个参数传入key,然后在切面类里面通过反射的方式拿到这个key,执行锁获取。
这种方式对方法的侵入比较大,需要函数多出一个参数,传入key,而在方法内部并没有使用到这个key,看着很不舒服。所以决定通过spel解决这个问题，spel就是 Spring表达式语言全称为“Spring Expression Language”，缩写为“SpEL”,具体的可以搜索下,网上相关的博文很多。
2. SpelUtil
在spring 的基础之上封装的用于解析spel表达式的工具方法
import org.springframework.context.expression.MethodBasedEvaluationContext;
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 java.lang.reflect.Method;
/**
* 解析SPEL 表达式
* @author huxingnan
* @date 2018/5/21 10:51
*/
public class SpelUtil {
public static String parse(String spel, Method method, Object[] args) {
//获取被拦截方法参数名列表(使用Spring支持类库)
LocalVariableTableParameterNameDiscoverer u =
new LocalVariableTableParameterNameDiscoverer();
String[] paraNameArr = u.getParameterNames(method);
//使用SPEL进行key的解析
ExpressionParser parser = new SpelExpressionParser();
//SPEL上下文
StandardEvaluationContext context = new StandardEvaluationContext();
//把方法参数放入SPEL上下文中
for (int i = 0; i < paraNameArr.length; i++) {
context.setVariable(paraNameArr[i], args[i]);
}
return parser.parseExpression(spel).getValue(context, String.class);
}
/**
* 支持 #p0 参数索引的表达式解析
* @param rootObject 根对象,method 所在的对象
* @param spel 表达式
* @param method ，目标方法
* @param args 方法入参
* @return 解析后的字符串
*/
public static String parse(Object rootObject,String spel, Method method, Object[] args) {
//获取被拦截方法参数名列表(使用Spring支持类库)
LocalVariableTableParameterNameDiscoverer u =
new LocalVariableTableParameterNameDiscoverer();
String[] paraNameArr = u.getParameterNames(method);
//使用SPEL进行key的解析
ExpressionParser parser = new SpelExpressionParser();
//SPEL上下文
StandardEvaluationContext context = new MethodBasedEvaluationContext(rootObject,method,args,u);
//把方法参数放入SPEL上下文中
for (int i = 0; i < paraNameArr.length; i++) {
context.setVariable(paraNameArr[i], args[i]);
}
return parser.parseExpression(spel).getValue(context, String.class);
}
}
3. 自定义注解addLock
import java.lang.annotation.*;
/**
* 自定义注解为了加锁使用
* Created by zhaosh on 2017/5/12.
*/
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface AddLock {
//spel表达式
String spel() ;
//log信息
String logInfo() default "";
}
4. AOP 切面类AddLockAspect
package com.dream.aspect;
import com.dream.annotation.AddLock;
import com.dream.service.AddLockService;
import com.dream.util.SpelUtil;
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.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.lang.reflect.Method;
import java.util.concurrent.atomic.AtomicBoolean;
/**
* @author hu
*/
@Aspect
@Component
public class AddLockAspect {
private Logger logger = LoggerFactory.getLogger(getClass());
@Resource
private AddLockService addLockService;
@Pointcut("@annotation(com.dream.annotation.AddLock)")
public void addLockAnnotationPointcut() {
}
@Around(value = "addLockAnnotationPointcut()")
public Object addKeyMethod(ProceedingJoinPoint joinPoint) throws Throwable {
//定义返回值
Object proceed;
//获取方法名称
String logInfo = getLogInfo(joinPoint);
//前置方法 开始
String redisKey = getRediskey(joinPoint);
logger.info("{}添加redisKey={}",logInfo,redisKey);
AtomicBoolean lockState = new AtomicBoolean(false);
try {
//对key加分布式锁：1表示加锁成功,-1表示存在锁且未过期,-2表示锁过期但被其它进程抢先
int addLock = addLockService.addLock(redisKey, 5);
if (addLock <=0 ) {
throw new RuntimeException("加锁失败:锁存在");
}
logger.info("{},设置redisKey成功,key={}",logInfo, redisKey);
lockState.set(true);
// 目标方法执行
proceed = joinPoint.proceed();
} catch (Exception exception) {
logger.error("{}REDIS加锁失败,key = {},message={}, code = {}", logInfo,redisKey, exception.getMessage(), exception);
throw exception;
} finally {
if (lockState.get()) {
logger.info("{}清除redisKey={}",logInfo,redisKey);
addLockService.clearLock(redisKey);
}
}
return proceed;
}
/**
* 获取 指定 loginfo
* 需要接口方法声明处 添加 AddLock 注解
* 并且 需要填写 loginfo
* @param joinPoint 切入点
* @return logInfo
*/
private String getLogInfo(ProceedingJoinPoint joinPoint){
MethodSignature methodSignature = (MethodSignature)joinPoint.getSignature();
Method method = methodSignature.getMethod();
AddLock annotation = AnnotationUtils.findAnnotation(method, AddLock.class);
if(annotation == null){
return methodSignature.getName();
}
return annotation.logInfo();
}
/**
* 获取拦截到的请求方法
* @param joinPoint 切点
* @return redisKey
*/
private String getRediskey(ProceedingJoinPoint joinPoint) {
Signature signature = joinPoint.getSignature();
MethodSignature methodSignature = (MethodSignature) signature;
Method targetMethod = methodSignature.getMethod();
Object target = joinPoint.getTarget();
Object[] arguments = joinPoint.getArgs();
AddLock annotation = AnnotationUtils.findAnnotation(targetMethod, AddLock.class);
String spel=null;
if(annotation != null){
spel = annotation.spel();
}
return SpelUtil.parse(target,spel, targetMethod, arguments);
}
}
5. AddLockService
具体实现就不贴出来啦
/**
* @author huxingnan
* @date 2018/5/21 13:33
*/
public interface AddLockService {
/**
* 加锁
* @param redisKey key
* @param i i秒之后失效
* @return 1 成功 -1 失败 -2 失败
*/
int addLock(String redisKey, int i);
/**
* 清除锁
* @param redisKey key
*/
void clearLock(String redisKey);
}
6. 使用AddLock
示范1：
@AddLock(spel = "'CreateOutOrder'+#p0.orderCode",logInfo = "日志信息")
public void testAddLock(Order order){
}
示范2：
@AddLock(spel = "'CreateOutOrder'+#order.orderCode",logInfo = "日志信息")
public void testAddLock(Order order){
}