RxJava2.0的使用代码

最新推荐文章于 2022-08-30 10:50:32 发布
最新推荐文章于 2022-08-30 10:50:32 发布
阅读量334 收藏
点赞数 1
分类专栏： Android随手记 文章标签： 异步 响应式 github
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Flybasker/article/details/78703369
版权

MainActivity

package com.think.rxjava;

import android.content.Intent;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.Button;

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    protected Button btn1;
    protected Button btn2;
    protected Button btn3;

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

    @Override
    public void onClick(View view) {
        if (view.getId() == R.id.btn1) {
            startActivity(new Intent(this, RxJavaDemo1Activity.class));
        } else if (view.getId() == R.id.btn2) {
            startActivity(new Intent(this, RxJavaDemo2Activity.class));
        } else if (view.getId() == R.id.btn3) {
            startActivity(new Intent(this, RxJavaDemo3Activity.class));
        }
    }

    private void initView() {
        btn1 = (Button) findViewById(R.id.btn1);
        btn1.setOnClickListener(MainActivity.this);
        btn2 = (Button) findViewById(R.id.btn2);
        btn2.setOnClickListener(MainActivity.this);
        btn3 = (Button) findViewById(R.id.btn3);
        btn3.setOnClickListener(MainActivity.this);
    }
}

RxJavaDemo1Activity

package com.think.rxjava;

import android.content.DialogInterface;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.Button;

import com.example.demonstrate.DemonstrateUtil;
import com.example.demonstrate.DialogUtil;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.functions.Consumer;
import io.reactivex.functions.Function;
import io.reactivex.functions.Predicate;

public class RxJavaDemo1Activity extends AppCompatActivity implements View.OnClickListener {

    protected Button btnSend1;
    protected Button btnSend2;
    protected Button btnSend3;
    protected Button btnSend4;
    protected Button btnSend5;
    protected Button btnSend6;

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

    @Override
    public void onClick(View view) {
        if (view.getId() == R.id.btn_send1) {
            test1();//普通使用
        } else if (view.getId() == R.id.btn_send2) {
            test2();//链式调用
        } else if (view.getId() == R.id.btn_send3) {
            test3();//发送中,中断.
        } else if (view.getId() == R.id.btn_send4) {
            test4();//只关心onnext事件的操作
        } else if (view.getId() == R.id.btn_send5) {
            test5();//
        } else if (view.getId() == R.id.btn_send6) {
            test6();
        }
    }

