SpringBoot自定义注解防止表单重复提交

最新推荐文章于 2024-07-26 11:21:22 发布
最新推荐文章于 2024-07-26 11:21:22 发布
阅读量2.9k 收藏 19
点赞数 1
分类专栏： 平凡之路每一步 文章标签： Spring AOP Redis 接口防重复提交 注解 切面编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/llwutong/article/details/118197189
版权
前言：

本文介绍基于redis和toke机制，自定义@RepeatSubmit注解来实现防止接口重复调用情况。

实现教程：
  1. 自定义注解是基于spring aop实现的，所以需要先查看是否引入了aop的依赖，如果没有的话在pom文件中添加以下依赖，还有redis的依赖。
<!-- 引入aop相关 -->
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<!-- redis-->
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
  1. redis配置为：
spring:
  redis:
    database: 0
    host: 127.0.0.1
    port: 6379
    timeout: 5000
    password:
  1. 接下来我们来自定义@RepeatSubmit注解，这里的time我们用来控制防止重复提交的时间，默认为一秒。
    使用@RepeatSubmit(time = xxx)来指定时间。
package com.blog.utils.aop;

import java.lang.annotation.*;

/**
 * @Description: 自定义注解防止表单重复提交
 * @Author: LiWT
 * @Date: 2021/6/24
 */
@Inherited
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RepeatSubmit {
    int time() default 1;

}
  1. 开头我们就提到了，是使用spring aop实现的，那么接下来我们来定义切面、切入点
package com.blog.utils.aop;

import com.blog.utils.Md5Utils;
import com.blog.utils.RedisCache;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

/**
 * @Description: 防止重复提交
 * @Author: LiWT
 * @Date: 2021/6/24
 */
@Component
@Slf4j
@Aspect
public class NoRepeatSubmitAspect {

    private static final String JWT_TOKEN_KEY = "Authorization";
    @Autowired
    private RedisCache redisCache;

    @Pointcut("@annotation(com.blog.utils.aop.RepeatSubmit)")
    public void serviceNoRepeat() {
    }

    @Around("serviceNoRepeat()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {

        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        String jwtToken = request.getHeader(JWT_TOKEN_KEY);
        if (!StringUtils.hasText(jwtToken)) {
            jwtToken = UUID.randomUUID().toString();
        }
        String key = Md5Utils.hash(jwtToken + "-" + request.getRequestURL().toString());
        if (redisCache.getCacheObject(key) == null) {
            try {
                Object o = pjp.proceed();
                MethodSignature signature = (MethodSignature) pjp.getSignature();
                RepeatSubmit repeatSubmit = signature.getMethod().getAnnotation(RepeatSubmit.class);
                // 默认1秒内统一用户同一个地址同一个参数，视为重复提交
                redisCache.setCacheObject(key, signature.getMethod().toString(), repeatSubmit.time(), TimeUnit.SECONDS);
                return o;
            } catch (Exception e) {
                throw new RuntimeException(e.getMessage());
            }
        } else {
            throw new RuntimeException("请勿重复请求");
        }
    }

}
  • 其中@Aspect定义了这个类是一个切面，@Pointcut为切入点，它指向了我们刚定义的注解，所以我们可以使用@RepeatSubmit
    这个注解来实现aop，@Around为环绕增强。
  • 其大概实现思路是我们将用户的token信息及用户的请求路径拼接作为key，将参数信息作为value，同时将我们注解中定义的time作为过期时间存入redis缓存中，在下次请求到来前先检测该key是否存在于缓存中，如果存在则认为它是重复提交，抛出相应异常。
  1. 刚我们也有提到是基于redis和token机制实现的防重复提交，所以会依赖于redis，这里不再过多讲述redis了，redis工具类如下，直接粘贴到项目中即可。
package com.blog.utils;

import com.alibaba.fastjson.support.spring.FastJsonRedisSerializer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Component;

import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * redis 工具类
 * @author LiWT
 * @Date 2021-06-22
 **/
@SuppressWarnings(value = {"unchecked", "rawtypes"})
@Component
public class RedisCache {
    public RedisTemplate redisTemplate;


    @Autowired
    public RedisCache(RedisTemplate redisTemplate){
        this.redisTemplate=redisTemplate;
        this.redisTemplate.setKeySerializer(new StringRedisSerializer());
        this.redisTemplate.setValueSerializer(new FastJsonRedisSerializer(Object.class));
    }

    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key   缓存的键值
     * @param value 缓存的值
     */
    public <T> void setCacheObject(final String key, final T value) {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key      缓存的键值
     * @param value    缓存的值
     * @param timeout  时间
     * @param timeUnit 时间颗粒度
     */
    public <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit) {
        redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
    }

