Java实现一定时间内同时请求接口时返回相同数据

1. 缓存机制

使用本地缓存（如Caffeine）

@Service
public class DataService {private final Cache<String, Object> cache = Caffeine.newBuilder().expireAfterWrite(30, TimeUnit.SECONDS)  // 30秒过期.maximumSize(1000).build();public Object getData(String key) {return cache.get(key, k -> fetchDataFromSource(k));}private Object fetchDataFromSource(String key) {// 实际的数据获取逻辑return new Object();}
}

使用Redis缓存

@Service
public class DataService {@Autowiredprivate StringRedisTemplate redisTemplate;public Object getData(String key) {String cachedData = redisTemplate.opsForValue().get(key);if (cachedData != null) {return JSON.parseObject(cachedData, Object.class);}// 获取新数据Object data = fetchDataFromSource(key);redisTemplate.opsForValue().set(key, JSON.toJSONString(data), 30, TimeUnit.SECONDS);return data;}
}

2. 请求合并机制

使用ConcurrentHashMap实现请求合并

@Service
public class MergingDataService {private final ConcurrentHashMap<String, CompletableFuture<Object>> pendingRequests = new ConcurrentHashMap<>();public CompletableFuture<Object> getDataAsync(String key) {// 检查是否有正在进行的相同请求CompletableFuture<Object> existingFuture = pendingRequests.get(key);if (existingFuture != null) {return existingFuture;}// 创建新的请求CompletableFuture<Object> newFuture = new CompletableFuture<>();CompletableFuture<Object> previousFuture = pendingRequests.putIfAbsent(key, newFuture);if (previousFuture != null) {// 其他线程已经创建了请求return previousFuture;}// 执行实际的数据获取try {Object data = fetchDataFromSource(key);newFuture.complete(data);return newFuture;} finally {pendingRequests.remove(key);}}private Object fetchDataFromSource(String key) {// 实际的数据获取逻辑return new Object();}
}

3. 控制器层实现

@RestController
public class DataController {@Autowiredprivate DataService dataService;@Autowiredprivate MergingDataService mergingDataService;@GetMapping("/data")public ResponseEntity<Object> getData(@RequestParam String key) {try {Object data = dataService.getData(key);return ResponseEntity.ok(data);} catch (Exception e) {return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();}}@GetMapping("/data/async")public CompletableFuture<ResponseEntity<Object>> getDataAsync(@RequestParam String key) {return mergingDataService.getDataAsync(key).thenApply(data -> ResponseEntity.ok(data)).exceptionally(throwable -> ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build());}
}

4. 使用Spring Cache注解

@Service
@EnableCaching
public class CachedDataService {@Cacheable(value = "dataCache", key = "#key", unless = "#result == null")@Cacheable(cacheNames = "dataCache", key = "#key")public Object getData(String key) {// 模拟耗时操作try {Thread.sleep(1000);} catch (InterruptedException e) {Thread.currentThread().interrupt();}return fetchDataFromSource(key);}private Object fetchDataFromSource(String key) {return new Object();}
}

推荐方案

1. 简单场景：使用本地缓存或Redis缓存
2. 高并发场景：使用请求合并机制避免重复计算
3. 复杂业务：结合多种方案，先检查缓存，再进行请求合并

这样可以有效减少重复请求对后端服务的压力，并保证在缓存有效期内返回相同的数据。