批量查询接口如何巧妙利用单查询接口中的@Cacheable

如标题所述，本文是为了探讨在已有jvm缓存的单查询接口的基础上增加批量查询接口功能，要如何实现，如何优化，如何抉择。

spring-cache用法请自行查询。

demo：

单查询接口如下：

@Service
public class BizCacheServiceImpl implements BizCacheService {

    /**
     * 单查询接口
     *
     * @param id
     * @return
     */
    @Cacheable(key = "'getBizCacheVO' + #id", value = "valueName")
    public BizCacheVO getStringById(Integer id) {
        //略去过程
        try {
            //模拟方法执行
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        BizCacheVO bizCacheVO = new BizCacheVO();
        bizCacheVO.setId(id);
        bizCacheVO.setValue("value");
        return bizCacheVO;
    }
}

一、单线程查询单个接口

  public Map<Integer, BizCacheVO> getListByIds(List<Integer> ids) {
        Map<Integer, BizCacheVO> result = new HashMap<>();
        for (Integer id : ids) {
            BizCacheVO bizCacheVO = bizCacheService.getStringById(id);
            if (bizCacheVO != null && bizCacheVO.getId() != null) {
                result.put(bizCacheVO.getId(), bizCacheVO);
            }
        }
        return result;
    }

缺点：如上图所述，单查询接口无缓存的情况下，执行时间大约为1s。如果同时请求20个，最起码也是20s。

优点：如果要查询的ids都被jvm缓存了，那完全没必要启用多线程，单线程完全可以适用，单线程还不浪费额外线程资源及上下文切换的损耗。

二、多线程查询单个接口

@Service
public class BizBatchCacheServiceImpl implements BizBatchCacheService {

    @Autowired
    private BizCacheService bizCacheService;
    //线程池
    private ExecutorService executor = Executors.newFixedThreadPool(50);

    /**
     * 批量接口
     *
     * @param ids
     * @return
     */
    public Map<Integer, BizCacheVO> getListByIds(List<Integer> ids) {
        Map<Integer, BizCacheVO> result = new HashMap<>();
        List<CompletableFuture<BizCacheVO>> completableFutureList = new ArrayList<>();
        for (Integer id : ids) {
            completableFutureList.add(CompletableFuture.supplyAsync(() -> bizCacheService.getStringById(id), executor));
        }
        try {
            CompletableFuture.allOf(completableFutureList.toArray(new CompletableFuture[]{})).get();
            for (CompletableFuture<BizCacheVO> future : completableFutureList) {
                BizCacheVO bizCacheVO = future.get();
                if (bizCacheVO != null && bizCacheVO.getId() != null) {
                    result.put(bizCacheVO.getId(), bizCacheVO);
                }
            }
        } catch (Exception e) {
            //异常处理
        }
        return result;
    }
}

多线程如上述代码。

单查询接口无缓存的情况下，执行时间大约为1s。如果同时请求20个，总耗时也在1s多一些时间。看起来性能很不错，但有这么一个问题，批量接口的入参不固定，这一批数据里，可能有的已经存在缓存了，有的还没有缓存，那么有缓存的数据，还是额外的开启了线程去调用单查询接口，这里就造成了线程的消耗以及上下文切换时间的损耗。

缺点：已经缓存过的数据，还是会开启线程查询，消耗额外资源。

优点：如果数据大部分都是没有缓存的，这样调用的性能会远超单线程。

分析了单线程和多线程方式的调用，各有利弊，那怎么去平衡这两种方式呢？

那就是接下来的第三种方式。

三、cache+多线程接口

平衡点：让已经缓存过的直接去取缓存，未缓存的数据去开启多线程处理

@Service
public class BizBatchCacheServiceImpl implements BizBatchCacheService {

    @Autowired
    private BizCacheService bizCacheService;
    //线程池
    private ExecutorService executor = Executors.newFixedThreadPool(50);
    @Resource
    private CacheManager cacheManager;


    /**
     * cache+多线程方式批量接口
     *
     * @param ids
     * @return
     */
    public Map<Integer, BizCacheVO> getListByIds(List<Integer> ids) {
        Map<Integer, BizCacheVO> result = new HashMap<>();
        Cache cache = cacheManager.getCache("valueName");
        List<CompletableFuture<BizCacheVO>> completableFutureList = new ArrayList<>();
        Set<Integer> noHit = new HashSet<>();
        for (Integer id : ids) {
            BizCacheVO bizCacheVO = cache.get("getBizCacheVO" + id, BizCacheVO.class);
            if (bizCacheVO != null && bizCacheVO.getId() != null) {
                result.put(bizCacheVO.getId(), bizCacheVO);
            } else {
                noHit.add(id);
            }
        }
        //将未命中缓存的数据进行多线程请求
        for (Integer id : noHit) {
            completableFutureList.add(CompletableFuture.supplyAsync(() -> bizCacheService.getStringById(id), executor));
        }
        try {
            CompletableFuture.allOf(completableFutureList.toArray(new CompletableFuture[]{})).get();
            for (CompletableFuture<BizCacheVO> future : completableFutureList) {
                BizCacheVO bizCacheVO = future.get();
                if (bizCacheVO != null && bizCacheVO.getId() != null) {
                    result.put(bizCacheVO.getId(), bizCacheVO);
                }
            }
        } catch (Exception e) {
            //异常处理
        }
        return result;
    }
}

优点：不再为已有的缓存数据浪费额外的线程资源，面对各种情况更灵活，更均衡

缺点：如果数据一直都有缓存，这样写就很鸡肋。