java后臺防止表單重復提交方法詳解

更新時間：2022年12月24日 09:00:54 作者：xin_shou123

這篇文章主要介紹了后臺防止表單重復提交,利用Session防止表單重復提交，判斷請求url和數(shù)據(jù)是否和上一次相同，利用Spring AOP和redis的鎖需要的朋友可以參考下

方案一：利用Session防止表單重復提交

具體的做法：

1、獲取用戶填寫用戶名和密碼的頁面時向后臺發(fā)送一次請求，這時后臺會生成唯一的隨機標識號，專業(yè)術語稱為Token(令牌)。
2、將Token發(fā)送到客戶端的Form表單中，在Form表單中使用隱藏域來存儲這個Token，表單提交的時候連同這個Token一起提交到服務器端。
3、服務器端判斷客戶端提交上來的Token與服務器端生成的Token是否一致，如果不一致，那就是重復提交了，此時服務器端就可以不處理重復提交的表單。如果相同則處理表單提交，處理完后清除當前用戶的Session域中存儲的標識號。

看具體的范例：

1.創(chuàng)建FormServlet，用于生成Token(令牌)和跳轉到form.jsp頁面

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
  public class FormServlet extends HttpServlet {
    private static final long serialVersionUID = -884689940866074733L;
 
    public void doGet(HttpServletRequest request, HttpServletResponse response)
             throws ServletException, IOException {
 
        String token =  UUID.randomUUID().toString() ;//創(chuàng)建令牌
        System.out.println("在FormServlet中生成的token："+token);
         request.getSession().setAttribute("token", token);  //在服務器使用session保存token(令牌)
         request.getRequestDispatcher("/form.jsp").forward(request, response);//跳轉到form.jsp頁面
     }
 
     public void doPost(HttpServletRequest request, HttpServletResponse response)
             throws ServletException, IOException {
         doGet(request, response);
     }
 
}

2.在form.jsp中使用隱藏域來存儲Token(令牌)

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
  <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
  <html>
  <head>
  <title>form表單</title>
  </head>
  
  <body>
      <form action="${pageContext.request.contextPath}/servlet/DoFormServlet" method="post">
         <%--使用隱藏域存儲生成的token--%>
         <%--
             <input type="hidden" name="token" value="<%=session.getAttribute("token") %>">
         --%>
         <%--使用EL表達式取出存儲在session中的token--%>
         <input type="hidden" name="token" value="${token}"/> 
         用戶名：<input type="text" name="username"> 
         <input type="submit" value="提交">
     </form>
 </body>
 </html>

3.DoFormServlet處理表單提交

import java.io.IOException;
  import javax.servlet.ServletException;
  import javax.servlet.http.HttpServlet;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  
  public class DoFormServlet extends HttpServlet {
 
     public void doGet(HttpServletRequest request, HttpServletResponse response)
                 throws ServletException, IOException {
 
             boolean b = isRepeatSubmit(request);//判斷用戶是否是重復提交
             if(b==true){
                 System.out.println("請不要重復提交");
                 return;
             }
             request.getSession().removeAttribute("token");//移除session中的token
             System.out.println("處理用戶提交請求！！");
         }
         
         /**
          * 判斷客戶端提交上來的令牌和服務器端生成的令牌是否一致
          * @param request
          * @return 
          *         true 用戶重復提交了表單 
          *         false 用戶沒有重復提交表單
          */
         private boolean isRepeatSubmit(HttpServletRequest request) {
             String client_token = request.getParameter("token");
             //1、如果用戶提交的表單數(shù)據(jù)中沒有token，則用戶是重復提交了表單
             if(client_token==null){
                 return true;
             }
             //取出存儲在Session中的token
             String server_token = (String) request.getSession().getAttribute("token");
             //2、如果當前用戶的Session中不存在Token(令牌)，則用戶是重復提交了表單
             if(server_token==null){
                return true;
             }
             //3、存儲在Session中的Token(令牌)與表單提交的Token(令牌)不同，則用戶是重復提交了表單
             if(!client_token.equals(server_token)){
                 return true;
             }
             
             return false;
         }
 
     public void doPost(HttpServletRequest request, HttpServletResponse response)
             throws ServletException, IOException {
         doGet(request, response);
     }
 
 }

方案二：判斷請求url和數(shù)據(jù)是否和上一次相同

推薦，非常簡單，頁面不需要任何傳入，只需要在驗證的controller方法上寫上自定義注解即可

1.寫好自定義注解

import java.lang.annotation.ElementType;  
import java.lang.annotation.Retention;  
import java.lang.annotation.RetentionPolicy;  
import java.lang.annotation.Target;  
  
