Android_Rxjava1.0、2.0

一：RxJava简单来说就是   异步

 特点：1.观察者模式

             2.链式调用

             3.线程调度

             4.灵活操作符

二：依赖

1.0依赖

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

2.0依赖

compile 'io.reactivex.rxjava2:rxjava:2.1.1'
compile 'io.reactivex.rxjava2:rxandroid:2.0.1'

三：1.0观察者与被观察者的创建方式

package com.rxjava;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;

import rx.Observable;
import rx.Observable.OnSubscribe;
import rx.Observer;
import rx.Subscriber;
import rx.Subscription;
import rx.android.schedulers.AndroidSchedulers;
import rx.functions.Action1;
import rx.functions.Func1;
import rx.schedulers.Schedulers;

public class MainActivity extends AppCompatActivity implements View.OnClickListener{

    private Button btn_1;
    private Button btn_2;
    private Button btn_3;
    private Button btn_4;
    private Button btn_5;
    private Button btn_6;
    private Subscription tag1;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        btn_1 = (Button)findViewById(R.id.btn_1);
        btn_1.setOnClickListener(this);
        btn_2 = (Button)findViewById(R.id.btn_2);
        btn_2.setOnClickListener(this);
        btn_3 = (Button)findViewById(R.id.btn_3);
        btn_3.setOnClickListener(this);
        btn_4 = (Button)findViewById(R.id.btn_4);
        btn_4.setOnClickListener(this);
        btn_5 = (Button)findViewById(R.id.btn_5);
        btn_5.setOnClickListener(this);
        btn_6 = (Button)findViewById(R.id.btn_6);
        btn_6.setOnClickListener(this);
    }

    @Override
    public void onClick(View view) {
        switch (view.getId()){
            case R.id.btn_1:
                //被观察者创建方式一
                tag1 = Observable.just(1, 2, 3, 4)
                        .subscribeOn(Schedulers.io())
                        //类型转换
                        .map(new Func1<Integer, String>() {
                            @Override
                            public String call(Integer integer) {
                                return String.valueOf(integer);
                            }
                        })
                        .subscribe(new Action1<String>() {
                            @Override
                            public void call(String s) {
                                Log.i("TAG",s);
                            }
                        });
                break;
            case R.id.btn_2:
                //被观察者创建方式二
                String[] str = {"Hello","World","RxJava"};
                Observable<String> observable2 = Observable.from(str);
                observable2
                        .subscribeOn(AndroidSchedulers.mainThread())
                        .observeOn(Schedulers.io())
                        //平铺
                        .flatMap(new Func1<Student, Observable<Score>>() {
                            @Override
                            public Observable<Score> call(Student student) {
                                List<Score> scores = student.getScores();
                                return Observable.from(scores);
                            }
                        })
                        .subscribe(new Action1<Score>() {
                            @Override
                            public void call(Score score) {
                                Log.i("TAG",score+"");
                            }
                        });
                break;
            case R.id.btn_3:
                //被观察者创建方式三
                Observable<String> observable3 = Observable.create(new OnSubscribe<String>() {
                    @Override
                    public void call(Subscriber<? super String> subscriber) {
                        subscriber.onNext("1");
                        subscriber.onNext("2");
                        subscriber.onNext("3");
                        //先执行完成就不会执行失败
                        //先执行失败就不会执行完成
                        subscriber.onCompleted();//完成
                        subscriber.onError(null);//失败
                    }
                });
                observable3
                        .subscribeOn(AndroidSchedulers.mainThread())
                        .observeOn(Schedulers.io())
                        .subscribe(new Observer() {
                            @Override
                            public void onCompleted() {

                            }

                            @Override
                            public void onError(Throwable e) {

                            }

                            @Override
                            public void onNext(Object o) {
                                Log.i("TAG",o+"");
                            }
                        });
                break;
            case R.id.btn_4:
                //观察者创建方式一
                Observable<Integer> observable4 = Observable.just(1,2,3,4);
                Observer observer = new Observer() {
                    @Override
                    public void onCompleted() {

                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onNext(Object o) {
                        Log.i("TAG",o+"");
                    }
                };
                observable4.subscribe(observer);
                break;

            case R.id.btn_5:

                //观察者创建方式二
                Observable<Integer> observable5 = Observable.just(1,2,3,4);

                Subscriber<Integer> intentSubscriber = new Subscriber<Integer>() {
                    @Override
                    public void onStart() {
                        super.onStart();
                    }

                    @Override
                    public void onCompleted() {

                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onNext(Integer integer) {
                        Log.i("TAG",integer+"");
                    }
                };
                observable5.subscribe(intentSubscriber);
                break;
            case R.id.btn_6:
                //观察者创建方式三
                Observable<Integer> observable6 = Observable.just(1,2,3,4);
                Action1 tag = new Action1() {
                    @Override
                    public void call(Object o) {
                        Log.i("TAG", o + "");
                    }
                };
                observable6.subscribe(tag);
                break;
        }
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        //防止内存泄漏
        if(tag1!=null){
            if(tag1.isUnsubscribed()){
                tag1.unsubscribe();
            }
        }
    }
}

四：2.0简单使用

package com.example.rxjava22;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;

import org.reactivestreams.Subscriber;
import org.reactivestreams.Subscription;

import io.reactivex.BackpressureStrategy;
import io.reactivex.Flowable;
import io.reactivex.FlowableEmitter;
import io.reactivex.FlowableOnSubscribe;
import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.Observer;
import io.reactivex.annotations.NonNull;
import io.reactivex.disposables.Disposable;
import io.reactivex.subscribers.DisposableSubscriber;

public class MainActivity extends AppCompatActivity {

    private Disposable d;
    private DisposableSubscriber<Integer> tag;

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

        //普通方式： Observer是观察者
        Observable.just(1,2)
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(@NonNull Disposable d) {
                        MainActivity.this.d = d;
                    }

                    @Override
                    public void onNext(@NonNull Integer integer) {
                        Log.i("TAG",integer+"");
                    }

                    @Override
                    public void onError(@NonNull Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });

        //Flowable方式一：Subscriber是观察者
        Flowable.create(new FlowableOnSubscribe<Integer>() {
            @Override
            public void subscribe(@NonNull FlowableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onNext(3);
                e.onNext(4);
            }
        }, BackpressureStrategy.BUFFER)
                .subscribe(new Subscriber<Integer>() {
                    private Subscription s;
                    @Override
                    public void onSubscribe(Subscription s) {
                        this.s=s;
                        s.request(1);
                    }

                    @Override
                    public void onNext(Integer integer) {
                        s.request(1);
                        Log.i("TAG",integer+"");
                    }

                    @Override
                    public void onError(Throwable t) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });
        //Flowable方式二：DisposableSubscriber是观察者
        tag = Flowable.just(1, 2, 3)
                .subscribeWith(new DisposableSubscriber<Integer>() {
                    @Override
                    public void onNext(Integer integer) {
                        Log.i("TAG", integer + "");
                    }

                    @Override
                    public void onError(Throwable t) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        //防止内存泄漏
        if(d!=null){
            if(!d.isDisposed()){
                d.dispose();
            }
        }
        if(tag!=null){
            if(!tag.isDisposed()){
                tag.dispose();
            }
        }
    }
}