SpringBoot接口+Redis解决用户重复提交问题

news2024/9/24 17:15:24

前言

1. 为什么会出现用户重复提交

  • 网络延迟的情况下用户多次点击submit按钮导致表单重复提交；
  • 用户提交表单后，点击【刷新】按钮导致表单重复提交（点击浏览器的刷新按钮，就是把浏览器上次做的事情再做一次，因为这样也会导致表单重复提交）；
  • 用户提交表单后，点击浏览器的【后退】按钮回退到表单页面后进行再次提交。

2. 重复提交不拦截可能导致的问题

  • 重复数据入库，造成脏数据。即使数据库表有UK索引，该操作也会增加系统的不必要负担；
  • 会成为黑客爆破攻击的入口，大量的请求会导致应用崩溃；
  • 用户体验差，多条重复的数据还需要一条条的删除等。

3. 解决办法

办法有很多，我这里只说一种，利用Redis的set方法搞定(不是redisson)

项目代码

项目结构

在这里插入图片描述

配置文件

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.9</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>RequestLock</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>RequestLock</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <!-- redis依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!-- web依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- 切面 -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.5</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

application.properties

spring.application.name=RequestLock
server.port=8080

# Redis服务器地址
spring.redis.host=127.0.0.1
# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码（默认为空）
spring.redis.password=
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.jedis.pool.max-active=20
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.jedis.pool.max-wait=-1
# 连接池中的最大空闲连接
spring.redis.jedis.pool.max-idle=10
# 连接池中的最小空闲连接
spring.redis.jedis.pool.min-idle=0
# 连接超时时间（毫秒）
spring.redis.timeout=1000

代码文件

RequestLockApplication.java

package com.example.requestlock;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class RequestLockApplication {

    public static void main(String[] args) {
        SpringApplication.run(RequestLockApplication.class, args);
    }

}

User.java

package com.example.requestlock.model;


import com.example.requestlock.lock.annotation.RequestKeyParam;

public class User {
    
    private String name;

    private Integer age;

    @RequestKeyParam(name = "phone")
    private String phone;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", phone='" + phone + '\'' +
                '}';
    }
}

RequestKeyParam.java

package com.example.requestlock.lock.annotation;

import java.lang.annotation.*;

/**
 * @description 加上这个注解可以将参数也设置为key，唯一key来源
 */