    /**
     * 设置有效时间
     *
     * @param key     Redis键
     * @param timeout 超时时间
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout) {
        return expire(key, timeout, TimeUnit.SECONDS);
    }

    /**
     * 设置有效时间
     *
     * @param key     Redis键
     * @param timeout 超时时间
     * @param unit    时间单位
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout, final TimeUnit unit) {
        return redisTemplate.expire(key, timeout, unit);
    }

    /**
     * 获得缓存的基本对象。
     *
     * @param key 缓存键值
     * @return 缓存键值对应的数据
     */
    public <T> T getCacheObject(final String key) {
        ValueOperations<String, T> operation = redisTemplate.opsForValue();
        return operation.get(key);
    }

    /**
     * 删除单个对象
     *
     * @param key
     */
    public boolean deleteObject(final String key) {
        return redisTemplate.delete(key);
    }

    /**
     * 删除集合对象
     *
     * @param collection 多个对象
     * @return
     */
    public long deleteObject(final Collection collection) {
        return redisTemplate.delete(collection);
    }

    /**
     * 缓存List数据
     *
     * @param key    缓存的键值
     * @param %values 待缓存的List数据
     * @return 缓存的对象
     */
    public <T> long setCacheList(final String key, final List<T> dataList) {
        Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
        return count == null ? 0 : count;
    }

    /**
     * 获得缓存的list对象
     *
     * @param key 缓存的键值
     * @return 缓存键值对应的数据
     */
    public <T> List<T> getCacheList(final String key) {
        return redisTemplate.opsForList().range(key, 0, -1);
    }

    /**
     * 缓存Set
     *
     * @param key     缓存键值
     * @param dataSet 缓存的数据
     * @return 缓存数据的对象
     */
    public <T> long setCacheSet(final String key, final Set<T> dataSet) {
        Long count = redisTemplate.opsForSet().add(key, dataSet);
        return count == null ? 0 : count;
    }

    /**
     * 获得缓存的set
     *
     * @param key
     * @return
     */
    public <T> Set<T> getCacheSet(final String key) {
        return redisTemplate.opsForSet().members(key);
    }

    /**
     * 缓存Map
     *
     * @param key
     * @param dataMap
     */
    public <T> void setCacheMap(final String key, final Map<String, T> dataMap) {
        if (dataMap != null) {
            redisTemplate.opsForHash().putAll(key, dataMap);
        }
    }

    /**
     * 获得缓存的Map
     *
     * @param key
     * @return
     */
    public <T> Map<String, T> getCacheMap(final String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * 往Hash中存入数据
     *
     * @param key   Redis键
     * @param hKey  Hash键
     * @param value 值
     */
    public <T> void setCacheMapValue(final String key, final String hKey, final T value) {
        redisTemplate.opsForHash().put(key, hKey, value);
    }

    /**
     * 获取Hash中的数据
     *
     * @param key  Redis键
     * @param hKey Hash键
     * @return Hash中的对象
     */
    public <T> T getCacheMapValue(final String key, final String hKey) {
        HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
        return opsForHash.get(key, hKey);
    }

    /**
     * 获取多个Hash中的数据
     *
     * @param key   Redis键
     * @param hKeys Hash键集合
     * @return Hash对象集合
     */
    public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys) {
        return redisTemplate.opsForHash().multiGet(key, hKeys);
    }

    /**
     * 获得缓存的基本对象列表
     *
     * @param pattern 字符串前缀
     * @return 对象列表
     */
    public Collection<String> keys(final String pattern) {
        return redisTemplate.keys(pattern);
    }

    /**
     * @param key 增长的key
     * @return
     */
    public Long increment(final String key) {
        return redisTemplate.opsForValue().increment(key);
    }
}
  1. 还需要一个MD5加密的方法，也是直接粘贴至项目中即可，当然也可以使用其他的加密算法。
package com.blog.utils;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.security.MessageDigest;

/**
 * Md5加密方法
 */
public class Md5Utils {
    private static final Logger log = LoggerFactory.getLogger(Md5Utils.class);

