不使用Redis分布式锁，如何避免用户重复点击提交？

于 2024-09-09 11:05:33 发布
阅读量1.2k 收藏 29
点赞数 24
分类专栏： Java后端面试 Java面试八股文 场景设计题 文章标签： redis 分布式 数据库 后端 面试 缓存 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30939943/article/details/142053735
版权

前端，在用户点击后，对按钮做置灰操作。但有些情况，用户会绕过置灰，实现重复点击。

后端，对客户端携带的token，验证是否使用过；验证逻辑，存储在数据库中，验证逻辑使用悲观锁或者乐观锁实现。
在这里插入图from hollis片描述

前端按钮置灰

  • 前端按钮置灰：在用户点击按钮后，将按钮禁用一段时间或直到请求响应。
    • 优点：简单易用，减少用户重复点击。
    • 缺点：用户可以绕过前端限制，使用浏览器开发工具重新启用按钮，因此这种方式不能完全防止重复提交。
<button id="submitBtn" οnclick="submitForm()">提交</button>

<script>
function submitForm() {
    const submitBtn = document.getElementById('submitBtn');
    
    // 禁用按钮
    submitBtn.disabled = true;

    // 模拟表单提交操作
    setTimeout(() => {
        alert("Form Submitted!");
        // 重新启用按钮
        submitBtn.disabled = false;
    }, 2000); // 模拟请求响应时间
}
</script>

使用token机制（本地缓存）

  • 使用token机制：用户在访问页面时获取一个token，提交操作时携带token，服务端验证token的有效性。这种方法通过数据库锁来确保操作的幂等性。
    • 优点：防止用户重复提交请求，尤其是在多次点击按钮的情况下，保证请求的幂等性。
    • 缺点：如果 Token 存储不当，可能会引入安全隐患，建议使用 Redis 等外部存储管理 Token 生命周期。
@RestController
public class OrderController {

    // Token存储 (可以使用Redis)
    private Map<String, Boolean> tokenStore = new ConcurrentHashMap<>();

    // 页面加载时，生成并返回一个token
    @GetMapping("/getToken")
    public String getToken() {
        String token = UUID.randomUUID().toString();
        tokenStore.put(token, true);
        return token;
    }

    // 提交表单时，验证token
    @PostMapping("/submitOrder")
    public ResponseEntity<String> submitOrder(@RequestParam String token) {
        // 验证token是否存在且有效
        if (!tokenStore.containsKey(token) || !tokenStore.get(token)) {
            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("Invalid or expired token");
        }

        // 一旦token验证通过，将其设置为无效
        tokenStore.put(token, false);

        // 处理订单逻辑
        return ResponseEntity.ok("Order submitted successfully");
    }
}
<form id="orderForm" method="POST" action="/submitOrder">
    <input type="hidden" id="token" name="token">
    <button type="submit">提交订单</button>
</form>

<script>
// 页面加载时获取token
fetch('/getToken')
    .then(response => response.text())
    .then(token => {
        document.getElementById('token').value = token;
    });
</script>

滑动窗口限流

  • 通过限制在一定时间内用户只能发起一次请求，来防止重复点击。这种方法适用于控制请求频率的场景。
    • 优点：可以有效防止用户在短时间内频繁发起请求，避免重复提交。
    • 缺点：滑动窗口限流比较适合频繁请求控制，不适合对特定操作的幂等控制。
@RestController
public class RateLimiterController {

    @Autowired
    private StringRedisTemplate redisTemplate;

    // 限制用户1分钟只能提交1次
    @PostMapping("/submitOrder")
    public ResponseEntity<String> submitOrder(@RequestParam String userId) {
        String key = "submit_rate_limit:" + userId;
        
        // 获取Redis中的限流信息
        String rateLimit = redisTemplate.opsForValue().get(key);
        
        if (rateLimit != null) {
            return ResponseEntity.status(HttpStatus.TOO_MANY_REQUESTS).body("Too many requests. Please try later.");
        }

        // 如果通过限流，则设置1分钟的限流
        redisTemplate.opsForValue().set(key, "1", 60, TimeUnit.SECONDS);

        // 处理订单提交
        return ResponseEntity.ok("Order submitted successfully");
    }
}

布隆过滤器

  • 布隆过滤器：使用布隆过滤器快速判断操作是否已执行过，如果未执行则进行操作，如果已执行则拒绝。这种方法适用于快速判断和减少数据库压力。
    • 优点：布隆过滤器在大规模数据中效率很高，能够快速判断数据是否已经存在。
    • 缺点：布隆过滤器有误判率，可能会误判一个没有提交过的订单为重复提交。