@Target({ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface RequestKeyParam {

    /**
     * key值名称
     *
     * @return 默认为空
     */
    String name() default "";
}

RequestLock.java

package com.example.requestlock.lock.annotation;

import java.lang.annotation.*;
import java.util.concurrent.TimeUnit;

/**
 * @description 请求防抖锁，用于防止前端重复提交导致的错误
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface RequestLock {
    /**
     * redis锁前缀
     *
     * @return 默认为空，但不可为空
     */
    String prefix() default "";

    /**
     * redis锁过期时间
     *
     * @return 默认2秒
     */
    int expire() default 2;

    /**
     * redis锁过期时间单位
     *
     * @return 默认单位为秒
     */
    TimeUnit timeUnit() default TimeUnit.SECONDS;

    /**
     * redis  key分隔符
     *
     * @return 分隔符
     */
    String delimiter() default ":";
}

RequestLockMethodAspect.java

package com.example.requestlock.lock.aspect;

import com.example.requestlock.lock.annotation.RequestLock;
import com.example.requestlock.lock.keygenerator.RequestKeyGenerator;
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.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisStringCommands;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.types.Expiration;
import org.springframework.util.StringUtils;

import java.lang.reflect.Method;

/**
 * @description 请求锁切面处理器
 */
@Aspect
@Configuration
public class RequestLockMethodAspect {

    private final StringRedisTemplate stringRedisTemplate;
    private final RequestKeyGenerator requestKeyGenerator;


    @Autowired
    public RequestLockMethodAspect(StringRedisTemplate stringRedisTemplate, RequestKeyGenerator requestKeyGenerator) {
        this.requestKeyGenerator = requestKeyGenerator;
        this.stringRedisTemplate = stringRedisTemplate;
    }

    @Around("execution(public * * (..)) && @annotation(com.example.requestlock.lock.annotation.RequestLock)")
    public Object interceptor(ProceedingJoinPoint joinPoint) {
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        Method method = methodSignature.getMethod();
        RequestLock requestLock = method.getAnnotation(RequestLock.class);
        if (StringUtils.isEmpty(requestLock.prefix())) {
//            throw new RuntimeException("重复提交前缀不能为空");
            return "重复提交前缀不能为空";
        }
        //获取自定义key
        final String lockKey = requestKeyGenerator.getLockKey(joinPoint);
        final Boolean success = stringRedisTemplate.execute(
                (RedisCallback<Boolean>) connection -> connection.set(lockKey.getBytes(), new byte[0], Expiration.from(requestLock.expire(), requestLock.timeUnit())
                        , RedisStringCommands.SetOption.SET_IF_ABSENT));
        if (!success) {
//            throw new RuntimeException("您的操作太快了,请稍后重试");
            return "您的操作太快了,请稍后重试";
        }
        try {
            return joinPoint.proceed();
        } catch (Throwable throwable) {
//            throw new RuntimeException("系统异常");
            return "系统异常";
        }
    }
}

RequestKeyGenerator.java

package com.example.requestlock.lock.keygenerator;

import org.aspectj.lang.ProceedingJoinPoint;

/**
 * 加锁key生成器
 */
public interface RequestKeyGenerator {
    /**
     * 获取AOP参数,生成指定缓存Key
     *
     * @param joinPoint 切入点
     * @return 返回key值
     */
    String getLockKey(ProceedingJoinPoint joinPoint);
}

RequestKeyGeneratorImpl.java

package com.example.requestlock.lock.keygenerator.impl;

import com.example.requestlock.lock.annotation.RequestKeyParam;
import com.example.requestlock.lock.annotation.RequestLock;
import com.example.requestlock.lock.keygenerator.RequestKeyGenerator;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Service;
import org.springframework.util.ReflectionUtils;
import org.springframework.util.StringUtils;

import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;

@Service
public class RequestKeyGeneratorImpl implements RequestKeyGenerator {

    @Override
    public String getLockKey(ProceedingJoinPoint joinPoint) {
        //获取连接点的方法签名对象
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        //Method对象
        Method method = methodSignature.getMethod();
        //获取Method对象上的注解对象
        RequestLock requestLock = method.getAnnotation(RequestLock.class);
        //获取方法参数
        final Object[] args = joinPoint.getArgs();
        //获取Method对象上所有的注解
        final Parameter[] parameters = method.getParameters();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < parameters.length; i++) {
            final RequestKeyParam cacheParams = parameters[i].getAnnotation(RequestKeyParam.class);
            //如果属性不是CacheParam注解，则不处理
            if (cacheParams == null) {
                continue;
            }
            //如果属性是CacheParam注解，则拼接 连接符（：）+ CacheParam
            sb.append(requestLock.delimiter()).append(args[i]);
        }
        //如果方法上没有加CacheParam注解
        if (StringUtils.isEmpty(sb.toString())) {
            //获取方法上的多个注解（为什么是两层数组：因为第二层数组是只有一个元素的数组）
            final Annotation[][] parameterAnnotations = method.getParameterAnnotations();
            //循环注解
            for (int i = 0; i < parameterAnnotations.length; i++) {
                final Object object = args[i];
                //获取注解类中所有的属性字段
                final Field[] fields = object.getClass().getDeclaredFields();
                for (Field field : fields) {
                    //判断字段上是否有CacheParam注解
                    final RequestKeyParam annotation = field.getAnnotation(RequestKeyParam.class);
                    //如果没有，跳过
                    if (annotation == null) {
                        continue;
                    }
                    //如果有，设置Accessible为true（为true时可以使用反射访问私有变量，否则不能访问私有变量）
                    field.setAccessible(true);
                    //如果属性是CacheParam注解，则拼接 连接符（：）+ CacheParam
                    sb.append(requestLock.delimiter()).append(ReflectionUtils.getField(field, object));
                }
            }
        }
        //返回指定前缀的key
        return requestLock.prefix() + sb;
    }
}

UserController.java

package com.example.requestlock.controller;

import com.example.requestlock.lock.annotation.RequestLock;
import com.example.requestlock.model.User;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/user")
public class UserController {

    @PostMapping("/addUser1")
    public String addUser1(@RequestBody User user) {
        System.out.println("不做任何处理" + user);
        return "添加成功";
    }

    @PostMapping("/addUser2")
    @RequestLock(prefix = "addUser")
    public String addUser2(@RequestBody User user) {
        System.out.println("防重提交" + user);
        return "添加成功";
    }
}

效果展示

调用addUser1接口

在这里插入图片描述
这里无论点击多少次提交，都会展示添加“添加成功”，这样是不行的。

调用addUser2接口

在这里插入图片描述
第一次提交，“添加成功”。
在这里插入图片描述
快速点击第二次提交，就会出现“您的操作太快了,请稍后重试”提示。

原理解释

该RequestLock（请求锁）利用了Redis的单线程处理以及Key值过期特点，核心通过RequestLock、RequestKeyParam注解生成一个唯一的key值，存入redis后设置一个过期时间（1-3秒），当第二次请求的时候，判断生成的key值是否在Redis中存在，如果存在则认为第二次提交是重复的。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/382700.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

前后端分页查询好大的一个坑（已解决）

前后端分页查询好大的一个坑（已解决）

