android RxJava 详解应用事例

RxJava的使用总感觉比较麻烦， 最近仔细看了一些关于这方面的讲解，写了一个测试Demo，还是见代码吧！

参考见<<给 Android 开发者的 RxJava 详解>>http://gank.io/post/560e15be2dca930e00da1083：

Demo 中有handler在程序中消息处理与RxJava替代hanlder处理方式的比较，以及关于RxJava_android 的使用。使用RxJava_的大致思路：创建出 Observable 和 Subscriber ，再用 subscribe() 将它们串起来。

形式如下：

Observable.subscribe( Subscriber);解读,Observable，被观察者；subscribe ：订阅，注册机制；Subscriber：观察者，我个人理解为，Observable加载的信息，通知给Subscriber。

build.gradle

github rxjava见https://github.com/ReactiveX/RxAndroid/和https://github.com/ReactiveX/RxJava;

compile 'io.reactivex:rxandroid:1.2.1'
compile 'io.reactivex:rxjava:1.1.6'

观察 与 被观察：

观察者	被观察者
Observer,Subscriber	Observable.create(OnSubscribe),Observable.create(OnSubscribe)
Action1< T > ,Action0< T >	Observable.just(T…),Observable.from(T[ ])

可以使用冒号来定义对齐方式：

just(T…) 的和 from(T[]) 的例子，都和之前的 create(OnSubscribe) 是等价的。

创建了 Observable 和 Observer 之后，再用 subscribe() 方法将它们联结起来

observable.subscribe(observer);
// 或者：
observable.subscribe(subscriber);

见代码：

MainActivity.java

package dome.rxjava.com.rxjavademo;

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Handler;
import android.os.Message;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.ImageView;
import android.widget.TextView;
import android.widget.Toast;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import rx.Observable;
import rx.Observer;
import rx.Subscriber;
import rx.android.schedulers.AndroidSchedulers;
import rx.functions.Action0;
import rx.functions.Action1;
import rx.functions.Func1;
import rx.schedulers.Schedulers;

/**
* 关于RxJava_android 的使用。
* 创建出 Observable 和 Subscriber ，再用 subscribe() 将它们串起来，
* 形式如下：
* Observable.subscribe( Subscriber);
* 解读,Observable，被观察者；subscribe ：订阅，注册机制；Subscriber：观察者，
* 我个人理解为，Observable加载的信息，通知给Subscriber。
*/
public class MainActivity extends AppCompatActivity implements View.OnClickListener {
private String TAG = "MainActivity";
private TextView handlerTestTv;
private TextView testRxJavaCreatTv;
private TextView testSubscriberTv;
private TextView testObservableFromTv;
private TextView testObservableJustTv;
private TextView testObservableMapTv;
private TextView contentTv;
private ImageView contentImage;

private List<String> arrayList;
private int post = 0;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
handlerTestTv = (TextView) findViewById(R.id.handlerTestTv);
handlerTestTv.setOnClickListener(this);
testRxJavaCreatTv = (TextView) findViewById(R.id.testRxJavaCreatTv);
testRxJavaCreatTv.setOnClickListener(this);
testSubscriberTv = (TextView) findViewById(R.id.testSubscriberTv);
testSubscriberTv.setOnClickListener(this);
testObservableFromTv = (TextView) findViewById(R.id.testObservableFromTv);
testObservableFromTv.setOnClickListener(this);
testObservableJustTv = (TextView) findViewById(R.id.testObservableJustTv);
testObservableJustTv.setOnClickListener(this);
testObservableMapTv = (TextView) findViewById(R.id.testObservableMapTv);
testObservableMapTv.setOnClickListener(this);

contentTv = (TextView) findViewById(R.id.contentTv);
contentImage = (ImageView) findViewById(R.id.contentImage);

arrayList = new ArrayList<>();
arrayList.add("姓名：");
arrayList.add("年龄：");
arrayList.add("成绩：");
}

