Java自定义拦截器处理防抖

已于 2022-10-21 14:32:48 修改
阅读量923 收藏 7
点赞数 1
分类专栏： java 文章标签： java servlet 开发语言
于 2022-10-21 11:53:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YXWik/article/details/127443110
版权

自定义注解 RepeatSubmit ， 用于防止表单重复提交

package com.goodsoft.shrk.common.annotation;

import java.lang.annotation.*;

/**
 * @author YXY
 * 自定义注解防止表单重复提交
 *
 * @Inherited
 * 1.类继承关系中@Inherited的作用：类继承关系中，子类会继承父类使用的注解中被@Inherited修饰的注解
 * 2.接口继承关系中@Inherited的作用：接口继承关系中，子接口不会继承父接口中的任何注解，不管父接口中使用的注解有没有被@Inherited修饰
 * 3.类实现接口关系中@Inherited的作用：类实现接口时不会继承任何接口中定义的注解
 * @Documented
 * 标注生成javadoc的时候是否会被记录。
 */
@Inherited
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RepeatSubmit
{

}

使用方式：
在需要拦截的接口上添加 @RepeatSubmit() 注解
在这里插入图片描述
自定义拦截器

package com.goodsoft.shrk.common.interceptor;

import com.alibaba.fastjson.JSONObject;
import com.goodsoft.shrk.common.annotation.RepeatSubmit;
import com.goodsoft.shrk.common.dto.ReturnData;
import com.goodsoft.shrk.common.util.ServletUtils;
//import org.springframework.messaging.handler.HandlerMethod;
import org.springframework.web.method.HandlerMethod;

import org.springframework.stereotype.Component;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.lang.reflect.Method;

/**
 * @author YXY
 * 防止重复提交拦截器
 */
@Component
public abstract class RepeatSubmitInterceptor extends HandlerInterceptorAdapter
{
    /**
     * preHandle方法都会在Controller方法调用之前执行，当preHandler中返回值为false时整个请求结束
     * postHandle方法 在请求完成后执行,会在DispatcherServlet进行视图的渲染之前执行
     * afterCompletion方法将在整个请求完成之后，也就是DispatcherServlet渲染了视图执行
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception
    {
        if (handler instanceof HandlerMethod)
        {
            // HandlerMethod 封装 方法参数，方法返回值和方法注释
            HandlerMethod handlerMethod = (HandlerMethod) handler;
            Method method = handlerMethod.getMethod();
            RepeatSubmit annotation = method.getAnnotation(RepeatSubmit.class);
            if (annotation != null)
            {
                if (this.isRepeatSubmit(request))
                {
                    ReturnData result = ReturnData.error("不允许重复提交，请稍后再试");
                    //将字符串渲染到客户端
                    ServletUtils.renderString(response, JSONObject.toJSONString(result));
                    return false;
                }
            }
            return true;
        }
        else
        {
            return super.preHandle(request, response, handler);
        }
    }

    /**
     * 验证是否重复提交由子类实现具体的防重复提交的规则
     * @param request
     * @return
     * @throws Exception
     */
    public abstract boolean isRepeatSubmit(HttpServletRequest request);
}

这里有个小问题，就是HandlerMethod的导包问题，
如果导入的是import org.springframework.messaging.handler.HandlerMethod; 这个包下的，
会导致 handler instanceof HandlerMethod 一直为false ，
应该导入：import org.springframework.web.method.HandlerMethod;
这里的 ReturnData 是我们项目封装的统一返回数据结果，需要替换为自己项目的

package com.goodsoft.shrk.common.interceptor;

import com.alibaba.fastjson.JSONObject;
import com.goodsoft.shrk.common.constant.Constants;
import com.goodsoft.shrk.common.util.HttpHelper;
import com.goodsoft.shrk.common.util.StringUtils;
import com.goodsoft.shrk.component.cache.CommonCache;
import com.goodsoft.shrk.component.filter.RepeatedlyRequestWrapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * @author YXY
 * 判断请求url和数据是否和上一次相同，
 * 如果和上次相同，则是重复提交表单。 有效时间为10秒内
 */
@Component
public class SameUrlDataInterceptor extends RepeatSubmitInterceptor
{
    public final String REPEAT_PARAMS = "repeatParams";

    public final String REPEAT_TIME = "repeatTime";


    @Autowired
    private CommonCache commonCache;

    /**
     * 间隔时间，单位:秒 默认10秒
     *
     * 两次相同参数的请求，如果间隔时间大于该参数，系统不会认定为重复提交的数据
     */
    private int intervalTime = 10;

    public void setIntervalTime(int intervalTime)
    {
        this.intervalTime = intervalTime;
    }

