链接地址：

    Futures是Guava Concurrency提供的用于处理Future实例的工具类，其中提供了需要有用方便的方法，一些方法的使用也有特定的场景，之前的学习中，我们提到 了AsyncFution和FutureFallback，本篇我们重点来学习一些与之相关的方法：AsyncFunctions 以及FutureFallbacks。

 

    之前的学习中，我们已经学习到了Futures的一些方法，如：Futures.addFallback，用于注册一个FutureCallback实例，在ListenableFuture实例完成其任务后执行。

 

    异步转换

    中，我们学习了AsyncFunction接口，以及如何接收Fuction进行异步的转换，Futures提供了transform方法，使我们能够简便的使用AsyncFunction接口：

@Testpublic void testFuturesTransform() throws ExecutionException, InterruptedException {    listenableFuture = executorService.submit(new Callable
    
     () {        @Override        public String call() throws Exception {            return "张三";        }    });    AsyncFunction
     
       asyncFunction = new AsyncFunction
      
       () {        @Override        public ListenableFuture
       
         apply(String input) throws Exception {            person.setName(input);            return executorService.submit(new Callable
        
         () {                @Override                public Person call() throws Exception {                    return person;                }            });        }    };    ListenableFuture
         
           lf =            Futures.transform(listenableFuture, asyncFunction);    assertThat(lf.get().getName(), is("张三"));}
         
        
       
      
     
    

    

    Futures.transform方法返回了一个ListenableFuture实例，其结果是通过对从传递到方法中的ListenableFuture的执行结果进行一个异步的转换。

 

    FutureFallbacks的应用

 

    中，我们同样学习了FutureFallback接口，能够帮助我们处理ListenableFuture执行出现的错误信息，Futures.withFallback方法使用类似的方法注册FutureFallback，我们可以像下面这样使用：

@Testpublic void testFuturesFallback() throws ExecutionException, InterruptedException {    listenableFuture = executorService.submit(new Callable
    
     () {        @Override        public String call() throws Exception {            throw new RuntimeException();        }    });    FutureFallback
     
       futureFallback = new FutureFallback
      
       () {        @Override        public ListenableFuture create(Throwable t) throws Exception {            if (t instanceof RuntimeException) {                SettableFuture
       
         settableFuture =                        SettableFuture.create();                settableFuture.set("Not Found");                return settableFuture;            }            throw new Exception(t);        }    };    ListenableFuture
        
          lf =            Futures.withFallback(listenableFuture,futureFallback);    assertThat(lf.get(), is("Not Found"));}
        
       
      
     
    

    Futures.withFallback方法返回了一个ListenableFuture实例，其接收一个listenableFuture参数和 futureFallback参数，如果给定的listenableFuture执行成功，则返回成功的结果，如果失败，则返回 FutureFallback中设置的错误信息。

 

    接下来，我们翻开Futures的源码，简单的整理一下其中的公共方法，如下：

makeChecked( ListenableFuture<V> future, Function<Exception, X> mapper)：根据传入ListenableFuture和Function构建一个CheckFuture，映射异常的实例到相应的检查类型。

 

immediateFuture(@Nullable V value)：创建一个设置value值的ListenableFuture，其value值立即会被设置，getter方法只是返回值。这个 Future不能取消或超时，Future的isDone()方法总是返回true。

 

immediateFailedFuture( Throwable throwable)：返回一个构造时设置传入异常的ListenableFuture，返回的Future不能被取消，isDone()方法总是返回 true，调用get()方法会抛出被ExecutionException包装的Throwable。

 

immediateCancelledFuture()：创建一个会被立即取消的ListenableFuture，所以isCancelled()方法总是返回true。

 

immediateCheckedFuture(@Nullable V value)：返回一个CheckedFuture，构造时其value值立即会被设置，返回的Future不能被取消，isDone()方法总是返回 true，调用get()或者checkGet()方法会立即返回设置的value值。

 

immediateFailedCheckedFuture(X exception)：返回一个构造时设置传入异常的CheckedFuture，返回的Future不能被取消，isDone()方法总是返回 true，调用get()方法会抛出被ExecutionException包装的Exception，调用checkGet()方法会抛出给定的 exception异常。

 

withFallback( ListenableFuture<? extends V> input, FutureFallback<? extends V> fallback)：返回一个Future，其结果来自于ListenableFuture，如果ListenableFuture出现失败，则结果由给 定的FutureFallback产生。

 

withFallback( ListenableFuture<? extends V> input, FutureFallback<? extends V> fallback, Executor executor)：返回一个Future，其结果来自于ListenableFuture，如果ListenableFuture出现失败，则结果由给 定的FutureFallback产生，并由给定的executor提供线程单独运行FutureFallback。

 

