springmvc 用拦截器+token防止重复提交

Token一般用在两个地方:

1: 防止表单重复提交
2: anti csrf攻击（Cross-site request forgery 跨站点请求伪造）

两者在原理上都是通过session token来实现的。当客户端请求页面时，服务器会生成一个随机数Token，并且将Token放置到session当中，然后将Token发给客户端（一般通过构造hidden表单）。
下次客户端提交请求时，Token会随着表单一起提交到服务器端。

Token，可以翻译成标记！最大的特点就是随机性，不可预测，一般黑客或软件无法猜测出来。

1、应用于“anti csrf攻击”：

服务器端会对Token值进行验证，判断是否和session中的Token值相等，若相等，则可以证明请求有效，不是伪造的。

2、应用于“防止表单重复提交”：

服务器端第一次验证相同过后，会将session中的Token值更新下，若用户重复提交，第二次的验证判断将失败，因为用户提交的表单中的Token没变，但服务器端session中Token已经改变了。

防止表单重复提交
2.1. 单机
2.1.1. 实现的思路步骤
2.1.2. 代码实现

第一种方法：判断session中保存的token

比较麻烦，每次在提交表单时都必须传入上次的token。而且当一个页面使用ajax时，多个表单提交就会有问题。

注解Token代码：

package com.thinkgem.jeesite.common.repeat_form_validator;
 
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
/**
 * 页面form   token
 * @author Administrator
 *
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface FormToken {
 
    boolean save() default false;
 
    boolean remove() default false;
}

拦截器TokenInterceptor代码：

package com.thinkgem.jeesite.common.repeat_form_validator;
 
import java.lang.reflect.Method;
import java.util.UUID;
 
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
 
public class FormTokenInterceptor extends HandlerInterceptorAdapter {
 
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        if (handler instanceof HandlerMethod) {
            HandlerMethod handlerMethod = (HandlerMethod) handler;
            Method method = handlerMethod.getMethod();
            FormToken annotation = method.getAnnotation(FormToken.class);
            if (annotation != null) {
                boolean needSaveSession = annotation.save();
                if (needSaveSession) {
                    request.getSession(false).setAttribute("formToken", UUID.randomUUID().toString());
                }
                boolean needRemoveSession = annotation.remove();
                if (needRemoveSession) {
                    if (isRepeatSubmit(request)) {
                        return false;
                    }
                    request.getSession(false).removeAttribute("formToken");
                }
            }
            return true;
        } else {
            return super.preHandle(request, response, handler);
        }
    }
 
    private boolean isRepeatSubmit(HttpServletRequest request) {
        String serverToken = (String) request.getSession(false).getAttribute("formToken");
        if (serverToken == null) {
            return true;
        }
        String clinetToken = request.getParameter("formToken");
        if (clinetToken == null) {
            return true;
        }
        if (!serverToken.equals(clinetToken)) {
            return true;
        }
        return false;
    }
}

然后在Spring MVC的配置文件里加入：

<mvc:interceptors>
<mvc:interceptor>
<mvc:mapping path="/**"/>
<bean class="com.thinkgem.jeesite.common.repeat_form_validator.FormTokenInterceptor"/>
</mvc:interceptor>
</mvc:interceptors>

关于这个方法的用法是：在跳转页面的方法加上@Token(save=true) 在提交的方法上加@Token(remove=true)

在需要生成token的controller上增加@FormToken(save=true)，

而在需要检查重复提交的controller上添加@FormToken(remove=true)就可以了。
另外，你需要在view里在form里增加下面代码：

<inputtype="hidden"name="formToken"value="${formToken}" />
已经完成了，去试试看你的数据还能重复提交了吧。

注意在ajax提交时要加上 formToken参数

第二种方法（判断请求url和数据是否和上一次相同）

推荐，非常简单，页面不需要任何传入，只需要在验证的controller方法上写上自定义注解即可

写好自定义注解

package com.thinkgem.jeesite.common.repeat_form_validator;
 
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
/**
 * 一个用户 相同url 同时提交 相同数据 验证
 * @author Administrator
 *
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface SameUrlData {
 
	
}

写好拦截器

package com.thinkgem.jeesite.common.repeat_form_validator;
 
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
 
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
 
import com.thinkgem.jeesite.common.mapper.JsonMapper;
 
/**
 * 一个用户 相同url 同时提交 相同数据 验证
 * 主要通过 session中保存到的url 和 请求参数。如果和上次相同，则是重复提交表单
 * @author Administrator
 *
 */
public class SameUrlDataInterceptor  extends HandlerInterceptorAdapter{
	
