import java.lang.annotation.*;
import java.util.concurrent.TimeUnit;
/**
 * 自定義鎖注解（本地鎖）
 * 用于標(biāo)記需要加鎖的方法，解決單實(shí)例并發(fā)問(wèn)題
 */
@Target(ElementType.METHOD) // 僅作用于方法
@Retention(RetentionPolicy.RUNTIME) // 運(yùn)行時(shí)生效
@Documented
public @interface Lock {
    /**
     * 鎖的唯一標(biāo)識(shí)（支持SpEL表達(dá)式，如 "#userId"）
     * 為空時(shí)默認(rèn)使用「類名.方法名」作為鎖標(biāo)識(shí)
     */
    String key() default "";
    /**
     * 加鎖超時(shí)時(shí)間（默認(rèn)5秒）
     * 超時(shí)未獲取鎖則拋出異常，避免線程阻塞
     */
    long waitTime() default 5;
    /**
     * 鎖的自動(dòng)釋放時(shí)間（默認(rèn)30秒）
     * 防止死鎖（ReentrantLock本身不會(huì)死鎖，但超時(shí)釋放更安全）
     */
    long leaseTime() default 30;
    /**
     * 時(shí)間單位（默認(rèn)秒）
     */
    TimeUnit timeUnit() default TimeUnit.SECONDS;
}

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.core.DefaultParameterNameDiscoverer;
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.lang.reflect.Method;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
 * @Lock注解的切面實(shí)現(xiàn)（本地鎖）
 */
@Aspect // 標(biāo)記為AOP切面
@Component // 交給Spring容器管理
public class LocalLockAspect {
    // 緩存鎖實(shí)例：key=鎖標(biāo)識(shí)，value=ReentrantLock對(duì)象（ConcurrentHashMap保證線程安全）
    private final Map<String, Lock> lockCache = new ConcurrentHashMap<>();
    // SpEL表達(dá)式解析器（解析注解中的key參數(shù)）
    private final ExpressionParser spelParser = new SpelExpressionParser();
    // 參數(shù)名解析器（獲取方法參數(shù)名，用于SpEL解析）
    private final DefaultParameterNameDiscoverer parameterNameDiscoverer = new DefaultParameterNameDiscoverer();
    /**
     * 環(huán)繞通知：攔截所有標(biāo)注了@Lock的方法
     */
    @Around("@annotation(lock)")
    public Object around(ProceedingJoinPoint joinPoint, Lock lock) throws Throwable {
        // 1. 解析鎖的唯一標(biāo)識(shí)（key）
        String lockKey = resolveLockKey(joinPoint, lock);
        // 2. 獲取或創(chuàng)建鎖（不存在則新建，存在則復(fù)用）
        Lock reentrantLock = lockCache.computeIfAbsent(lockKey, k -> new ReentrantLock());
        // 3. 加鎖（支持超時(shí)等待，避免線程無(wú)限阻塞）
        boolean locked = false;
        try {
            locked = ((java.util.concurrent.locks.Lock) reentrantLock).tryLock(
                    lock.waitTime(),
                    lock.leaseTime(),
                    lock.timeUnit()
            );
            if (!locked) {
                throw new RuntimeException("獲取鎖失敗，請(qǐng)稍后重試");
            }
            // 4. 執(zhí)行原方法（核心業(yè)務(wù)邏輯）
            return joinPoint.proceed();
        } finally {
            // 5. 釋放鎖（僅當(dāng)前線程持有鎖時(shí)釋放，避免誤釋放）
            if (locked && reentrantLock.isHeldByCurrentThread()) {
                reentrantLock.unlock();
            }
        }
    }
    /**
     * 解析@Lock注解中的key（支持SpEL表達(dá)式）
     */
    private String resolveLockKey(ProceedingJoinPoint joinPoint, Lock lock) {
        // 如果注解key為空，默認(rèn)使用「類名.方法名」作為鎖標(biāo)識(shí)
        if (lock.key().isEmpty()) {
            return joinPoint.getTarget().getClass().getName() + "." + joinPoint.getSignature().getName();
        }
        // 解析SpEL表達(dá)式（如 "#userId" 解析為實(shí)際的用戶ID）
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        String[] paramNames = parameterNameDiscoverer.getParameterNames(method);
        Object[] args = joinPoint.getArgs();
        StandardEvaluationContext context = new StandardEvaluationContext();
        for (int i = 0; i < paramNames.length; i++) {
            context.setVariable(paramNames[i], args[i]);
        }
        return spelParser.parseExpression(lock.key()).getValue(context, String.class);
    }
}