    private static byte[] md5(String s) {
        MessageDigest algorithm;
        try {
            algorithm = MessageDigest.getInstance("MD5");
            algorithm.reset();
            algorithm.update(s.getBytes("UTF-8"));
            byte[] messageDigest = algorithm.digest();
            return messageDigest;
        } catch (Exception e) {
            log.error("MD5 Error...", e);
        }
        return null;
    }

    private static String toHex(byte hash[]) {
        if (hash == null) {
            return null;
        }
        StringBuffer buf = new StringBuffer(hash.length * 2);
        int i;

        for (i = 0; i < hash.length; i++) {
            if ((hash[i] & 0xff) < 0x10) {
                buf.append("0");
            }
            buf.append(Long.toString(hash[i] & 0xff, 16));
        }
        return buf.toString();
    }

    public static String hash(String s) {
        try {
            return new String(toHex(md5(s)).getBytes("UTF-8"), "UTF-8");
        } catch (Exception e) {
            log.error("not supported charset...", e);
            return s;
        }
    }
}
  1. ok，我们的配置到这里就结束了，接下来让我们来测试一下，测试接口如下：
package com.blog.controller;

import com.blog.utils.aop.RepeatSubmit;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @Author: LiWT
 * @Date: 2021/6/22
 */
@RestController
@RequestMapping("/test")
public class TestController {

    /**
     * 测试重复提交
     * 这里我们将time设置为3秒，也就是3秒内我们同一个请求，同一个token，同一个参数不能重复请求。
     * @param param 参数
     */
    @GetMapping("/testRepeatSubmit")
    @RepeatSubmit(time = 3)
    public String testRepeatSubmit(String param) {
        System.out.println("param:" + param);
        return "请求成功，参数为：" + param;
    }
}

  • 这里我使用的是postman测试工具，首先在请求头中设置Authorization为我们的token，token我就随意填写了，然后填入我们的测试接口开始测试。
    在这里插入图片描述
    在这里插入图片描述

  • 可以看出我们第一次请求是成功响应，紧接着我们再进行第二次请求，也就是我们模拟的重复提交表单
    在这里插入图片描述

  • 第二次提示请勿重复请求，且响应状态码为500，ok，到这里我们的防止重复提交的注解就完成了，防止重复提交在实际项目中还是比较实用的，小伙伴们快去自己项目中体验吧！

