SpringBoot接口防抖(防重复提交)的一些实现方案

Question

SpringBoot接口防抖(防重复提交)的一些实现方案
SpringBoot接口防抖(防重复提交)的一些实现方案
SpringBoot接口防抖(防重复提交)的一些实现方案

Answer 1

引自免费微信小程序：皆我百晓生

在Spring Boot应用中实现接口防抖（防止重复提交）可以通过多种方式来实现。这里提供三种常见的实现方案：基于Redis、基于数据库和基于Spring Cloud Gateway。

1. 基于Redis 利用Redis的有序集合（Sorted Set）特性来存储请求。当一个新的请求到达时，检查该请求是否已经在有序集合中存在，如果不存在，则添加并设置过期时间，否则忽略该请求。

首先，确保已经添加了Redis依赖，并配置Redis连接。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

然后创建一个配置类，用于配置RedisTemplate：

@Configuration
public class RedisConfig {

    @Bean
    public LettuceConnectionFactory redisConnectionFactory() {
        return new LettuceConnectionFactory();
    }

    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, String> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

接下来，在控制器方法上添加注解，使用AOP进行拦截处理：

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class DuplicateRequestInterceptor {

    private static final String DUPLICATE_REQUEST_KEY_PATTERN = "duplicate_request:%s";

    private final StringRedisTemplate stringRedisTemplate;

    @Autowired
    public DuplicateRequestInterceptor(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }

    @Around("execution(* com.example.yourpackage.controller.YourController.yourMethod(..))")
    public Object preventDuplicateRequests(ProceedingJoinPoint joinPoint) throws Throwable {
        // 获取请求参数，作为唯一标识
        String requestHash = generateRequestHash(joinPoint.getArgs());
        
        long score = System.currentTimeMillis();

        // 添加请求到有序集合，如果已存在则返回0
        if (stringRedisTemplate.opsForZSet().add(DUPLICATE_REQUEST_KEY_PATTERN, requestHash, score) == 0) {
            throw new DuplicateRequestException("Duplicate request detected");
        }

        // 执行业务逻辑
        return joinPoint.proceed();
    }

    private String generateRequestHash(Object[] args) {
        // 根据实际需求生成请求哈希，可以考虑将所有重要参数组合成字符串并进行哈希
        StringBuilder hashBuilder = new StringBuilder();
        for (Object arg : args) {
            hashBuilder.append(arg.toString()).append(",");
        }
        return hashBuilder.toString().hashCode() + "";
    }
}

1. 基于数据库 使用数据库的唯一索引来防止重复插入。每次发送请求时，先查询数据库，如果数据已存在则忽略请求，否则执行操作并插入数据。

2. 基于Spring Cloud Gateway 如果你的应用使用了Spring Cloud Gateway，可以在网关层实现防抖。可以编写一个GatewayFilterFactory，实现对请求的拦截和判断。

import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.web.server.ServerWebExchange;

public class DuplicateRequestGatewayFilterFactory implements GatewayFilterFactory<DuplicateRequestGatewayFilterFactory.Config> {

    @Override
    public GatewayFilter apply(Config config) {
        return (exchange, chain) -> {
            ServerHttpRequest request = exchange.getRequest();
            
            // 获取请求参数，作为唯一标识
            String requestHash = generateRequestHash(request);

            // 检查请求是否已在数据库中
            boolean isDuplicate = checkDuplicateInDatabase(requestHash);

            if (isDuplicate) {
                throw new DuplicateRequestException("Duplicate request detected");
            }

            return chain.filter(exchange);
        };
    }

    private String generateRequestHash(ServerHttpRequest request) {
        // 实现根据请求头或请求体生成哈希的方法
    }

    private boolean checkDuplicateInDatabase(String requestHash) {
        // 在数据库中检查请求是否存在
    }

    public static class Config {}
}

别忘了在Spring Cloud Gateway的配置文件中注册这个过滤器。

这些方法都可以有效地防止重复提交，具体选择哪种取决于你的项目需求和技术栈。注意，无论选择哪种方案，都需要考虑幂等性以及如何处理并发场景下的竞态条件。