自定义注解+RedisLockRegistry实现注解加锁解决并发问题

一、引入依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.integration</groupId>
    <artifactId>spring-integration-redis</artifactId>
</dependency>

二、 定义注解

package com.example.projecttest2.baseInterface;

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

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyLock {


    /**
     * 锁的名称
     * @return
     */
    String lockName() default "";

}

三、配置RedisLockRegistry

package com.example.projecttest2.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.integration.redis.util.RedisLockRegistry;

@Configuration
public class RedisLockConfig {

    @Bean
    public RedisLockRegistry redisLockRegistry(RedisConnectionFactory redisConnectionFactory) {
        return new RedisLockRegistry(redisConnectionFactory, "my-lock",180000L);
    }
}

四、定义切面

package com.example.projecttest2.aop;

import com.example.projecttest2.baseInterface.MyLock;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.integration.redis.util.RedisLockRegistry;
import org.springframework.stereotype.Component;
import org.aspectj.lang.reflect.MethodSignature;

import java.lang.reflect.Method;
import java.util.concurrent.locks.Lock;

@Aspect
@Component
@Slf4j
public class LockAspect {
    

    @Autowired
    private RedisLockRegistry redisLockRegistry;

    /**
     * 声明切入点
     */
    @Pointcut("@annotation(com.example.projecttest2.baseInterface.MyLock)")
    public void pointcutExecute() {
    }

    @Around("pointcutExecute()")
    public Object pointAround(ProceedingJoinPoint joinPoint) {
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        Method method = methodSignature.getMethod();
        MyLock lockAnnotation = method.getAnnotation(MyLock.class);
        String methodDict = method.getDeclaringClass() + "." + method.getName();
        String lockName = null == lockAnnotation.lockName() ? methodDict : lockAnnotation.lockName();
        //加锁
        Lock lock = redisLockRegistry.obtain(lockName);
        lock.lock();
        try {
            log.info("获取redis锁");
            Object result = joinPoint.proceed();
            return result;
        } catch (Throwable e) {
            log.error("redis加锁方法{}执行异常：{}", methodDict, e);
        } finally {
            log.info("释放redis锁");
            lock.unlock();
        }
        return null;
    }

}

五、测试

@Override
@MyLock(lockName = "testLock")
public String testLock() throws InterruptedException {
   log.info("redis锁开始");
   //睡眠30s
    Thread.sleep(30000);
    log.info("睡眠结束");
    return ""+new Date();
}