目录
- Lock注解
- LockASPect切面
- RedisLockUtils工具类
- 总结
在现代微服务架构中，分布式锁是一种常用的技术手段，用于确保在分布式系统中，同一时间只有一个服务实例能够执行某个特定的操作。
这对于防止并发问题、保证数据一致性至关重要。在Spring Boot应用中，我们可以通过自定义注解和切面的方式，来实现一个既简洁又强大的分布式锁机制。
Lock注解
首先，我们定义一个Lock注解，用于标记需要加锁的方法。这个注解包含了锁的键值、超时时间和等待时间等信息。
import Java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.util.concurrent.TimeUnit;
/**
* @author tangzx
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Lock {
/**
* 锁的键值
*
* @return 锁的键值
*/
String value() default "";
/**
* 锁的键值
*
* @return 锁的键值
*/
String key() default "";
/**
* 超时时间
*
* @return 超时时间
*/
long leaseTime() default 30L;
/**
* 等待时间
*
* @return 等待时间
*/
long waitTime() default 0L;
/**
* 超时时间单http://www.devze.com位(默认秒)
*
* @return 超时时间单位
*/
TimeUnit leaseTimeTimeUnit() default TimeUnit.SECONDS;
/**
* 等待时间单位(默认秒)
*
* @return 等待时间单位
*/
TimeUnit waitTimeTimeUnit() default TimeUnit.SECONDS;
}
LockAspect切面
接下来，我们创建一个LockAspect切面类，用于处理Lock注解。
这个切面会在方法执行前尝试获取锁，如果获取成功，则执行方法体；如果获取失败，则执行相应的失败逻辑。
import com.lock.core.exception.AppException;
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.reflect.MethodSignature;
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 org.springframework.stereotype.Component;
import java.util.concurrent.atomic.AtomicReference;
/**
* @author tangzx
*/
@Slf4j
@Aspect
@Component
public class LockAspect {
@Around("@annotation(lock)")
public Objecjst around(ProceedingJoinPoint joinPoint, Lock lock) throws Throwable {
String value = lock.value();
String key = lock.key();
long leaseTimeMs = lock.leaseTimeTimeUnit().toMillis(lock.leaseTime());
long waitTimeMs = lock.waitTimeTimeUnit().toMillis(lock.waitTime());
String lockKey = resolveLockKey(value, key, joinPoint);
AtomicReference<Object> result = new AtomicReference<>(null);
AtomicReference<Throwable> throwable = new AtomicReference<>(null);
RedisUtils.LockOps.execute(lockKey, leaseTimeMs, waitTimeMs, () -> {
try {
result.set(joinPoint.proceed());
} catch (Throwable t) {
throwable.set(t);
}
}, () -> {
AppLogger.append("未获取到Lock锁[{}]", lockKey);
throw new AppException("正在处理中，请稍后再试");
});
if (null != throwable.get()) {
throw throwable.get();
}
return result.get();
}
public String resolveLockKey(String lockName, String key, ProceedingJoinPoint joinPoint) {
MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
String[] parameterNames = methodSignature.getParameterNames();
Object[] args = joinPoint.getArgs();
ExpressionParser parser = new SpelExpressionParser();
Expression expression = parser.parseExpression(key);
StandardEvaluationContext context = new StandardEvaluationContext();
for (int i = 0; i < args.length; i++) {
context.setVariable(parameterNames[i], args[i]);
}
String value = expression.getValue(context, String.class);
if (StringUtils.isNotBlank(value)) {
return lockName + ":" + value;
}
if (log.isWarnEnabled()) {
log.warn("lockName={},根据规则[key={}],未在参数中获取到对应的值,默认使用lockName作为key", lockName, key);
}
return lockName;
}
}
RedisLockUtils工具类
最后，我们实现一个RedisLockUtils工具类，用于与Redis交互，实现锁的获取和释放。
这个类会使用Redisson客户端来简化分布式锁的操作。
import com.redis.utils.ServiceLocator;
import lombok.extern.slf4j.Slf4j;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import java.util.Optional;
import java.util.concurrent.TimeUnit;
/**
* @author ：Tzx
* @date ：Created in 2021/8/2 18:09
* @description： redis锁
* @version: 1.0
*/
@Slf4j
public class RedisLockUtils {
private final static String REDIS_LOCK_HANDLER_PREFIX = RedisLockUtils.class.getSimpleName().toLowerCase() + ":";
private static volatile RedissonClient redissonClient;
/**
* 获取分布式锁执行
*
* @param redisKey redisKey
* @param codeToExecute 获取锁执行
*/
public static void execute(String redisKey, Runnable codeToExecute) {
execute(redisKey, null, null, codeToExecute, null);
}
/**
* 获取分布式锁执行
*
* @param redisKey redisKey
* @param codeToExecute 获取锁执行
* @param codeIfLockNotAcquired 未获取到锁执行
*/
puphpblic static void execute(String redisKey, Runnable codeToExecute, Runnable codeIfLockNotAcquired) {
execute(redisKey, null, null, codeToExecute, codeIfLockNotAcquired);
}
/**
* 获取分布式锁执行
*
* @param key redisKey
* @param leaseTimeMs 锁超时时间
* @param waitTimeMs 获取锁等待时间
* @param codeToExecute 获取锁执行
* @param codeIfLockNotAcquired 未获取到锁执行
*/
public static void execute(String key, Long leaseTimeMs, Long waitTimeMs, Runnable codeToExecute, Runnable codeIfLockNotAcquired) {
waitTimeMs = Optional.ofNullable(waitTimeMs).orElse(0L);
String lockKey = REDIS_LOCK_HANDLER_PREFIX + key;
RLock lock = getRedissonClient().getLock(lockKey);
boolean tryLock = false;
try {
if (null != leandroidaseTimeMs && leaseTimeMs > 0L) {
tryLock = lock.tryLock(waitTimeMs, leaseTimeMs, TimeUnit.MILLISECONDS);
} else {
tryLock = lock.tryLock(waitTimeMs, TimeUnit.MILLISECONDS);
}
} catch (InterruptedException interruptedException) {
log.warn("获取锁异常", interruptedException);
Thread.currentThread().interrupt();
}
if (tryLock) {
try {
codeToExecute.run();
return;
} finally {
if (lock.isHeldByCurrentThread()) {
lock.unlock();
}
}
}
if (log.isDebugEnabled()) {
log.debug("未获取到锁[{}]", key);
}
Optional.ofNullable(codeIfLockNotAcquired).ifPresent(Runnable::run);
}
private static RedissonClient getRedissonClient() {
if (null == redissonClient) {
synchronized (RedisLockUtils.class) {
if (null == redissonClient) {
redissonClient = ServiceLocator.getService(RedissonClient.class);
}
}
}
return redissonClientphp;
}
}
下面是一个使用Lock注解的示例，展示了如何在Spring Boot应用中实现分布式锁。
假设我们有一个OrderService服务，其中包含一个方法createOrder，这个方法需要保证在多服务实例中同时只有一个能够被执行，以防止创建重复的订单。
import org.springframework.stereotype.Service;
@Service
public class OrderService {
@Lock(value = "order", key = "#orderId", leaseTime = 10, waitTime = 5)
public void createOrder(String orderId) {
// 业务逻辑，比如创建订单、保存订单等
System.out.println("Creating order: " + orderId);
}
}
在这个示例中，createOrder方法使用了Lock注解。当这个方法被调用时，LockAspect切面会拦截这个调用，并尝试获取一个分布式锁。锁的键值是由key属性的SpEL表达式计算得出的，这里使用了方法的参数orderId。leaseTime和waitTime分别设置了锁的超时时间和等待时间。
当多个服务实例尝试同时创建同一个订单时，由于分布式锁的存在，只有一个实例能够成功执行createOrder方法，其他实例将会在等待一段时间后失败，或者执行Lock注解中定义的失败逻辑。
这种使用注解的方式，使得分布式锁的集成变得非常简单和直观。开发者不需要关心锁的具体实现细节，只需要在需要加锁的方法上添加Lock注解，并设置相应的参数即可。
通过这三个组件，我们可以在Spring Boot应用中非常优雅地实现分布式锁。Lock注解提供了一种声明式的方式，让开发者可以轻松地为方法添加分布式锁。LockAspect切面确保了锁的逻辑在方法执行前后被正确地处理。而RedisLockUtils工具类则负责与Redis交互，确保锁的原子性和一致性。
在实现这些组件时，我们还需要注意一些细节，比如如何处理锁的键值解析、如何处理锁获取失败的情况、如何确保锁的释放等。
总结
以上为个人经验，希望能给大家一个参考，也希望大家多多支持编程客栈(www.devze.com)。
加载中,请稍侯......
精彩评论