Bolts-Android

对Android客户端编程来说，有个明确的规则是不能在ui线程里面做耗时的操作。这样就要求网络请求、文件读写等等操作都要异步操作。
而异步操作完成后，往往需要再更新ui界面。最直接的想法是回调，只要保证在ui线程里面，更新ui组件不会困难。
但有些情况下，往往需要多层异步操作，这时候代码就很丑了，不管是维护，还是编写都是挑战。

举例

以发布内容举例：

1. 先上传所有图片，图片依次上传。
2. 图片上传完成后，调用接口发布内容。

这是个很常见的场景，我们先以回调的方式来实现，感受下。

首先，定义图片上传的接口,由于是异步操作，添加回调。

private void uploadImage(Image image, ImageUploadCallback callback) {
...
}

第二步，定义多个图片上传的接口，依次上传图片，这时需要用到递归大法。（我不喜欢递归，因为递归要思考下，才能考虑清楚，不管是编写还是维护阅读。）

private void uploadImages(List<Image> images, UploadAllImageCallback callback) {
    Image poped = images.remove(0);    
    uploadImageRecursive(images, poped, callback);
}
private void uploadImageRecursive(final List<Image> left, Image image, final UploadAllImageCallback callback) {
    uploadImage(image, new ImageUploadCallback() {
        public void onFinished(Exception e, String url) {
            if (e != null) {
                if (callback != null) callback.onFinished(e/*failed*/);
                return;            
            }
            if (left.isEmpty()) {
                if (callback != null) callback.onFinished(null/*sucess*/);
                return;            
            } 
            Image poped = left.remove(0);    
            uploadImageRecursive(left, poped, callback);
        }    
    })    
}

第三步，定义发布内容接口。

private void httpPublishPost(Post post, HttpPublishPostCallback callback) {
    ...
}

第四步，整合发布图片和发布内容。

public void publishPost(Post post, PublishPostCallback callback) {
    uploadImages(post.images, new UploadAllImageCallback() {
        public void onFinished(Exception e) {
            if (e != null) {
                if (callback != null) callback.onFinished(e);
                return;            
            }        
            httpPublishPost(post, new HttpPublishPostCallback() {
                 public void onFinished(Exception e) {
                    if (callback != null) {
                        callback.onFinished(e);                    
                    }
                 }
            })
        }    
    })
}

整套代码至少以下几个方面不利于代码维护：

1. 图片发布用到递归，代码不够清晰，编写和维护都不方便
2. 最后的整合很操蛋，用到了多层回调。
3. java不比js，要定义一堆的回调传递，很痛苦。

Bolts

Javascript 有Promise处理异步操作，程序逻辑扁平化，非常有利于扩展和组合。
对于Android也有类似的解决方案，就是Bolts-Android
iOS也有相应的版本：Bolts-iOS
Bolts 是Parse 开源的框架，Parse 前端时间被Facebook收购，是个云平台服务提供商。

Bolts 提供了一种对任务的封装，将所有的操作抽象为Task, 只包含两种结果，出错 & 成功。并提供了一系列接口，方便开发者使用。
我们仍然以发布内容为例，说明Bolts的使用方法和好处。

首先，定义单个图片上传接口。

private Task<Void> uploadImage(Image image) {
    return Task.callInBackground(new Callable<Void>() {
        public Void call() {
            ...
            throw new Exception(); //for error
            //or
            return null;//for success.
        }    
    });
}

这里图片上传，返回一个Task对象，而不是传入回调。Task可以用来监听，获取执行完成的事件，以及执行结果。

第二步，定义多个图片上传的接口。牛逼的地方来了哈。

private Task<Void> uploadImages(List<Image> images) {
    Task<Void> task = Task.forResult(null);
    for (Image image : images) {
        task = task.onSuccessTask(new Continuation<Void, Task<Void>>() {
          public Task<Void> then(Task<Void> task) throws Exception {
            return uploadImage(image);
          }
        });
    }
    return task;
}

好处：

1. 没有递归没有递归没有递归。
2. 错误码直接向下传递，出错后自动中断。

第三步，定义发布内容的接口。

private Task<Void> httpPublishPost(Post post) {
    ...
}

第四步，整合发布图片和发布内容接口。

public Task<Void> publishPost(Post post) {
    return uploadImages(post.images)
        .onSuccessTask(new Continuation<Void, Task<Void>>() {
              public Task<Void> then(Task<Void> task) throws Exception {
                    return httpPublishPost(post);
              }
        });}

Bolts 是最近才开始使用，着实对异步处理有很大的帮助。
之前有看过RxJava, 也是一种扁平化的编程方式，对异步处理也很有方便，但包很大，整个编程思想也与原有模式有很大的不同，之前有用到一个小项目上，后来折腾来折腾去，始终没有用顺。
Bolts 很轻量，有作用的类也就Task一个，代码也不多，很喜欢。