    private void test6() {
        DialogUtil.showListDialog(this, "rxjava的操作符号使用", new String[]{
                "0map()操作符",
                "1flatMap()操作符",
                "2filter()操作符",
                "3take()操作符",
                "4doOnNext()操作符",
        }, new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                switch (which) {
                    case 0:
                        map0();
                        break;
                    case 1:
                        map1();
                        break;
                    case 2:
                        map2();
                        break;
                    case 3:
                        map3();
                        break;
                    case 4:
                        map4();
                        break;
                }
            }
        });
    }

    private void map4() {
        Observable.just(new ArrayList<String>(){
            {
                for (int i = 0; i < 6; i++) {
                    add("data"+i);
                }
            }
        }).flatMap(new Function<List<String>, ObservableSource<?>>() {
            @Override
            public ObservableSource<?> apply(List<String> strings) throws Exception {
                return Observable.fromIterable(strings);
            }
        }).take(5).doOnNext(new Consumer<Object>() {
            @Override
            public void accept(Object o) throws Exception {
                DemonstrateUtil.showLogResult("额外的准备工作!");
            }
        }).subscribe(new Consumer<Object>() {
            @Override
            public void accept(Object s) throws Exception {
                DemonstrateUtil.showLogResult(s.toString());
            }
        });
    }

    private void map3() {
        Observable.just(new ArrayList<String>(){
            {
                for (int i = 0; i < 8; i++) {
                    add("data"+i);
                }
            }
        }).flatMap(new Function<List<String>, ObservableSource<?>>() {
            @Override
            public ObservableSource<?> apply(List<String> strings) throws Exception {
                return Observable.fromIterable(strings);
            }
        }).take(5).subscribe(new Consumer<Object>() {
            @Override
            public void accept(Object s) throws Exception {
                DemonstrateUtil.showLogResult(s.toString());
            }
        });
    }

    private void map2() {
        Observable
                .just(new ArrayList<String>(){
                    {
                        for (int i = 0; i < 5; i++) {
                            add("data"+i);
                        }
                    }
                })
                .flatMap(new Function<List<String>, ObservableSource<?>>() {
                    @Override
                    public ObservableSource<?> apply(List<String> strings) throws Exception {
                        return Observable.fromIterable(strings);
                    }
                }).filter(new Predicate<Object>() {
            @Override
            public boolean test(Object s) throws Exception {
                String newStr = (String) s;
                if (newStr.contains("3")){
                    return true;
                }
                return false;
            }
        }).subscribe(new Consumer<Object>() {
            @Override
            public void accept(Object o) throws Exception {
                DemonstrateUtil.showLogResult((String)o);
            }
        });
    }

    private void map1() {
        Observable.just(new ArrayList<String>(){
            {
                for (int i = 0; i < 3; i++) {
                    add("data"+i);
                }
            }
        }).flatMap(new Function<List<String>, ObservableSource<?>>() {
            @Override
            public ObservableSource<?> apply(List<String> strings) throws Exception {
                return Observable.fromIterable(strings);
            }
        }).subscribe(new Observer<Object>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Object o) {
                DemonstrateUtil.showLogResult("flatMap转换后,接收到的"+o);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
    }

    private void map0() {
        Observable.just("hellorxjava")
                .map(new Function<String, Integer>() {
                    @Override
                    public Integer apply(String s) throws Exception {
                        return s.length();
                    }
                }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Integer integer) {
                DemonstrateUtil.showLogResult("接收到被转换的数据结果:"+integer);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
    }

    private void test5() {
        DialogUtil.showListDialog(this, "rxjava的其他操作", new String[]{
                "0just()方式创建Observable",
                "1fromIterable()方式创建Observable",
                "2defer()方式创建Observable",
                "3interval( )方式创建Observable",
                "4timer( )方式创建Observable",
                "5range( )方式创建Observable",
                "6repeat( )方式创建Observable",
        }, new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                switch (which) {
                    case 0:
                        other0();
                        break;
                    case 1:
                        other1();
                        break;
                    case 2:
                        other2();
                        break;
                    case 3:
                        other3();
                        break;
                    case 4:
                        other4();
                        break;
                    case 5:
                        other5();
                        break;
                    case 6:
                        other6();
                        break;
                }
            }
        });
    }

    private void other6() {
        Observable.just(123).repeat().subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Integer integer) {
                DemonstrateUtil.showLogResult("重复integer" + integer);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
    }

    private void other5() {
        Observable.range(1, 5).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Integer integer) {
                DemonstrateUtil.showLogResult("连续收到:" + integer);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
    }

    private void other4() {
        Observable.timer(5, TimeUnit.SECONDS).subscribe(new Observer<Long>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Long aLong) {
                DemonstrateUtil.showLogResult("延迟5s后调用了:onNext");
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
    }

    private void other3() {
        Observable.interval(3, TimeUnit.SECONDS).subscribe(new Observer<Long>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Long aLong) {
                DemonstrateUtil.showLogResult("数字是:" + aLong);
                //DemonstrateUtil.showToastResult(RxJavaDemo1Activity.this,"数字是:"+aLong);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
    }

    private void other2() {
        Observable<String> observable = Observable.defer(new Callable<ObservableSource<? extends String>>() {
            @Override
            public ObservableSource<? extends String> call() throws Exception {
                return Observable.just("hello,defer");
            }
        });

        //上游衔接下游!
        observable.subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(String s) {
                DemonstrateUtil.showLogResult(s);
                DemonstrateUtil.showToastResult(RxJavaDemo1Activity.this, s);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
    }

    private void other1() {
        Observable.fromIterable(new ArrayList<String>() {
            {
                for (int i = 0; i < 5; i++) {
                    add("Hello," + i);
                }
            }
        }).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(String s) {
                DemonstrateUtil.showToastResult(RxJavaDemo1Activity.this, s);
                DemonstrateUtil.showLogResult(s);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
    }

    private void other0() {
        Observable.just("hello,you hao!").subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(String s) {
                DemonstrateUtil.showLogResult(s);
                DemonstrateUtil.showToastResult(RxJavaDemo1Activity.this, s);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
    }

    private void test4() {
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                DemonstrateUtil.showLogResult("emitter 1");
                emitter.onNext(1);

                DemonstrateUtil.showLogResult("emitter 2");
                emitter.onNext(2);

                DemonstrateUtil.showLogResult("emitter 3");
                emitter.onNext(3);

                DemonstrateUtil.showLogResult("complete");
                emitter.onComplete();

                DemonstrateUtil.showLogResult("emitter 4");
                emitter.onNext(4);
            }
        }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                DemonstrateUtil.showLogResult("accept:" + integer);
            }
        });
    }

    private void test3() {
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                DemonstrateUtil.showLogResult("emitter 1");
                emitter.onNext(1);

                DemonstrateUtil.showLogResult("emitter 2");
                emitter.onNext(2);

                DemonstrateUtil.showLogResult("emitter 3");
                emitter.onNext(3);

                DemonstrateUtil.showLogResult("complete");
                emitter.onComplete();

                DemonstrateUtil.showLogResult("emitter 4");
                emitter.onNext(4);
            }
        }).subscribe(new Observer<Integer>() {
            private Disposable mDisposable;
            private int i;

            @Override
            public void onSubscribe(Disposable d) {
                DemonstrateUtil.showLogResult("subscribe");
                mDisposable = d;
            }

            @Override
            public void onNext(Integer value) {
                DemonstrateUtil.showLogResult("onNext:" + value);
                i++;
                if (i == 2) {
                    DemonstrateUtil.showLogResult("dispose:" + value);
                    mDisposable.dispose();
                    DemonstrateUtil.showLogResult("isDisposed : " + mDisposable.isDisposed());
                }
            }

            @Override
            public void onError(Throwable e) {
                DemonstrateUtil.showLogResult("error:");
            }

            @Override
            public void onComplete() {
                DemonstrateUtil.showLogResult("complete");
            }
        });

    }

    private void test2() {
        //链式调用
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onNext(3);
            }
        }).subscribe(new Observer<Integer>() {

            @Override
            public void onSubscribe(Disposable d) {
                DemonstrateUtil.showLogResult("onSubscribe");
            }

            @Override
            public void onNext(Integer integer) {
                DemonstrateUtil.showLogResult("onNext-->integer" + integer);
            }

            @Override
            public void onError(Throwable e) {
                DemonstrateUtil.showLogResult("onError");
            }

            @Override
            public void onComplete() {
                DemonstrateUtil.showLogResult("onComplete");
            }
        });
    }

    private void test1() {

        //创建上游,数据发射源!
        //ObservableOnSubscribe对象作为参数，它的作用相当于一个计划表，当 Observable被订阅的时候，
        // ObservableOnSubscribe的subscribe()方法会自动被调用，事件序列就会依照设定依次触发
        //ObservableEmitter,发射器,触发事件.
        Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {

            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onNext(3);
            }
        });

        //创建下游,数据接收处!
        Observer<Integer> observer = new Observer<Integer>() {

            @Override
            public void onSubscribe(Disposable d) {
                DemonstrateUtil.showLogResult("onSubscribe");
            }

            @Override
            public void onNext(Integer integer) {
                DemonstrateUtil.showLogResult("onNext--integer" + integer);
            }

            @Override
            public void onError(Throwable e) {
                DemonstrateUtil.showLogResult("onError");
            }

            @Override
            public void onComplete() {
                DemonstrateUtil.showLogResult("onComplete");
            }
        };

        //数据源连接接收处,上游衔接下游!
        //只有当上游和下游建立连接之后, 上游才会开始发送事件
        observable.subscribe(observer);
    }

    private void initView() {
        btnSend1 = (Button) findViewById(R.id.btn_send1);
        btnSend1.setOnClickListener(RxJavaDemo1Activity.this);
        btnSend2 = (Button) findViewById(R.id.btn_send2);
        btnSend2.setOnClickListener(RxJavaDemo1Activity.this);
        btnSend3 = (Button) findViewById(R.id.btn_send3);
        btnSend3.setOnClickListener(RxJavaDemo1Activity.this);
        btnSend4 = (Button) findViewById(R.id.btn_send4);
        btnSend4.setOnClickListener(RxJavaDemo1Activity.this);
        btnSend5 = (Button) findViewById(R.id.btn_send5);
        btnSend5.setOnClickListener(RxJavaDemo1Activity.this);
        btnSend6 = (Button) findViewById(R.id.btn_send6);
        btnSend6.setOnClickListener(RxJavaDemo1Activity.this);
    }
}