`送你一朵小红花
关注
专栏目录
SpringBoot自定义注解防止表单重复提交(幂等性)
实战架构师
07-31 426
文章目录一.前端限制二.后端限制三.实现3.1 自定义注解防止表单重复提交3.2 配置父类拦截器3.3 重复提交的拦截器实现类3.4 配置拦截器3.5 构建可重复读取inputStream的request3.5.1 继承HttpServletRequestWrapper类3.5.2 实现Filter接口3.5.3 配置Filter3.5.4 辅助类3.5.4.1 转义和反转义工具类3.5.4.2 HTML过滤器，用于去除XSS漏洞隐患3.5.4.3 通用http工具封装3.5.4.4 通用http发送方法
Spring Boot使用@RepeatSubmit 防止重复提交
热门推荐
weixin_43978032的博客
11-20 1万+
自定义防止重复提交的注解 @Inherited @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface RepeatSubmit { } 防止重复提交的拦截器 @Component public abstract class RepeatSubmitInterceptor extends HandlerInterceptorAdapter {
SpringBoot自定义注解 + AOP 防止重复提交（建议收藏）
王不困的博客
03-24 881
Annotation(注解)从JDK 1.5开始, Java增加了对元数据(MetaData)的支持，也就是 Annotation(注解)。注解其实就是代码里的特殊标记，它用于替代配置文件，常见的很多，有 @Override、@Deprecated等什么是元注解元注解是注解的注解，比如当我们需要自定义注解时会需要一些元注解（meta-annotation），如@Target和@Retentionjava内置4种元注解@Target 表示该注解用于什么地方。
一个注解实现后端防重复提交
最新发布
ASDASDASX的博客
07-26 382
一个注解实现接口防重
SpringBoot 自定义注解+AOP+Redis 防止接口重复提交表单数据
Lyndon的专栏
10-28 1281
数据重复提交导致多次请求服务、入库，产生脏数据、冗余数据等情况。禁止重复提交使我们保证数据准确性及安全性的必要操作。
springboot自定义注解实现防重复提交（服务缓存）
bobjy_happybird的专栏
02-10 439
自定义注解实现防重复提交（服务缓存），单位时间内（unitTime）参数一样的重复请求会直接从redis中读取上次的缓存结果返回
springboot防止重复提交自定义注解
黑科技的专栏
01-04 290
springboot防止重复提交自定义注解
防止重复提交注解
qq_38795959的博客
04-30 6767
防止重复提交 标记注解 /** * Title: NoRepeatSubmit * Description: 防止重复提交标记注解 * * @author kindin */ @Target(ElementType.METHOD) // 作用到方法上 @Retention(RetentionPolicy.RUNTIME) // 运行时有效 public @interface NoRe...
SpringBoot自定义注解 + AOP 解决防止重复提交
2301_76607156的博客
04-06 331
Annotation(注解)从JDK 1.5开始, Java增加了对元数据(MetaData)的支持，也就是 Annotation(注解)。注解其实就是代码里的特殊标记，它用于替代配置文件，常见的很多，有 @Override、@Deprecated等什么是元注解元注解是注解的注解，比如当我们需要自定义注解时会需要一些元注解（meta-annotation），如@Target和@Retentionjava内置4种元注解@Target 表示该注解用于什么地方。
SpringBoot使用Session防止表单重复提交（提供Gitee源码）
黄团团的个人博客
06-17 1657
在日常开发中，客户可能会存在反复点击提交按钮导致表单的重复提交，这个问题也是非常需要重视的，在本篇博客中，采用的是session、自定义注解和拦截器的方式来防止重复表单的重复提交，提高整体代码的优雅和整洁度！
Spring注解方式防止重复提交原理详解
08-26
主要为大家详细介绍了Spring注解方式防止重复提交原理，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
防重复提交注解
xiaoshitou_2015的博客
04-15 202
【代码】防重复提交注解。
防止表单重复提交注解类
qq_33550151的博客
07-22 146
注解类 import java.lang.annotation.*; @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) @Documented @Inherited public @interface NoRepeatSubmit { /** * Key前缀 */ String key() default ""; /** * 拼接方式 */ Str
防重复提交（注解+AOP）
Be_insighted的博客
03-21 2001
第一步：定义防刷注解、启动类开启切面支持、pom引入依赖 @Target({ElementType.TYPE,ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface RequestRepeatAnnotation { //允许访问的次数，默认值MAX_VALUE int count() default Integer.MAX_VALUE; // 时间段，单.
若依-（@RepeatSubmit）（防止重复提交）
hwp_ing的博客
06-26 1383
第一个框是生成了唯一的key，仔细看key的组成为url+token+参数,意味着每一个用户的每一个请求都在redis当中存了个key，值的化存了个空字符串（因为我们只需要key来保证唯一性，值不存东西也行）。首先，我们获取这个key的值，如果是空说明用户第一次请求，然后将key存进去。如果不为空，说明在限制时间里（key没过期）用户再次进行了提交，返回错误信息。原版若依的判定如下通过判断用户的url是否一致，在判断参数是否一致，在比较两次请求的时间是否小于限制时间来进行防止重复提交。
SpringBoot2.7.x 添加防止表单重复提交
u014212540的博客
02-27 119
SpringBoot2.7.x 添加防止表单重复提交
注解实现防止重复提交(Aop)
欢迎一起学习交流
06-28 490
书接上回，上次实现了springboot整合redis，在使用过程中就避免不了重复提交的场景。为了防止以上情况的出现需要自定义一个注解来完成防止重复提交操作。
springboot 防止重复提交
03-29
在Spring Boot中，防止重复提交可以使用以下方法： 1. 使用Token机制：在表单中添加一个隐藏的Token字段，当用户提交表单时，服务器会检查该Token是否有效，如果有效则处理请求，否则拒绝请求。Token可以在服务器端生成并存储在会话中，每次提交表单时，服务器会从会话中获取Token并比较。 2. 使用拦截器：在Spring Boot中，可以使用拦截器来防止重复提交。拦截器可以在请求到达Controller之前拦截请求，检查请求是否已经处理过，如果已经处理过，则拒绝请求。可以在拦截器中使用Redis等缓存技术来存储请求信息。 3. 使用注解：在Spring Boot中，可以使用自定义注解来防止重复提交。可以在Controller的方法上添加自定义注解，当用户提交表单时，服务器会检查该注解是否存在，如果存在则处理请求，否则拒绝请求。可以在注解中使用Redis等缓存技术来存储请求信息。 4. 使用前端技术：在前端页面中，可以使用JavaScript等技术来防止重复提交。可以在提交表单时，禁用提交按钮，防止用户多次提交。可以在提交完成后，重新启用提交按钮。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值