import io.rebloom.client.Client;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
public class OrderController {

    @Autowired
    private Client bloomFilter;

    // 假设布隆过滤器的名字是 "order_bloom"
    @PostMapping("/submitOrder")
    public ResponseEntity<String> submitOrder(@RequestParam String orderId) {
        // 检查布隆过滤器中是否已存在该订单号
        boolean exists = bloomFilter.exists("order_bloom", orderId);

        if (exists) {
            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("Duplicate order submission");
        }

        // 将新订单号添加到布隆过滤器
        bloomFilter.add("order_bloom", orderId);

        // 处理订单逻辑
        return ResponseEntity.ok("Order submitted successfully");
    }
}

数据库锁机制

  • 数据库锁机制：参考某些框架的实现，将表单信息保存在数据库中，再次提交时进行校验，如果内容相同且时间间隔短则拒绝请求。这种方法通过数据库来保证操作的幂等性。
    • 优点：数据库唯一约束可以彻底防止重复提交，即使多个并发请求都提交同一订单号，也只能保存一条记录
    • 缺点：数据库锁机制可能会在高并发场景下带来一定的性能开销，不适合超高并发场景。
@Entity
public class Order {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(unique = true)
    private String orderId;

    private String userId;
    private Date createTime;

    // getter/setter
}

@Repository
public interface OrderRepository extends JpaRepository<Order, Long> {
    Optional<Order> findByOrderId(String orderId);
}

@Service
public class OrderService {

    @Autowired
    private OrderRepository orderRepository;

    @Transactional
    public String submitOrder(String orderId, String userId) {
        // 查找是否已有相同订单号的记录
        if (orderRepository.findByOrderId(orderId).isPresent()) {
            throw new IllegalArgumentException("Duplicate order submission");
        }

        // 创建新订单
        Order order = new Order();
        order.setOrderId(orderId);
        order.setUserId(userId);
        order.setCreateTime(new Date());

        orderRepository.save(order);

        return "Order submitted successfully";
    }
}

@RestController
public class OrderController {

    @Autowired
    private OrderService orderService;

    @PostMapping("/submitOrder")
    public ResponseEntity<String> submitOrder(@RequestParam String orderId, @RequestParam String userId) {
        try {
            String result = orderService.submitOrder(orderId, userId);
            return ResponseEntity.ok(result);
        } catch (IllegalArgumentException e) {
            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(e.getMessage());
        }
    }
}

数据库乐观锁

乐观锁和分布式锁可以有效地防止并发请求时的重复提交或数据更新冲突。

乐观锁通过在数据库中增加一个 version 字段来实现，每次更新数据时检查该字段的版本号，只有当版本号匹配时，才允许更新成功。

首先，在数据库的表中添加一个 version 字段：

CREATE TABLE orders (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    order_id VARCHAR(255) UNIQUE,
    user_id VARCHAR(255),
    status VARCHAR(50),
    version INT DEFAULT 0  -- 版本号，作为乐观锁
);

实体类 Order.java：

import javax.persistence.*;

@Entity
public class Order {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(unique = true)
    private String orderId;

    private String userId;

    private String status;

    @Version  // 乐观锁的版本号字段
    private Integer version;

    // Getters and Setters
}

Repository 接口 OrderRepository.java：

import org.springframework.data.jpa.repository.JpaRepository;
import java.util.Optional;

public interface OrderRepository extends JpaRepository<Order, Long> {
    Optional<Order> findByOrderId(String orderId);
}

服务层 OrderService.java：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class OrderService {

    @Autowired
    private OrderRepository orderRepository;

    @Transactional
    public String updateOrderStatus(String orderId, String newStatus) {
        Order order = orderRepository.findByOrderId(orderId)
                .orElseThrow(() -> new IllegalArgumentException("Order not found"));

        // 更新订单状态，同时会检查版本号是否匹配
        order.setStatus(newStatus);
        orderRepository.save(order);

        return "Order status updated successfully";
    }
}

控制器 OrderController.java：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

@RestController
public class OrderController {

    @Autowired
    private OrderService orderService;

    @PostMapping("/updateOrderStatus")
    public ResponseEntity<String> updateOrderStatus(@RequestParam String orderId, @RequestParam String newStatus) {
        try {
            String result = orderService.updateOrderStatus(orderId, newStatus);
            return ResponseEntity.ok(result);
        } catch (Exception e) {
            return ResponseEntity.badRequest().body(e.getMessage());
        }
    }
}

