RxAndroid学习1

    RxJava最核心的两个东西是Observables（被观察者，事件源）和Subscribers（订阅者）。Observables发出一系列事件，Subscribers处理这些事件。这里的事件可以是任何你感兴趣的东西，触摸事件，web接口调用返回的数据等等。

    关于RxAndroid的github：https://github.com/ReactiveX/RxAndroid。

    新建emRxAndroidStudy工程， 然后在build.grade的dependencies里添加：

[java] view plain copy

1. compile 'io.reactivex:rxandroid:1.1.0'  
2. compile 'io.reactivex:rxjava:1.1.0'  

    接着我们来试下RxAndroid了， 首先这里我们还是使用上次的注解的方式，把4个和Annotation相关的文件拷贝到工程，编写MainActivity代码如下：

[java] view plain copy

1. package com.jared.emrxandroidstudy;  
2.   
3. import android.os.Bundle;  
4. import android.util.Log;  
5. import android.view.View;  
6. import android.widget.Button;  
7. import android.widget.TextView;  
8.   
9. import rx.Observable;  
10. import rx.Subscriber;  
11.   
12. @EMLayoutBinder(R.layout.activity_main)  
13. public class MainActivity extends BaseActivity {  
14.   
15.     private static final String TAG = "MainActivity";  
16.     private Subscriber<String> subscriber;  
17.     private Observable<String> observable;  
18.   
19.     @EMViewBinder(R.id.hello)  
20.     private TextView mHello;  
21.     @EMViewBinder(R.id.test1)  
22.     private Button mTest1;  
23.   
24.     @Override  
25.     protected void onCreate(Bundle savedInstanceState) {  
26.         super.onCreate(savedInstanceState);  
27.         createSubscriber();  
28.     }  
29.   
30.     private void bindSubscriber() {  
31.         observable.subscribe(subscriber);  
32.     }  
33.   
34.     private void createSubscriber() {  
35.   
36.         subscriber = new Subscriber<String>() {  
37.   
38.             @Override  
39.             public void onCompleted() {  
40.                 Log.d(TAG, "onCompleted");  
41.             }  
42.   
43.             @Override  
44.             public void onError(Throwable e) {  
45.                 e.printStackTrace();  
46.             }  
47.   
48.             @Override  
49.             public void onNext(String t) {  
50.                 Log.d(TAG, "onNext");  
51.                 mHello.setText(t);  
52.             }  
53.         };  
54.     }  
55.   
56.     private String getHello() {  
57.         return "Hello RxAndroid";  
58.     }  
59.   
60.     private String getHello1() {  
61.         return "Hello RxAndroid 1";  
62.     }  
63.   
64.     @EMOnClickBinder({R.id.test1})  
65.     public void myOnClick(View view) {  
66.         switch (view.getId()) {  
67.             case R.id.test1:  
68.                 createObservable();  
69.                 break;  
70.             default:  
71.                 break;  
72.         }  
73.     }  
74.   
75.     private void createObservable() {  
76.         Log.d(TAG, "observable");  
77.         observable = Observable.create(new Observable.OnSubscribe<String>() {  
78.             @Override  
79.             public void call(Subscriber<? super String> subscriber) {  
80.                 subscriber.onNext(getHello());  
81.                 subscriber.onCompleted();  
82.             }  
83.         });  
84.         bindSubscriber();  
85.     }  
86. }  

     布局文件如下：

[html] view plain copy

1. <?xml version="1.0" encoding="utf-8"?>  
2. <LinearLayout  
3.     xmlns:android="http://schemas.android.com/apk/res/android"  
4.     xmlns:tools="http://schemas.android.com/tools"  
5.     android:layout_width="match_parent"  
6.     android:layout_height="match_parent"  
7.     android:orientation="vertical"  
8.     tools:context="com.jared.emrxandroidstudy.MainActivity">  
9.   
10.     <TextView  
11.         android:id="@+id/hello"  
12.         android:text="Hello World!"  
13.         android:layout_width="wrap_content"  
14.         android:layout_height="wrap_content" />  
15.   
16.     <Button  
17.         android:id="@+id/test1"  
18.         android:text="Test"  
19.         android:layout_width="match_parent"  
20.         android:layout_height="wrap_content"  
21.         android:textAllCaps="false"/>  
22. </LinearLayout>  

    这里创建了Observable，用来发送一字符串，然后创建了Subscriber，用来接收事件处理，然后把这两个绑定，按下按钮后，subscriber会调用onNext方法和onCompleted方法。

    当然这里的createObservable可以通过just方法简化：

[java] view plain copy

1. private void createObservableByJust() {  
2.        Log.d(TAG, "createObservable");  
3.        observable = Observable.just(getHello());  
4.        bindSubscriber();  
5.    }  

    效果和上述的是一样一样的。接着简化subscriber了：

[java] view plain copy

1. private void createSubscriberByAction() {  
2.         onNextAction = new Action1<String>() {  
3.             @Override  
4.             public void call(String s) {  
5.                 mHello.setText(s);  
6.             }  
7.         };  
8.     }  

    这里通过Action1来实现，完全没有了subscriber了的感觉，接着修改绑定如下：

[java] view plain copy

1. private void bindSubscriber() {  
2.        //observable.subscribe(subscriber);  
3.        observable.subscribe(onNextAction);  
4.    }  

    效果还是一样一样的。

    好了，接着我们来使用下操作符map，修改如下：

[java] view plain copy

1. private void createObservableByMap() {  
2.        Log.d(TAG, "createObservableByMap");  
3.        Observable.just(getHello()).map(new Func1<String, String>() {  
4.            @Override  
5.            public String call(String s) {  
6.                return s + " by eastmoon";  
7.            }  
8.        }).subscribe(onNextAction);  
9.    }  

    运行结果后原来字符串加上了by eastmoon了。其实map的功能就是在observable和subscribe之间可以对数据进行操作。