	  @Override
	    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
	        if (handler instanceof HandlerMethod) {
	            HandlerMethod handlerMethod = (HandlerMethod) handler;
	            Method method = handlerMethod.getMethod();
	            SameUrlData annotation = method.getAnnotation(SameUrlData.class);
	            if (annotation != null) {
	            	if(repeatDataValidator(request))//如果重复相同数据
	            		return false;
	            	else 
	            		return true;
	            }
	            return true;
	        } else {
	            return super.preHandle(request, response, handler);
	        }
	    }
	/**
	 * 验证同一个url数据是否相同提交  ,相同返回true
	 * @param httpServletRequest
	 * @return
	 */
	public boolean repeatDataValidator(HttpServletRequest httpServletRequest)
	{
		String params=JsonMapper.toJsonString(httpServletRequest.getParameterMap());
		String url=httpServletRequest.getRequestURI();
		Map<String,String> map=new HashMap<String,String>();
		map.put(url, params);
		String nowUrlParams=map.toString();//
		
		Object preUrlParams=httpServletRequest.getSession().getAttribute("repeatData");
		if(preUrlParams==null)//如果上一个数据为null,表示还没有访问页面
		{
			httpServletRequest.getSession().setAttribute("repeatData", nowUrlParams);
			return false;
		}
		else//否则，已经访问过页面
		{
			if(preUrlParams.toString().equals(nowUrlParams))//如果上次url+数据和本次url+数据相同，则表示城府添加数据
			{
				
				return true;
			}
			else//如果上次 url+数据 和本次url加数据不同，则不是重复提交
			{
				httpServletRequest.getSession().setAttribute("repeatData", nowUrlParams);
				return false;
			}
			
		}
	}
}

配置spring mvc

<mvc:interceptor>
<mvc:mapping path="/**"/>
<bean class="com.thinkgem.jeesite.common.repeat_form_validator.SameUrlDataInterceptor"/>
</mvc:interceptor>

2.2. 分布式
2.2.1. 实现的思路步骤
2.2.2. 代码实现

很显然在分布式的情况下，使用上述方法已无法防止表单重复提交了；一者在分布式部署下 Session 是不共享的，二者使用上一次请求的 url 和参数和这次的对比已无法对比请求的 url 和参数了。在此情况下，就可以使用 Redisson 的分布式锁来实现了

2.2.1. 实现的思路步骤
使用分布式锁 Redisson 来尝试获取一把锁
如果成功获取锁，再获取判断 Redis 中的 key 值是否存在（key 值自定义）
如果 key 值不存在，则证明不是重复请求，再给 Redis 中存入数据（使用 UUID 不重复）；反之，则证明是重复请求进行提交
最后，释放分布式锁
2.2.2. 代码实现
Maven 依赖

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

<dependency>
	<groupId>org.redisson</groupId>
	<artifactId>redisson-spring-boot-starter</artifactId>
	<version>3.11.0</version>
</dependency>

配置文件配置 Redis 信息

spring.redis.host=127.0.0.1
spring.redis.port=6379
spring.redis.password=
spring.redis.database=0
spring.redis.timeout=2000
spring.redis.lettuce.pool.max-active=10
spring.redis.lettuce.pool.max-wait=2
spring.redis.lettuce.pool.min-idle=5
spring.redis.lettuce.pool.max-idle=10

RedissonClient 配置类

@Configuration
public class RedissonConfig {

	@Bean
	public RedissonClient redissonClient() {
		Config config = new Config();
		config.useSingleServer().setAddress("redis://127.0.0.1:6379");
		RedissonClient client = Redisson.create(config);
		return client;
	}
}

Controller 层，伪代码如下

@Controller
public class TestController {

	@Autowired
    private StringRedisTemplate stringRedisTemplate;

	@Autowired
	private RedissonClient redissonClient;

	@PostMapping(path="/registerLock")
	@ResponseBody
	public ResultMap registerLock(UserDto userDto) {
		RLock rLock = redissonClient.getLock(userDto.getUserName());   
		// redis中的key值
       	String key = userDto.getUserName() + "-redissonLock";
       	boolean resultLock = rLock.tryLock(30, 10, TimeUnit.SECONDS);
		if (resultLock) {
			try {        	
        		// 如果不存在key
        		if (!stringRedisTemplate.hasKey(key)) {
            		// 给redis中存入数据
            		stringRedisTemplate.opsForValue().set(key,UUID.randomUUID().toString(),10L,TimeUnit.SECONDS);
            		// .....................你的业务
            		
            	}
            	// 如果存在，则提示不可重复提交
            	return new ResultMap().fail().message("请勿重复提交");
    		} catch (Exception e) {
    			return new ResultMap().fail().message("获取redisson分布式锁异常");
    		}
		} finally {
    		// 释放锁
        	rLock.unlock();
    	}
		return null;
	}
}

posted @ 2022-02-16 13:53 hanease 阅读(1021) 评论(0) 收藏举报

刷新页面返回顶部

hanease