Springboot分布式锁实践(redis)
springboot2本地锁实践一文中提到用Guava Cache实现锁机制,但在集群中就行不通了,所以我们还一般要借助类似Redis、ZooKeeper 之类的中间件实现分布式锁,下面我们将利用自定义注解
、Spring Aop
、Redis Cache
实现分布式锁。
项目代码结构整体图
一、导入依赖
在 pom.xml
中添加上 starter-web
、starter-aop
、starter-data-redis
的依赖
1 <dependencies> 2 <dependency> 3 <groupId>org.springframework.boot</groupId> 4 <artifactId>spring-boot-starter-web</artifactId> 5 </dependency> 6 <dependency> 7 <groupId>org.springframework.boot</groupId> 8 <artifactId>spring-boot-starter-aop</artifactId> 9 </dependency> 10 <dependency> 11 <groupId>org.springframework.boot</groupId> 12 <artifactId>spring-boot-starter-data-redis</artifactId> 13 </dependency> 14 </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 的分隔符,将不同参数值分割开来
1 import java.lang.annotation.*; 2 import java.util.concurrent.TimeUnit; 3 4 /** 5 * 锁的注解 6 */ 7 @Target(ElementType.METHOD) 8 @Retention(RetentionPolicy.RUNTIME) 9 @Documented 10 @Inherited 11 public @interface CacheLock { 12 13 /** 14 * redis 锁key的前缀 15 * 16 * @return redis 锁key的前缀 17 */ 18 String prefix() default ""; 19 20 /** 21 * 过期秒数,默认为5秒 22 * 23 * @return 轮询锁的时间 24 */ 25 int expire() default 5; 26 27 /** 28 * 超时时间单位 29 * 30 * @return 秒 31 */ 32 TimeUnit timeUnit() default TimeUnit.SECONDS; 33 34 /** 35 * <p>Key的分隔符(默认 :)</p> 36 * <p>生成的Key:N:SO1008:500</p> 37 * 38 * @return String 39 */ 40 String delimiter() default ":"; 41 }
2、 key 的生成规则是自己定义的,如果通过表达式语法自己得去写解析规则还是比较麻烦的,所以依旧是用注解的方式
1 import java.lang.annotation.*; 2 3 /** 4 * 锁的参数 5 * 6 */ 7 @Target({ElementType.PARAMETER, ElementType.METHOD, ElementType.FIELD}) 8 @Retention(RetentionPolicy.RUNTIME) 9 @Documented 10 @Inherited 11 public @interface CacheParam { 12 13 /** 14 * 字段名称 15 * 16 * @return String 17 */ 18 String name() default ""; 19 }
四、Key生成策略
1、接口
1 import org.aspectj.lang.ProceedingJoinPoint; 2 3 /** 4 * key生成器 5 */ 6 public interface CacheKeyGenerator { 7 8 /** 9 * 获取AOP参数,生成指定缓存Key 10 * 11 * @param pjp PJP 12 * @return 缓存KEY 13 */ 14 String getLockKey(ProceedingJoinPoint pjp); 15 }
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
我们认为它获取到锁了,在锁未释放的时候我们进行异常的抛出….
1 import com.carry.annotation.CacheLock; 2 import com.carry.common.CacheKeyGenerator; 3 import org.aspectj.lang.ProceedingJoinPoint; 4 import org.aspectj.lang.annotation.Around; 5 import org.aspectj.lang.annotation.Aspect; 6 import org.aspectj.lang.reflect.MethodSignature; 7 import org.springframework.beans.factory.annotation.Autowired; 8 import org.springframework.context.annotation.Configuration; 9 import org.springframework.data.redis.core.StringRedisTemplate; 10 import org.springframework.util.StringUtils; 11 12 import java.lang.reflect.Method; 13 14 /** 15 * redis 方案 16 */ 17 @Aspect 18 @Configuration 19 public class LockMethodInterceptor { 20 21 @Autowired 22 public LockMethodInterceptor(StringRedisTemplate lockRedisTemplate, CacheKeyGenerator cacheKeyGenerator) { 23 this.lockRedisTemplate = lockRedisTemplate; 24 this.cacheKeyGenerator = cacheKeyGenerator; 25 } 26 27 private final StringRedisTemplate lockRedisTemplate; 28 private final CacheKeyGenerator cacheKeyGenerator; 29 30 31 @Around("execution(public * *(..)) && @annotation(com.carry.annotation.CacheLock)") 32 public Object interceptor(ProceedingJoinPoint pjp) { 33 MethodSignature signature = (MethodSignature) pjp.getSignature(); 34 Method method = signature.getMethod(); 35 CacheLock lock = method.getAnnotation(CacheLock.class); 36 if (StringUtils.isEmpty(lock.prefix())) { 37 throw new RuntimeException("lock key can't be null..."); 38 } 39 final String lockKey = cacheKeyGenerator.getLockKey(pjp); 40 try { 41 //key不存在才能设置成功 42 final Boolean success = lockRedisTemplate.opsForValue().setIfAbsent(lockKey, ""); 43 if (success) { 44 lockRedisTemplate.expire(lockKey, lock.expire(), lock.timeUnit()); 45 } else { 46 //按理来说 我们应该抛出一个自定义的 CacheLockException 异常; 47 throw new RuntimeException("请勿重复请求"); 48 } 49 try { 50 return pjp.proceed(); 51 } catch (Throwable throwable) { 52 throw new RuntimeException("系统异常"); 53 } 54 } finally { 55 //如果演示的话需要注释该代码;实际应该放开 56 // lockRedisTemplate.delete(lockKey); 57 } 58 } 59 }
六、控制层
在接口方法上添加 @CacheLock(prefix = "test")
,然后动态的值可以加上@CacheParam
;生成后的新 key 将被缓存起来;(如:该接口 token = 1,那么最终的 key 值为 test:1,如果多个条件则依次类推)
1 import com.carry.annotation.CacheLock; 2 import com.carry.annotation.CacheParam; 3 import org.springframework.web.bind.annotation.GetMapping; 4 import org.springframework.web.bind.annotation.RequestParam; 5 import org.springframework.web.bind.annotation.RestController; 6 7 @RestController 8 public class LockController { 9 10 @CacheLock(prefix = "test") 11 @GetMapping("/test") 12 public String query(@CacheParam(name = "token") @RequestParam String token) { 13 return "success - " + token; 14 } 15 16 }
七、主函数
需要注入前面定义好的 CacheKeyGenerator
接口具体实现…
1 import com.carry.common.CacheKeyGenerator; 2 import com.carry.common.LockKeyGenerator; 3 import org.springframework.boot.SpringApplication; 4 import org.springframework.boot.autoconfigure.SpringBootApplication; 5 import org.springframework.context.annotation.Bean; 6 7 @SpringBootApplication 8 public class SpringbootCacheRedislockApplication { 9 10 public static void main(String[] args) { 11 SpringApplication.run(SpringbootCacheRedislockApplication.class, args); 12 } 13 14 @Bean 15 public CacheKeyGenerator cacheKeyGenerator() { 16 return new LockKeyGenerator(); 17 } 18 }
八、测试
启动项目,在postman中输入url:localhost:8080/test?token=1
第一次请求结果:
第二次请求结果:
等key过期了请求又恢复正常。