基于SpringMVC拦截器和自定义注解实现接口防重复提交

原理：页面在访问接口之前，需要在服务器端申请一个token，在访问接口的时候把token提交给服务器，拦截器中做验证，如果token无效则则返回错误提示，token可用，则删除服务器端token,继续访问接口。

token 使用Redis存储，每次申请token时候，创建一个唯一序列，保存到Redis里，校验token通过后，在Redis中删除这个token。Redis del(String key)方法,返回删除的数量，如果这个key不存在,返回0.

自定义注解：这里只是用来需要做防重复提交的接口，毕竟不是所有接口都需要做，把需要做的接口打上注解。

代码基础，参考文章《SpringMVC 使用AOP添加日志》

代码目录：

关键代码：

自定义注解：

package cn.tnt.aop.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface NoRetry {

}

GoodsController

package cn.tnt.aop.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import cn.tnt.aop.annotation.NoRetry;
import cn.tnt.aop.service.GoodsService;

@RestController
@RequestMapping("/goods")
public class GoodsController {
	@Autowired
	private GoodsService goodsService;
	
	@RequestMapping("/q")
	@NoRetry
	public String query(String id){
		return goodsService.query(id);
	}
}

package cn.tnt.aop.controller;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;

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

import cn.tnt.aop.util.RedisClient;

@RestController
@RequestMapping("/token")
public class TokenController {
	@RequestMapping("/q")
	public String get(){
		LockSupport.parkNanos(TimeUnit.MILLISECONDS.toNanos(300));
		return RedisClient.getToken();
	}
	
	@RequestMapping("/broken")
	public String broken(){
		String res="{'code':500,'msg':'请求已失效'}";
		return res;
	}
}

NoRetryInterceptor

package cn.tnt.aop.interceptor;

import java.lang.reflect.Method;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

import cn.tnt.aop.annotation.NoRetry;
import cn.tnt.aop.util.RedisClient;

/**
 * 防重复提交拦截器
 * @author WQ
 *
 */
public class NoRetryInterceptor extends HandlerInterceptorAdapter{
	
	
	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {
		
		//如果请求的方法是handler方法
		if(handler instanceof HandlerMethod){
			HandlerMethod handlerMethod=(HandlerMethod)handler;
			//获取请求的方法
			Method method = handlerMethod.getMethod();
			//获取方法上标注的Noretry注解，没有返回null
			NoRetry annotation = method.getAnnotation(NoRetry.class);
			//标注了注解,则进行拦截
			if(annotation!=null){ 
				String token = request.getHeader("NO_RETRY_TOKEN");
				//没有提交token进行拦截
				if(token==null){
					System.out.println("======== NO_RETRY_TOKEN IS NULL ========");
					response.setStatus(200);
					request.getRequestDispatcher("/token/broken").forward(request, response);
					return false;
				}
				//无效的token,删除成功返回key的数量
				if(RedisClient.del(token)<1){ 
					System.out.println("======== NO_RETRY_TOKEN IS BROKEN ========");
					request.getRequestDispatcher("/token/broken").forward(request, response);
					return false;
				}
				
			}
			
		}
		System.out.println("======== NO_RETRY_TOKEN IS PASS ========");
		return true;
	}
}

在请求接口的时候，需要在header里添加NO_RETRY_TOKEN ，value为token/q接口申请的token，访问通过后，再次使用相同的token访问，接口被转发 返回{'code':500,'msg':'无效的请求'}。