SpringBoot+Redis实现后端接口防重复提交校验的示例

2024-04-02 19:04:59 376人浏览独家记忆

Python 官方文档：入门教程 => 点击学习

摘要

目录1 Maven依赖2 RepeatedlyRequestWrapper3 RepeatableFilter4 RepeatSubmit5

1 Maven依赖


        <!--Redis缓存-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
 
        <!-- 阿里JSON解析器 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.76</version>
        </dependency>
        <!--hutool工具包-->
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.5.1</version>
        </dependency>

2 RepeatedlyRequestWrapper

构建可重复读取inputStream的request。


package com.servlet;
 
 
import javax.servlet.*;
import javax.servlet.Http.*;
import java.io.*;
import java.NIO.charset.Charset;
 

public class RepeatedlyRequestWrapper extends httpservletRequestWrapper {
    private final String body;
 
    public RepeatedlyRequestWrapper(HttpServletRequest request, ServletResponse response) throws IOException {
        super(request);
        request.setCharacterEncoding("UTF-8");
        response.setCharacterEncoding("UTF-8");
 
        body = getBodyString(request);
    }
 
    @Override
    public BufferedReader getReader() throws IOException {
        return new BufferedReader(new InputStreamReader(getInputStream()));
    }
 
    public String getBody() {
        return body;
    }
 
    @Override
    public ServletInputStream getInputStream() throws IOException {
        final ByteArrayInputStream bais = new ByteArrayInputStream(body.getBytes("UTF-8"));
        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) {
 
            }
        };
    }
 
    
    private String getBodyString(ServletRequest request) {
        StringBuilder sb = new StringBuilder();
        BufferedReader reader = null;
        try (InputStream 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 (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return sb.toString();
    }
}

3 RepeatableFilter

将原生的request变为可重复读取inputStream的request。


package com.filter;
 
import com.servlet.RepeatedlyRequestWrapper;
import org.springframework.http.MediaType;
import org.springframework.util.StringUtils;
 
import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
 

public class RepeatableFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        ServletRequest requestWrapper = null;
        //将原生的request变为可重复读取inputStream的request
        if (request instanceof HttpServletRequest
                && StringUtils.startsWithIgnoreCase(request.getContentType(), MediaType.APPLICATION_JSON_VALUE)) {
            requestWrapper = new RepeatedlyRequestWrapper((HttpServletRequest) request, response);
        }
        if (null == requestWrapper) {
            chain.doFilter(request, response);
        } else {
            chain.doFilter(requestWrapper, response);
        }
    }
}

4 RepeatSubmit

自定义注解（防止表单重复提交）。


package com.annotation;
 
import java.lang.annotation.*;
 

@Inherited
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RepeatSubmit {
}

5 RepeatSubmitInterceptor

防止重复提交拦截器。


package com.interceptor;
 
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSONObject;
import com.annotation.RepeatSubmit;
import com.service.*;
import com.servlet.RepeatedlyRequestWrapper;
import org.springframework.beans.factory.annotation.*;
import org.springframework.stereotype.Component;
import org.springframework.WEB.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
 
import javax.servlet.http.*;
import java.io.IOException;
import java.lang.reflect.Method;
import java.util.*;
import java.util.concurrent.TimeUnit;
 

@Component
public class RepeatSubmitInterceptor implements HandlerInterceptor {
    public final String REPEAT_PARAMS = "repeatParams";
 
    public final String REPEAT_TIME = "repeatTime";
    
    public final String REPEAT_SUBMIT_KEY = "repeat_submit:";
 
    // 令牌自定义标识
    @Value("${token.header}")
    private String header;
 
