分布式锁在Spring Boot应用中的实现过程

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;
 
    /**
     * 超时时间单位(默认秒)
     *
     * @return 超时时间单位
     */
    TimeUnit leaseTimeTimeUnit() default TimeUnit.SECONDS;
 
    /**
     * 等待时间单位(默认秒)
     *
     * @return 等待时间单位
     */
    TimeUnit waitTimeTimeUnit() default TimeUnit.SECONDS;
 
}

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 Object 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;
    }
 
}

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 未获取到锁执行
     */
    public 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 != leaseTimeMs && 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 redissonClient;
    }
 
}

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);
    }
}