Rxjava（1.基本使用）

1、rxjava

rxjava的本质

rxjava是响应式编程的意思，本质是观察者模式，以观察者observe和订阅subscribe异步响应式开发。

RxJava is a Java VM implementation of Reactive Extensions: a library for composing asynchronous and event-based programs by using observable sequences.

rxjava的核心三步

依赖

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

1、创建Observer（观察者），如果通过订阅后，被观察者发生改变，观察者做出相应的事件处理

 Subscriber<String> subscribers = new Subscriber<String>() {
        @Override
        public void onCompleted() {
        //完毕
        }
        @Override
        public void onError(Throwable e) {
        //发生异常
        }
        @Override
        public void onNext(String s) {
         //事件来了
        }
    };

2、创建Observables（被观察者）

Observable observable = Observable.create(new Observable.OnSubscribe<String>() {

        @Override
        public void call(Subscriber<? super String> subscriber) {
            subscriber.onNext("hello rxjava");
        }
    });

3、subscribe 订阅关系

 observable.subscribe(subscribers);

全部代码如下：

package com.example.administrator.rxjavademo;

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.widget.TextView;

import rx.Observable;
import rx.Subscriber;

public class MainActivity extends AppCompatActivity {
    private TextView text;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        text= (TextView) findViewById(R.id.text);
        //确立订阅关系，把订阅（subscribers）事件加入到观察者中（observable）
        observable.subscribe(subscribers);
    }
    //定义被观察者，观察对象对观察者订阅的Subscribe对象
    Observable observable = Observable.create(new Observable.OnSubscribe<String>() {

        @Override
        public void call(Subscriber<? super String> subscriber) {
            subscriber.onNext("hello rxjava");
        }
    });
    //观察者，当观察者事件改变时，订阅者收到事件，处理事件
    Subscriber<String> subscribers = new Subscriber<String>() {
        @Override
        public void onCompleted() {

        }
        @Override
        public void onError(Throwable e) {
        }
        @Override
        public void onNext(String s) {
            text.setText(s);
        }
    };
}

2、线程切换

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

        Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("sss");
                Log.d("------->call线程:", Thread.currentThread().getName() + "");
            }
        }).subscribeOn(Schedulers.io()).
                observeOn(AndroidSchedulers.mainThread()).
                subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(String s) {
                Log.d("------->onNext线程:", Thread.currentThread().getName() + "");
            }
        });

运行结果：

------->call线程:: RxCachedThreadScheduler-1
------->onNext线程:: main

3、rxjava三步分析

1、Observable

 //定义被观察者，被观察对象与观察者订阅的Subscribe对象
    Observable observable = Observable.create(new Observable.OnSubscribe<String>() {

        @Override
        public void call(Subscriber<? super String> subscriber) {
            subscriber.onNext("hello rxjava");
        }
    });

---

通过Observable类创建一个Observable对象，传入的参数为OnSubscribe，OnSubscribe继承接口Action1

2、Subscriber创建：通过new创建一个Subscriber对象

 Subscriber<String> subscribers = new Subscriber<String>() {
        @Override
        public void onCompleted() {

        }
        @Override
        public void onError(Throwable e) {
        }
        @Override
        public void onNext(String s) {
            text.setText(s);
        }
    };

Subscriber实现两个接口，一个 Observer另一个 Subscription
源代码如下：

public interface Observer<T> {

    /**
     * 观察者发送事件结束
     */
    void onCompleted();

    /**
     *观察者发送事件发生异常
     */
    void onError(Throwable e);

    /**
     *为观察者提供一个新的观察项
     */
    void onNext(T t);

}

3、订阅关系

 observable.subscribe(subscribers);

源代码

//给观察者订阅事件，并给订阅者一些方法的回调，比如事件完成，事件发生异常

  public final Subscription subscribe(Subscriber<? super T> subscriber) {
        return Observable.subscribe(subscriber, this);
    }

    private static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T> observable) {
     // validate and proceed
        if (subscriber == null) {
            throw new IllegalArgumentException("observer can not be null");
        }
        if (observable.onSubscribe == null) {
            throw new IllegalStateException("onSubscribe function can not be null.");
            /*
             * the subscribe function can also be overridden but generally that's not the appropriate approach
             * so I won't mention that in the exception
             */
        }

        // new Subscriber so onStart it
        subscriber.onStart();

        /*
         * See https://github.com/ReactiveX/RxJava/issues/216 for discussion on "Guideline 6.4: Protect calls
         * to user code from within an Observer"
         */
        // if not already wrapped
        if (!(subscriber instanceof SafeSubscriber)) {
            // assign to `observer` so we return the protected version
            subscriber = new SafeSubscriber<T>(subscriber);
        }

        // The code below is exactly the same an unsafeSubscribe but not used because it would 
        // add a significant depth to already huge call stacks.
        try {
            // allow the hook to intercept and/or decorate
            hook.onSubscribeStart(observable, observable.onSubscribe).call(subscriber);
            return hook.onSubscribeReturn(subscriber);
        } catch (Throwable e) {
            // special handling for certain Throwable/Error/Exception types
            Exceptions.throwIfFatal(e);
            // if an unhandled error occurs executing the onSubscribe we will propagate it
            try {
                subscriber.onError(hook.onSubscribeError(e));
            } catch (Throwable e2) {
                Exceptions.throwIfFatal(e2);
                // if this happens it means the onError itself failed (perhaps an invalid function implementation)
                // so we are unable to propagate the error correctly and will just throw
                RuntimeException r = new RuntimeException("Error occurred attempting to subscribe [" + e.getMessage() + "] and then again while trying to pass to onError.", e2);
                // TODO could the hook be the cause of the error in the on error handling.
                hook.onSubscribeError(r);
                // TODO why aren't we throwing the hook's return value.
                throw r;
            }
            return Subscriptions.unsubscribed();
        }
    }

3、Oberver与Subscriber关系

其中的Observer有一个具体的实现类 Subscriber，所以在开发中我们经常会使用Subscriber来代替Observer，所以在功能使用是二者是基本一样的。

Observer与Subscriber的主要区别在于onCompleted()方法执行完毕后是否取消了订阅。

Observer：在执行onCompleted()方法后没有取消订阅
Subscriber：在执行onCompleted()方法后取消订阅，如果想要触发事件的话，需要重新new 订阅。