1.原始写法
我们平常使用redisson的分布式锁是不是基本都用下面的这个模板，既然是模板，那为何不把他抽出来呢？
// 尝试加锁，最多等待100秒，上锁以后10秒自动解锁
boolean res = lock.tryLock(100, 10, TimeUnit.SECONDS);
if (res) {
try {
...业务代码
} finally {
lock.unlock();
}
}
2.抽出分布式锁工具类
我们可以抽出一个 LockService 方法，把锁的模板写在方法里，调用的时候只需要指定 key，把锁内的代码块用 supplier 函数传进来。
@Service
@Slf4j
public class LockService {
@Autowired
private RedissonClient redissonClient;
public <T> T executeWithLock(String key, int waitTime, TimeUnit unit, SupplierThrow<T> supplier) throws Throwable {
RLock lock = redissonClient.getLock(key);
boolean lockSuccess = lock.tryLock(waitTime, unit);
if (!lockSuccess) {
throw new BusinessException(CommonErrorEnum.LOCK_LIMIT);
}
try {
return supplier.get();//执行锁内的代码逻辑
} finally {
lock.unlock();
}
}
}使用起来就方便了
lockService.executeWithLock(key, 10, TimeUnit.SECONDS, ()->{
//执行业务逻辑
。。。。。
return null;
});如果我们不需要排队等锁，甚至还能重载方法减少两个参数。
lockService.executeWithLock(key, ()->{
//执行业务逻辑
。。。。。
return null;
});还能不能更简便呢？当然！
3.注解实现分布式锁
其实锁工具类已经是核心功能代码了，用注解只是为了使用方便。就像很多底层sdk，都是有接口调用的方法来实现核心功能，然后再加个注解让使用更加简便。来想一想场景，我们的分布式锁很多时候都是加在最外层，也就是controller上，或者是service某个方法上。我们通常加锁需要的key，都是由入参组装的。那是不是可以用el表达式来组装key呢？
3.1 创建注解@RedissonLock
/**
* 分布式锁注解
*/
@Retention(RetentionPolicy.RUNTIME)//运行时生效
@Target(ElementType.METHOD)//作用在方法上
public @interface RedissonLock {
/**
* key的前缀,默认取方法全限定名，除非我们在不同方法上对同一个资源做分布式锁，就自己指定
*
* @return key的前缀
*/
String prefixKey() default "";
/**
* springEl 表达式
*
* @return 表达式
*/
String key();
/**
* 等待锁的时间，默认-1，不等待直接失败,redisson默认也是-1
*
* @return 单位秒
*/
int waitTime() default -1;
/**
* 等待锁的时间单位，默认毫秒
*
* @return 单位
*/
TimeUnit unit() default TimeUnit.MILLISECONDS;
}约定大于配置的思想，我们的大多数参数都是可以默认的。很多时候我们的锁都是针对方法的，要锁同一处地方，调用同一个方法就好了，这样前缀可以直接默认根据类+方法名来实现，同样针对特例我们也提供了自己指定前缀的入口。
3.2 实现切面RedissonLockAspect
切面其实很简单，构建key=前缀+el表达式，然后把参数都传进去，调用我们核心功能的工具类LockService。
@Slf4j
@Aspect
@Component
@Order(0)//确保比事务注解先执行，分布式锁在事务外
public class RedissonLockAspect {
@Autowired
private LockService lockService;
@Around("@annotation(com.abin.mallchat.common.common.annotation.RedissonLock)")
public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
Method method = ((MethodSignature) joinPoint.getSignature()).getMethod();
RedissonLock redissonLock = method.getAnnotation(RedissonLock.class);
String prefix = StrUtil.isBlank(redissonLock.prefixKey()) ? SpElUtils.getMethodKey(method) : redissonLock.prefixKey();//默认方法限定名+注解排名（可能多个）
String key = SpElUtils.parseSpEl(method, joinPoint.getArgs(), redissonLock.key());
return lockService.executeWithLockThrows(prefix + ":" + key, redissonLock.waitTime(), redissonLock.unit(), joinPoint::proceed);
}
}上述解析EL表达式需要定义以下解析类
import org.springframework.core.DefaultParameterNameDiscoverer;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;
import java.lang.reflect.Method;
import java.util.Optional;
/**
* Description: spring el表达式解析
*/
public class SpElUtils {
private static final ExpressionParser parser = new SpelExpressionParser();
private static final DefaultParameterNameDiscoverer parameterNameDiscoverer = new DefaultParameterNameDiscoverer();
public static String parseSpEl(Method method, Object[] args, String spEl) {
//解析参数名
String[] params = Optional.ofNullable(parameterNameDiscoverer.getParameterNames(method)).orElse(new String[]{});
EvaluationContext context = new StandardEvaluationContext();//el解析需要的上下文对象
for (int i = 0; i < params.length; i++) {
context.setVariable(params[i], args[i]);//所有参数都作为原材料扔进去
}
Expression expression = parser.parseExpression(spEl);
return expression.getValue(context, String.class);
}
public static String getMethodKey(Method method) {
return method.getDeclaringClass() + "#" + method.getName();
}
}3.3 使用
以mallchat项目为例，使用起来就非常方便了，发奖的时候，我们需要对uid加锁，直接一个注解搞定。如果需要等待，再加个等待时间就行。这里需要注意，分布式锁要在事务外层。所以我们锁的切面优先级要高一些。
@Service
public class UserBackpackServiceImpl implements IUserBackpackService {
@Autowired
private UserBackpackDao userBackpackDao;
@Autowired
private ItemCache itemCache;
@Autowired
private ApplicationEventPublisher applicationEventPublisher;
@Autowired
@Lazy
private UserBackpackServiceImpl userBackpackService;
@Override
public void acquireItem(Long uid, Long itemId, IdempotentEnum idempotentEnum, String businessId) {
//组装幂等号
String idempotent = getIdempotent(itemId, idempotentEnum, businessId);
userBackpackService.doAcquireItem(uid, itemId, idempotent);
}
@RedissonLock(key = "#idempotent", waitTime = 5000)//相同幂等如果同时发奖，需要排队等上一个执行完，取出之前数据返回
public void doAcquireItem(Long uid, Long itemId, String idempotent) {
UserBackpack userBackpack = userBackpackDao.getByIdp(idempotent);
//幂等检查
if (Objects.nonNull(userBackpack)) {
return;
}
//业务检查
ItemConfig itemConfig = itemCache.getById(itemId);
if (ItemTypeEnum.BADGE.getType().equals(itemConfig.getType())) {//徽章类型做唯一性检查
Integer countByValidItemId = userBackpackDao.getCountByValidItemId(uid, itemId);
if (countByValidItemId > 0) {//已经有徽章了不发
return;
}
}
//发物品
UserBackpack insert = UserBackpack.builder()
.uid(uid)
.itemId(itemId)
.status(YesOrNoEnum.NO.getStatus())
.idempotent(idempotent)
.build();
userBackpackDao.save(insert);
//用户收到物品的事件
applicationEventPublisher.publishEvent(new ItemReceiveEvent(this, insert));
}
private String getIdempotent(Long itemId, IdempotentEnum idempotentEnum, String businessId) {
return String.format("%d_%d_%s", itemId, idempotentEnum.getType(), businessId);
}
}
本文含有隐藏内容，请 开通VIP 后查看