请求合并-把多次请求合并为一次请求

最新推荐文章于 2025-12-18 11:03:17 发布

原创最新推荐文章于 2025-12-18 11:03:17 发布 · 975 阅读

2 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#java

文章介绍了一种通过合并请求来优化数据库查询性能的方法。使用一个阻塞队列存储请求，然后通过定时任务线程池定期处理队列中的请求，将单次查询转为批量查询。在处理过程中，限制每次批量的数量并使用CompletableFuture管理异步响应，从而提高系统效率。

合并请求思路就是等待一段时间，把该段时间的请求一次性进行处理，把一次次查询变为批量查询，针对数据库查询能提高性能

@Data
public class HotelGatherInfoVo implements Serializable {

    private Long id;

    private String hotelSource;

    private String hotelCode;

    private String wjsHotelCode;

    private Long createDatetime;

    private String validFlag;
}

@Data
public class Req<T,R> {
    private T req;
    private CompletableFuture<R> resp;
}```

```java
LinkedBlockingDeque<Req> queue = new LinkedBlockingDeque<>();

    public List<HotelGatherInfoVo> listByWjsHotelCode(String wjsHotelCode){
        Req<String,List<HotelGatherInfoVo>> req = new Req<>();
        req.setReq(wjsHotelCode);
        CompletableFuture<List<HotelGatherInfoVo>> resp = new CompletableFuture<>();
        req.setResp(resp);
        queue.add(req);
        try {
            return resp.get(2000, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
        return null;
    }


    @PostConstruct
    public void init() {
        //定时任务线程池,创建一个支持定时、周期性或延时任务的限定线程数目的线程池
        
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1);
         //scheduleAtFixedRate是周期性执行 schedule是延迟执行 initialDelay是初始延迟 period是周期间隔 后面是单位
        scheduledExecutorService.scheduleAtFixedRate(() -> {
            int size = queue.size();
            //如果队列没数据,表示这段时间没有请求,直接返回
            if (size == 0) {
                return;
            }
            List<Req<String,List<HotelGatherInfoVo>>> list = new ArrayList<>();
            //将队列的请求消费到一个集合保存
            for (int i = 0; i < size; i++) {
                // 后面的SQL语句是有长度限制的，所以还要做限制每次批量的数量,超过最大任务数，等下次执行
                if (i < 100) {
                     Req poll = queue.poll();
                    if(poll != null){
                        list.add(poll);
                    }
                }
            }
            System.out.println("合并 [" + size + "] 个请求,"+list);

            List<String> wjsHotelCode = list.stream().map(e -> e.getReq()).collect(Collectors.toList());
            // 批量查询入口
            List<HotelGatherInfoVo> hotelGatherInfoVos = listAllValidByWjsHotelCode(wjsHotelCode);
            Map<String, List<HotelGatherInfoVo>> maps = hotelGatherInfoVos.stream().collect(Collectors.groupingBy(e -> e.getWjsHotelCode()));
            for (Req<String, List<HotelGatherInfoVo>> req : list) {
                List<HotelGatherInfoVo> hotelGatherInfoVos1 = maps.get(req.getReq());
                if (hotelGatherInfoVos1!=null){
                    req.getResp().complete(hotelGatherInfoVos1);
                }else {
                    req.getResp().cancel(true);
                }
            }
        }, 100, 10, TimeUnit.MILLISECONDS);

        //这里我写的是 初始化后100毫秒后执行，周期性执行10毫秒执行一次
    }