@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.handlerTestTv:
handler();
break;
case R.id.testRxJavaCreatTv:
rxJavaCreat();
break;
case R.id.testSubscriberTv:
testSubscriber();
break;
case R.id.testObservableFromTv:
testObservableFrom();
break;
case R.id.testObservableJustTv:
tes
4000
tObservableJust();
break;
case R.id.testObservableMapTv:
testObservableMap();
break;
default:

}

}

public void handler() {
Toast.makeText(MainActivity.this, "handler测试", Toast.LENGTH_SHORT).show();
post = 0;
startThread();

}

public void rxJavaCreat() {
post = 1;
Toast.makeText(MainActivity.this, "RxJavaCreat测试", Toast.LENGTH_SHORT).show();
startThread();

}

public void testSubscriber() {
post = 2;
Toast.makeText(MainActivity.this, "RxJavaCreat测试", Toast.LENGTH_SHORT).show();
startThread();

}

public void testObservableFrom() {
post = 3;
Toast.makeText(MainActivity.this, "RxJavaFrom测试", Toast.LENGTH_SHORT).show();
startThread();

}

private void testObservableJust() {

post = 4;
Toast.makeText(MainActivity.this, "RxJavaJust测试", Toast.LENGTH_SHORT).show();
startThread();

}

private void testObservableMap() {
post = 5;
Toast.makeText(MainActivity.this, "RxJavaJust测试", Toast.LENGTH_SHORT).show();
startThread();

}

/**
* 模拟在非UI线程，共同的线程运行环境下，handler，与RxJava的运行
*/
private void startThread() {
new Thread(new Runnable() {
@Override
public void run() {
if (post == 0) doHandler();
if (post == 1) doRxJava_ObservableCreat();
if (post == 2) doObserver();
if (post == 3) doObservableFrom();
if (post == 4) doObservableJust();
if (post == 5) doObservableMap();

}
}).start();

}

/**
* Observable与Subscriber
* Observable().observeOn()---指定 Subscriber 的回调发生在主线程,刷新UI线程。
* <p>
* Schedulers.immediate(): 直接在当前线程运行，相当于不指定线程。这是默认的 Scheduler。
* Schedulers.newThread(): 总是启用新线程，并在新线程执行操作。
* Schedulers.io(): I/O 操作（读写文件、读写数据库、网络信息交互等）所使用的 Scheduler。
* 行为模式和 newThread() 差不多，区别在于 io() 的内部实现是是用一个无数量上限的线程池，
* 可以重用空闲的线程，因此多数情况下 io() 比 newThread() 更有效率。不要把计算工作放在 io() 中，可以避免创建不必要的线程。
*/
private void doRxJava_ObservableCreat() {
//第一种形式，被观察者

/**
*  这个就类似handler.sendMessage()
*
*
*/

getObservableCreate()
//                .subscribeOn(Schedulers.io()) // 指定 subscribe() 发生在 IO 线程
.observeOn(AndroidSchedulers.mainThread())// Android 还有一个专用的 AndroidSchedulers.mainThread().它指定的操作将在 Android 主线程运行。
.subscribe(mSubscriber);

}

/**
* Observable与observer
*/
private void doObserver() {

//这个就类似handler.sendMessage()
getObservableCreate().subscribeOn(AndroidSchedulers.mainThread()).subscribe(observer);

}

/**
* Observable.from()与Action1
*/
private void doObservableFrom() {

getObservableFrom().subscribe(action1);
//        getObservableFrom().subscribe(mSubscriber);//这种方式没有输出结果，我不知道为什么

}

/**
* Observable.just()与Action1，可以放入1--3个action
*/
private void doObservableJust() {
/**
* 经过代码测试，如果第一个action1与第二个onErrorAction里面的参数类型一致，第二个不执行
*/
getObservableJust().subscribeOn(AndroidSchedulers.mainThread()).subscribe(action1, onErrorAction, onCompletedAction);
}

