本人深根后台系统多年的经验;用户在网络不好情况下; 在做表单提交时;会出现重复提交的情况;故而我们需要:做到防止表单重提。
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[i].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[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)
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();
}
相关推荐
0评论