使用CompletableFuture实现业务服务的异步调用实战代码

假如我有一个订单相关的统计接口，需要返回3样数据：今日订单数、今日交易额、总交易额。

一般的我们的做法是串行调用3个函数，把调用返回的结果返回给调用者，这3次调用时串行执行的，如果每个调用耗时1秒的话，3次调用总耗时就是3秒。

这种做法效率非常低，因为3次调用之间无所谓先后顺序，所以采用并行执行效率会更好。比如使用线程池ExecutorService实现异步调用。

其实Java8提供了一个非常牛逼的CompletableFuture类，也可以实现异步化：

 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;

 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.TimeUnit;

 @Slf4j
 @Service
 public class OrderService {

     /**
      * 今日订单数
      *
      * @return
      */
     public CompletableFuture<String> todayOrderCount() {
         return CompletableFuture.supplyAsync(() -> this.getTodayOrderCount());
     }

     public CompletableFuture<String> todayTurnover() {
         return CompletableFuture.supplyAsync(() -> this.getTodayTurnover());
     }

     public CompletableFuture<String> totalTurnover() {
         return CompletableFuture.supplyAsync(() -> this.getTotalTurnover());
     }

     private String getTodayOrderCount() {
         System.out.println(">>>>>>> 查询今日订单数:" + Thread.currentThread().getName());
         try {
             TimeUnit.SECONDS.sleep(1);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         return "50";
     }

     /**
      * 今日交易额
      *
      * @return
      */
     private String getTodayTurnover() {
         System.out.println(">>>>>>> 查询今日交易额:" + Thread.currentThread().getName());
         try {
             TimeUnit.SECONDS.sleep(1);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         return "200";
     }

     /**
      * 总交易额
      *
      * @return
      */
     private String getTotalTurnover() {
         System.out.println(">>>>>>> 查询总交易额:" + Thread.currentThread().getName());
         try {
             TimeUnit.SECONDS.sleep(1);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         return "800";
     }
 }

 import com.alibaba.fastjson.JSONObject;
 import com.example.sb.service.test.impl.OrderService;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;

 import java.util.concurrent.CompletableFuture;

 @Slf4j
 @RestController
 @RequestMapping("/order")
 public class OrderController {

     @Autowired
     private OrderService orderService;

     @GetMapping("/report")
     public JSONObject report() {
         long start = System.currentTimeMillis();
         JSONObject json = orderReport();
         System.out.println("耗时:" + (System.currentTimeMillis() - start));
         return json;
     }

     private JSONObject orderReport() {
         CompletableFuture<String> todayOrderCountFuture = orderService.todayOrderCount();
         CompletableFuture<String> todayTurnoverFuture = orderService.todayTurnover();
         CompletableFuture<String> totalTurnoverFuture = orderService.totalTurnover();

         JSONObject json = new JSONObject();

         todayOrderCountFuture.whenComplete((v, t) -> {
             json.put("todayOrderCountFuture", v);
         });
         todayTurnoverFuture.whenComplete((v, t) -> {
             json.put("todayTurnoverFuture", v);
         });
         totalTurnoverFuture.whenComplete((v, t) -> {
             json.put("totalTurnoverFuture", v);
         });

         CompletableFuture.allOf(todayOrderCountFuture, todayTurnoverFuture, totalTurnoverFuture)
                 .thenRun(() -> System.out.println("完成！！！！"))
                 .join();
         return json;
     }
 }

浏览器访问：http://localhost:8080/order/report 执行结果截图如下：

因为每个OrderService的调用模拟都是耗时1秒，3个调用并行执行，最终耗时自然也是1秒。