前言&#xff1a;如果你在做前后端的分页查询&#xff0c;找不到错误&#xff0c;请你来看看是否是和我一样的情况&#xff1f;情况&#xff1a;做了一个前后盾UI的项目&#xff0c;有一个页面是查询系统日志&#xff0c;要进行分页查询&#xff1b;第一页的&#xff1a;第5页的…
阅读更多...
MYSQL 基础篇 | 02-MYSQL基础应用

MYSQL 基础篇 | 02-MYSQL基础应用

文章目录1 MySQL概述2 SQL2.1 SQL通用语法2.2 SQL分类2.3 DDL2.3.1 数据库操作2.3.2 表操作2.4 DML2.4.1 添加数据2.4.2 修改数据2.4.3 删除数据2.5 DQL2.5.1 基础查询2.5.2 条件查询2.5.3 聚合查询2.5.4 分组查询2.5.5 排序查询2.5.6 分页查询2.5.7 综合练习2.6 DCL2.6.1 管理…
阅读更多...
SQLMAP使用

SQLMAP使用

SQLMAPSQLMAP是什么SQLMAP可以对URL做什么&#xff1f;SQLMAP支持的注入技术SQLMAP检测注入漏洞流程&#xff1a;SQLMAP的误报检测机制SQLMAP基本使用常见用法常见参数tamper参数操作系统权限参数文件读写参数SQLMAP是什么 SQLMAP是一个开源的自动化SQL注入工具&#xff0c;主…
阅读更多...
SAP 生产订单/流程订单中日期的解释

SAP 生产订单/流程订单中日期的解释

SAP 生产订单/流程订单中日期的解释 基本开始日期&#xff1a;表示订单的开始日期 基本完成日期&#xff1a;表示订单的完成日期 我们在输入基本开始日期和基本完成日期时需要关注 调度 下面的“类型”&#xff0c;其中有向前、向后、当天日期等&#xff1a; 调度类型 为向前…
阅读更多...
上海交大陈海波教授、夏虞斌教授领衔巨作上市：《操作系统：原理与实现》

上海交大陈海波教授、夏虞斌教授领衔巨作上市：《操作系统：原理与实现》

❤️作者主页&#xff1a;小虚竹 ❤️作者简介&#xff1a;大家好,我是小虚竹。2022年度博客之星评选TOP 10&#x1f3c6;&#xff0c;Java领域优质创作者&#x1f3c6;&#xff0c;CSDN博客专家&#x1f3c6;&#xff0c;华为云享专家&#x1f3c6;&#xff0c;掘金年度人气作…
阅读更多...
java 进阶—线程的常用方法

java 进阶—线程的常用方法

大家好&#xff0c;通过java进阶—多线程&#xff0c;我们知道的什么是进程&#xff0c;什么是线程&#xff0c;以及线程的三种创建方式的选择 今天&#xff0c;我们来看看线程的基础操作 start() 开启线程 public class Demo implements Runnable {Overridepublic void run…
阅读更多...
第五回：样式色彩秀芳华

第五回：样式色彩秀芳华

import matplotlib as mpl import matplotlib.pyplot as plt import numpy as np第五回详细介绍matplotlib中样式和颜色的使用&#xff0c;绘图样式和颜色是丰富可视化图表的重要手段&#xff0c;因此熟练掌握本章可以让可视化图表变得更美观&#xff0c;突出重点和凸显艺术性。…
阅读更多...
施工机械设备群远程在线监控管理系统

施工机械设备群远程在线监控管理系统

一、项目背景 在加强基础设施建设等一系列政策的牵引下&#xff0c;我国工程机械设备市场连续保持强劲增长势头&#xff0c;伴随国内中高端机械设备公司业务的不断扩展&#xff0c;施工大型机械设备的应用率不断提高&#xff0c;铁路施工特别是架桥机作业过程被认为是一个极易出…
阅读更多...
元宇宙到底是什么？元宇宙解读，这一篇就够了！

元宇宙到底是什么？元宇宙解读，这一篇就够了！

欢迎来到Hubbleverse &#x1f30d; 关注我们 关注宇宙新鲜事 &#x1f4cc; 预计阅读时长&#xff1a;12分钟 本文仅代表作者个人观点&#xff0c;不代表平台意见&#xff0c;不构成投资建议。 在元宇宙中&#xff0c;我们被承诺可以成为任何人&#xff0c;做任何事&#…
阅读更多...
JavaSE20-集合1-list

JavaSE20-集合1-list

文章目录一、集合概念二、list集合1、list集合特点2、ArrayList2.1 创建对象2.2 常用方法2.3 遍历2.3.1 使用索引遍历2.3.2 使用迭代器遍历2.3.3 使用foreach遍历2.3.4 集合转换为数组遍历3、LinkedList3.1 创建对象3.2 常用方法3.3 遍历4、ArrayList和LinkedList的区别一、集合…
阅读更多...
支持DDR5，超频更简单，小雕够给力，技嘉B760M小雕WIFI主板上手

