lambda表达式滥用之殇：解耦三层嵌套lambda表达式

自从 Java8 支持 lambda 表达式， 代码中的 lambda 就处处都是。 但大可能是滥用。

lambda 表达式用于表达简短的逻辑（能够看作 C 语言的内联函数）很是清晰，但用来表达比较长的业务逻辑，就与其设计初衷背道而驰了。

以下所示，三层嵌套 lambda 表达式，晕了没有 ？

如何解开这些结呢 ？ 一步步来。

首先， allImageIds.forEach 是一个明显的 Stream-add 模式，能够使用 stream.map 来表达：

List<CompletableFuture<String>> completableFutureList
                = allImageIds.stream().map(imageId -> buildCompletableFuture(imageId, comId, newGroup)).collect(Collectors.toList());

    private CompletableFuture<String> buildCompletableFuture(String imageId, String comId, int newGroup) {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            String lockKey = String.format("%s%s%s", comId, newGroup, imageId);
            return redisLock.call(lockKey, () -> {
                return dealWith(comId, newGroup, imageId);
            });
        }, executorService);
        return future;
    }

这样，就解耦了一层。

接下来，CompletableFuture.supplyAsync 须要提供一个 Supplier ， 能够把这个 lambda 提取出来：

private CompletableFuture<String> buildCompletableFuture(String imageId, String comId, int newGroup) {

        Supplier<String> futureSupplier = () -> {
            String lockKey = String.format("%s%s%s", comId, newGroup, imageId);
            return redisLock.call(lockKey, () -> {
                return dealWith(comId, newGroup, imageId);
            });
        };

        CompletableFuture<String> future = CompletableFuture.supplyAsync(futureSupplier, executorService);
        return future;
    }

这样，咱们又让结构清晰了一些。

最后，咱们把 redisLock.call 里面的 lambda 表达式分离出来。 这个 lambda 表达式表明的是 ValueLockCallback 接口。 能够把这个表达式变成一个内部类（还原） ImageIdValueCallback ：

private CompletableFuture<String> buildCompletableFuture(String imageId, String comId, int newGroup) {
 
    Supplier<String> futureSupplier = () -> {
        String lockKey = String.format("%s%s%s", comId, newGroup, imageId);
        return redisLock.call(lockKey, new ImageIdValueCallback(imageId, comId, newGroup));
    };
 
    CompletableFuture<String> future = CompletableFuture.supplyAsync(futureSupplier, executorService);
    return future;
}

    class ImageIdValueCallback implements ValueLockCallback<String> {

        private String imageId;
        private String comId;
        private int newGroup;

        public ImageIdValueCallback(String imageId, String comId, int newGroup) {
            this.imageId = imageId;
            this.comId = comId;
            this.newGroup = newGroup;
        }

        @Override
        public String execute() {
            return dealWith(comId, newGroup, imageId);   // dealWith 是 redisLock.call 里面的 lambda 表达式里的代码块。
        }
    }

这样，是否是清晰不少了 ？