Springboot分布式锁实践（redis）

springboot2本地锁实践一文中提到用Guava Cache实现锁机制，但在集群中就行不通了，所以我们还一般要借助类似Redis、ZooKeeper 之类的中间件实现分布式锁，下面我们将利用自定义注解、Spring Aop、Redis Cache 实现分布式锁。

项目代码结构整体图

一、导入依赖

在 pom.xml 中添加上 starter-web、starter-aop、starter-data-redis 的依赖

 <dependencies>

     <dependency>

         <groupId>org.springframework.boot</groupId>

         <artifactId>spring-boot-starter-web</artifactId>

     </dependency>

     <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>

 </dependencies>

二、属性配置

在 application.properites 资源文件中添加 redis 相关的配置项

spring.redis.host=192.168.68.110

spring.redis.port=6379

spring.redis.password=123456

三、注解

1、创建一个 CacheLock 注解，属性配置如下

prefix：缓存中 key 的前缀
expire：过期时间，此处默认为 5 秒
timeUnit：超时单位，此处默认为秒
delimiter： key 的分隔符，将不同参数值分割开来

 import java.lang.annotation.*;

 import java.util.concurrent.TimeUnit;

 /**

  * 锁的注解

  */

 @Target(ElementType.METHOD)

 @Retention(RetentionPolicy.RUNTIME)

 @Documented

 @Inherited

 public @interface CacheLock {

     /**

      * redis 锁key的前缀

      *

      * @return redis 锁key的前缀

      */

     String prefix() default "";

     /**

      * 过期秒数,默认为5秒

      *

      * @return 轮询锁的时间

      */

     int expire() default 5;

     /**

      * 超时时间单位

      *

      * @return 秒

      */

     TimeUnit timeUnit() default TimeUnit.SECONDS;

     /**

      * <p>Key的分隔符（默认 :）</p>

      * <p>生成的Key：N:SO1008:500</p>

      *

      * @return String

      */

     String delimiter() default ":";

 }

2、 key 的生成规则是自己定义的，如果通过表达式语法自己得去写解析规则还是比较麻烦的，所以依旧是用注解的方式

 import java.lang.annotation.*;

 /**

  * 锁的参数

  *

  */

 @Target({ElementType.PARAMETER, ElementType.METHOD, ElementType.FIELD})

 @Retention(RetentionPolicy.RUNTIME)

 @Documented

 @Inherited

 public @interface CacheParam {

     /**

      * 字段名称

      *

      * @return String

      */

     String name() default "";

 }

四、Key生成策略

1、接口

 import org.aspectj.lang.ProceedingJoinPoint;

 /**

  * key生成器

  */

 public interface CacheKeyGenerator {

     /**

      * 获取AOP参数,生成指定缓存Key

      *

      * @param pjp PJP

      * @return 缓存KEY

      */

     String getLockKey(ProceedingJoinPoint pjp);

 }

2、接口实现

import com.carry.annotation.CacheLock;

import com.carry.annotation.CacheParam;

import com.carry.common.CacheKeyGenerator;

import org.aspectj.lang.ProceedingJoinPoint;

import org.aspectj.lang.reflect.MethodSignature;

import org.springframework.util.ReflectionUtils;

import org.springframework.util.StringUtils;

import java.lang.annotation.Annotation;


import java.lang.reflect.Field;


import java.lang.reflect.Method;


import java.lang.reflect.Parameter;

/**
通过接口注入的方式去写不同的生成规则;


*/


public class LockKeyGenerator implements CacheKeyGenerator {

@Override


public String getLockKey(ProceedingJoinPoint pjp) {


MethodSignature signature = (MethodSignature) pjp.getSignature();


Method method = signature.getMethod();


CacheLock lockAnnotation = method.getAnnotation(CacheLock.class);


final Object[] args = pjp.getArgs();


final Parameter[] parameters = method.getParameters();


StringBuilder builder = new StringBuilder();


//默认解析方法里面带 CacheParam 注解的属性,如果没有尝试着解析实体对象中的


for (int i = 0; i < parameters.length; i++) {


final CacheParam annotation = parameters[i].getAnnotation(CacheParam.class);


if (annotation == null) {


continue;


}


builder.append(lockAnnotation.delimiter()).append(args[i]);


}


if (StringUtils.isEmpty(builder.toString())) {


final Annotation[][] parameterAnnotations = method.getParameterAnnotations();


for (int i = 0; i < parameterAnnotations.length; i++) {


final Object object = args[i];


final Field[] fields = object.getClass().getDeclaredFields();


for (Field field : fields) {


final CacheParam annotation = field.getAnnotation(CacheParam.class);


if (annotation == null) {


continue;


}


field.setAccessible(true);


builder.append(lockAnnotation.delimiter()).append(ReflectionUtils.getField(field, object));


}


}


}


return lockAnnotation.prefix() + builder.toString();


}


}

