初识rxJava

一直不知道如何下手写技术相关的文章，但好歹也是做技术的，总要踏出第一步，各位看官不喜勿喷。
刚好前段时间被rxJava所吸引，中间断断续续的学习，虽然算不上精通，但应对一般的应用场景还是没问题的，记录下学习过程中的小小心得，如果有不对的地方欢迎指正，希望有更多对rxJava感兴趣的小伙伴共同学习。
由于本人学习的是rxJava 1.x版本，后续文章都是基于rx 1.x

什么是rxJava

rxJava 1.x的github地址https://github.com/ReactiveX/RxJava/tree/1.x， 引用原文介绍“RxJava – Reactive Extensions for the JVM – a library for composing asynchronous and event-based programs using observable sequences for the Java VM.”（一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库），相信各位大神都能看懂，这是一个响应式编程的库。rxJava 1.x文档地址http://reactivex.io/RxJava/1.x/javadoc/rx/Observable.html，英文好的同学可以直接阅读学习。

使用rxJava

舞台有了，接下来就差演员了，使用rxJava一般需要3类角色，Observable，Subscriber，subscribe。相信做android开发的同学对添加监听器毫不陌生，如果我们要监听一个按钮的点击事件，也需要3个角色，Button 、OnClickListener 、setOnClickListener，当调用
Button.setOnClickListener(OnClickListener)时，OnClickListener 就开始监听Button的点击事件了，同理，这里的Observable相当于Button，Subscriber相当于OnClickListener，subscribe相当于setOnClickListener，它们之间的对应关系如下表：

	被监听者	监听者	建立关系
监听按钮	Button	OnClickListener	setOnClickListener
rxJava	Observable	Subscriber	subscribe

Observable

创建Observable一般有两种最常见的方法：

1. 直接发送一个对象
   调用Observable的just方法，这是一个静态泛型方法，泛型参数T就是发送对象

public static  Observable just(final T value) {
        return ScalarSynchronousObservable.create(value);
}

比如发送一个字符串

Observable observable = Observable.just("Hello world!");

2. 通过create方法，传入一个OnSubscribe对象

public static  Observable create(OnSubscribe f) {
        return new Observable(RxJavaHooks.onCreate(f));
}

有的同学要问了，OnSubscribe是什么鬼？看源码

public interface OnSubscribe extends Action1> {
        // cover for generics insanity
}

public interface Action1 extends Action {
    void call(T t);
}

这是一个接口类，继承自Action1，总之，生成OnSubscribe需要实现void call(T t)方法，下面我们还是发送一个字符串

Observable observable1 = Observable.create(new Observable.OnSubscribe() {
            @Override
            public void call(Subscriber subscriber) {
                subscriber.onNext("Hello World!");
                subscriber.onCompleted();
            }
});

为了好理解，你可以把call方法里的Subscriber看成是我们的观察者Subscriber（相当于监听按钮中的OnClickListener），call方法里的Subscriber发送一个事件，然后由观察者Subscriber最终接收这个事件，是不是就很好理解了~~~

Subscriber

观察者，通过Observable 发送的事件，最终都由Subscriber处理，这是一个抽象类，实例化需要实现3个方法

Subscriber subscriber = new Subscriber() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(String s) {

            }
};

onNext处理Observable 中subscriber.onNext("Hello World!")发送的对象；
onCompleted表示收到Observable中subscriber.onCompleted()事件；
onError表示在发送事件或者处理事件中出现异常；
注意：subscriber无论是收到onError事件还是onCompleted事件，都表示订阅关系结束，无论Observable是否还在发送事件，都不会再收到消息。也就是说onCompleted事件和onError事件不会同时发生。

subscribe

好了，有了被观察者和观察者，让他们发生关系吧，subscribe就是让他们确立关系的纽带，只有当Subscriber通过subscribe方法订阅Observable后，才可能收到消息。

observable.subscribe(subscriber);

Hello RxJava

首先在gradle中加入rxjava库

//rxjava
compile 'io.reactivex:rxjava:1.2.7'
compile 'io.reactivex:rxandroid:1.2.1'

ok让我们试一下吧，点击按钮，在TextView里显示Hello RxJava，代码很简单

package com.rxdemo.liuqiang.rxjavademo;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
import com.rxdemo.liuqiang.rxjavademo.utils.LogUtil;
import rx.Observable;
import rx.Subscriber;

public class MainActivity extends AppCompatActivity implements View.OnClickListener{
    private static final String TAG = "rxDemo";
    private Button btn_send;
    private TextView tv_log;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        btn_send = (Button) findViewById(R.id.btn_send);
        tv_log = (TextView) findViewById(R.id.tv_log);

        btn_send.setOnClickListener(this);
    }

    @Override
    public void onClick(View view) {
        switch (view.getId()) {
            case R.id.btn_send:
                print("Hello rxJava!");
                break;
        }
    }

    private void print(String content){
        Observable observable = Observable.just(content);
        Observable observable1 = Observable.create(new Observable.OnSubscribe() {
            @Override
            public void call(Subscriber subscriber) {
                subscriber.onNext("Hello rxJava!");
                subscriber.onCompleted();
            }
        });
        Subscriber subscriber = new Subscriber() {
            @Override
            public void onCompleted() {
                LogUtil.v("onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                LogUtil.v("onError" + e.getMessage());
            }

            @Override
            public void onNext(String s) {
                LogUtil.v("onNext");
                tv_log.setText(s);
            }
        };
        observable.subscribe(subscriber);
    }
}

是不是很简单呢？
可能有的小伙伴会问了，显示一个字符串用这么多代码，这叫好用？呃。。。先别着急喷，后面再介绍它更多更强大的用法，今天先到这里吧。