    /**
     * @SuppressWarnings("unchecked"): 告诉编译器忽略 unchecked 警告信息
     * @param request
     * @return
     */
    @SuppressWarnings("unchecked")
    @Override
    public boolean isRepeatSubmit(HttpServletRequest request)
    {
        String nowParams = "";
        if (request instanceof RepeatedlyRequestWrapper)
        {
            RepeatedlyRequestWrapper repeatedlyRequest = (RepeatedlyRequestWrapper) request;
            nowParams = HttpHelper.getBodyString(repeatedlyRequest);
        }

        // body参数为空，获取Parameter的数据
        if (StringUtils.isEmpty(nowParams))
        {
            nowParams = JSONObject.toJSONString(request.getParameterMap());
        }
        Map<String, Object> nowDataMap = new HashMap<String, Object>();
        nowDataMap.put(REPEAT_PARAMS, nowParams);
        nowDataMap.put(REPEAT_TIME, System.currentTimeMillis());

        // 请求地址（作为存放cache的key值）
        String url = request.getRequestURI();

        // 唯一值（没有消息头则使用请求地址）
        String submitKey = request.getHeader( "token");
        if (StringUtils.isEmpty(submitKey))
        {
            submitKey = url;
        }

        // 唯一标识（指定key + 消息头）
        String cacheRepeatKey = Constants.REPEAT_SUBMIT_KEY + submitKey;

        Object sessionObj = commonCache.getVal(cacheRepeatKey);
        if (sessionObj != null)
        {
            Map<String, Object> sessionMap = (Map<String, Object>) sessionObj;
            if (sessionMap.containsKey(url))
            {
                Map<String, Object> preDataMap = (Map<String, Object>) sessionMap.get(url);
                if (compareParams(nowDataMap, preDataMap) && compareTime(nowDataMap, preDataMap))
                {
                    return true;
                }
            }
        }
        Map<String, Object> cacheMap = new HashMap<String, Object>();
        cacheMap.put(url, nowDataMap);
        commonCache.set(cacheRepeatKey, cacheMap, intervalTime, TimeUnit.SECONDS);
        return false;
    }

    /**
     * 判断参数是否相同
     */
    private boolean compareParams(Map<String, Object> nowMap, Map<String, Object> preMap)
    {
        String nowParams = (String) nowMap.get(REPEAT_PARAMS);
        String preParams = (String) preMap.get(REPEAT_PARAMS);
        return nowParams.equals(preParams);
    }

    /**
     * 判断两次间隔时间
     */
    private boolean compareTime(Map<String, Object> nowMap, Map<String, Object> preMap)
    {
        long time1 = (Long) nowMap.get(REPEAT_TIME);
        long time2 = (Long) preMap.get(REPEAT_TIME);
        if ((time1 - time2) < (this.intervalTime * 1000))
        {
            return true;
        }
        return false;
    }
}

CommonCache 是操作redis缓存用 ，这里替换成自己系统中的操作redis存取方法即可

commonCache.getVal()

commonCache.set()

   /**
     * 根据key获取缓存中的val
     *
     * @param key 键 不能为null
     * @return 缓存中的值
     */
    public <T> T getVal(String key) {
        return (T) redisTemplate.opsForValue().get(key);
    }
   /**
     * 缓存放入并设置过期时间
     *
     * @param key   键
     * @param value 值
     * @param time  时间(毫秒) time要大于0 如果time小于等于0 将设置无限期
     * @param unit  默认毫秒
     * @return true成功 false 失败
     */
    public boolean set(String key, Object value, long time, TimeUnit unit) {
        try {
            if (time > 0 && unit != null) {
                redisTemplate.opsForValue().set(key, value, time, unit);
                return true;
            }
        } catch (Exception e) {
            LOG.error("redis缓存放入并设置过期时间", e);
        }
        return false;
    }

HttpHelper工具类

package com.goodsoft.shrk.common.util;

import javax.servlet.ServletRequest;
import java.io.*;
import java.nio.charset.Charset;

/**
 *  @author YXY
 */