RxJavaDemo2Activity

package com.think.rxjava;

import android.content.DialogInterface;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.Button;
import android.widget.ImageView;

import com.example.demonstrate.DemonstrateUtil;
import com.example.demonstrate.DialogUtil;

import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.functions.Consumer;
import io.reactivex.schedulers.Schedulers;

public class RxJavaDemo2Activity extends AppCompatActivity implements View.OnClickListener {

    protected Button btn;
    protected ImageView iv;

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

    @Override
    public void onClick(View view) {
        if (view.getId() == R.id.btn) {
            DialogUtil.showListDialog(this, "rxJava操作！", new String[]{
                    "0发送事件io线程并变换主线程接收",
                    "1子线程发送事件主线程接收",
                    "2默认线程发送事件默认线程接收",
            }, new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int which) {
                    switch (which) {
                        case 0:
                            show0();
                            break;
                        case 1:
                            show1();
                            break;
                        case 2:
                            show2();
                            break;
                    }
                }
            });
        }
    }

    private void show2() {
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                DemonstrateUtil.showLogResult("发送的线程名称：" + Thread.currentThread().getName());
                DemonstrateUtil.showLogResult("发送的线程id：" + Thread.currentThread().getId());

                DemonstrateUtil.showLogResult("发送的数据:" + 1);
                e.onNext(1);
            }
        }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                DemonstrateUtil.showLogResult("接收的线程：" + Thread.currentThread().getName());
                DemonstrateUtil.showLogResult("接收的线程id：" + Thread.currentThread().getId());
                DemonstrateUtil.showLogResult("接收到的数据:-integer:" + integer);
            }
        });
    }

    private void show1() {
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                DemonstrateUtil.showLogResult("发送的线程名称：" + Thread.currentThread().getName());
                DemonstrateUtil.showLogResult("发送的线程id：" + Thread.currentThread().getId());

                DemonstrateUtil.showLogResult("发送的数据:" + 1);
                e.onNext(1);
            }
        }).subscribeOn(Schedulers.newThread())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        DemonstrateUtil.showLogResult("接收的线程：" + Thread.currentThread().getName());
                        DemonstrateUtil.showLogResult("接收的线程id：" + Thread.currentThread().getId());
                        DemonstrateUtil.showLogResult("接收到的数据:-integer:" + integer);
                    }
                });
    }

    private void show0() {
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                DemonstrateUtil.showLogResult("所在的线程：", Thread.currentThread().getName());
                DemonstrateUtil.showLogResult("发送的数据:", 1 + "");
                e.onNext(1);
            }
        }).subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        DemonstrateUtil.showLogResult("所在的线程：", Thread.currentThread().getName());
                        DemonstrateUtil.showLogResult("接收到的数据:", "integer:" + integer);
                    }
                });
    }

    private void initView() {
        btn = (Button) findViewById(R.id.btn);
        btn.setOnClickListener(RxJavaDemo2Activity.this);
        iv = (ImageView) findViewById(R.id.iv);
    }
}

