搜搜吧

查看: 564|回复: 0

Springboot2.x AOP 实现缓存锁,分布式锁

[复制链接]

超级钻石贵宾会员

1万

主题

2万

帖子

3万

搜搜币

Rank: 1

UID
15343
威望
-561
在线时间
393 小时
注册时间
2015-10-12
发表于 2021-7-13 14:58:40 | 显示全部楼层 |阅读模式


Springboot2.x AOP 实现 缓存锁, 分布式锁 防止重复提交

本人深根后台系统多年的经验;用户在网络不好情况下; 在做表单提交时;会出现重复提交的情况;故而我们需要:做到防止表单重提

google的guave cache
  • <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>com.google.guava</groupId>
  •     <artifactId>guava</artifactId>
  •     <version>21.0</version>
  • </dependency>
注解接口
  • package com.ouyue.xiwenapi.annotation;
  • import java.lang.annotation.*;
  • /**
  • * @ClassName:${}
  • * @Description:TODO
  • * @author:xx@163.com
  • * @Date:
  • */
  • @Target(ElementType.METHOD)
  • @Retention(RetentionPolicy.RUNTIME)
  • @Documented
  • @Inherited
  • public @interface GuaveLock
  • {
  •     String key() default "";
  •     /**
  •      * 过期时间 TODO 由于用的 guava 暂时就忽略这属性吧 集成 redis 需要用到
  •      *
  •      * @author fly
  •      */
  •     int expire() default 5;
  • }
AOP的运用
  • package com.ouyue.xiwenapi.config;
  • import com.google.common.cache.Cache;
  • import com.google.common.cache.CacheBuilder;
  • import com.ouyue.xiwenapi.annotation.GuaveLock;
  • 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.context.annotation.Configuration;
  • import org.springframework.util.StringUtils;
  • import java.lang.reflect.Method;
  • import java.util.concurrent.TimeUnit;
  • /**
  • * @ClassName:${}
  • * @Description:TODO
  • * @author:xx@163.com
  • * @Date:
  • */
  • @Aspect
  • @Configuration
  • public class LockMethodAopConfigure {
  •     private static final Cache<String, Object> CACHES = CacheBuilder.newBuilder()
  •             // 最大缓存 100 个
  •             .maximumSize(1000)
  •             // 设置写缓存后 5 秒钟过期
  •             .expireAfterWrite(5, TimeUnit.SECONDS)
  •             .build();
  •     @Around("execution(public * *(..)) && @annotation(com.ouyue.xiwenapi.annotation.GuaveLock)")
  •     public Object interceptor(ProceedingJoinPoint pjp) {
  •         MethodSignature signature = (MethodSignature) pjp.getSignature();
  •         Method method = signature.getMethod();
  •         GuaveLock localLock = method.getAnnotation(GuaveLock.class);
  •         String key = getKey(localLock.key(), pjp.getArgs());
  •         if (!StringUtils.isEmpty(key)) {
  •             if (CACHES.getIfPresent(key) != null) {
  •                 throw new RuntimeException("请勿重复请求");
  •             }
  •             // 如果是第一次请求,就将 key 当前对象压入缓存中
  •             CACHES.put(key, key);
  •         }
  •         try {
  •             return pjp.proceed();
  •         } catch (Throwable throwable) {
  •             throw new RuntimeException("服务器异常");
  •         } finally {
  •             // TODO 为了演示效果,这里就不调用 CACHES.invalidate(key); 代码了
  •         }
  •     }
  •     /**
  •      * key 的生成策略,如果想灵活可以写成接口与实现类的方式(TODO 后续讲解)
  •      *
  •      * @param keyExpress 表达式
  •      * @param args       参数  可以 采用MD5加密成一个
  •      * @return 生成的key
  •      */
  •     private String getKey(String keyExpress, Object[] args) {
  •         for (int i = 0; i < args.length; i++) {
  •             keyExpress = keyExpress.replace("arg[" + i + "]", args.toString());
  •         }
  •         return keyExpress;
  •     }
  • }