    @Autowired
    private RedisService redisService;
 
    
    @Value("${repeatSubmit.intervalTime}")
    private int intervalTime;
 
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        if (handler instanceof HandlerMethod) {
            HandlerMethod handlerMethod = (HandlerMethod) handler;
            Method method = handlerMethod.getMethod();
            RepeatSubmit annotation = method.getAnnotation(RepeatSubmit.class);
            if (annotation != null) {
                if (this.isRepeatSubmit(request)) {
                    //返回重复提交提示
                    Map<String, Object> resultMap = new HashMap<>();
                    resultMap.put("code", "500");
                    resultMap.put("msg", request.getRequestURI() + "不允许重复提交，请稍后再试");
                    try {
                        response.setStatus(200);
                        response.setContentType("application/json");
                        response.setCharacterEncoding("utf-8");
                        response.getWriter().print(JSONObject.toJSONString(resultMap));
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    return false;
                }
            }
            return true;
        } else {
            return preHandle(request, response, handler);
        }
    }
 
    
    public boolean isRepeatSubmit(HttpServletRequest request) {
        String nowParams = "";
        if (request instanceof RepeatedlyRequestWrapper) {
            RepeatedlyRequestWrapper repeatedlyRequest = (RepeatedlyRequestWrapper) request;
            nowParams = repeatedlyRequest.getBody();
        }
        // body参数为空，获取Parameter的数据
        if (StrUtil.isBlank(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(header);
        if (StrUtil.isBlank(submitKey)) {
            submitKey = url;
        }
 
        // 唯一标识（指定key + 消息头）
        String cacheRepeatKey = REPEAT_SUBMIT_KEY + submitKey;
 
        Object sessionObj = redisService.getCacheObject(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);
        redisService.setCacheObject(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;
    }
 
 
}

6 RepeatSubmitConfig

防重复提交配置。


package com.config;
 
import com.filter.RepeatableFilter;
import com.interceptor.RepeatSubmitInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.web.servlet.FilterReGIStrationBean;
import org.springframework.context.annotation.*;
import org.springframework.web.servlet.config.annotation.*;
 

@Configuration
public class RepeatSubmitConfig implements WebmvcConfigurer {
    @Autowired
    private RepeatSubmitInterceptor repeatSubmitInterceptor;
    
    @Override
    public void addInterceptors(InterceptorRegistry registry)
    {
        registry.addInterceptor(repeatSubmitInterceptor).addPathPatterns("
    @SuppressWarnings({ "rawtypes", "unchecked" })
    @Bean
    public FilterRegistrationBean createRepeatableFilter()
    {
        FilterRegistrationBean registration = new FilterRegistrationBean();
        registration.setFilter(new RepeatableFilter());
        registration.addUrlPatterns("
    @RepeatSubmit
    @PostMapping("/saveParam/{name}")
    public String saveParam(@PathVariable("name")String name){
        return "保存Param成功";
    }
    
    @RepeatSubmit
    @PostMapping("/saveBody")
    public String saveBody(@RequestBody List<String> name){
        return "保存Body成功";
    }
}

8 调试结果

param传参：

body传参：

注：

（1）RedisService源码请查看以下博客。

Spring Boot 配置Redis（缓存数据库）实现保存、获取、删除数据

（2）只有加上@RepeatSubmit的接口才会进行防重复提交校验。

到此这篇关于SpringBoot+Redis实现后端接口防重复提交校验的示例的文章就介绍到这了,更多相关SpringBoot接口防重复提交内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

您可能感兴趣的文档:

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: SpringBoot+Redis实现后端接口防重复提交校验的示例

本文链接: https://www.lsjlt.com/news/128918.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档

去做题

猜你喜欢

SpringBoot+Redis实现后端接口防重复提交校验的示例

目录1 Maven依赖2 RepeatedlyRequestWrapper3 RepeatableFilter4 RepeatSubmit5 ...

99+

2024-04-02
SpringBoot基于redis自定义注解实现后端接口防重复提交校验

目录一、添加依赖二、代码实现三、测试一、添加依赖 <dependency> <groupId>org.springfr...

99+

2024-04-02
Java结合redis实现接口防重复提交

redis 接口防重技术点：redis/aop 说明：简易版本实现防止重复提交，适用范围为所有接口适用，采用注解方式，在需要防重的接口上使用注解，可以设置防重时效。场景： ...

99+

2024-04-02
利用Redis实现防止接口重复提交功能

目录前言1、自定义注解2、自定义拦截器3、Redis工具类4、其他想说的前言在划水摸鱼之际，突然听到有的用户反映增加了多条一样的数据，这用户立马就不干了，让我们要马上修复，不然就要...

99+

2024-04-02
SpringBoot实现接口的各种参数校验的示例

目录1.添加依赖2.接口参数校验2.1 requestBody参数校验2.2 requestParam/PathVariable参数校验3.统一异常处理4.进阶使用4.1 分组校验4...

99+

2024-04-02
SpringBoot实现接口等幂次校验的示例代码

目录主流的实现方案如下：第一步：书写redis工具类第二步、书写token工具类第三步：定义注解，使用在方法上，当控制层的方法上被注释时，表示该请求为等幂性请求第四步：拦截器配置。选...

99+

2024-04-02
Springboot+Redis实现API接口限流的示例代码

添加Redis的jar包. <dependency> <groupId>org.springframework.boot</groupId&...

99+

2024-04-02
Java后端限制频繁请求和重复提交的实现

目录步骤一、写限制注解步骤二、解析注解步骤三、控制层注解使用当前端按连续请求多次，请求过于频繁或者是多次重复提交数据，对系统或者是数据造成了一点的损害。为了解决这个问题，下面介绍了...

99+

2024-04-02
Springboot使用redis实现接口Api限流的示例代码

前言该篇介绍的内容如题，就是利用redis实现接口的限流（某时间范围内最大的访问次数）。正文惯例，先看下我们的实战目录结构：首先...

99+

2024-04-02
SpringBoot结合Redis实现接口幂等性的示例代码

目录介绍实现过程引入 maven 依赖spring 配置文件写入引入 Redis自定义注解token 的创建和实现拦截器的配置测试用例介绍幂等性的概念是，任意多次执行所产生的影响都...

99+

2024-04-02
微信小程序登录对接Django后端实现JWT方式验证登录的示例分析

这篇文章将为大家详细讲解有关微信小程序登录对接Django后端实现JWT方式验证登录的示例分析，小编觉得挺实用的，因此分享给大家做个参考，希望大家阅读完这篇文章后可以有所收获。先上效果图点击授权按钮后可以显...

99+

2024-04-02