前言

此文档只粗略的讲解实现思路，具体的实现逻辑还需要针对业务区别处理。

需求

因为此业务中有读和写的操作，写的执行条件依赖于读，并发条件下可能出现读到相同的条件均可以去执行写操作，此时写就会出现脏数据，。所以项目需要实现，在处理业务时，加锁防止并发问题，此处利用Redis实现，但是如果多个业务都需要这么操作的话，其实操作Redis的代码是相同的，这样就显得麻烦，所以楼主采用注解的形式实现，具体方法见下述。

实现逻辑

在请求调用Controller层时，RequestMapping 映射到的方法上加上注解,如自定义注解 @Debounce(防止多次提交)。

此时需要考虑几个问题

1、利用Redis实现并发锁的操作对Redis来说实际上就是一种Key的操作，那么自定义注解@Debounce如何实现key的自定义且根据参数可变化？

2、如何实现调用请求真实的处理方法时的拦截？

3、什么情况下才会去做这个事情？

针对第一个问题解决方法

利用处理请求的方法中的参数，实现动态定义，此时又有个问题，就是说如果时基本数据类型+String,这样的可以直接将值获取拼接，但是如果参数中有对象的话，同时又想用对象中的属性作为key值的一部分，那么直接拼接就行不通。像这种情况，统一的方式行不通，那么自然而然就会想到此处必须用到了拓展类，在上层只是定义这种功能，具体的实现由子类负责具体实现。(详见后述)。

在@Debounce注解中有定义一个处理参数数组，值为处理请求的方法中的参数位置Num,从0开始依次递增，同时也有个处理类class,作用是具体实现key值的拼接。

针对第二个问题解决方法

当然是利用代理实现，此处利用的是Spring的Cglib动态代理。同时利用Spring开放的拓展Bean处理的接口BeanPostProcessor,在bean实例化后，实例化Cglib代理。

针对第三个问题解决方法

在Controller层即在有注解@Controller 或者 @RestController 的类中才会去判断是否需要做此操作。

具体实现方法

Debounce 注解

@Target({ElementType.METHOD})

@Retention(RetentionPolicy.RUNTIME)

@Documented

public @interface Debounce {

/**

* 使用的锁键值

*/

String lockKey() default "";

/**

* 使用方法的参数(toString)做为锁的KEY使用

* 规则：从0开始计，0表示方法中的第一个参数，以此类推

* 和 lockKey 都为空时，使用方法名进行锁定

*/

int[] methodParameters() default {};

/**

* 对注释中的参数进行修改，默认为字符串拼接

*

* @return

*/

Class extends MethodParametersHandler> handler() default MethodParametersHandler.class;

/**

* 延时关闭，当调用的方法结束后并不关闭锁，只有真正超时后才关闭

* 即在锁定时间内，只允许被调用一次

*

* @return

*/

boolean delayClose() default false;

/**

* 默认的超时时间，这个时间内除非原来的方法调用结束，否则无法点击

* 如果原来的方法已经结束，时间比这个短，那么这时间无效

*/

@AliasFor("lockExpireEsc")

int value() default 5;

/**

* 锁的超时时间

*

* @return

*/

@AliasFor("value")

int lockExpireEsc() default 5;

}

参数处理接口 MethodParametersHandler

此处做参数参数值的拼接同时返回拼接后的数据

public interface MethodParametersHandler {

String handler(Object[] args) throws IllegalAccessException;

static class Default implements MethodParametersHandler {

@Override

public String handler(Object[] args) {

StringBuilder sb = new StringBuilder();

for (Object arg : args) {

if (arg != null) {

sb.append(String.valueOf(arg));

sb.append("#");

}

}

return sb.toString();

}

}

}

方法拦截器定义 DebounceInvocationHandler

public class DebounceInvocationHandler implements MethodInterceptor {

private Map, MethodParametersHandler> methodParametersHandlerMap = new ConcurrentHashMap<>();

private final Object target;

private static final MethodParametersHandler methodParametersHandler = new MethodParametersHandler.Default();

public DebounceInvocationHandler(Object bean) {

this.target = bean;

}

@Override

public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {

Debounce annotation = method.getAnnotation(Debounce.class);

if (annotation != null) {

int value = (int) AnnotationUtils.getValue(annotation);

if (value <= 0) {

value = 10;

}

// 组装Redis的key

String key = annotation.lockKey();

int[] methodParameters = annotation.methodParameters();

if (methodParameters != null && methodParameters.length > 0) {

Object[] handlerArgs = new Object[methodParameters.length];

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

if (methodParameters[i] < args.length) {

handlerArgs[i] = args[methodParameters[i]];

}

}

MethodParametersHandler parametersHandler = null;

Class extends MethodParametersHandler> handler = annotation.handler();

if (handler == MethodParametersHandler.class) {

parametersHandler = methodParametersHandler;

} else {

if (methodParametersHandlerMap.containsKey(handler)) {

parametersHandler = methodParametersHandlerMap.get(handler);

} else {

MethodParametersHandler instance = handler.newInstance();

parametersHandler = methodParametersHandlerMap.putIfAbsent(handler, instance);

}

}

key += parametersHandler.handler(handlerArgs);

}

if (StringUtils.isEmpty(key)) {

key = method.toString();

}

// Redis 的分布式锁实现，代码省略 ， 不满足锁的条件可以直接返回或是抛异常

}

try {

if (target == null) {

return methodProxy.invokeSuper(proxy, args);

} else {

return methodProxy.invoke(target, args);

}

} finally {

// 释放Reids 锁判断

if (annotation != null && (Redis 锁不为空) && !annotation.delayClose()) {

// 释放Redis锁

}

}

}

}

Bean实例化后的实现方式-BeanPostProcessor

@Configuration

public class RestfulMVCAutoConfiguration implements BeanPostProcessor {

@Override

public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {

return bean;

}

@Override

public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {

Class> beanClass = bean.getClass();

RestController annotation = beanClass.getAnnotation(RestController.class);

if (annotation == null) {

return bean;

}

boolean haveDebounce = false;

Method[] methods = beanClass.getDeclaredMethods();

for (Method method : methods) {

Debounce debounce = method.getAnnotation(Debounce.class);

if (debounce != null) {

haveDebounce = true;

break;

}

}

if (haveDebounce) {

Enhancer en = new Enhancer();

en.setSuperclass(beanClass);

en.setUseFactory(false);

en.setCallback(new DebounceInvocationHandler(bean));

return en.create();

}

return bean;

}

}

使用方式

其中的MyHandler.class 为 implements MethodParametersHandler ，参数组装的具体实现

@RestController

@RequestMapping("/test/debounce/")

public class DebounceController {

@PostMapping(value = "/post")

@Debounce(value = 10, handler = MyHandler.class , delayClose = true, methodParameters = 0)

public TResponseObject post(@RequestBody MyRequest request) {

return TResponseObject.Success("Success");

}

}