关于java:Java-8-CompletableFuture-对比-ES6-Promise

JavaScript 语言的执行环境是单线程的，异步编程对于 JavaScript 来说必不可少。JavaScript 传统异步解决方案次要是通过回调函数，而回调函数最大的问题就是 Callback Hell。所以 ES6 规范提供的 Promise 对象，专门用于解决异步编程的问题。

而 Java 语言是一个反对多线程的语言，语法以同步为主，在理论开发中很少须要用到大量的异步编程。然而要想谋求更高的性能，异步通常是更好的抉择。例如 Servlet 3 的异步反对、Spring 5 提供的 Spring WebFlux 等，都是为了谋求更高的性能。和 JavaScript 一样，传统的 Callback 形式解决 Java 异步也会有 Callback Hell 问题，所以在 Java 8 中新增了和 ES6 的 Promise 相似的对象：java.util.concurrent.CompletableFuture 。

在 JavaScript 中创立 Promise 对象：

const promise = new Promise(function(resolve, reject) {if (success){
        // 胜利
        resolve(value);  
    } else {
        // 失败
        reject(error);   
    }
});

例如，jQuery 传统的应用回调函数的 ajax 写法是这样的：

$.ajax({
    url: "/url",
    success: function(data) {// 胜利},
    error: function(jqXHR, textStatus, error) {// 失败}
});

如果要把它封装一下，返回一个 Promise 对象，能够这样来写：

function promisifyAjax(url) {const promise = new Promise(function(resolve, reject) {
        $.ajax({
            url: url,
            success: function(data) {
                // 将 Promise 更新为胜利状态
                resolve(data);   
            },
            error: function(jqXHR, textStatus, error) {
                // 将 Promise 更新为失败状态
                reject(error);   
            }
        });
    });
    return promise;
}

调用这个封装好的 promisifyAjax 办法：

promisifyAjax("/url").then(function(data) {// 胜利}).catch(function(error) {// 失败});

在 Java 中创立 CompletableFuture 对象：

CompletableFuture<String> completableFuture = new CompletableFuture<>();
if (success) {completableFuture.complete("工作胜利");
} else {completableFuture.completeExceptionally(new RuntimeException("工作失败"));
}

CompletableFuture 能够应用泛型，用于指定这个工作胜利后返回的后果的数据类型。

这里能够用 OkHttp 的异步申请来实战应用一下 CompletableFuture。OkHttp 异步申请的官网示例中应用的异步实现形式是基于 Callback 回调的形式：

private final OkHttpClient client = new OkHttpClient();

public void run() throws Exception {Request request = new Request.Builder()
        .url("http://publicobject.com/helloworld.txt")
        .build();
    
    client.newCall(request).enqueue(new Callback() {
        @Override 
        public void onFailure(Call call, IOException e) {
            // HTTP 申请异样
            e.printStackTrace();}
        
        @Override 
        public void onResponse(Call call, Response response) throws IOException {try (ResponseBody responseBody = response.body()) {if (!response.isSuccessful()) { 
                    // 响应状态码异样
                    throw new IOException("Unexpected code" + response);
                } else {
                    // 胜利
                    System.out.println(responseBody.string());  
                }
            }
        }
    });
}

上面将这个异步申请封装为一个返回 CompletableFuture 的办法：

public static CompletableFuture<String> asyncRequest(String url) {CompletableFuture<String> completableFuture = new CompletableFuture<>();

    Request request = new Request.Builder()
        .url(url)
        .build();
    
    client.newCall(request).enqueue(new Callback() {
        @Override 
        public void onFailure(Call call, IOException e) {
            // HTTP 申请异样
            completableFuture.completeExceptionally(e);  
        }
        
        @Override 
        public void onResponse(Call call, Response response) throws IOException {try (ResponseBody responseBody = response.body()) {if (!response.isSuccessful()) { 
                    // 响应状态码异样
                    completableFuture.completeExceptionally(new IOException("Unexpected code" + response));
                } else {   
                    // 胜利
                    completableFuture.complete(responseBody.string());
                }
            }
        }
    });
}

应用封装好的 asyncRequest() 办法：

asyncRequest("/url").thenAccept(responseText -> {// 胜利}).exceptionally(e -> {// 失败});

能够看到这个写法简直和 ES6 Promise 写法一样。

下面基于 jQuery.ajax() 函数封装并返回 Promise 对象，是为了学习 Promise 对象是如何创立的。实际上，曾经有十分优良的开源我的项目 Axios，它是一个基于 Promise 的 HTTP 客户端，既反对浏览器 Ajax，又反对 Node.js：

axios.get('/user?ID=12345')
    .then(function (response) {
        // handle success
        console.log(response);
    })
    .catch(function (error) {
        // handle error
        console.log(error);
    });

同样，在 Java 11 版本中新增了 java.net.http.HttpClient，纯天然反对 CompletableFuture：

public static void main(String[] args) throws InterruptedException {HttpClient client = HttpClient.newBuilder().build();
    HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("http://xxx.com/"))
            .build();
    CompletableFuture<HttpResponse<String>> responseFuture = client.sendAsync(request, HttpResponse.BodyHandlers.ofString());
    
    responseFuture.thenAccept(response -> {System.out.println(response.body());
    }).exceptionally(e -> {System.out.println(e);
        return null;
    });

    // 避免主线程完结后程序进行
    Thread.sleep(Integer.MAX_VALUE);
}

ES6 Promise 的 then 办法的返回值同样是一个 Promise，所以能够链式调用：

axios.get('/request1')
    .then(function (response) {
        // 把第一个申请的后果作为第二个申请的参数，并且返回一个新的 Promise 作为下一个 then 的后果
        const newPromise = axios.get('/request2?param=' + response);
        return newPromise;
    })
    .then(function (response) {
        // 输入第二个申请的后果
        console.log(response);
    })
    .catch(function (error) {console.log(error);
    });

Java CompletableFuture 可通过 thenCompose 办法来实现多个 CompletableFuture 链式调用：

public static void main(String[] args) throws InterruptedException {HttpClient client = HttpClient.newBuilder().build();
    HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("http://foo.com/"))
            .build();
    CompletableFuture<HttpResponse<String>> responseFuture = client.sendAsync(request, HttpResponse.BodyHandlers.ofString());

    responseFuture.thenCompose(response -> {
        // 把第一个申请的后果作为第二个申请的参数
        HttpRequest request2 = HttpRequest.newBuilder()
                .uri(URI.create("http://foo.com/?param=" + response.body()))
                .build();
        // 这里必须返回一个新的 CompletableFuture 作为下一个 then 的后果
        CompletableFuture<HttpResponse<String>> responseFuture2 = client.sendAsync(request2, HttpResponse.BodyHandlers.ofString());
        return responseFuture2;
    }).thenAccept(response -> {
        // 输入第二个申请的后果
        System.out.println(response);
    }).exceptionally(e -> {e.printStackTrace();
        return null;
    });

    // 避免主线程完结后程序进行
    Thread.sleep(Integer.MAX_VALUE); 
}

Promise 中的工具办法：

Promise.all() 用于将多个 Promise 包装成一个新的 Promise，相当于让所有工作同时进行，当所有工作都胜利后，新的 Promise 才会变为胜利状态，只有有一个工作失败，新的 Promise 就会变为失败状态

// 同时执行 3 个异步工作
const allPromise = Promise.all([promise1, promise2, promise3]);
allPromise.then(([result1, result2, result3]) => {// 3 个异步工作全副胜利后，这里能够拿到所有工作的后果}).catch(err => {// 只有有一个工作失败，最终后果就是失败});

Promise.race() 用于让多个工作同时进行，只有有一个工作执行实现后（无论胜利还是失败），返回的新的 Promise 就会跟随着变更状态

// 发动 HTTP 申请，5 秒内没有响应则超时失败
Promise.race([httpGet('http://example.com/file.txt'),
    delay(5000).then(function () {throw new Error('timeout');
    })
])

CompletableFuture 中也提供了上述相似的静态方法：

static CompletableFuture<Void> allOf(CompletableFuture<?>... cfs)
static CompletableFuture<Object> anyOf(CompletableFuture<?>... cfs)

其中，CompletableFuture 的 allOf() 办法相似于 Promise.all()，anyOf() 办法相似于 Promise.race()。

其中有一个区别是 CompletableFuture 的 allOf() 办法返回的是一个 CompletableFuture<Void>，也就是拿不到异步工作的执行后果。如果想要像 Promise.all() 一样拿到每一个工作的执行后果，能够对这个办法再进行一下封装：

public static <T> CompletableFuture<List<T>> all(CompletableFuture<T> ... cfs) {return CompletableFuture.allOf(cfs)
            .thenApply(v -> Stream.of(cfs)
                    .map(future -> future.join())
                    .collect(Collectors.toList()));
}

java.util.concurrent.CompletableFuture
java.net.http.HttpClient
Promise
Axios

关于java:Java-8-CompletableFuture-对比-ES6-Promise

创建对象

创立 Promise

创立 CompletableFuture

根本应用

then 的链式调用

工具办法

参考文档

关注我的公众号