import org.springframework.stereotype.Service;
@Service
public class StockService {
    // 共享資源：模擬庫(kù)存（多線程競(jìng)爭(zhēng)的核心）
    private int stock = 100;
    /**
     * 扣減庫(kù)存（并發(fā)場(chǎng)景）
     * @param productId 商品ID（按商品ID加鎖，不同商品不互斥，提高并發(fā)效率）
     * @param num 扣減數(shù)量
     */
    @Lock(key = "'stock:' + #productId") // SpEL表達(dá)式：鎖標(biāo)識(shí)為 "stock:商品ID"
    public void deductStock(Long productId, int num) {
        if (stock >= num) {
            // 模擬耗時(shí)操作（如數(shù)據(jù)庫(kù)查詢/更新）
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            stock -= num;
            System.out.printf("商品%s扣減庫(kù)存%d，剩余庫(kù)存：%d%n", productId, num, stock);
        } else {
            throw new RuntimeException("商品" + productId + "庫(kù)存不足");
        }
    }
    // 獲取庫(kù)存（測(cè)試用）
    public int getStock() {
        return stock;
    }
}

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class LockTest {
    public static void main(String[] args) {
        // 初始化Spring容器（掃描注解所在包）
        AnnotationConfigApplicationContext context =
                new AnnotationConfigApplicationContext("com.example");
        StockService stockService = context.getBean(StockService.class);
        // 模擬10個(gè)線程并發(fā)扣減同一商品（productId=1）的庫(kù)存（每個(gè)扣10）
        for (int i = 0; i < 10; i++) {
            new Thread(() -> stockService.deductStock(1L, 10)).start();
        }
    }
}

<!-- Redisson：Redis分布式鎖的最佳實(shí)踐 -->
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.23.3</version>
</dependency>

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.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.DefaultParameterNameDiscoverer;
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.lang.reflect.Method;
/**
 * @Lock注解的切面實(shí)現(xiàn)（分布式鎖）
 */
@Aspect
@Component
public class DistributedLockAspect {
    @Autowired
    private RedissonClient redissonClient; // 注入Redisson客戶端（SpringBoot自動(dòng)配置）
    private final ExpressionParser spelParser = new SpelExpressionParser();
    private final DefaultParameterNameDiscoverer parameterNameDiscoverer = new DefaultParameterNameDiscoverer();
    @Around("@annotation(lock)")
    public Object around(ProceedingJoinPoint joinPoint, Lock lock) throws Throwable {
        // 1. 解析鎖標(biāo)識(shí)
        String lockKey = resolveLockKey(joinPoint, lock);
        // 2. 獲取分布式鎖
        RLock redissonLock = redissonClient.getLock(lockKey);
        // 3. 加鎖
        boolean locked = false;
        try {
            locked = redissonLock.tryLock(
                    lock.waitTime(),
                    lock.leaseTime(),
                    lock.timeUnit()
            );
            if (!locked) {
                throw new RuntimeException("獲取分布式鎖失敗，請(qǐng)稍后重試");
            }
            // 4. 執(zhí)行業(yè)務(wù)方法
            return joinPoint.proceed();
        } finally {
            // 5. 釋放鎖（僅當(dāng)前線程持有鎖時(shí)釋放）
            if (locked && redissonLock.isHeldByCurrentThread()) {
                redissonLock.unlock();
            }
        }
    }
    // 復(fù)用之前的resolveLockKey方法（解析SpEL）
    private String resolveLockKey(ProceedingJoinPoint joinPoint, Lock lock) {
        if (lock.key().isEmpty()) {
            return joinPoint.getTarget().getClass().getName() + "." + joinPoint.getSignature().getName();
        }
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        String[] paramNames = parameterNameDiscoverer.getParameterNames(method);
        Object[] args = joinPoint.getArgs();
        StandardEvaluationContext context = new StandardEvaluationContext();
        for (int i = 0; i < paramNames.length; i++) {
            context.setVariable(paramNames[i], args[i]);
        }
        return spelParser.parseExpression(lock.key()).getValue(context, String.class);
    }
}

@Service
public class OrderService {
    /**
     * 提交訂單（分布式并發(fā)場(chǎng)景）
     * @param orderId 訂單ID（按訂單ID加鎖，不同訂單不互斥）
     */
    @Lock(key = "'order:' + #orderId", leaseTime = 10) // 鎖過(guò)期時(shí)間10秒
    public void submitOrder(String orderId) {
        // 分布式并發(fā)操作：扣減庫(kù)存、生成訂單記錄
        System.out.println("訂單" + orderId + "提交成功");
    }
}