RxJavaDemo3Activity

package com.think.rxjava;

import android.content.DialogInterface;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.Button;

import com.example.demonstrate.DemonstrateUtil;
import com.example.demonstrate.DialogUtil;

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.android.schedulers.AndroidSchedulers;
import io.reactivex.functions.Consumer;
import io.reactivex.schedulers.Schedulers;

public class RxJavaDemo3Activity extends AppCompatActivity implements View.OnClickListener {

    protected Button btnBackpressure;
    private Flowable mFlowable;
    private Subscriber mSubscriber;
    private Subscription mSubscription;
    private Flowable flowableLATEST;
    private Subscriber subscriberLatest;
    private Subscription subscriptionLatest;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        super.setContentView(R.layout.activity_rx_java_demo3);
        initView();
        init4();
        init6();
    }

    private void init6() {
        flowableLATEST = Flowable.create(new FlowableOnSubscribe<Integer>() {
            @Override
            public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {

                for (int i = 1; i<=200; i++) {
                    emitter.onNext(i);
                    DemonstrateUtil.showLogResult("LATEST生产onNext:"+i);
                }
            }
        }, BackpressureStrategy.LATEST);

        //mSubscription = s;
        subscriberLatest = new Subscriber<Integer>() {
            @Override
            public void onSubscribe(Subscription s) {
                subscriptionLatest = s;
                s.request(100);
            }

            @Override
            public void onNext(Integer integer) {
                DemonstrateUtil.showLogResult("Latest消费onNext:" + integer);
            }

            @Override
            public void onError(Throwable t) {
                DemonstrateUtil.showLogResult("onError");
                DemonstrateUtil.showLogResult(t.getMessage());
                DemonstrateUtil.showLogResult(t.toString());
            }

            @Override
            public void onComplete() {
                DemonstrateUtil.showLogResult("onComplete");
            }
        };
    }

    private void init4() {
        mFlowable = Flowable.create(new FlowableOnSubscribe<Integer>() {
            @Override
            public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {

                for (int i = 1; i <= 200; i++) {
                    emitter.onNext(i);
                    DemonstrateUtil.showLogResult("生产onNext:"+i);
                }
            }
        }, BackpressureStrategy.DROP);

        //mSubscription = s;
        mSubscriber = new Subscriber<Integer>() {
            @Override
            public void onSubscribe(Subscription s) {
                mSubscription = s;
                s.request(100);
            }

            @Override
            public void onNext(Integer integer) {
                DemonstrateUtil.showLogResult("消费onNext:" + integer);
            }

            @Override
            public void onError(Throwable t) {
                DemonstrateUtil.showLogResult("onError");
                DemonstrateUtil.showLogResult(t.getMessage());
                DemonstrateUtil.showLogResult(t.toString());
            }

            @Override
            public void onComplete() {
                DemonstrateUtil.showLogResult("onComplete");
            }
        };

    }


    @Override
    public void onClick(View view) {
        if (view.getId() == R.id.btn_backpressure) {
            DialogUtil.showListDialog(this, "Flowable的理解使用", new String[]{
                    "0事件堆积现象",
                    "1正常使用策略ERROR!",
                    "2使用策略ERROR出现的异常!",
                    "3使用策略BUFFER,更大的缓存池",
                    "4使用策略DROP,事件关联100",
                    "5使用策略DROP,再申请100",
                    "6使用策略LATEST,事件关联100",
                    "7使用策略LATEST,再申请100",
                    "8使用策略MISSING",
            }, new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int which) {
                    switch (which) {
                        case 0:
                            show0();
                            break;
                        case 1:
                            show1();
                            break;
                        case 2:
                            show2();
                            break;
                        case 3:
                            show3();
                            break;
                        case 4:
                            show4();
                            break;
                        case 5:
                            show5();
                            break;
                        case 6:
                            show6();
                            break;
                        case 7:
                            show7();
                            break;
                        case 8:
                            show8();
                            break;
                    }
                }
            });
        }
    }

    private void show8() {
        Flowable.create(new FlowableOnSubscribe<Integer>() {
            @Override
            public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {
                for (int i = 0; i < 200; i++) {
                    DemonstrateUtil.showLogResult("MISSING-生成emitter" + i);
                    emitter.onNext(i);
                }
            }
        }, BackpressureStrategy.MISSING).subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber<Integer>() {
                    @Override
                    public void onSubscribe(Subscription s) {
                        //mSubscription = s;
                        //s.request(0);
                    }

                    @Override
                    public void onNext(Integer integer) {
                        DemonstrateUtil.showLogResult("MISSING-消费onNext" + integer);
                    }

                    @Override
                    public void onError(Throwable t) {
                        DemonstrateUtil.showLogResult("onError" + t.getMessage());
                        DemonstrateUtil.showLogResult("onError" + t.toString());
                        t.printStackTrace();
                    }

                    @Override
                    public void onComplete() {
                        DemonstrateUtil.showLogResult("onComplete");
                    }
                });
    }

    private void show7() {
        subscriptionLatest.request(100);
    }

    private void show6() {
        flowableLATEST.subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(subscriberLatest);
    }

    private void show5() {
        //128-100-100=  -72.
        mSubscription.request(100);
    }

    private void show4() {
        mFlowable.subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(mSubscriber);
    }


    private void show3() {
        Flowable.create(new FlowableOnSubscribe<Integer>() {
            @Override
            public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {
                for (int i = 0; i < 200; i++) {
                    DemonstrateUtil.showLogResult("emitter" + i);
                    emitter.onNext(i);
                }
            }
        }, BackpressureStrategy.BUFFER).subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber<Integer>() {
                    @Override
                    public void onSubscribe(Subscription s) {
                        //mSubscription = s;
                        //s.request(0);
                    }

                    @Override
                    public void onNext(Integer integer) {
                        DemonstrateUtil.showLogResult("onNext" + integer);
                    }

                    @Override
                    public void onError(Throwable t) {
                        DemonstrateUtil.showLogResult("onError" + t.getMessage());
                        DemonstrateUtil.showLogResult("onError" + t.toString());
                        t.printStackTrace();
                    }

                    @Override
                    public void onComplete() {
                        DemonstrateUtil.showLogResult("onComplete");
                    }
                });
    }

    private void show2() {
        Flowable.create(new FlowableOnSubscribe<Integer>() {
            @Override
            public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {
                for (int i = 0; i < 200; i++) {
                    DemonstrateUtil.showLogResult("emitter" + i);
                    emitter.onNext(i);
                }
            }
        }, BackpressureStrategy.ERROR).subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber<Integer>() {
                    @Override
                    public void onSubscribe(Subscription s) {
                        //mSubscription = s;
                        //s.request(0);
                    }

                    @Override
                    public void onNext(Integer integer) {
                        DemonstrateUtil.showLogResult("onNext" + integer);
                    }

                    @Override
                    public void onError(Throwable t) {
                        DemonstrateUtil.showLogResult("onError" + t.getMessage());
                        DemonstrateUtil.showLogResult("onError" + t.toString());
                        t.printStackTrace();
                    }

                    @Override
                    public void onComplete() {
                        DemonstrateUtil.showLogResult("onComplete");
                    }
                });
    }

    private void show1() {
        Flowable.create(new FlowableOnSubscribe<Integer>() {
            @Override
            public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {
                for (int i = 0; i < 127; i++) {//128
                    DemonstrateUtil.showLogResult("emitter " + i);
                    emitter.onNext(i);
                }
                DemonstrateUtil.showLogResult("emitter complete");
                emitter.onComplete();
            }
        }, BackpressureStrategy.ERROR) //增加了一个参数,设置处理策略.
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber<Integer>() {
                    @Override
                    public void onSubscribe(Subscription s) {
                        DemonstrateUtil.showLogResult("onSubscribe");
                        //用来向生产者申请可以消费的事件数量,这样我们便可以根据本身的消费能力进行消费事件.
                        s.request(Long.MAX_VALUE);
                    }

                    @Override
                    public void onNext(Integer integer) {
                        DemonstrateUtil.showLogResult("onNext: " + integer);
                    }

                    @Override
                    public void onError(Throwable t) {
                        DemonstrateUtil.showLogResult("onError: " + t.getMessage());
                        DemonstrateUtil.showLogResult("onError: " + t.toString());
                        t.printStackTrace();
                    }

                    @Override
                    public void onComplete() {
                        DemonstrateUtil.showLogResult("onComplete: ");
                    }
                });
    }

    private void show0() {
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                while (true) {
                    for (int i = 0; i < 129; i++) {
                        e.onNext(1);
                    }
                }
            }
        }).subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Thread.sleep(5000);
                        DemonstrateUtil.showLogResult("接受到" + integer);
                    }
                });
    }

    private void initView() {
        btnBackpressure = (Button) findViewById(R.id.btn_backpressure);
        btnBackpressure.setOnClickListener(RxJavaDemo3Activity.this);
    }
}