说明：

  • 每次更新 Order 时，Mybatis会自动检查 version 字段。如果在更新时发现 version 字段与数据库中的不一致（说明已经有其他请求更新了数据），则会抛出 OptimisticLockException。
  • 乐观锁适用于读操作远多于写操作的场景，适合防止并发写冲突。

数据库悲观锁

使用 数据库的悲观锁 来防止用户重复点击，可以通过 SQL 锁机制 来确保在处理当前操作时，阻止其他请求对同一条记录进行操作。悲观锁会在事务处理期间锁定一行数据，防止其他事务修改或读取该行数据，从而有效避免并发请求导致的数据冲突或重复提交。

在 Spring Boot + MyBatis 技术栈中，通常通过在 SQL 语句中使用 SELECT ... FOR UPDATE 实现悲观锁。FOR UPDATE 会锁定查询到的行，直到事务提交或回滚为止，其他事务在这段时间内无法对该行数据进行修改。

1. 创建订单表

假设我们有一个订单表，包含订单 ID 和状态字段。

CREATE TABLE orders (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    order_id VARCHAR(255) UNIQUE,
    user_id VARCHAR(255),
    status VARCHAR(50) DEFAULT 'PENDING'
);

2. MyBatis Mapper 接口

在 MyBatis 中，我们通过编写 SQL 来实现悲观锁。FOR UPDATE 语句用于锁定一条记录。

@Mapper
public interface OrderMapper {

    // 查询并锁定订单，防止重复操作
    @Select("SELECT * FROM orders WHERE order_id = #{orderId} FOR UPDATE")
    Order selectOrderForUpdate(String orderId);

    // 更新订单状态
    @Update("UPDATE orders SET status = #{status} WHERE order_id = #{orderId}")
    void updateOrderStatus(@Param("orderId") String orderId, @Param("status") String status);
}

3. Service 层实现悲观锁逻辑

在 Service 层中，我们可以通过事务管理和悲观锁来防止用户重复点击提交订单。

@Service
public class OrderService {

    @Autowired
    private OrderMapper orderMapper;

    @Transactional // 使用事务确保数据一致性
    public String processOrder(String orderId) {
        // 查询并锁定订单（悲观锁）
        Order order = orderMapper.selectOrderForUpdate(orderId);

        // 检查订单状态，防止重复操作
        if (!"PENDING".equals(order.getStatus())) {
            throw new IllegalStateException("Order has already been processed");
        }

        // 模拟订单处理逻辑
        try {
            Thread.sleep(2000); // 模拟处理时间
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        // 更新订单状态
        orderMapper.updateOrderStatus(orderId, "COMPLETED");

        return "Order processed successfully";
    }
}

4. Controller 层调用

在 Controller 中，调用 OrderService 处理订单。

@RestController
@RequestMapping("/orders")
public class OrderController {

    @Autowired
    private OrderService orderService;

    @PostMapping("/process")
    public ResponseEntity<String> processOrder(@RequestParam String orderId) {
        try {
            String result = orderService.processOrder(orderId);
            return ResponseEntity.ok(result);
        } catch (IllegalStateException e) {
            return ResponseEntity.status(HttpStatus.CONFLICT).body(e.getMessage());
        }
    }
}

关键点说明

  1. 悲观锁 (FOR UPDATE)：在 OrderMapper 中，SELECT ... FOR UPDATE 会在数据库中锁定查询到的订单行，其他事务必须等待当前事务提交后才能访问该行数据。这就防止了多个用户同时点击按钮并发提交的情况。
  2. 事务管理：使用 @Transactional 注解确保所有操作在同一个事务中执行。如果操作失败，可以通过回滚事务来恢复原始状态。
  3. 状态检查：在悲观锁生效的情况下，仍然需要通过检查订单的状态字段（如 status）来防止重复提交。如果订单状态已经不是 PENDING，说明订单已经处理过了，可以直接拒绝请求。
  4. 并发问题的解决：通过悲观锁，确保同一时间只能有一个线程处理某个订单，其他并发请求会被阻塞直到锁释放。

运行流程