/**
* <p>
* Schedulers.immediate(): 直接在当前线程运行，相当于不指定线程。这是默认的 Scheduler。
*Schedulers.newThread(): 总是启用新线程，并在新线程执行操作。
*Schedulers.io(): I/O 操作（读写文件、读写数据库、网络信息交互等）所使用的 Scheduler。行为模式和 newThread() 差不多，区别在于 io() 的内部实现是是用一个无数量上限的线程池，可以重用空闲的线程，因此多数情况下 io() 比 newThread() 更有效率。不要把计算工作放在 io() 中，可以避免创建不必要的线程。
*Schedulers.computation(): 计算所使用的 Scheduler。这个计算指的是 CPU 密集型计算，即不会被 I/O 等操作限制性能的操作，例如图形的计算。这个 Scheduler 使用的固定的线程池，大小为 CPU 核数。不要把 I/O 操作放在 computation() 中，否则 I/O 操作的等待时间会浪费 CPU。
*另外， Android 还有一个专用的 AndroidSchedulers.mainThread()，它指定的操作将在 Android 主线程运行。
* </p>
* Observable.map((new Func1<String, Bitmap>()),Func1的第一个参数类型String为输入参数类型，第二个为返回值参数类型
* Observable.subscribeOn(): 指定 subscribe() 所发生的线程，即 Observable.OnSubscribe 被激活时所处的线程。或者叫做事件产生的线程
* Observable.observeOn(): 指定 Subscriber 所运行在的线程。或者叫做事件消费的线程。
*/
private void doObservableMap() {

getObservableJust("banner.png")
.subscribeOn(Schedulers.io()) // 指定 subscribe() 发生在 IO 线程
.observeOn(AndroidSchedulers.mainThread())//即 Observable.OnSubscribe 被激活时所处的线程。或者叫做事件产生的线程。 * observeOn(): 指定 Subscriber 所运行在的线程。或者叫做事件消费的线程。
.map(getBitmapFuncl)
.subscribe(showBitmapAction);

}
Func1<String, Bitmap> getBitmapFuncl = new Func1<String, Bitmap>() {
@Override
public Bitmap call(String filePath) { // 参数类型 String
Log.e(TAG, "filePath========" + filePath);
return getBitmapFromPath(filePath); // 返回类型 Bitmap
}

};
Action1<Bitmap> showBitmapAction  =new Action1<Bitmap>() {

@Override
public void call(Bitmap bitmap) {
contentImage.setImageBitmap(bitmap);
}
};
Action1<String> action1 = new Action1<String>() {
@Override
public void call(String s) {
contentTv.setText(s);
Toast.makeText(MainActivity.this, "action1===Item:==" + s, Toast.LENGTH_SHORT).show();
Log.e(TAG, "action1xxxxxxxxxxx===Item: " + s);
}
};
Action1<Throwable> onErrorAction = new Action1<Throwable>() {
@Override
public void call(Throwable s) {

Toast.makeText(MainActivity.this, "onErrorAction===Item:==" + s, Toast.LENGTH_SHORT).show();
Log.e(TAG, "action2yyyyyyyyyyyyyy===Item: " + s);
}
};
Action0 onCompletedAction = new Action0() {
@Override
public void call() {

Toast.makeText(MainActivity.this, "onCompletedAction===Item:==", Toast.LENGTH_SHORT).show();
Log.e(TAG, "onCompletedAction===Item: ");
}
};

Observer<String> observer = new Observer<String>() {
@Override
public void onNext(String s) {
contentTv.setText(s);
Toast.makeText(MainActivity.this, "observer===Item:=====" + s, Toast.LENGTH_SHORT).show();
Log.e(TAG, "observer===Item: " + s);

}

@Override
public void onCompleted() {
Log.e(TAG, "action2yyyyyyyyyyyyyy===Item: " + "onCompleted");

Log.d(TAG, "Completed!");
}

@Override
public void onError(Throwable e) {
Log.d(TAG, "Error!");
}
};