public class HttpHelper {
    /** * 获取post请求中的Body * * @param request * @return */
    public static String getBodyString(ServletRequest request) {
        StringBuilder sb = new StringBuilder();
        InputStream inputStream = null;
        BufferedReader reader = null;
        try {
            inputStream = request.getInputStream();
            //读取流并将流写出去,避免数据流中断;
            reader = new BufferedReader(new InputStreamReader(inputStream, Charset.forName("UTF-8")));
            String line = "";
            while ((line = reader.readLine()) != null) {
                sb.append(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return sb.toString();
    }
    //添加自定义的信息到请求体中;
    public static String appendCustomMsgToReqBody(String newReqBodyStr) {
        StringBuilder sb = new StringBuilder();
        InputStream inputStream = null;
        BufferedReader reader = null;
        String newReqBody = null;
        try {
            //通过字符串构造输入流;
            inputStream = String2InputStream(newReqBodyStr);
            reader = new BufferedReader(new InputStreamReader(inputStream, Charset.forName("UTF-8")));
            String line = "";
            while ((line = reader.readLine()) != null) {
                sb.append(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        //返回字符串;
        newReqBody = sb.toString();
        return newReqBody;
    }
    //将字符串转化为输入流;
    public static InputStream String2InputStream(String str) {
        ByteArrayInputStream stream = null;
        try {
            stream = new ByteArrayInputStream(str.getBytes("UTF-8"));
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return stream;
    }
}

Constants 常量

package com.goodsoft.shrk.common.constant;

/**
 * 通用常量信息
 * 
 * @author ruoyi
 */
public class Constants
{
    /**
     * UTF-8 字符集
     */
    public static final String UTF8 = "UTF-8";

    /**
     * GBK 字符集
     */
    public static final String GBK = "GBK";

    /**
     * 防重提交 redis key
     */
    public static final String REPEAT_SUBMIT_KEY = "repeat_submit:";

    /**
     * 限流 redis key
     */
    public static final  String RATE_LIMIT_KEY = "rate_limit:";

}

RepeatedlyRequestWrapper过滤器

package com.goodsoft.shrk.component.filter;

import cn.hutool.core.io.IoUtil;
import com.goodsoft.shrk.common.constant.Constants;

import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;

/**
 * 构建可重复读取inputStream的request
 *
 * @author ruoyi
 */
public class RepeatedlyRequestWrapper extends HttpServletRequestWrapper {
    private final byte[] body;

    public RepeatedlyRequestWrapper(HttpServletRequest request, ServletResponse response) throws IOException {
        super(request);
        request.setCharacterEncoding(Constants.UTF8);
        response.setCharacterEncoding(Constants.UTF8);

        body = IoUtil.readUtf8(request.getInputStream()).getBytes(StandardCharsets.UTF_8);
    }

    @Override
    public BufferedReader getReader() throws IOException {
        return new BufferedReader(new InputStreamReader(getInputStream()));
    }

    @Override
    public ServletInputStream getInputStream() throws IOException {
        final ByteArrayInputStream bais = new ByteArrayInputStream(body);
        return new ServletInputStream() {
            @Override
            public int read() throws IOException {
                return bais.read();
            }

            @Override
            public int available() throws IOException {
                return body.length;
            }

            @Override
            public boolean isFinished() {
                return false;
            }

            @Override
            public boolean isReady() {
                return false;
            }

            @Override
            public void setReadListener(ReadListener readListener) {

            }
        };
    }
}

这里需要导入 hutool 工具包

        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-core</artifactId>
            <version>5.8.6</version>
        </dependency>

注册RepeatSubmitInterceptor拦截器，需要继承WebMvcConfigurerAdapter类
需要重写addInterceptors方法，这里是对根目录"/"进行拦截，可以指定拦截url请求目录

package com.goodsoft.shrk.common.config;

import com.goodsoft.shrk.common.interceptor.RepeatSubmitInterceptor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
@Slf4j
public class InterceptorConfig implements WebMvcConfigurer {
    @Autowired
    RepeatSubmitInterceptor repeatSubmitInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(repeatSubmitInterceptor).addPathPatterns("/**");
    }
}

在这里插入图片描述

YXWik6
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
防抖、防止频繁请求(重复提交相同数据)
总结分享
03-12 3422
这篇文章将介绍如何在 `java `中`不依赖数据库`完成防抖、防止重复提交相同数据
java接口防抖的优雅处理
超级博客
12-29 1917
接口以redis 键值判断的形式直接做防抖
在Spring Boot中实现接口防抖（即防止接口在短时间内被频繁调用）
最新发布
qq_45801211的博客
06-07 161
在springboot中实现接口防抖
Java版的防抖(debounce)和节流(throttle)
Chenhui98的博客
08-09 2107
Java版的防抖(debounce)和节流(throttle)
如何编写拦截器？
mc_ChenF_B的博客
06-29 901
拦截器是指在处理请求或响应数据之前，先对其进行拦截并进行一些自定义的处理，常用于实现权限认证、数据统计等功能。以上是Java编写拦截器的基本步骤，具体实现可根据项目需求进行调整。
java自定义拦截器用法实例
09-03
Java自定义拦截器是Java开发中一种常见的设计模式，它主要用于在执行某个操作或方法之前进行额外的处理，如权限检查、日志记录等。在Java Web应用中，特别是使用Struts2框架时，拦截器扮演着至关重要的角色。下面...
实现java自定义注解拦截器.docx
07-03
内容：拦截器的使用很简单，定义一个自己的拦截器，向配置中添加一下就可以使用。...oTokenInterceptor.java 自定义拦截器 oInterceptorConfig.java 添加拦截器进入项目 oNoNeedToken.java 自定义注解
SpringMVC自定义拦截器实现过程详解
08-19
SpringMVC自定义拦截器实现过程详解 SpringMVC自定义拦截器是指在SpringMVC框架中，开发者可以自定义一些拦截器来实现特定的功能。拦截器是AOP思想的具体应用，用于对处理器进行预处理和后处理。在SpringMVC框架中...
SpringBoot 自定义拦截器 的 源代码
01-27
我们对拦截器并不陌生，无论是 Struts 2 还是 Spring MVC 中都提供了拦截器功能，它可以根据 URL 对请求进行拦截，主要应用于登陆校验、权限验证、乱码解决、性能监控和异常处理等功能上。Spring Boot 同样提供了...
Mybatis自定义拦截器,对模糊查询传值的特殊字符(\,_,%)统一进行转义处理的代码
07-27
代码包含: EscapeUtil.java:特殊字符(\,_,%)转义工具类 MyQueryInterceptor.java: Mybatis自定义拦截器 注意:该拦截器只支持QueryWrapper的like方法,serviceImpl层传全角模糊查询(%%) mapper或xml层的全角模糊查询(%...
SpringBoot项目防止重复提交表单（防抖机制）插件
u011584350的博客
09-27 1503
基于SpringBoot的后端防抖插件
SpringMVC 5.0版本 使用HandlerInterceptor之后handler instanceof HandlerMethod报false的解决
码码哈哈的博客
08-12 1114
问题: 在使用拦截器之后会出现 拦截器放行的请求路径 使用@CrossOrigin可以正常实现跨域,但是被拦截器拦截的前端会依旧报跨域,也就是部分请求可以跨域部分不可以 添加如下配置 import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.web.cors.CorsConfigurat
（转载）BUG记录: 拦截器 handler instanceof HandlerMethod 一直为false ( 原因导错了jar包 )
qq_44329807的博客
04-15 461
BUG记录: 拦截器 handler instanceof HandlerMethod 一直为false ( 原因导错了jar包 )
接口安全----接口防刷（拦截器）
qq_47614329的博客
01-03 1093
接口安全----接口防刷（拦截器）
登录认证功能的统一拦截技术(拦截器)
m0_72167535的博客
04-09 1725
实现HandlerInterceptor接口，并重写其所有方法//自定义拦截器@Component//目标资源方法执行前执行。返回true：放行 返回false：不放行@Override//true表示放行//目标资源方法执行后执行@Override//视图渲染完毕后执行，最后执行@Override注意：preHandle方法：目标资源方法执行前执行。返回true：放行 返回false：不放行。postHandle方法：目标资源方法执行后执行。
防抖处理(后端处理)
qq_44706044的博客
06-28 4833
什么是防抖 ？ 在一定时间间隔内函数被触发多次，但只执行最后一次。 PS:虽然实际场景中都是前端在处理，但是后端也是需要进行处理的。 解决方案思路：通过SpringMvc对请求进行拦截，然后进行重复校验，具体步骤看下面。 1.配置自定义的拦截器 /** * 防止重复提交拦截器 * * @author ruoyi */ @Component public abstract class RepeatSubmitInterceptor extends HandlerInterceptorAdapter {
java 自定义拦截器
m0_38068812的博客
09-24 930
一、拦截器    过滤器作用于Web端，而拦截器作用于整个java,作用范围也就更加的广泛 二、下面就对拦截器在开发中的使用做一个例子举例说明    以用户登陆为例子，用户在登陆后，才能访问其他页面，如果没有登陆，就跳转到登陆页面，此时我们用拦截器来实现 三、拦截器的简单示例 1.web页面 &lt;%@ page language="java" import="java.util....
java数据防抖
weixin_49314548的博客
03-03 662
java数据防抖
防抖算法小结
热门推荐
nachoe的博客
05-12 2万+
最近研究了一下防抖算法，总结如下，欢迎大家交流。防抖算法我总结一下三个方向： deconv method base gyro method feature method 下面说一下我对上述各种方法的理解。 - deconv method 该方法的模型数学表示如下：Blurred image=Sharp image* kernel+Noise 公式1 这样问题就来了，当我们有且仅有一个模糊图像

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值