  1. 用户点击按钮提交订单时，系统通过 SELECT ... FOR UPDATE 锁定对应订单。
  2. 如果该订单尚未处理（状态为 PENDING），则继续处理订单逻辑，并更新状态为 COMPLETED。
  3. 如果在处理过程中，另一个用户试图重复提交该订单，由于该订单行已被锁定，后续请求会被阻塞，直到前一个事务完成并释放锁。
  4. 一旦事务提交，锁释放，系统会根据订单状态决定是否处理新请求或拒绝重复提交。

总结

通过使用悲观锁（FOR UPDATE）和事务机制，可以确保在处理订单时避免并发冲突，防止用户重复点击导致的订单重复处理问题。在 MyBatis 和 Spring Boot 组合中，这种方法非常有效。

棒棒的AI编程
关注
专栏目录
SpringBoot 使用 Redis 分布式锁解决并发问题
qhh0205
07-24 2890
问题背景 现在的应用程序架构中，很多服务都是多副本运行，从而保证服务的稳定性。一个服务实例挂了，其他服务依旧可以接收请求。但是服务的多副本运行随之也会引来一些分布式问题，比如某个接口的处理逻辑是这样的：接收到请求后，先查询 DB 看是否有相关的数据，如果没有则插入数据，如果有则更新数据。在这种场景下如果相同的 N 个请求并发发到后端服务实例，就会出现重复插入数据的情况： 解决方案 针对上面问题，一般的解决方案是使用分布式锁来解决。同一个进程内的话用本进程内的锁即可解决，但是服务多实例部署的话是分布式的，各
Redis分布式锁setNx防止用户重复提交请求。
weixin_42642782的博客
04-09 1148
Redis分布式锁setNx防止用户重复提交请求 首先定义一个注解： @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) public @interface UnRepeatSubmit { /** * 设置请求(key)的锁定时间，默认5秒钟 * @return */ int lockTime() default 5; } 为了能够方便注解实现控制每个handler，提供注解，根据
防止表单重复提交
08-14
这是一个关于防止表单重复提交的练习，大神勿喷！
SpringBoot接口防抖(防重复提交)的一些实现方案
最新发布
lxw1844912514的博客
08-16 92
所谓防抖，一是防用户手抖，二是防网络抖动。在Web系统中，表单提交是一个非常常见的功能，如果不加控制，容易因为用户的误操作或网络延迟导致同一请求被发送多次，进而生成重复的数据记录。要针对用户的误操作，前端通常会实现按钮的loading状态，阻止用户进行多次点击。而对于网络波动造成的请求重发问题，仅靠前端是不行的。为此，后端也应实施相应的防抖逻辑，确保在网络波动的情况下不会接收并处理同一请求多次。????...
防重复请求处理的实践与总结
糖糖糖糖糖先森
10-30 2032
#防重复处理总结 ##背景 在业务开发中，我们常会面对防止重复请求的问题。当服务端对于请求的响应涉及数据的修改，或状态的变更时，可能会造成极大的危害。重复请求的后果在交易系统、售后维权，以及支付系统中尤其严重。 前台操作的抖动，快速操作，网络通信或者后端响应慢，都会增加后端重复处理的概率。 前台操作去抖动和防快速操作的措施，我们首先会想到在前端做一层控制。当前端触发操作时，或弹出确
2020-11-24
Qaaaaaaaaaaaaa的博客
11-24 182
13.你的项目中使用过哪些JSTL标签？ 项目中主要使用了JSTL的核心标签库，包括< c:if>、< c:choose>、< c: when>、< c: otherwise>、< c:forEach>等，主要用于构造循环和分支结构以控制显示逻辑。虽然JSTL标签库提供了core、sql、fmt、xml等标签库，但是实际开发中建议只使 用核心标签库（core），而且最好只使用分支和循环标签并辅以表达式语言（EL），这样才能真正做到数据显示和
防止重复提交
qq_41846658的博客
01-18 184
layer.confirm('确认充值该矿工?', { btn: ['确定','取消'] //按钮            },          function (index) {           if(!$(".layui-layer-btn0").hasClass("layui-btn-disabled")){             //$(".layui-layer-btn0")这个...
redis分布式锁原理面试题,java面试老是面试不上
m0_54828003的博客
08-25 727
解决这个问题的办法可以在第3步进行优化，内存中存储了锁key的value，在执行访问共享数据源前再判断内存存储的锁key的value与此时redis中锁key的value是否相等如果相等则说明获得了锁，如果不相等则说明在之前有其他的机器修改了锁key，加锁失败。基于memcached的add命令和分布式锁定的思想是，key定义为分布式锁定，如果add过期的key成功，则执行相应的业务操作，执行完成后判断锁定是否过期，如果锁定过期，则不删除锁定带有效期限是防止机器停机，不能解除锁定。ster宕机的情况。...
redis分布式锁(springboot实现)
weixin_43864927的博客
11-25 843
在公司的项目中用到了分布式锁，但只会用却不明白其中的规则 所以写一篇文章来记录 使用场景：交易服务，使用redis分布式锁，防止重复提交订单，出现超卖问题 分布式锁的实现方式 基于数据库乐观锁/悲观锁 Redis分布式锁（本文） Zookeeper分布式锁 redis是如何实现加锁的？ 在redis中，有一条命令，实现锁 SETNX key value 该命令的作用是将 key 的值设为 value ，当且仅当 key 不存在。若给定的 key 已经存在，则 SETNX 不做任何动作。设置成功，返.
SpringBoot+Redis分布式锁+AOP解决页面重复提交
大军的博客
02-14 1125
引入依赖 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependenc...
防重复提交代码
07-09
java开发时防止jsp刷新造成的重复提交 经测试完美
几种防止表单重复提交的方法
01-08
表单重复提交是在多用户Web应用中最常见、带来很多麻烦的一个问题。有很多的应用场景都会遇到重复提交问题，比如： 点击提交按钮两次。 点击刷新按钮。 使用浏览器后退按钮重复之前的操作，导致重复提交表单。 使用浏览器历史记录重复提交表单。 浏览器重复的HTTP请求。  几种防止表单重复提交的方法 禁掉提交按钮。表单提交后使用Javascript使提交按钮disable。这种方法防止心急的用户多次点击按钮。但有个问题，如果客户端把Javascript给禁止掉，这种方法就无效了。 我之前的文章曾说过用一些Jquery插件效果不错。 Post/Redirect/Get模式。在提交后执行页面重定向，这就是
最简单的 6 种防止数据重复提交的方法
weijia521的博客
10-23 1115
最简单的 6 种防止数据重复提交的方法！(干货) 有位朋友，某天突然问磊哥：在 Java 中，防止重复提交最简单的方案是什么？ 这句话中包含了两个关键信息，第一：防止重复提交；第二：最简单。 于是磊哥问他，是单机环境还是分布式环境？ 得到的反馈是单机环境，那就简单了，于是磊哥就开始装*了。 话不多说，我们先来复现这个问题。 模拟用户场景 根据朋友的反馈，大致的场景是这样的，如下图所示： 简化的模拟代码如下（基于 Spring Boot）： importorg.springfr..
防止表单重复提交的八种简单有效的策略
热门推荐
天下熙熙，皆为利来；天下攘攘，皆为利往。
09-28 8万+
表单重复提交是在多用户Web应用中最常见、带来很多麻烦的一个问题。有很多的应用场景都会遇到重复提交问题，比如： 点击提交按钮两次。 点击刷新按钮。 使用浏览器后退按钮重复之前的操作，导致重复提交表单。 使用浏览器历史记录重复提交表单。 浏览器重复的HTTP请求。 用户提交表单时可能因为网速的原因，或者网页被恶意刷新，致使同一条记录重复插入到数据库中，这是一个比较棘手的问题。我们可以
防止重复提交的解决方法
prettyzhou的专栏
04-17 233
前两种是利用javascript,后面一种是在使用Struts的情况下的参考实现: 1、javascript ，设置一个变量，只允许提交一次。 &lt;script language="javascript"&gt;    var checkSubmitFlg = false;    function checkSubmit() {      if (checkSubmitFlg == tr...
如何防止重复提交
qq_35125764的博客
06-20 1万+
转载 如何防止重复提交 一、有很多的应用场景都会遇到重复提交问题，比如： 1、点击提交按钮两次。 2、点击刷新按钮。 3、使用浏览器后退按钮重复之前的操作，导致重复提交表单。 4、使用浏览器历史记录重复提交表单。 5、浏览器重复的 HTTP 请求。 二、防止表单重复提交的方法 1、禁掉提交按钮 表单提交后使用 Javascript 使提交按钮disable。这种方法防止心急的用户多次点击按钮。但有...
防止按钮点击事件如何多次重复点击
静墨客的博客
11-22 1223
如果为假，将该变量设置为真，并执行按钮点击事件的操作。在操作完成后，可以在适当的时间将该变量重新设置为假，以允许再次点击按钮。3. 使用RxJS的`throttleTime`操作符：如果你已经在项目中使用了RxJS，你可以使用`throttleTime`操作符来限制按钮点击事件的频率。`throttleTime`会在特定时间内只允许第一次点击事件通过，忽略后续的点击事件。2. 禁用按钮：在按钮被点击后，可以通过设置按钮的`disabled`属性为`true`来禁用按钮，防止多次点击。
防止重复提交的redis分布式锁怎么设计的？
06-11
防止重复提交可以使用 Redis 分布式锁来实现。一般来说，可以采用以下步骤来实现： 1. 客户端发起请求，获取锁：客户端向 Redis 发送请求，尝试获取一个名为 lock 的分布式锁。如果该锁没有被占用，则获取成功，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值