前言：要是想对某个接口进行加锁操作，每次在方法前加锁，方法结束释放锁会显得很麻烦，这里可以基于AOP的环绕通知@Around实现功能。

1、基于RedisTemplate实现封装分布式锁

RedisTemplate实现setnx分布式锁https://blog.csdn.net/qq_39648029/article/details/124926230

2、自定义注解

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @program: zy-common
 * @description: 分布式锁注解,方法注解
 * @author: zhangyi
 * @create: 2022-05-10 16:17
 */
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface ZyLock {

    /**
     * 锁的key
     *
     * @return
     */
    String value();

}

3、aop实现

package com.zyweb.admin.aop.lock;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.zy.base.utils.RedisUtil;
import com.zy.base.vo.ResponseVo;
import com.zyweb.admin.aop.dict.Dict;
import com.zyweb.admin.service.impl.DictServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * @program: zy-common
 * @description: 字典切面
 * @author: zhangyi
 * @create: 2022-05-10 16:33
 */
@Aspect
@Component
@Slf4j
public class ZyLockAop {

    @Autowired
    private RedisUtil redisUtil;

    /**
     * 切点，切入 controller 包下面的所有方法
     */
    @Pointcut("execution( * com.zyweb.admin.controller.*.*(..))")
    public void zyLock() {
    }

    @Around("zyLock()")
    public Object AroundLock(ProceedingJoinPoint joinPoint) throws Throwable {
        //获取自定义注解 @ZyLock
        Signature signature = joinPoint.getSignature();
        MethodSignature methodSignature = (MethodSignature) signature;
        Method method = methodSignature.getMethod();
        ZyLock zyLock = method.getAnnotation(ZyLock.class);
        if (zyLock != null) {
            //得到注解值
            String key = zyLock.value();

            //得到获取参数000
            Object[] args = joinPoint.getArgs();
            String[] parameterNames = methodSignature.getParameterNames();
            //最后加密的key

            // 判断是否是动态值,动态值前缀是#
            if (key.startsWith("#")) {
                //取出#号后面的数据
                String substring = key.substring(1);
                //根据.进行拆分,如果拆分后只有一个值,则表示单个参数,否则表示对象
                String[] split = substring.split("\\.");
                //第0个数据,表示参数名,找到他的索引,索引表示args的参数值
                int i = getIndex(parameterNames, split[0]);
                if (i < 0) {
                    return ResponseVo.error("@ZyLock注解解析失败");
                }
                //找到要取的那个参数了
                Object arg = args[i];
                //判断是否是对象
                if(isObject(arg)){
                    String[] ofRange = Arrays.copyOfRange(split, 1, split.length);
                    key = getVal((JSONObject)arg, ofRange);
                }else{
                    key=arg.toString();
                }
            }
            //获取锁,10秒过期
            boolean nx = redisUtil.setNx(key, 10);
            //如果没有拿到锁,表示该锁被占用
            if (!nx) {
                return ResponseVo.error("锁获取失败,请重新发起请求");
            }
            //环绕通知,执行目标方法
            Object proceed = joinPoint.proceed();

            //释放锁
            redisUtil.del(key);
            return proceed;
        } else {
            return joinPoint.proceed();
        }
    }

    //找出对象中改层级下的值
    public String getVal(JSONObject obj, String[] split) {
        for (String s : split) {
            Object o = obj.get(s);
            if(o==null){
                return "";
            }
            //表示json字符串,则还需要转换
            if (o instanceof String) {
                return o.toString();
            } else {
                JSONObject jo = JSONObject.parseObject(JSON.toJSONString(o));
                return getVal(jo, Arrays.copyOfRange(split, 1, split.length));
            }
        }
        return "";
    }

    public int getIndex(String[] arr, String val) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i].equals(val)) {
                return i;
            }
        }
        return -1;
    }

    // 判断参数是不是JSON对象
    public boolean isObject(Object obj) {
       try{
           JSONObject.parseObject(JSON.toJSONString(obj));
           return true;
       }catch (Exception e){
           return false;
       }
    }
}

4、使用栗子

我这里做了注解的动态值操作，具体值从方法参数里获取，参数可以是基本数据类型，可以是对象，也可以是对象套对象套对象(套娃)
动态值：最前面使用"#"开头，然后进行对象.属性的方式
普通值：直接填

1、请求为单个参数

    @GetMapping("/fbssTest3")
    @ZyLock("#id")//这里取的是参数名叫做"id"的值
    public ResponseVo fbssTest3(Integer id,String name) throws InterruptedException {
        System.out.println("我是方法内容1");
        Thread.sleep(1000*2);
        return ResponseVo.success("执行完成");
    }

2、请求参数为普通的json对象

    @PostMapping("/fbssTest2")
    @ZyLock("#obj.key")//这里获取的是参数名叫obj这个对象里面属性名为key的值
    public ResponseVo fbssTest2(@RequestBody JSONObject obj) throws InterruptedException {
        System.out.println("我是方法内容1");
        Thread.sleep(1000*2);
        return ResponseVo.success("执行完成");
    }

3、请求参数为套娃对象

@PostMapping("/fbssTest")
@ZyLock("#obj.obj1.obj2.obj3.key")//套娃对象
public ResponseVo fbssTest(@RequestBody JSONObject obj) throws InterruptedException {
    System.out.println("我是方法内容1");
    Thread.sleep(1000*2);
    return ResponseVo.success("执行完成");
}

 4、代码内容加了2秒的休眠操作，模拟执行时间，进行并发访问