Controller
  • @RestController
  • @RequestMapping("/business")
  • public class BusinessController {
  •     @GuaveLock(key = "business:arg[0]")
  •     @GetMapping
  •     public String query(@RequestParam String token) {
  •         return "success - " + token;
  •     }
  • }

上面的基本都是居于内存级别的缓存;在分布式系统上; 是无法满足的;故而我们需要做到分布式系统中;也能使用

基于Redis 缓存锁的实现pom.xml
  • <dependency>
  •     <groupId>org.springframework.boot</groupId>
  •     <artifactId>spring-boot-starter-data-redis</artifactId>
  • </dependency>
  • spring.redis.host=localhost
  • spring.redis.port=6379
RedisLock
  • prefix: 缓存中 key 的前缀
  • expire: 过期时间,此处默认为 5 秒
  • timeUnit: 超时单位,此处默认为秒
  • delimiter: key 的分隔符,将不同参数值分割开来
  • package com.ouyue.xiwenapi.annotation;
  • import java.lang.annotation.*;
  • import java.util.concurrent.TimeUnit;
  • /**
  • * @ClassName:${}
  • * @Description:TODO
  • * @author:xx@163.com
  • * @Date:
  • */
  • @Target(ElementType.METHOD)
  • @Retention(RetentionPolicy.RUNTIME)
  • @Documented
  • @Inherited
  • public @interface RedisLock {
  •     /**
  •      * 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 ":";
  • }
CacheParam 注解
  • package com.ouyue.xiwenapi.annotation;
  • import java.lang.annotation.*;
  • /**
  • * @ClassName:${}
  • * @Description:TODO
  • * @author:xx@163.com
  • * @Date:
  • */
  • @Target({ElementType.PARAMETER, ElementType.METHOD, ElementType.FIELD})
  • @Retention(RetentionPolicy.RUNTIME)
  • @Documented
  • @Inherited
  • public @interface CacheParam {
  •     /**
  •      * 字段名称
  •      *
  •      * @return String
  •      */
  •     String name() default "";
  • }
Key 生成策略
  • package com.ouyue.xiwenapi.componet;
  • import org.aspectj.lang.ProceedingJoinPoint;
  • public interface CacheKeyGenerator {
  •     /**
  •      * 获取AOP参数,生成指定缓存Key
  •      *
  •      * @param pjp PJP
  •      * @return 缓存KEY
  •      */
  •     String getLockKey(ProceedingJoinPoint pjp);
  • }
Key 生成策略(实现)
  • package com.ouyue.xiwenapi.service;
  • import com.ouyue.xiwenapi.annotation.CacheParam;
  • import com.ouyue.xiwenapi.annotation.RedisLock;
  • import com.ouyue.xiwenapi.componet.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;
  • /**
  • * @ClassName:${}
  • * @Description:TODO
  • * @author:xx@163.com
  • * @Date:
  • */
  • public class LockKeyGenerator implements CacheKeyGenerator {
  •     @Override
  •     public String getLockKey(ProceedingJoinPoint pjp) {
  •         MethodSignature signature = (MethodSignature) pjp.getSignature();
  •         Method method = signature.getMethod();
  •         RedisLock lockAnnotation = method.getAnnotation(RedisLock.class);
  •         final Object[] args = pjp.getArgs();
  •         final Parameter[] parameters = method.getParameters();
  •         StringBuilder builder = new StringBuilder();
  •         // TODO 默认解析方法里面带 CacheParam 注解的属性,如果没有尝试着解析实体对象中的
  •         for (int i = 0; i < parameters.length; i++) {
  •             final CacheParam annotation = parameters.getAnnotation(CacheParam.class);
  •             if (annotation == null) {
  •                 continue;
  •             }
  •             builder.append(lockAnnotation.delimiter()).append(args);
  •         }
  •         if (StringUtils.isEmpty(builder.toString())) {
  •             final Annotation[][] parameterAnnotations = method.getParameterAnnotations();
  •             for (int i = 0; i < parameterAnnotations.length; i++) {
  •                 final Object object = args;
  •                 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)
  • package com.ouyue.xiwenapi.config;
  • import com.ouyue.xiwenapi.annotation.RedisLock;
  • import com.ouyue.xiwenapi.componet.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.connection.RedisStringCommands;
  • import org.springframework.data.redis.core.RedisCallback;
  • import org.springframework.data.redis.core.StringRedisTemplate;
  • import org.springframework.data.redis.core.types.Expiration;
  • import org.springframework.util.StringUtils;
  • import java.lang.reflect.Method;
  • /**
  • * @ClassName:${}
  • * @Description:TODO
  • * @author:xx@163.com
  • * @Date:
  • */
  • @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.ouyue.xiwenapi.annotation.RedisLock)")
  •     public Object interceptor(ProceedingJoinPoint pjp) {
  •         MethodSignature signature = (MethodSignature) pjp.getSignature();
  •         Method method = signature.getMethod();
  •         RedisLock lock = method.getAnnotation(RedisLock.class);
  •         if (StringUtils.isEmpty(lock.prefix())) {
  •             throw new RuntimeException("lock key don't null...");
  •         }
  •         final String lockKey = cacheKeyGenerator.getLockKey(pjp);
  •         try {
  •             // 采用原生 API 来实现分布式锁
  •             final Boolean success = lockRedisTemplate.execute((RedisCallback<Boolean>) connection -> connection.set(lockKey.getBytes(), new byte[0], Expiration.from(lock.expire(), lock.timeUnit()), RedisStringCommands.SetOption.SET_IF_ABSENT));
  •             if (!success) {
  •                 // TODO 按理来说 我们应该抛出一个自定义的 CacheLockException 异常;这里偷下懒
  •                 throw new RuntimeException("请勿重复请求");
  •             }
  •             try {
  •                 return pjp.proceed();
  •             } catch (Throwable throwable) {
  •                 throw new RuntimeException("系统异常");
  •             }
  •         } finally {
  •             // TODO 如果演示的话需要注释该代码;实际应该放开
  •             // lockRedisTemplate.delete(lockKey);
  •         }
  •     }
  • }
请求
  • package com.ouyue.xiwenapi.controller;
  • import com.ouyue.xiwenapi.annotation.CacheParam;
  • import com.ouyue.xiwenapi.annotation.GuaveLock;
  • import com.ouyue.xiwenapi.annotation.RedisLock;
  • import org.springframework.web.bind.annotation.GetMapping;
  • import org.springframework.web.bind.annotation.RequestMapping;
  • import org.springframework.web.bind.annotation.RequestParam;
  • import org.springframework.web.bind.annotation.RestController;
  • /**
  • * @ClassName:${}
  • * @Description:TODO
  • * @author:xx@163.com
  • * @Date:
  • */
  • @RestController
  • @RequestMapping("/business")
  • public class BusinessController {
  •     @GuaveLock(key = "business:arg[0]")
  •     @GetMapping
  •     public String query(@RequestParam String token) {
  •         return "success - " + token;
  •     }
  •     @RedisLock(prefix = "users")
  •     @GetMapping
  •     public String queryRedis(@CacheParam(name = "token") @RequestParam String token) {
  •         return "success - " + token;
  •     }
  • }

mian 函数启动类上;将key 生产策略函数注入

  • @Bean
  • public CacheKeyGenerator cacheKeyGenerator() {
  •     return new LockKeyGenerator();
  • }

过年了,祝各位新年快乐
Powered by www.sosoba.org Copyright © 2013-2021 搜搜吧社区 小黑屋|手机版|Archiver|地图|联系站长|腾讯云代金券|公共DNS|seo优化服务|搜搜吧
广告服务/项目合作/会员购买:QQ 侵权举报邮箱: fuwu-sosoba@qq.com 举报流程必看 搜搜吧建站时间:创建于2013年07月23日
免责声明:本站所有的内容均来自互联网以及第三方作者自由发布,版权归原作者版权所有,搜搜吧不承担任何的法律责任,若有侵权请来信告知,我们立即删除!
版权声明:搜搜吧影视资源均收集自互联网,没有提供影片资源存储和下载,也未参与录制上传,若本站收录的资源涉及您的版权或知识产权或其他利益,我们会立即删除

GMT+8, 2021-9-21 22:13 , Processed in 0.026176 second(s), 6 queries , Redis On.

快速回复 返回顶部 返回列表