transform(ListenableFuture<I> input, AsyncFunction<? super I, ? extends O> function)：创建一个新的ListenableFuture，它的结果异步来自于给定ListenableFuture的结果，更准确的说，返回 的结果是由原始的结果应用给定的function后的结果。

 

transform(ListenableFuture<I> input, AsyncFunction<? super I, ? extends O> function, Executor executor)：创建一个新的ListenableFuture，它的结果异步来自于给定ListenableFuture的结果，更准确的说，返回 的结果是由原始的结果应用给定的function后的结果，给定的function操作由executor执行。

 

transform(ListenableFuture<I> input, final Function<? super I, ? extends O> function)：创建一个新的ListenableFuture，它的结果是给定input ListenableFuture的结果应用给定的function后的结果。

 

transform(ListenableFuture<I> input, final Function<? super I, ? extends O> function, Executor executor)：创建一个新的ListenableFuture，它的结果是给定input ListenableFuture的结果应用给定的function后的结果，给定的function操作由executor执行。

 

lazyTransform(final Future<I> input, final Function<? super I, ? extends O> function)：与transform方法类似，不过function的转换过程会每次调用返回的Future的get()方法。

 

dereference( ListenableFuture<? extends ListenableFuture<? extends V>> nested)：返回一个新的ListenableFuture，它的结果是给定nested ListenableFuture调用get()的结果， 此方法能够有效的将一个ListenableFuture链接到另一个ListenableFuture。

 

allAsList( ListenableFuture<? extends V>... futures)：创建一个新的ListenableFuture，当给定的futures集合中future都完成时返回结果的list，如果任一 future失败，则创建的ListenableFuture会失败。

allAsList( Iterable<? extends ListenableFuture<? extends V>> futures)：创建一个新的ListenableFuture，当给定的futures集合中future都完成时返回结果的list，如果任一 future失败，则创建的ListenableFuture会失败。

 

nonCancellationPropagating( ListenableFuture<V> future)：创建一个新的ListenableFuture，当给定的future完成时，它的结果才会被设置。取消给定的future也会取消返回 的ListenableFuture，但是取消返回的ListenableFuture对给定的future没有影响。

 

successfulAsList( ListenableFuture<? extends V>... futures)：创建一个新的ListenableFuture，它的值是一个列表包含所有传入Future集合中Future执行成功后返回的值，结 果的顺序与传入集合的顺序一致，如果任何一个传入集合中的Future失败或被取消，其对应的位置的值将会被设置为null，（这导致了将无法区别执行成 功后返回值为null的任务）。

 

successfulAsList( Iterable<? extends ListenableFuture<? extends V>> futures)：创建一个新的ListenableFuture，它的值是一个列表包含所有传入Future集合中Future执行成功后返回的值，结 果的顺序与传入集合的顺序一致，如果任何一个传入集合中的Future失败或被取消，其对应的位置的值将会被设置为null，（这导致了将无法区别执行成 功后返回值为null的任务）。

 

inCompletionOrder( Iterable<? extends ListenableFuture<? extends T>> futures)：返回一个委托的Future的列表，对应Future完成的顺序，委托的Future会返回相同的值或者抛出相同的异常，和原生的 Future一致。

 

addCallback(ListenableFuture<V> future, FutureCallback<? super V> callback)：注册一个在任务成功或失败时运行的回调函数，一旦Future完成，则立即执行回调函数。

 

addCallback(final ListenableFuture<V> future, final FutureCallback<? super V> callback, Executor executor)：注册一个在任务成功或失败时单独运行的回调函数，这个单独操作Callback的线程由传入的executor提供，一旦 Future完成，则立即执行回调函数。

 

get( Future<V> future, Class<X> exceptionClass)：返回Future.get()的结果，转换大部分的异常为新给定的异常类型，这样减少了大量的代码，对异常代码不必要的区分类型。

 

get( Future<V> future, long timeout, TimeUnit unit, Class<X> exceptionClass)：返回Future.get(long,TimeUnit)的结果，转换大部分的异常为新给定的异常类型，这样减少了大量 的代码，对异常代码不必要的区分类型。

 

getUnchecked(Future<V> future)：返回Future.get()的结果，这个结果不会阻塞任务也不抛出被检查出的异常，这使得任务执行更轻量级，更快速运行，除非是遇到代码bug，否则不会失败。

 

    总结：Futures是强大的操作Future的工具类，不过其中的一些方法目前自己的理解还不清晰，其中的一些方法也没有用到，还需要在以后的工作和学习中，反复思考，反复总结。学无止境。

 

    代码地址：