/** 
 * 一個用戶 相同url 同時提交 相同數(shù)據(jù) 驗證 
 * @author Administrator 
 * 
 */  
@Target(ElementType.METHOD)  
@Retention(RetentionPolicy.RUNTIME)  
public @interface SameUrlData {  
  
      
}

2.寫好攔截器

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 同時提交 相同數(shù)據(jù) 驗證 
 * 主要通過 session中保存到的url 和 請求參數(shù)。如果和上次相同，則是重復提交表單 
 * @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))//如果重復相同數(shù)據(jù)  
                        return false;  
                    else   
                        return true;  
                }  
                return true;  
            } else {  
                return super.preHandle(request, response, handler);  
            }  
        }  
    /** 
     * 驗證同一個url數(shù)據(jù)是否相同提交  ,相同返回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)//如果上一個數(shù)據(jù)為null,表示還沒有訪問頁面  
        {  
            httpServletRequest.getSession().setAttribute("repeatData", nowUrlParams);  
            return false;  
        }  
        else//否則，已經(jīng)訪問過頁面  
        {  
            if(preUrlParams.toString().equals(nowUrlParams))//如果上次url+數(shù)據(jù)和本次url+數(shù)據(jù)相同，則表示城府添加數(shù)據(jù)  
            {  
                  
                return true;  
            }  
            else//如果上次 url+數(shù)據(jù) 和本次url加數(shù)據(jù)不同，則不是重復提交  
            {  
                httpServletRequest.getSession().setAttribute("repeatData", nowUrlParams);  
                return false;  
            }  
              
        }  
    }  
  
}  
<mvc:interceptor>  
     <mvc:mapping path="/**"/>  
     <bean class="*.*.SameUrlDataInterceptor"/>  
</mvc:interceptor>

方案三：利用Spring AOP和redis的鎖來實現(xiàn)防止表單重復提交

主要是利用了redis的分布式鎖機制

1、注解：

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* 防止重復提交注解
* @author zzp 2018.03.11
* @version 1.0
*/
@Retention(RetentionPolicy.RUNTIME) // 在運行時可以獲取
@Target(value = {ElementType.METHOD, ElementType.TYPE})  // 作用到類，方法，接口上等
public @interface PreventRepetitionAnnotation {
}

2、AOP代碼

import java.lang.reflect.Method;
import java.util.UUID;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
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.com.rlid.utils.json.JsonBuilder;
import  org.springframework.beans.factory.annotation.Autowired;
import  org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.stereotype.Component;
import demo.zzp.app.aop.annotation.OperaterAnnotation;
import demo.zzp.app.redis.JedisUtils;
/**
* 防止重復提交操作AOP類
* @author zzp 2018.03.10
* @version 1.0
*/
@Aspect
@Component
@EnableAspectJAutoProxy(proxyTargetClass=true)
public class PreventRepetitionAspect {
     
     @Autowired
     private JedisUtils jedisUtils;
     private static final String PARAM_TOKEN = "token";
    private static final String PARAM_TOKEN_FLAG =  "tokenFlag";
    
    /**
      * around
      * @throws Throwable
      */
     @Around(value =  "@annotation(demo.zzp.app.aop.annotation.PreventRepetitionAnnotation)")
     public Object excute(ProceedingJoinPoint  joinPoint) throws Throwable{
         try {
              Object result = null;
              Object[] args = joinPoint.getArgs();
              for(int i = 0;i < args.length;i++){
                  if(args[i] != null && args[i]  instanceof HttpServletRequest){
                       HttpServletRequest request =  (HttpServletRequest) args[i];//被調用的方法需要加上HttpServletRequest request這個參數(shù)
                       HttpSession session =  request.getSession();
                       if(request.getMethod().equalsIgnoreCase("get")){
                            //方法為get
                            result =  generate(joinPoint, request, session,  PARAM_TOKEN_FLAG);
                       }else{
                            //方法為post
                            result =  validation(joinPoint, request, session,  PARAM_TOKEN_FLAG);
                       }
                  }
              }
              
              return result;
         } catch (Exception e) {
              e.printStackTrace();
              return JsonBuilder.toJson(false, "操作失敗！", "執(zhí)行防止重復提交功能AOP失敗，原因：" +  e.getMessage());
         }
     }
     
     public Object generate(ProceedingJoinPoint  joinPoint, HttpServletRequest request, HttpSession  session,String tokenFlag) throws Throwable {
        String uuid = UUID.randomUUID().toString();
        request.setAttribute(PARAM_TOKEN, uuid);
        return joinPoint.proceed();
    }
     