五、Lock拦截器（AOP）

熟悉 Redis 的朋友都知道它是线程安全的，我们利用它的特性可以很轻松的实现一个分布式锁，如 opsForValue().setIfAbsent(key,value)它的作用就是如果缓存中没有当前 Key 则进行缓存同时返回 true 反之亦然；当缓存后给 key 在设置个过期时间，防止因为系统崩溃而导致锁迟迟不释放形成死锁；那么我们是不是可以这样认为当返回 true 我们认为它获取到锁了，在锁未释放的时候我们进行异常的抛出….

 import com.carry.annotation.CacheLock;

 import com.carry.common.CacheKeyGenerator;

 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.beans.factory.annotation.Autowired;

 import org.springframework.context.annotation.Configuration;

 import org.springframework.data.redis.core.StringRedisTemplate;

 import org.springframework.util.StringUtils;

 import java.lang.reflect.Method;

 /**

  * redis 方案

  */

 @Aspect

 @Configuration

 public class LockMethodInterceptor {

     @Autowired

     public LockMethodInterceptor(StringRedisTemplate lockRedisTemplate, CacheKeyGenerator cacheKeyGenerator) {

         this.lockRedisTemplate = lockRedisTemplate;

         this.cacheKeyGenerator = cacheKeyGenerator;

     }

     private final StringRedisTemplate lockRedisTemplate;

     private final CacheKeyGenerator cacheKeyGenerator;

     @Around("execution(public * *(..)) && @annotation(com.carry.annotation.CacheLock)")

     public Object interceptor(ProceedingJoinPoint pjp) {

         MethodSignature signature = (MethodSignature) pjp.getSignature();

         Method method = signature.getMethod();

         CacheLock lock = method.getAnnotation(CacheLock.class);

         if (StringUtils.isEmpty(lock.prefix())) {

             throw new RuntimeException("lock key can't be null...");

         }

         final String lockKey = cacheKeyGenerator.getLockKey(pjp);

         try {

             //key不存在才能设置成功

             final Boolean success = lockRedisTemplate.opsForValue().setIfAbsent(lockKey, "");

             if (success) {

                 lockRedisTemplate.expire(lockKey, lock.expire(), lock.timeUnit());

             } else {

                 //按理来说 我们应该抛出一个自定义的 CacheLockException 异常;

                 throw new RuntimeException("请勿重复请求");

             }

             try {

                 return pjp.proceed();

             } catch (Throwable throwable) {

                 throw new RuntimeException("系统异常");

             }

         } finally {

             //如果演示的话需要注释该代码;实际应该放开

             // lockRedisTemplate.delete(lockKey);

         }

     }

 }

六、控制层

在接口方法上添加 @CacheLock(prefix = "test")，然后动态的值可以加上@CacheParam；生成后的新 key 将被缓存起来；（如：该接口 token = 1，那么最终的 key 值为 test:1，如果多个条件则依次类推）

 import com.carry.annotation.CacheLock;

 import com.carry.annotation.CacheParam;

 import org.springframework.web.bind.annotation.GetMapping;

 import org.springframework.web.bind.annotation.RequestParam;

 import org.springframework.web.bind.annotation.RestController;

 @RestController

 public class LockController {

     @CacheLock(prefix = "test")

     @GetMapping("/test")

     public String query(@CacheParam(name = "token") @RequestParam String token) {

         return "success - " + token;

     }

 }

七、主函数

需要注入前面定义好的 CacheKeyGenerator 接口具体实现…

 import com.carry.common.CacheKeyGenerator;

 import com.carry.common.LockKeyGenerator;

 import org.springframework.boot.SpringApplication;

 import org.springframework.boot.autoconfigure.SpringBootApplication;

 import org.springframework.context.annotation.Bean;

 @SpringBootApplication

 public class SpringbootCacheRedislockApplication {

     public static void main(String[] args) {

         SpringApplication.run(SpringbootCacheRedislockApplication.class, args);

     }

     @Bean

     public CacheKeyGenerator cacheKeyGenerator() {

         return new LockKeyGenerator();

     }

 }

八、测试

启动项目，在postman中输入url：localhost:8080/test?token=1

第一次请求结果：

第二次请求结果：

等key过期了请求又恢复正常。