【译文】RxAndroid and Kotlin (Part1)

原文作者:Ahmed Rizwan

原文链接:RxAndroid and Kotlin (Part1)

译文作者:Dimon

译者语:由于本人水平有限,翻译可能会存在偏差,望大大们谅解。如发现问题,可评论告知,好及时改正~翻译文章只为交流学习,谢谢观看。

文中的Subscriber我直接译为观察者了,只是为了方便自己理解,如有不悦,见谅。


我开始关注RxAndroid已经差不多一周时间了。一开始,我并没有真正意义上地理解它...我的意思是:我抓住了它的概念,但是我却不清楚该何时使用它。不过后来看了一些例子以及一些干货文章(链接在文章末)后,我才算了解RxAndroid!(到了个良好的程度)当时的内心如下:

Such Rx. Much Reactive. Wow!

简而言之,你几乎可以在任何地方使用Rx,但你不能这样做。你应该明智地揣摩哪儿更适合使用它,因为在某种情况下,Rx可以提升100倍以上的生产性或者比正常命令性编程更好,而在其他情况下,则是没必要使用它的。

那么以下,我将展示KotlinJava这两种语言关于Rx的一些例子。

如果你现在对Kotlin不那么熟悉,那么我建议您可以访问以下链接:

Official Kotlin Website

Getting Started on Android

Jake Wharton’s Paper on Kotlin

摘要: Kotlin is an awesometacular alternative to Java, that works amazingly well on Android. And oh, it's developed by JetBrains!

P.S. Kotlin 是没有分号的。:-)


Rx:概念

如果你已经对于Rx有了很好的概念,那么你可以跳过这一part。否则...请你继续吞了下面的这颗安利!!!

那么什么是Rx呢?(⊙v⊙)蒽...其实就是响应式编程reactive programming...用简单的话说,响应式编程reactive programming其实就是一种与观察者模式Observer Pattern密切相关的编程模式。
其中,由被观察者Observable调用了观察者Subscriber的回调方法,就实现了由被观察者Observable向观察者Subscriber的事件传递,即观察者模式Observer Pattern

Observer Pattern

Rx也是函数式编程的一个子集。所以经常被称为Functional Reactive Programming。因为...作为用户接收的数据,它们可以申请它们的转换序列。(类似于我们在Java8中的对流所做的)

转换为用户观察到的接收数据

我们甚至可以结合或者说合并不同的流streams。它就是这么的灵活!所以,现在我们只记得有一堆不同的、我们(观察者Subscriber)可以从被观察者Observable中接收的数据。

现在,概念开始有点清晰,让我们回过头来看看RxJava。

在Rx中,观察者subscriber的三个事件回调方法:

1.onNext(Data) :从被观察者Observale中接收数据(相当于 onClick() / onEvent())

2.onError(Exception) :如果抛出异常,这个方法将被调用

3.onCompleted() :将在事件队列完结时调用。

RxJava不仅把每个事件单独处理,还会把它们看做一个队列。RxJava 规定,当不会再有新的 onNext() 发出时,需要触发 onCompleted() 方法作为标志。

其实这就像IterablesJava里那样。但有所不同的是,Iterablespull型,而Rx中的被观察者们Observalespush型,这是被观察者Observable将数据推到了其观察者subscribers中。以下是他们之间的比较表格:

comparison table

另外需要注意的是,Rx本质上是异步的,也就是说观察者subscribers不会等待其他观察者subscribers。他们其实“异步”的过程流。

所以被观察者Observables推出的数据流给他们的观察者subscribers,然后观察者subscribers可以处置这些流(在上面的方法的帮助下)。我们可以通过下面的 Marble Diagrams来更好地了解流:

两个不同的数据流

这些圆圈代表着的是流上的数据对象。箭头代表该数据流动的一个方向,以有序的方式!再看看以下图:


A mapping of a stream.

就像我之前提到的,我们可以将类似于map、filter、zip等等使用operators转变成数据(以及流)。上图表示的是一种简单的映射。所以这一转变后,观察者subscriber这个流将得到转变后的流,怎么样?酷吧!

我想你现在应该对Rx是如何工作已经有了一个很好的概念,所以现在让我们开始实际操作吧。

  • 好,我们要做的第一件事就是打坐。(莫打趣,其实只是想思考代码)
meditate
  • 然后,创建一个被观察者Observable亦不是难事。

