为了账号安全,请及时绑定邮箱和手机立即绑定

逻辑连续性和回调地狱

标签:
Java Android
0x00 问题点
  • 复杂逻辑如何保证连续性?
    类似于网络请求和各种持久化操作,由于回调的原因,每一步的代码可能并不是写在同一个地方,如何解决逻辑连续性和代码可维护性?
  • 基于回调的操作如何解决回调地狱问题?
    这和第一个问题是有关联的,如果大量的操作都是基于回调的,那么该如何解决回调地狱(Callback Hell)的问题?
0x01 答案

使用RxJava可以解决上述两个问题。

0x02 举个例子
  • 案例描述
    有这样一个需求,需要先去调用一个接口,从服务器拉取图片地址,然后显示在界面上,显示后将这个图片和此界面上的其他元素一起截图保存,然后调用微信分享出去。
  • 案例分析
    需求并不复杂,但是涉及到了多次线程切换和异步操作,做网络请求需要在线程执行,将图片显示到界面上需要在主线程执行,将界面截图保存需要在线程执行,调用微信分享出去又需要在主线程执行。短短的一个简单的需求,就需要来回几次的线程切换。
  • 不使用RxJava的写法
// 调用接口获取图片地址
NetworkService.execute(request, new Callback() {

            @Override
            public void onSuccess(String url) {
                // 加载图片
                ImageLoader.load(url, new Callback() {

                    @Override
                    public void onSuccess(final Bitmap bitmap) {

                        runOnUiThread(new Runnable() {

                            @Override
                            public void run() {
                                // 设置显示图片
                                tImageView.setImageBitmap(bitmap);
                                new Thread(new Runnable() {

                                    @Override
                                    public void run() {
                                        // 获取当前View的Bitmap
                                        tContentView.setDrawingCacheEnabled(true);
                                        Bitmap tScreenshotBitmap = tContentView.getDrawingCache();
                                        // 拷贝图片
                                        final Bitmap tShareBitmap = Bitmap.createBitmap(tScreenshotBitmap);
                                        tContentView.setDrawingCacheEnabled(false);
                                        runOnUiThread(new Runnable() {

                                            @Override
                                            public void run() {
                                                // 微信分享
                                                WeiXinShare.share(tShareBitmap);
                                            }
                                        });
                                    }
                                }).start();
                            }
                        });
                    }
                });
            }
        });

可以看出,如果不使用RxJava,代码中存在多处回调,这还是一个简单的需求,如果需求再复杂一点,回调嵌套的层数多了,这就是回调地狱。还有,我们这里的代码使用的是单一回调处理,每做一个事情写一个单独的回调对象,如果使用的是统一回调处理,或者用Android里的AsyncTask,那么处理后的逻辑,势必要散在各处,难以阅读,逻辑连续性不好。

  • 使用RxJava的写法
Observable.
                        create(new Observable.OnSubscribe<String>() {
                            @Override
                            public void call(Subscriber<? super String> subscriber) {
                                // 调用接口获取图片地址
                                String tUrl = NetworkService.execute(request);
                                if (subscriber.isUnsubscribed()) {
                                    return;
                                }
                                subscriber.onNext(tUrl);
                                subscriber.onCompleted();
                            }
                        }).
                        subscribeOn(Schedulers.io()).
                        map(new Func1<String, Bitmap>() {
                            @Override
                            public Bitmap call(String s) {
                                // 加载图片
                                return ImageLoader.load(s);
                            }
                        }).
                        observeOn(AndroidSchedulers.mainThread()).
                        map(new Func1<Bitmap, Boolean>() {
                            @Override
                            public Boolean call(Bitmap bitmap) {
                                // 显示图片
                                tImageView.setImageBitmap(bitmap);
                                return true;
                            }
                        }).
                        observeOn(Schedulers.io()).
                        map(new Func1<Boolean, Bitmap>() {
                            @Override
                            public Bitmap call(Boolean aBoolean) {
                                // 获取当前View的Bitmap
                                tContentView.setDrawingCacheEnabled(true);
                                Bitmap tScreenshotBitmap = tContentView.getDrawingCache();
                                // 拷贝图片
                                final Bitmap tShareBitmap = Bitmap.createBitmap(tScreenshotBitmap);
                                tContentView.setDrawingCacheEnabled(false);
                                return tShareBitmap;
                            }
                        }).
                        observeOn(AndroidSchedulers.mainThread()).
                        subscribe(new Action1<Bitmap>() {
                            @Override
                            public void call(Bitmap bitmap) {
                                // 微信分享   
                                WeiXinShare.share(bitmap);
                            }
                        });

可以看出,使用了RxJava并不是使代码减少,而且让代码逻辑连续且整洁,杜绝回调地狱,所有的步骤都是在一个代码层级上,没有过多层次的嵌套,这就是RxJava的优点。

但是RxJava是如何实现这一效果的,这就是我们以后要探讨的问题了。

点击查看更多内容
6人点赞

若觉得本文不错,就分享一下吧!

评论

作者其他优质文章

正在加载中
JAVA开发工程师
手记
粉丝
27
获赞与收藏
9

关注作者,订阅最新文章

阅读免费教程

感谢您的支持,我会继续努力的~
扫码打赏,你说多少就多少
赞赏金额会直接到老师账户
支付方式
打开微信扫一扫,即可进行扫码打赏哦
今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与 放弃机会
意见反馈 帮助中心 APP下载
官方微信

举报

0/150
提交
取消