/**
* 观察者Subscriber，Observer 的子类，被观察者 myObservable
*/
private Subscriber<String> mSubscriber = new Subscriber<String>() {
@Override
public void onCompleted() {

}

@Override
public void onError(Throwable e) {

}

@Override
public void onNext(String s) {
contentTv.setText(s);
Toast.makeText(MainActivity.this, "观察者输出的数据=====" + s, Toast.LENGTH_SHORT).show();
Log.e("tag", "观察者输出的数据=====" + s);

}
};

private Handler myHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
contentTv.setText(msg.obj.toString());
Log.e("tag", "myHandler=====" + msg.obj.toString());
}
};

/**
* handler处理方式
*/
private void doHandler() {
for (int i = 0; i < arrayList.size(); i++) {
Message mg = myHandler.obtainMessage(0, arrayList.get(i));
myHandler.sendMessage(mg);
}

}

/**
* 第一种，Observable，被观察者
*
* @return
*/
private Observable<String> getObservableCreate() {

Observable<String> myObservable = Observable.create(new Observable.OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> subscriber) {
for (int i = 0; i < arrayList.size(); i++) {
subscriber.onNext(arrayList.get(i));
}

d592
subscriber.onCompleted();

}
});

return myObservable;

}

private Observable getObservableFrom() {
//注意Observable<String>里的泛型String与Observable.from()传入的参数类型一致
//        String[] strs = new String[arrayList.size()];
//        for (int i = 0; i < arrayList.size(); i++) {
//            strs[i] = arrayList.get(i);
//
//        }
//    return     Observable.from(strs).subscribeOn(AndroidSchedulers.mainThread())
/**
* Observable.from(),可传入参数为数组(E[])与List集合
*/
return Observable.from(arrayList).subscribeOn(AndroidSchedulers.mainThread());
}

private Observable getObservableJust() {
return Observable.just(arrayList.get(0), arrayList.get(1), arrayList.get(2));
}

private Observable getObservableJust(String file) {
return Observable.just(file).subscribeOn(Schedulers.io()).subscribeOn(AndroidSchedulers.mainThread());

}

private Bitmap getBitmapFromPath(String filePath) {
InputStream in = null;
Bitmap bm = null;
try {
in = getResources().getAssets().open(filePath);
bm = BitmapFactory.decodeStream(in);
} catch (IOException e) {
e.printStackTrace();
} finally {
if (in != null) {
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}

return bm;
}

}

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
tools:context="dome.rxjava.com.rxjavademo.MainActivity">

<TextView
android:id="@+id/handlerTestTv"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_marginTop="15dp"
android:background="@color/colortv"
android:text="handler测试"
android:textSize="15sp" />

<TextView
android:id="@+id/testRxJavaCreatTv"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_marginTop="15dp"
android:background="@color/colortv"
android:text="testRxJava_ObservableCreat测试"
android:textSize="15sp" />

<TextView
android:id="@+id/testSubscriberTv"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_marginTop="15dp"
android:background="@color/colortv"
android:text="SuscriberCreat测试"
android:textSize="15sp" />
<TextView
android:id="@+id/testObservableFromTv"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_marginTop="15dp"
android:background="@color/colortv"
android:text="testObservableFrom测试"
android:textSize="15sp" />

<TextView
android:id="@+id/testObservableJustTv"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_marginTop="15dp"
android:background="@color/colortv"
android:text="testObservableJsut测试"
android:textSize="15sp" />
<TextView
android:id="@+id/testObservableMapTv"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_marginTop="15dp"
android:background="@color/colortv"
android:text="testObservableMap测试"
android:textSize="15sp" />

<TextView
android:id="@+id/contentTv"
android:layout_width="match_parent"
android:layout_height="50dp"
android:layout_marginTop="15dp"
android:background="@color/colortv"
android:text="显示内容，更新UI结果用"
android:textSize="15sp" />
<ImageView
android:id="@+id/contentImage"
android:layout_width="match_parent"
android:layout_height="50dp"
android:layout_marginTop="15dp"
/>
</LinearLayout>

()