这有一些可以创建被观察者Observables的方式,我只是将其中三个罗列出来:

1.Observable.from() : 将传入的数组或 Iterable 拆分成具体对象后,依次发送出来。

//Kotlin
Observable.from(listOf(1, 2, 3, 4, 5))
//Java
Observable.from(Arrays.asList(1, 2, 3, 4, 5));
//它将会发出以下这些数字 : 1 - 2 - 3 - 4 - 5
String[] words = {"Hello", "Hi", "Aloha"};
Observable observable = Observable.from(words);
// 将会依次调用:
// onNext("Hello");
// onNext("Hi");
// onNext("Aloha");
// onCompleted();

2.Observable.just() :将传入的参数依次发送出来。

Observable observable = Observable.just("Hello", "Hi", "Aloha");
// 将会依次调用:
// onNext("Hello");
// onNext("Hi");
// onNext("Aloha");
// onCompleted();

3.Observable.create() :创建一个 Observable,实现OnSubscribe接口,并告诉被观察者observable当它被订阅时,OnSubscribecall() 方法会自动被调用,将数据发送到观察者subscriber(s)

//Kotlin
Observable.create(object : Observable.OnSubscribe {
    override fun call(subscriber: Subscriber) {
        for(i in 1 .. 5)
            subscriber.onNext(i)

        subscriber.onCompleted()
    }
})

相同代码的Java版本:

//Java
Observable.create(new Observable.OnSubscribe() {
    @Override
    public void call(final Subscriber
subscriber) {
        for (int i = 1; i <= 5; i++)
            subscriber.onNext(i);

        subscriber.onCompleted();
    }
});

上面写的代码就相当于我写了Observable.from()的例子,但你可以看到,我们可以充分控制发出什么东西、什么时候流可以结束。还可以使用subscribe.onError(e)发送捕获到的异常。

好了,到了现在,我们需要实现观察者subscriber


实现观察者subscriber

在我们已经实现被Observables之后,我们需要的一个subscriber!对于安卓而言,订阅一个被Observable我们首先要告诉observable有关我们打算订阅和观察的线程。RxAndroid给我们的Schedulers,通过它我们可以指定相应的线程。所以,让我们举一个简单的“Hello World”observable的例子,实现在worker thread完成订阅,在main thread上观察。

//Kotlin
Observable.just("Hello World")
          .subscribeOn(Schedulers.newThread())
          //each subscription is going to be on a new thread.
          .observeOn(AndroidSchedulers.mainThread()))
          //observation on the main thread
          //Now our subscriber!
          .subscribe(object:Subscriber(){
            override fun onCompleted() {
             //Completed
            }

            override fun onError(e: Throwable?) {
             //TODO : Handle error here
            }

            override fun onNext(t: String?) {
             Log.e("Output",t);
            }
           })
//Java
Observable.just("Hello World")
        .subscribeOn(Schedulers.newThread())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Subscriber() {
            @Override
            public void onCompleted() {
                //Completion
            }

            @Override
            public void onError(final Throwable e) {
                //TODO : Handle error here
            }

            @Override
            public void onNext(final String s) {
                Log.e("Output",s);
            }
        });

你可以在这里得到有关调度与线程的更多信息。

那,它是怎么工作的呢?

当你运行上面那段代码时,它会显示一个日志消息

Output: Hello World!

你看,“订阅”就是如此的简单。你可以点击这里获取更多关于订阅的相关详情。


一个简单的实例:Debounce!!!

好了,你现在知道了如何创建简单的observables了对不对?~

那么让我们来做我们自己喜欢的RxExamples~~

我呢~想实现这个:

RxExamples

在这个例子里,我将文本输入到一个EditText中,并且针对该文本:当我输入时,一个响应将被自动触发,从而打印出我输入的文本。现在这样的反应可能被称为一个API的调用。所以,如果我触发此要求输入了的每一个字符——这将是一种浪费,因为我只需要知道最后一个输入,这意味着在我停止打字的时候它应该只触发一个call——也就是在我打字后,静止一秒的说~!

那么该如何才能在non-reactive programming做到这一点呢?

Non-Reactive Solution

我用一个定时器,并且安排它在afterTextChanged()方法延时1000毫秒后调用run()方法。呃,不要忘记了也要在那添加runOnUiThread()。-_-

其实在概念上,实现起来并不难,但是却会让代码变得非常混乱,在Java中更是如此。

  • Java version