GetBitmapForURL

package com.think.rxjava;

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;

import java.io.BufferedInputStream;
import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;

/**
 * Created by think on 2017/11/28.
 */

public class GetBitmapForURL {

    public static Bitmap getBitmap(String url) {
        //获取传进来的参数
        Bitmap bitmap = null;
        URLConnection connection;
        InputStream is;
        BufferedInputStream bis;
        try {
            connection = new URL(url).openConnection();
            is = connection.getInputStream();
            //为了更清楚的看到加载图片的等待操作,将线程休眠2秒钟
            Thread.sleep(2000);
            bis = new BufferedInputStream(is);
            //通过decodeStream方法解析输入流
            bitmap = BitmapFactory.decodeStream(bis);
            is.close();
            bis.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return bitmap;
    }
}

MyObserver

package com.think.rxjava;

import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;

/**
 * Created by think on 2017/11/29.
 */

public class MyObserver implements Observer {
    @Override
    public void onSubscribe(Disposable d) {

    }

    @Override
    public void onNext(Object o) {

    }

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onComplete() {

    }
}
枫爻筝
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RxJava2.0操作符详解
qq_43093708的博客
03-06 532
Rxjava2.0概述 通过前面的文章介绍，读者对RxJava2.0应该有了初步的认识。RxJava2.0相对1.0没有增加新的功能，最大的变化是把原来与背压有关的操作符抽取出来放在Flowable中处理；另外2.0的接口定义更符合ReactiveStream的规范。操作符的功能和1.0相比没有太大的变化，不过Flowable是背压相关的功能抽离出来的，本篇我们来详细分析下各种操作符的作用和用法...
word源码java-RxJava2.0:RxJava2.0使用介绍，官方文档翻译
06-05
RxJava2.0使用介绍，参考官方文档，每个操作符对应一个示例，帮助更好理解RxJava2.0 RxJava是什么？ Rx（Reactive Extensions）历史 是LINQ的一个扩展，由微软的架构师Erik Meijer领导的团队开发，在2012年11月开源...
Rxjava 源码分析
最新发布
qx102的博客
08-30 785
主要介绍了Rxjava订阅流程，事件流向，线程切换等。
RxJava 2.0 使用详解
热门推荐
苦逼的程序猿☺
11-29 4万+
前言在上一篇博客中，提到了RxJava的一些比较核心的东西，还有与1.x版本的一些区别！ 现在我们具体了解一下它的使用！使用最基本的的使用我们知道一个简单的RxJava的应用，需要一个观察者或者订阅者Observer，一个被观察者Observable，最后调用subscribe()方法将两者绑定起来！ 示例：//创建观察者或者订阅者 Observer observer = new
Rxjava简单的实现
faskjj的博客
07-18 1217
首先要想在android中使用RXjava2，先添加Gradle配置：   implementation 'io.reactivex.rxjava2:rxjava:2.1.16'   implementation 'io.reactivex.rxjava2:rxandroid:2.0.2' 先来一个简单的Hello Word，看看是一个怎样的情况。不多说，直接上代码： Obser...
给 Android 开发者的 RxJava 详解
weixin_34204722的博客
10-12 755
2019独角兽企业重金招聘Python工程师标准>>> ...
Rxjava 2.x 源码系列 - 基础框架分析
徐公，微信公众号同名
05-29 4583
前言 Rxjava RxAndroid 本篇博客讲解的 Rxjava 的原理基于版本 2.1.4，RxAndroid 的原理的版本基于 2.0.2 。 基本框架 Rxjava 有四个基本的概念 Observable (可观察者，即被观察者) Observer (观察者) subscribe (订阅) 通过该方法，将 Observable 与 Observer 关联起来 ...
RxJava2.0 结合Retrofit2.0 的简单的封装
06-14
在"Demo"项目中，可能包含了具体的示例代码，展示了如何将RxJava2.0和Retrofit2.0结合使用，实现一个简单的网络请求封装。通过查看这些代码，你可以更深入地理解这两者如何协同工作，以及如何在实际项目中应用。对于...
Rxjava 2.0+Retrofit 2.0+Mvp架构研究
02-06
在Android开发领域，RxJava 2.0、Retrofit 2.0 和 MVP（Model-View-Presenter）架构是常见的组合，它们各自扮演着重要的角色，以提高代码的可读性、可维护性和测试性。下面我们将深入探讨这三个技术及其在实际项目中...
基于RxJava2.0的任务队列
12-11
"基于RxJava2.0的任务队列"是一种解决方案，它利用了RxJava库的强大功能来实现任务的有序执行。RxJava是一个响应式编程库，而RxJava2.0是其第二个主要版本，它提供了更稳定、更优化的性能和API设计。 首先，我们来...
Android-rxjava2.0和retrofit2.0兼容的网络框架的封装
08-13
在Android开发中，网络请求是应用必不可少的一部分，而RxJava2.0与Retrofit2.0的结合使用，为开发者提供了高效、灵活的网络请求解决方案。这个“Android-rxjava2.0和retrofit2.0兼容的网络框架的封装”就是针对这两...
RxJava简单使用及代码
无趣的博客
02-25 2439
概述 RxJava 是一个 基于事件流、实现异步操作的库 类似于 Android中的Handler作用 “四剑客” 被观察者（Observable） 产生事件 观察者（Observer） 接收事件并响应 订阅（Subscribe） 关联 被观察者 和 观察者 事件（Event） 被观察者 和 观察者 交互的载体 模型 “被观察者”通过“订阅”按顺序发送“事件”给“观察者”， “观察者”按顺序接收“事件”作出响应。 用法（代码） 一、依赖 imp
Android拾萃 - 从零打造一个RxJava（搞清楚RxJava代码为什么这么写）
philos3的博客
10-21 675
任何框架都是从无到有，都是为了解决问题而产生，那么RxJava是如何产生的呢？RxJava代码的写法，为何如此让人看不懂，回调的参数等等，让小白看了摸不着头脑。接下来的文章，主要是依据NotRxJava懒人专用指南,结合自己的理解，写的一篇更加小白的文章，以帮助我们更好的梳理和理解。Cat 应用程序让我们来创建一个真实世界的例子。我们都知道猫是我们技术发展的引擎，所以就让我们也来创建这么一个用来下载
RxJava之一——一次性学会使用RxJava
薛瑄的博客
07-30 7607
转载请标明出处：http://blog.csdn.net/xx326664162/article/details/52068014 文章出自：薛瑄的博客你也可以查看我的其他同类文章，也会让你有一定的收货！关于RxJava，但从表面上看起来很容易使用，但是如果理解不够深刻，使用过程中，往往会出现一些问题，所以我写了四篇文章，从入门到精通，从简单的使用到部分源码详解，希望能给读者一个质的飞跃： 1
RxJava代码初探(一)
githkobe的博客
10-12 431
感谢抛物线作者的rxjava讲解 本文章将所讲解的内容进行了代码化更容易加深实战理解 原文出处：https://gank.io/post/560e15be2dca930e00da1083  本文中如有不对的地方欢迎大家提出  /* 创建被观察者方法一 */ public void createObservableOne() { Observable observable
关于RxJava2.0你不知道的事
Dream It Possible
02-03 3万+
前言如果你对RxJava1.x还不是了解，可以参考下面文章。1. RxJava使用介绍 【视频教程】 2. RxJava操作符   • Creating Observables(Observable的创建操作符) 【视频教程】   • Transforming Observables(Observable的转换操作符) 【视频教程】   • Filtering Observa
wifidirect wifi-直连简单使用
Flybasker的博客
10-21 4801
请问文件中加相应的权限           package="alice.bw.com.wifidirectdemo">             android:name="android.permission.INTERNET"         android:required="true"/>             android:name="android.
使用SurfaceView+Medaplayer+SeekBar完成视频的播放加进度条
Flybasker的博客
10-21 2652
在主页面中activity_main布局中     xmlns:android="http://schemas.android.com/apk/res/android"     xmlns:tools="http://schemas.android.com/tools"     android:layout_width="match_parent"     android:layo
调用系统相机开启录像功能
Flybasker的博客
10-21 2437
在清单文件中加入相应的权限           在布局中activity_camera_vodeo               android:id="@+id/activity_camera_vodeo"               android:layout_width="match_parent"               android:layout_he
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值