     public Object validation(ProceedingJoinPoint  joinPoint, HttpServletRequest request, HttpSession  session,String tokenFlag) throws Throwable {
         String requestFlag =  request.getParameter(PARAM_TOKEN);
         //redis加鎖
         boolean lock =  jedisUtils.tryGetDistributedLock(tokenFlag +  requestFlag, requestFlag, 60000);
         if(lock){
              //加鎖成功
              //執(zhí)行方法
              Object funcResult = joinPoint.proceed();
              //方法執(zhí)行完之后進行解鎖
              jedisUtils.releaseDistributedLock(tokenFlag +  requestFlag, requestFlag);
              return funcResult;
         }else{
              //鎖已存在
              return JsonBuilder.toJson(false, "不能重復提交！",  null);
         }
    }
     
}

3、Controller代碼

@RequestMapping(value = "/index",method =  RequestMethod.GET)
@PreventRepetitionAnnotation
 public String toIndex(HttpServletRequest  request,Map<String, Object> map){
         return "form";
  }
     
  @RequestMapping(value = "/add",method =  RequestMethod.POST)
  @ResponseBody
  @PreventRepetitionAnnotation
   public String add(HttpServletRequest request){
         try {
              Thread.sleep(5000);
         } catch (InterruptedException e) {
              e.printStackTrace();
         }
         return JsonBuilder.toJson(true, "保存成功！",null);
     }

第一次點擊提交表單，判斷到當前的token還沒有上鎖，即給該token上鎖。如果連續(xù)點擊提交，則提示不能重復提交，當上鎖的那次操作執(zhí)行完，redis釋放了鎖之后才能繼續(xù)提交。

以上就是java后臺防止表單重復提交方法詳解的詳細內容，更多關于java后臺防止表單重復提交的資料請關注腳本之家其它相關文章！

您可能感興趣的文章:

java
表單

Spring MVC Controller傳遞枚舉值的實例
這篇文章主要介紹了Spring MVC Controller傳遞枚舉值的實例，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教
2021-09-09
SpringBoot配置多個數(shù)據(jù)源超簡單步驟(連接多個數(shù)據(jù)庫)
公司項目有連接多個不同數(shù)據(jù)庫的需求,特研究了一下,根據(jù)網(wǎng)上的資料,這篇文章主要給大家介紹了關于SpringBoot配置多個數(shù)據(jù)源(連接多個數(shù)據(jù)庫)的相關資料,需要的朋友可以參考下
2024-05-05
java通過實例了解值傳遞和引用傳遞
這篇文章主要介紹了java通過實例了解值傳遞和引用傳遞,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下
2019-11-11
Java異常架構和異常關鍵字圖文詳解
Java異常是Java提供的一種識別及響應錯誤的一致性機制,下面這篇文章主要給大家介紹了關于Java異常架構和異常關鍵字的相關資料,文中通過實例代碼介紹的非常詳細,需要的朋友可以參考下
2022-05-05
背包問題-動態(tài)規(guī)劃java實現(xiàn)的分析與代碼
這篇文章主要給大家介紹了關于背包問題動態(tài)規(guī)劃java實現(xiàn)的相關資料，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧
2020-12-12
關于Spring配置文件加載方式變化引發(fā)的異常詳解
這篇文章主要給大家介紹了關于Spring配置文件加載方式變化引發(fā)的異常的相關資料,文中通過實例代碼介紹的非常詳細,對大家學習或者使用Spring具有一定的參考學習價值,需要的朋友可以參考下
2022-01-01
Maven 打包項目到私服 (deploy)的配置方法
這篇文章主要介紹了Maven 打包項目到私服 (deploy)的配置方法，本文給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值,需要的朋友可以參考下
2020-07-07
SpringBoot @Scope與@RefreshScope注解使用詳解
spring的bean管理中，每個bean都有對應的scope。在BeanDefinition中就已經(jīng)指定scope，默認的RootBeanDefinition的scope是prototype類型，使用@ComponentScan掃描出的BeanDefinition會指定是singleton，最常使用的也是singleton
2022-11-11
JDBC連接SQL?Server數(shù)據(jù)庫實現(xiàn)增刪改查的全過程
實際開發(fā)中手動的輸入SQL語句是少之又少,大多數(shù)情況下是通過編譯代碼進行來控制自動執(zhí)行,下面這篇文章主要給大家介紹了關于JDBC連接SQL?Server數(shù)據(jù)庫實現(xiàn)增刪改查的相關資料,需要的朋友可以參考下
2023-04-04
Java中Integer類型值相等判斷方法
這篇文章主要給大家介紹了關于Java中Integer類型值相等判斷的相關資料，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧
2021-02-02