//Java
Timer timer = new Timer();

final TextView textView = (TextView) findViewById(R.id.textView);
final EditText editText = (EditText) findViewById(R.id.editText);

editText.addTextChangedListener(new TextWatcher() {
    @Override
    public void beforeTextChanged(CharSequence s, int start, int count,
                                  int after) {
    }

    @Override
    public void onTextChanged(final CharSequence s, int start, int before,
                              int count) {
        if (timer != null)
            timer.cancel();
    }

    @Override
    public void afterTextChanged(final Editable s) {
        timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        textView.setText("Output : " + editText.getText());
                    }
                });
            }

        }, 1000);
    }
});
  • Kotlin
//Kotlin
var timer: Timer? = Timer()

val editTextStop = findViewById(R.id.editText) as EditText
editTextStop.addTextChangedListener(object : TextWatcher {
    override fun beforeTextChanged(s: CharSequence, start: Int, count: Int, after: Int) = Unit

    override fun onTextChanged(s: CharSequence, start: Int, before: Int, count: Int) {
            timer?.cancel()
    }

    override fun afterTextChanged(s: Editable) {
        timer = Timer()
        timer!!.schedule(object : TimerTask() {
            override fun run() {
                runOnUiThread { textView.setText("Output : " + editTextStop.getText()) }
            }
        }, 1000)
    }
})

Reactive Solution

反应式的解决方案是一个非常自由的样板。而且只有3个步骤。

1.创建一个observable
2.添加Debounce operator,1000毫秒(1秒)的延迟
3.订阅它

  • 首先是Java代码
  Observable.create(new Observable.OnSubscribe() {
                    @Override
                    public void call(final Subscriber subscriber) {
                        editText.addTextChangedListener(new TextWatcher() {
                            @Override
                            public void beforeTextChanged(final CharSequence s, final int start, final int count, final int after) {
                            }

                            @Override
                            public void onTextChanged(final CharSequence s, final int start, final int before, final int count) {
                                subscriber.onNext(s.toString());
                            }

                            @Override
                            public void afterTextChanged(final Editable s) {
                            }
                        });
                    }
                })
                .debounce(1000, TimeUnit.MILLISECONDS)
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action1() {
                    @Override
                    public void call(final String s) {
                        textView.setText("Output : " + s);
                    }
                });
  • Kotlin
 Observable.create(Observable.OnSubscribe { subscriber ->
            editText.addTextChangedListener(object : TextWatcher {
                override fun afterTextChanged(s: Editable?) = Unit

                override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) = Unit

                override fun onTextChanged(s: CharSequence, start: Int, before: Int, count: Int)
                        = subscriber.onNext(s.toString())
            })
        }).debounce(1000, TimeUnit.MILLISECONDS)
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe({
                    text ->
                    textView.text = "Output : " + text
                })

更少的样板——RxBindings!

我们可以使用RxBindings——这是RxJava结合了Android的UI组件的API。它适用于JavaKotlin!快去使用它吧!!

    //Java with Retrolambda and RxBinding
    RxTextView.afterTextChangeEvents(editText)
              .debounce(1000,TimeUnit.MILLISECONDS)
              .observeOn(AndroidSchedulers.mainThread())
              .subscribe(tvChangeEvent -> {
                 textView.setText("Output : " + tvChangeEvent.view()
                            .getText());
              });

    //Kotlin with RxBinding
    RxTextView.afterTextChangeEvents(editText)
              .debounce(1000, TimeUnit.MILLISECONDS)
              .observeOn(AndroidSchedulers.mainThread())
              .subscribe { tvChangeEvent ->
                        textView.text = "Output : " + tvChangeEvent.view().text
              }

正如你所看到的,更少的代码。如果在几个月前看着段代码,我很难在一分钟你弄清楚这是怎么回事。这可真是无价之宝!


下面是一些我推荐的关于Rx的一些资源!我将会继续研究Rx+(kotlin&Java)和继续完成part2的,敬请关注!

  • Official Rx Page
  • Grokking RxJava Series by Dan Lew
  • Android Rx, and Kotlin : A case study
  • Replace AsyncTasks with Rx
  • PhilosophicalHacker Blog on Rx
  • Implementing EventBus in Rx
  • RxKotlin

你可能感兴趣的:(【译文】RxAndroid and Kotlin (Part1))