支持DDR5，超频更简单，小雕够给力，技嘉B760M小雕WIFI主板上手

目前13代酷睿已经全员集结了&#xff0c;其中全新的i5 13490F应该依然会备受欢迎&#xff0c;当然了&#xff0c;刚上市不久的13代酷睿价格方面还不是很有吸引力&#xff0c;好在12代酷睿在新一代主板上面依然可用&#xff0c;所以预算有限的朋友&#xff0c;完全可用继续使用1…
阅读更多...
原生微信小程序引入npm和安装Vant Weapp

原生微信小程序引入npm和安装Vant Weapp

目录一、引入npm安装Vant Weapp1、引入npm2、安装Vant Weapp3、修改 app.json4、修改 project.config.json二、构建npm一、引入npm安装Vant Weapp 环境&#xff1a;Windows10 开发工具&#xff1a;微信开发者工具 本地环境&#xff1a;已安装过node.js 1、引入npm cmd进入到你…
阅读更多...
MyBatis源码分析（二、续）SqlSource创建流程，SQL如何解析？如何将#{id}变成?的

MyBatis源码分析（二、续）SqlSource创建流程，SQL如何解析？如何将#{id}变成?的

文章目录实例一、SqlSource处理入口二、SqlSource处理逻辑1、XMLScriptBuilder 构造方法2、解析动态sql3、DynamicSqlSource4、RawSqlSource解析sql&#xff08;1&#xff09;parse方法解析sql写在后面实例 此处我们分析的sql&#xff1a; <select id"selectBlog&quo…
阅读更多...
|干货 | 五种常用类型之String字符串详解

|干货 | 五种常用类型之String字符串详解

一. 背景说明小白&#xff1a;哥&#xff0c;java中String是最常用类型&#xff0c;Redis中也是吗?哥&#xff1a;差不多&#xff0c;我给你稍微讲一下。二. 数据类型依据Redis官网&#xff0c;目前Redis数据类型共计九种。具体整理如下&#xff1a;常用的数据类型有&#xff…
阅读更多...
第九章 实现isReactive和isReadonly

第九章 实现isReactive和isReadonly

实现isReactive和isReadonly isReactive实现 先上测试用例&#xff08;其实这个测试用例也是reactive.spec.ts中追加的两个&#xff09;: import { isReactive, reactive } from "../reactive"describe(reactive,()>{it(happy path,()>{const original {fo…
阅读更多...
taobao.item.sku.add( 添加SKU )

taobao.item.sku.add( 添加SKU )

&#xffe5;开放平台免费API必须用户授权 新增一个sku到num_iid指定的商品中 传入的iid所对应的商品必须属于当前会话的用户 公共参数 请求地址: HTTP地址 http://gw.api.taobao.com/router/rest 公共请求参数: 公共响应参数: 请求参数 响应参数 点击获取key和secret 请求…
阅读更多...
第十四节 包、权限修饰符、final、常量

第十四节 包、权限修饰符、final、常量

包 1.同一个包下的类&#xff0c;相互可以直接访问。 2.不同包下的类要导包后才能访问。 AIT回车键导包。 权限修饰符 什么是权限修饰符? ●权限修饰符:是用来控制一个成员能够被访问的范围。 ●可以修饰成员变量&#xff0c;方法&#xff0c;构造器&#xff0c;内部类&…
阅读更多...
并发就一定快吗？答：肯定不是啊

并发就一定快吗？答：肯定不是啊

文章目录一、多线程概念1.1 程序的并发与并行1.1.1 程序的并行1.1.2 程序的并发1.2 进程与线程1.2.1 进程1.2.2 线程1.2.3 多线程并发就一定快吗&#xff1f;答案直接戳这里&#x1f449;&#xff1a;多线程并发就一定快吗&#xff1f; 一、多线程概念 在实际应用中&#xff…
阅读更多...
车载测试之电子设备有哪些测试点？

车载测试之电子设备有哪些测试点？

现在车上大大小小的控制器大几十个&#xff0c;主机厂都要做哪些测试&#xff0c;满足哪些要求&#xff0c;才能使控制器达到量产要求呢&#xff1f; 整车开发流程 在聊测试之前&#xff0c;首先了解一下一款车的开发流程。在主机厂我们经常能听到“某某项目开G2阀”、“某某…
阅读更多...
Java接口专题

Java接口专题

基本介绍 接口给出一些没有实现的方法&#xff0c;封装到一起&#xff0c;到某个类使用时再根据具体情况把这些方法写出来。 注意&#xff1a;在jdk7之前&#xff0c;接口里所有的方法都是抽象方法。在jdk8之后接口中可以有静态方法&#xff0c;默认方法 interface 接口名{/…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023