Spring Boot 中实现防抖的几种方案,拒绝重复提交

🤖AI 摘要

本文介绍Spring Boot中实现接口防抖以防止重复提交的几种常见方案。包括使用@Scheduled注解定时任务处理后台防抖，利用@Async异步处理减少处理频率，借助Google Guava的RateLimiter控制请求速率，以及通过缓存机制（如Spring Cache）实现防抖，并分析各方案适用场景。

此内容根据文章生成，不代表个人观点，仅用于文章内容的解释与总结

在 Spring Boot 中实现接口防抖（debouncing）可以防止频繁的请求触发操作，例如重复点击按钮或频繁请求接口。防抖技术通常用于限制某个操作在一定时间内只能执行一次。

在 Spring Boot 中实现防抖有多种方法，下面提供了几种常见的方法：

1. 使用 `@Scheduled` 注解定时任务（适用于后台任务）#

这种方法适用于需要在后台任务中进行防抖的场景。例如，定时处理数据，避免频繁操作。

1
import org.springframework.scheduling.annotation.Scheduled;
2
import org.springframework.stereotype.Service;
3

4
import java.util.concurrent.ConcurrentHashMap;
5

6
@Service
7
public class DebounceService {
8

9
    private final ConcurrentHashMap<String, Long> lastExecution = new ConcurrentHashMap<>();
10

11
    // 假设防抖时间为 1 秒
12
    private final long DEBOUNCE_TIME = 1000L;
13

14
    public boolean shouldProcess(String key) {
15
        long currentTime = System.currentTimeMillis();
16
        long lastTime = lastExecution.getOrDefault(key, 0L);
17

18
        if (currentTime - lastTime > DEBOUNCE_TIME) {
19
            lastExecution.put(key, currentTime);
20
            return true;
21
        }
22
        return false;
23
    }
24

25
    @Scheduled(fixedDelay = 1000) // 定时执行任务
26
    public void processDebouncedRequests() {
27
        // 在这里处理被防抖的请求
28
    }
29
}

2. 使用 `@Async` 异步处理#

异步方法可以配合防抖逻辑来减少处理频率。确保启用了 Spring 的异步支持（@EnableAsync）。

1
import org.springframework.beans.factory.annotation.Autowired;
2
import org.springframework.scheduling.annotation.Async;
3
import org.springframework.stereotype.Service;
4

5
import java.util.concurrent.ConcurrentHashMap;
6

7
@Service
8
public class DebounceService {
9

10
    private final ConcurrentHashMap<String, Long> lastExecution = new ConcurrentHashMap<>();
11
    private final long DEBOUNCE_TIME = 1000L;
12

13
    @Autowired
14
    private SomeOtherService someOtherService; // 假设你有另一个服务需要异步处理
15

16
    public void processRequest(String key) {
17
        if (shouldProcess(key)) {
18
            // 执行异步任务
19
            executeAsyncTask(key);
20
        }
21
    }
22

23
    private boolean shouldProcess(String key) {
24
        long currentTime = System.currentTimeMillis();
25
        long lastTime = lastExecution.getOrDefault(key, 0L);
26

27
        if (currentTime - lastTime > DEBOUNCE_TIME) {
28
            lastExecution.put(key, currentTime);
29
            return true;
30
        }
31
        return false;
32
    }
33

34
    @Async
35
    public void executeAsyncTask(String key) {
36
        // 异步处理逻辑
37
        someOtherService.process(key);
38
    }
39
}

3. 使用 `RateLimiter` 控制请求频率（如 Google Guava 的 `RateLimiter`）#

RateLimiter 可以控制请求的速率，适合于防抖的场景。

1
import com.google.common.util.concurrent.RateLimiter;
2
import org.springframework.stereotype.Service;
3

4
@Service
5
public class DebounceService {
6

7
    // 创建一个 RateLimiter，每秒允许处理 1 个请求
8
    private final RateLimiter rateLimiter = RateLimiter.create(1.0);
9

10
    public void processRequest(String request) {
11
        if (rateLimiter.tryAcquire()) {
12
            // 处理请求
13
            handleRequest(request);
14
        } else {
15
            // 请求被抑制
16
            System.out.println("Request suppressed: " + request);
17
        }
18
    }
19

20
    private void handleRequest(String request) {
21
        // 处理请求的逻辑
22
    }
23
}

4. 使用缓存机制（例如 Spring Cache）#

可以利用缓存机制来实现防抖。假设防抖的时间为 1 秒钟。

1
import org.springframework.cache.annotation.Cacheable;
2
import org.springframework.stereotype.Service;
3

4
@Service
5
public class DebounceService {
6

7
    @Cacheable(value = "debounceCache", key = "#request", cacheManager = "cacheManager")
8
    public void processRequest(String request) {
9
        // 处理请求的逻辑
10
    }
11
}

配置缓存管理器#

1
import org.springframework.cache.CacheManager;
2
import org.springframework.cache.annotation.EnableCaching;
3
import org.springframework.cache.concurrent.ConcurrentMapCacheManager;
4
import org.springframework.context.annotation.Bean;
5
import org.springframework.context.annotation.Configuration;
6

7
@Configuration
8
@EnableCaching
9
public class CacheConfig {
10

11
    @Bean
12
    public CacheManager cacheManager() {
13
        return new ConcurrentMapCacheManager("debounceCache");
14
    }
15
}

选择合适的方法#

定时任务 适合于周期性处理请求。
异步处理 适合于后台任务和并发处理。
RateLimiter 适合于控制请求速率，避免过于频繁的请求。
缓存机制 适合于简单的防抖需求，特别是请求的去重。

1. 使用 @Scheduled 注解定时任务（适用于后台任务）#

2. 使用 @Async 异步处理#

3. 使用 RateLimiter 控制请求频率（如 Google Guava 的 RateLimiter）#