Rxjava具体方法详解

最新推荐文章于 2024-09-18 09:53:01 发布
最新推荐文章于 2024-09-18 09:53:01 发布
阅读量2.5k 收藏 6
点赞数 2
分类专栏： Android 文章标签： Android rxjava

原文是简书一位猿友写的。写的很实在，不错，值得收藏。http://www.jianshu.com/p/64aa976a46be

想写好一篇文章确实不容易，感谢那些大牛们能够分享自己的所见所得。关于rxjava的原理以及观察者模式等理论性的内容我就不在这里献丑了，网上有很多很优秀的博客。回头我添加几篇到这里，大家可以看一看，这篇文章只是简单的通过例子告诉大家rxjava的基本使用方法，如果有任何的批评、建议或者疑问可以评论，第一时间给予答复。

[TOC]

一、Obervable的创建

1.create

//通过create创建observable对象，在call中调用subscriber的onnext方法
Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {          
  @Override    
  public void call(Subscriber<? super String> subscriber) {              
    for (int i = 0;i < 20;i++)        {            
      subscriber.onNext("fuck i is " + i);        
    }    
    subscriber.onCompleted();
  }});
//上面的代码我们已经构建了一个观察者，我们接下来新建一个订阅者
Subscriber<String> subscriber = new Subscriber<String>()             
{   
   @Override    
    public void onCompleted() {  
          Log.i("rxjava", "onCompleted");       
    }          
    @Override    
    public void onError(Throwable e) {    
     Log.i("rxjava", "error");    
    }    
    @Override    
    public void onNext(String o) {            
      Log.i("rxjava", o);    
}};
//通过调用subscribe方法使观察者和订阅者产生关联，一旦订阅就观察者就开始发送消息
  observable.subscribe(subscriber);

2.from

      //在下面的例子代码中，我们从一个已有的列表中创建一个Observable序列：
    List<String> items = new ArrayList<String>();      
       items.add("1");
       items.add("10");
       items.add("100");
       items.add("200");
    Observable<String> observableString = Observable.from(items);
    //有了observable,再调用1中的subscribe方法即可开始打印
    observable.subscribe(subscriber);

3.just

//通过调用just方法，传入你想发送的数据源，当订阅者进行订阅的时候就开始打印数据
Observable<String> observableString = Observable.just("i", "love", "you","very", "much");
observable.subscribe(subscriber);
//just()方法可以传入一到九个参数，它们会按照传入的参数的顺序来发射它们。just()方法也可以接受列表或数组，就像from()方法，但是它不会迭代列表发射每个值,它将会发射整个列表。通常，当我们想发射一组已经定义好的值时会用到它。

4、repeat重复

//假如你想对一个Observable重复发射三次数据。例如，我们用just()例子中的Observable：
Observable<String> observableString = Observable.just("i", "love", "you","very", "much").repeat(3);
observable.subscribe(subscriber);//通过添加repeat(3)，just里面的内容会被打印3次

5、range

从一个指定的数字x开发发射n个数字
Observable.range(10,3)
    .subscribe(new Observer<Integer>() {

        @Override
        public void onCompleted() {
            Toast.makeText(getActivity(), "Yeaaah!", Toast.LENGTH_LONG).show();
        }

        @Override
        public void onError(Throwable e) {
            Toast.makeText(getActivity(), "Something went wrong!",Toast.LENGTH_SHORT).show();
        }

        @Override
        public void onNext(Integer number) {
            Toast.makeText(getActivity(), "I say " + number, Toast.LENGTH_SHORT).show();
        }
    });
    //range()函数用两个数字作为参数：第一个是起始点，第二个是我们想发射数字的个数。

6、interval轮询

//interval()函数在你需要创建一个轮询程序时非常好用。
 Observable.interval(3,TimeUnit.SECONDS)
    .subscribe(new Observer<Integer>() {

        @Override
        public void onCompleted() {
            Toast.makeText(getActivity(), "Yeaaah!", Toast.LENGTH_LONG).show();
        }

        @Override
        public void onError(Throwable e) {
            Toast.makeText(getActivity(), "Something went wrong!", Toast.LENGTH_SHORT).show();
        }

        @Override
        public void onNext(Integer number) {
            Toast.makeText(getActivity(), "I say " + number, Toast.LENGTH_SHORT).show();
        }
    });
//interval()函数的两个参数：一个指定两次发射的时间间隔，另一个是用到的时间单位。这个只会执行一次，添加subscribeOn(Schedulers.newThread())好像能够达到轮训的效果

7、timer

//如果你需要一个一段时间之后才发射的Observable，你可以像下面的例子使用timer()：
Observable.timer(3,TimeUnit.SECONDS)
    .subscribe(new Observer<Long>() {

        @Override
        public void onCompleted() {

        }

        @Override
        public void onError(Throwable e) {

        }

        @Override
        public void onNext(Long number) {
            Log.d("RXJAVA", "I say " + number);
        }
    });
//它将3秒后发射0,然后就完成了。

二、过滤

这一章中，我们将研究可观测序列的本质：过滤。我们将学到如何从发射的Observable中选取我们想要的值，如何获取有限个数的值，如何处理溢出的场景，以及更多的有用的技巧。

1、filter

//RxJava让我们使用filter()方法来过滤我们观测序列中不想要的值
Observable.just("H1", "h2","h3","h4","h5").filter(new Func1<String, Boolean>() {
            @Override
            public Boolean call(String s) {
                return s.startsWith("H");
            }
        }).subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(String s) {
                Log.i(tag, s);
            }
        });
//通过设置filter，然后在call里面添加s.startsWith("H")，如果是H开头就返回true，否则返回false。从而能够过滤掉不是h开头的消息，打印出以H开头的消息。

2、take

//take()函数用整数N来作为一个参数，从原始的序列中发射前N个元素，然后完成：
Observable.just("H1", "h2","h3","h4","h5").take(3).subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(String s) {
                Log.i(tag, s);
            }
        });
//通过设置take(3),就可以取出前3个消息，打印出H1,h2,h3
注：如果想从后面取数据，可以调用takeLast(3)取最后3条消息

3、Distinct

//我们可以对我们的序列使用distinct()函数去掉重复的。就像takeLast()一样，distinct()作用于一个完整的序列，然后得到重复的过滤项，它需要记录每一个发射的值。
Observable o = Observable.just("H1", "h2","h3","h4","h5").repeat(3);//输入重复3遍
o.distinct().subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(String s) {
                Log.i(tag, s);
            }
        });

4、DistinctUntilsChanged

//它能轻易的忽略掉所有的重复并且只发射出新的值。
//下图用图形化的方式展示了我们如何将distinctUntilChanged()函数应用在一个存在的序列上来创建一个新的不重复发射元素的序列。

5、First and last

first()方法和last()方法很容易弄明白。它们从Observable中只发射第一个元素或者最后一个元素。

5.1、first


5.2、last


6、skip和skipLast

skip()和skipLast()函数与take()和takeLast()相对应。它们用整数N作参数，从本质上来说，它们不让Observable发射前N个或者后N个值。


skip(2)

举个例子

Observable.just("hello", "my", "world").skip(1).skipLast(1)
                .subscribe(new Subscriber<String>() {
                    @Override
                    public void onCompleted() {

                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onNext(String s) {
                        Log.i(tag, s);
                    }
                });
//跳过第一个hello和最后一个world，打印my

7、ElementAt和elementAtOrDefault

elementAt()函数仅从一个序列中发射第n个元素然后就完成了。如果我们想查找第五个元素但是可观测序列只有三个元素可供发射时该怎么办？我们可以使用elementAtOrDefault()。

下图展示了如何通过使用elementAt(2)从一个序列中选择第三个元素以及如何创建一个只发射指定元素的新的Observable。


举个例子

        Observable.just("hello", "my", "world").elementAt(1)
                .subscribe();
        Observable.just("hello", "my", "world").elementAtOrDefault(10, "null")
                .subscribe();

8、Sampling

在Observable后面加一个sample()，我们将创建一个新的可观测序列，它将在一个指定的时间间隔里由Observable发射最近一次的数值：


List<String> list = new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            list.add("i = " + i);
        }
        Observable<String> observable = Observable.from(list);
        observable.sample(50, TimeUnit.MILLISECONDS).subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(String s) {
                Log.i(tag, s);
            }
        });
        //50毫秒取一次最近的消息进行打印

9、timeout

我们可以认为timeout()为一个Observable的限时的副本。如果在指定的时间间隔内Observable不发射值的话，它监听的原始的Observable时就会触发onError()函数。我们可以使用timeout()函数来监听源可观测序列,就是在我们设定的时间间隔内如果没有得到一个值则发射一个错误。


三、Observable变化

3.1 map家族

RxJava提供了几个mapping函数：map(),flatMap(),concatMap(),flatMapIterable()以及switchMap().所有这些函数都作用于一个可观测序列，然后变换它发射的值，最后用一种新的形式返回它们。让我们用合适的“真实世界”的例子一个个的学习下。

3.1.1 map

RxJava的map函数接收一个指定的Func对象然后将它应用到每一个由Observable发射的值上。下图展示了如何将一个乘法函数应用到每个发出的值上以此创建一个新的Observable来发射转换的数据。


举个例子：接收一系列的数字，经过map转成string类型，然后打印出来。

Observable.just(1, 2, 3, 4, 5)
                .map(new Func1<Integer, String>() {
                    @Override
                    public String call(Integer integer) {
                        return "the position is" + integer;
                    }
                }).subscribe(new Observer<String>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(String s) {
                Log.i(tag, s);
            }
        });
3.1.2 flatMap

flatMap是map中比较常见但也是比较难理解内。

在复杂的场景中，我们有一个这样的Observable：它发射一个数据序列，这些数据本身也可以发射Observable。RxJava的flatMap()函数提供一种铺平序列的方式，然后合并这些Observables发射的数据，最后将合并后的结果作为最终的Observable。


举个例子：假设我有个天气客户端，某个页面需要获取四个城市(南昌、北京、天津和深圳)的天气。那么首先我们需要传入四个城市名，然后分别根据城市名获取天气信息，然后更行ui更新。

public void flatMap() {
        Observable.just("南昌", "深圳", "天津", "北京").flatMap(new Func1<String, Observable<WeatherInfo>>() {
            @Override
            public Observable<WeatherInfo> call(String s) {
                return getWeather(s);
            }
        }).observeOn(AndroidSchedulers.mainThread()).//更新ui一定要加这句
        subscribe(new Subscriber<WeatherInfo>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(WeatherInfo weatherInfo) {
                //更新ui
            }
        });
    }

    //新建天气信息类
    class WeatherInfo {

    }

    private Observable<WeatherInfo> getWeather(final String city) {
        Observable<WeatherInfo> observable = Observable.create(new Observable.OnSubscribe<WeatherInfo>() {
            @Override
            public void call(Subscriber<? super WeatherInfo> subscriber) {
                subscriber.onNext(getWeatherInfo(city));
                subscriber.onCompleted();
            }
        }).subscribeOn(Schedulers.io());//网络请求一定要加这句
        return observable;
    }

    private WeatherInfo getWeatherInfo(String city) {
        //模拟网络请求返回weatherinfo
        return new WeatherInfo();
    }
    //南昌－>能够获取南昌天气的observable->更新ui
3.1.3 ConcatMap

RxJava的concatMap()函数解决了flatMap()的交叉问题，提供了一种能够把发射的值连续在一起的铺平函数，而不是合并它们，如下图所示：


注：拿上面的例子来说我们传入的是"南昌", "深圳", "天津", "北京"，flatmap转换之后得到的顺序并不是这样，而是被打乱了的；用concaatmap的话就是按顺序的转换，只有这种区别。

3.1.4 SwitchMap

如下图所示，switchMap()和flatMap()很像，除了一点：每当源Observable发射一个新的数据项（Observable）时，它将取消订阅并停止监视之前那个数据项产生的Observable，并开始监视当前发射的这一个。


例子参考

SwitchMap

3.1.5 Scan

scan操作符对一个序列的数据应用一个函数，并将这个函数的结果发射出去作为下个数据应用这个函数时候的第一个参数使用，有点类似于递归操作


举个例子

private Observable<Integer> scanObserver() {
        return Observable.from(list).scan((x, y) -> x * y).observeOn(AndroidSchedulers.mainThread());
    }

结果为：


3.2 GroupBy

groupBy操作符是对源Observable产生的结果进行分组，形成一个类型为GroupedObservable的结果集，GroupedObservable中存在一个方法为getKey()，可以通过该方法获取结果集的Key值（类似于HashMap的key)。

值得注意的是，由于结果集中的GroupedObservable是把分组结果缓存起来，如果对每一个GroupedObservable不进行处理（既不订阅执行也不对其进行别的操作符运算），就有可能出现内存泄露。因此，如果你对某个GroupedObservable不进行处理，最好是对其使用操作符take(0)处理。

groupBy操作符的流程图如下： 


调用例子如下：
Observable.interval(1, TimeUnit.SECONDS).take(10).groupBy(new Func1<Long, Long>() {
            @Override
            public Long call(Long value) {
                //按照key为0,1,2分为3组
                return value % 3;
            }
        }).subscribe(new Action1<GroupedObservable<Long, Long>>() {
            @Override
            public void call(GroupedObservable<Long, Long> result) {
                result.subscribe(new Action1<Long>() {
                    @Override
                    public void call(Long value) {
                        System.out.println("key:" + result.getKey() +", value:" + value);
                    }
                });
            }
        });
运行结果如下： 
key:0, value:0 
key:1, value:1 
key:2, value:2 
key:0, value:3 
key:1, value:4 
key:2, value:5 
key:0, value:6 
key:1, value:7 
key:2, value:8 
key:0, value:9

3.3 Buffer

RxJava中的buffer()函数将源Observable变换一个新的Observable，这个新的Observable每次发射一组列表值而不是一个一个发射。


上图中展示了buffer()如何将count作为一个参数来指定有多少数据项被包在发射的列表中。实际上，buffer()函数有几种变体。其中有一个是允许你指定一个skip值：此后每skip项数据，然后又用count项数据填充缓冲区。如下图所示：


举个例子

List<String> list = new ArrayList<>();
for (int i = 0; i < 30; i++)
{
    list.add("hello i:" + i);
}

Observable.from(list).buffer(4).subscribe(new Subscriber<List<String>>() {
    @Override
    public void onCompleted() {

    }

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onNext(List<String> strings) {
        for (String s : strings)
        {
            Log.i(tag, s);
        }
        Log.i(tag, "\n next group");
    }
});

3.4 window

RxJava的window()函数和buffer()很像，但是它发射的是Observable而不是列表。下图展示了window()如何缓存3个数据项并把它们作为一个新的Observable发射出去。


List<String> list = new ArrayList<>();
for (int i = 0; i < 30; i++) {
    list.add("hello i:" + i);
}
Observable.from(list).window(4).subscribe(new Subscriber<Observable<String>>() {
    @Override
    public void onCompleted() {

    }

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onNext(Observable<String> stringObservable) {
        stringObservable.subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(String s) {
                Log.i(tag, s);
            }
        });
        Log.i(tag, "\n next group");
    }
});

这些Observables中的每一个都发射原始Observable数据的一个子集，数量由count指定,最后发射一个onCompleted()结束。正如buffer()一样,window()也有一个skip变体,如下图所示：


3.5 cast

RxJava的cast()函数是本章中最后一个操作符。它是map()操作符的特殊版本。它将源Observable中的每一项数据都转换为新的类型，把它变成了不同的Class。


public void cast() {
    List<Person> list = new ArrayList<>();
    for (int i = 0; i < 30; i++) {
        list.add(new Male(true, "i" + i));
    }
    Observable.from(list).cast(Male.class).subscribe(new Subscriber<Male>() {
        @Override
        public void onCompleted() {

        }

        @Override
        public void onError(Throwable e) {

        }

        @Override
        public void onNext(Male s) {
            Log.i(tag, "name:" + s.name + "\n hasJJ:" + s.hasJJ);
        }
    });
}

class Person {
    String name;

    public Person(String name) {
        this.name = name;
    }
}

class Male extends Person {
    public boolean hasJJ;

    public Male(boolean hasJJ, String name) {
        super(name);
        this.hasJJ = hasJJ;
    }
}
//多态，我们用Person接收Male对象，然后通过cast转成Male类型。有点instanceof的意思。

四、组合Observables

我们学到如何转换可观测序列。我们也看到了map(),scan(),groupBY(),以及更多有用的函数的实际例子，它们帮助我们操作Observable来创建我们想要的Observable。

我们将研究组合函数并学习如何同时处理多个Observables来创建我们想要的Observable。

4.1、merge

RxJava的merge()方法将帮助你把两个甚至更多的Observables合并到他们发射的数据项里。下图给出了把两个序列合并在一个最终发射的Observable。


举个例子

List<String> list1 = new ArrayList<>();
for (int i = 0; i < 30; i++) {
    list1.add("hello i:" + i);
}
List<String> list = new ArrayList<>();
for (int j = 0; j < 30; j++) {
    list.add("world j:" + j);
}
List<String> list2 = new ArrayList<>();
for (int m = 0; m < 30; m++) {
    list2.add("fuck m:" + m);
}
Observable<String> world = Observable.from(list);
Observable<String> hello = Observable.from(list1);
Observable<String> fuck = Observable.from(list2);
Observable.merge(world, hello, fuck).subscribe(new Subscriber<String>() {
    @Override
    public void onCompleted() {

    }

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onNext(String s) {
        Log.i(tag, s);
    }
});

注意错误时的toast消息，你可以认为每个Observable抛出的错误都将会打断合并。如果你需要避免这种情况，RxJava提供了mergeDelayError()，它能从一个Observable中继续发射数据即便是其中有一个抛出了错误。当所有的Observables都完成时，mergeDelayError()将会发射onError()，如下图所示：


4.2 zip

我们在处理多源时可能会带来这样一种场景：多从个Observables接收数据，处理它们，然后将它们合并成一个新的可观测序列来使用。RxJava有一个特殊的方法可以完成：zip() 合并两个或者多个Observables发射出的数据项，根据指定的函数Func* 变换它们，并发射一个新值。下图展示了zip() 方法如何处理发射的“numbers”和“letters”然后将它们合并一个新的数据项：


举个例子

List<String> hellos = new ArrayList<>();
for (int i = 0; i < 30; i++) {
    hellos.add("hello i:" + i);
}
List<Integer> worlds = new ArrayList<>();
for (int j = 0; j < 20; j++) {
    worlds.add(j);
}

Observable.zip(Observable.from(hellos).subscribeOn(Schedulers.io()), Observable.from(worlds).subscribeOn(Schedulers.io()), new Func2<String, Integer, String>() {
    @Override
    public String call(String s, Integer integer) {
        return "index:" + integer + "\t s:" + s;
    }
}).subscribe(new Subscriber<String>() {
    @Override
    public void onCompleted() {
        Log.i(tag, "onCompleted");
    }

    @Override
    public void onError(Throwable e) {
        Log.i(tag, "error");
    }

    @Override
    public void onNext(String s) {
        Log.i(tag, s);
    }
});
//这里只会打印20条，而不是30条，应该是有个observable完成就完成

五、Schedulers

我们提升标准看看如何使用RxJava的调度器来处理多线程和并发编程的问题。我们将学习到如何以响应式的方式创建网络操作，内存访问，以及耗时任务。

5.1、StrictMode

为了获得更多出现在代码中的关于公共问题的信息，我们激活了StrictMode模式。

StrictMode帮助我们侦测敏感的活动，如我们无意的在主线程执行磁盘访问或者网络调用。正如你所知道的，在主线程执行繁重的或者长时的任务是不可取的。因为Android应用的主线程时UI线程，它被用来处理和UI相关的操作：这也是获得更平滑的动画体验和响应式App的唯一方法。

为了在我们的App中激活StrictMode，我们只需要在MainActivity中添加几行代码，即onCreate()方法中这样：

@Override
public void onCreate() { 
    super.onCreate();
    if (BuildConfig.DEBUG) {
        StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder().detectAll().penaltyLog().build()); 
        StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder().detectAll().penaltyLog().build());
    } 
}
//我们并不想它总是激活着，因此我们只在debug构建时使用。这种配置将报告每一种关于主线程用法的违规做法，并且这些做法都可能与内存泄露有关：Activities、BroadcastReceivers、Sqlite等对象。
//选择了penaltyLog()，当违规做法发生时，StrictMode将会在logcat打印一条信息。

阻塞I/O的操作会导致App必须等待结果返回（阻塞结束）才能进行下一步操作。在UI线程上执行一个阻塞操作会将UI强行卡住，直接造成很糟糕的用户体验。

我们激活StrictMode后，我们开始收到了关于我们的App错误操作磁盘I/O的不良信息。

D/StrictMode  StrictMode policy violation; ~duration=998 ms: android.os.StrictMode$StrictModeDiskReadViolation: policy=31 violation=2
at android.os.StrictMode$AndroidBlockGuardPolicy.onReadFromDisk (StrictMode.java:1135)
at libcore.io.BlockGuardOs.open(BlockGuardOs.java:106) at libcore.io.IoBridge.open(IoBridge.java:393)
at java.io.FileOutputStream.<init>(FileOutputStream.java:88) 
at android.app.ContextImpl.openFileOutput(ContextImpl.java:918) 
at android.content.ContextWrapper.openFileOutput(ContextWrapper. java:185)
at com.packtpub.apps.rxjava_essentials.Utils.storeBitmap (Utils.java:30)

上一条信息告诉我们Utils.storeBitmap()函数执行完耗时998ms：在UI线程上近1秒的不必要的工作和App上近1秒不必要的迟钝。这是因为我们以阻塞的方式访问磁盘。我们的storeBitmap()函数包含了：

FileOutputStream fOut = context.openFileOutput(filename, Context.MODE_PRIVATE);

它直接访问智能手机的固态存储然后就慢了。我们该如何提高访问速度呢？storeBitmap()函数保存了已安装App的图标。他的返回值类型为void，因此在执行下一个操作前我们毫无理由去等待直到它完成。我们可以启动它并让它执行在不同的线程。近几年来Android的线程管理发生了许多变化，导致App出现诡异的行为。我们可以使用AsyncTask，但是我们要避免掉入前几章里的onPre... onPost...doInBackGround地狱。下面我们将换用RxJava的方式。调度器万岁！

5.2 、Schedulers

调度器以一种最简单的方式将多线程用在你的Apps的中。它们是RxJava重要的一部分并能很好地与Observables协同工作。它们无需处理实现、同步、线程、平台限制、平台变化而可以提供一种灵活的方式来创建并发程序。

RxJava提供了5种调度器：

  • .io()
  • .computation()
  • .immediate()
  • .newThread()
  • .trampoline()

让我们一个一个的来看下它们：

5.2.1、Schedulers.io

这个调度器时用于I/O操作。它基于根据需要，增长或缩减来自适应的线程池。我们将使用它来修复我们之前看到的StrictMode违规做法。由于它专用于I/O操作，所以并不是RxJava的默认方法；正确的使用它是由开发者决定的。

重点需要注意的是线程池是无限制的，大量的I/O调度操作将创建许多个线程并占用内存。一如既往的是，我们需要在性能和简捷两者之间找到一个有效的平衡点。

5.2.2、Schedulers.computation

这个是计算工作默认的调度器，它与I/O操作无关。它也是许多RxJava方法的默认调度器：buffer(),debounce(),delay(),interval(),sample(),skip()。

5.2.3、Schedulers.immediate

这个调度器允许你立即在当前线程执行你指定的工作。它是timeout(),timeInterval(),以及timestamp()方法默认的调度器。

5.2.4、Schedulers.newThread()

这个调度器正如它所看起来的那样：它为指定任务启动一个新的线程。

5.2.5、Schedulers.trampoline

当我们想在当前线程执行一个任务时，并不是立即，我们可以用.trampoline()将它入队。这个调度器将会处理它的队列并且按序运行队列中每一个任务。它是repeat()和retry()方法默认的调度器。

5.2.5、SubscribeOn and ObserveOn

我们如何利用它来和Observables一起工作呢？RxJava提供了subscribeOn()方法来用于每个Observable对象。subscribeOn()方法用Scheduler来作为参数并在这个Scheduler上执行Observable调用。

在“真实世界”这个例子中，我们调整loadList()函数。首先，我们需要一个新的getApps()方法来检索已安装的应用列表：

private Observable<AppInfo> getApps() { 
    return Observable.create(subscriber -> {
        List<AppInfo> apps = new ArrayList<>();
        SharedPreferences sharedPref = getActivity().getPreferences(Context.MODE_PRIVATE);
        Type appInfoType = new TypeToken<List<AppInfo>>(){}.getType();
        String serializedApps = sharedPref.getString("APPS", "");
        if (!"".equals(serializedApps)) {
            apps = new Gson().fromJson(serializedApps,appInfoType); 
        }
        for (AppInfo app : apps) {
            subscriber.onNext(app);
        }
        subscriber.onCompleted(); 
    });
}

getApps()方法返回一个AppInfo的Observable。它先从Android的SharePreferences读取到已安装的应用程序列表。反序列化，并一个接一个的发射AppInfo数据。使用新的方法来检索列表，loadList()函数改成下面这样：

private void loadList() {
    mRecyclerView.setVisibility(View.VISIBLE);
    getApps().subscribe(new Observer<AppInfo>() {
        @Override
        public void onCompleted() {
            mSwipeRefreshLayout.setRefreshing(false);
            Toast.makeText(getActivity(), "Here is the list!", Toast.LENGTH_LONG).show();
        }

        @Override
        public void onError(Throwable e) {
            Toast.makeText(getActivity(), "Something went wrong!", Toast.LENGTH_SHORT).show();
            mSwipeRefreshLayout.setRefreshing(false);
        }

        @Override
        public void onNext(AppInfo appInfo) {
            mAddedApps.add(appInfo);
                mAdapter.addApplication(mAddedApps.size() - 1, appInfo);
        } 
    });
}

如果我们运行代码，StrictMode将会报告一个不合规操作，这是因为SharePreferences会减慢I/O操作。我们所需要做的是指定getApps()需要在调度器上执行：

getApps().subscribeOn(Schedulers.io())
        .subscribe(new Observer<AppInfo>() { [...]

Schedulers.io()将会去掉StrictMode的不合规操作，但是我们的App现在崩溃了是因为：

at rx.internal.schedulers.ScheduledAction.run(ScheduledAction.jav a:58)
at java.util.concurrent.Executors$RunnableAdapter.call(Executors. java:422)
at java.util.concurrent.FutureTask.run(FutureTask.java:237) 
at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutu reTask.access$201(ScheduledThreadPoolExecutor.java:152)
at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutu reTask.run(ScheduledThreadPoolExecutor.java:265)
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolEx ecutor.java:1112)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolE xecutor.java:587)
at java.lang.Thread.run(Thread.java:841) Caused by:
    android.view.ViewRootImpl$CalledFromWrongThreadException: Only the original thread that created a view hierarchy can touch its views.

Only the original thread that created a view hierarchy can touch its views.

我们再次回到Android的世界。这条信息简单的告诉我们我们试图在一个非UI线程来修改UI操作。意思是我们需要在I/O调度器上执行我们的代码。因此我们需要和I/O调度器一起执行代码，但是当结果返回时我们需要在UI线程上操作。RxJava让你能够订阅一个指定的调度器并观察它。我们只需在loadList()函数添加几行代码，那么每一项就都准备好了：

getApps()
.onBackpressureBuffer()
.subscribeOn(Schedulers.io())//获取app信息的操作放在io线程
.observeOn(AndroidSchedulers.mainThread())//更新和显示应用的操作放在android的mainThread线程(ui线程)
.subscribe(new Observer<AppInfo>() { [...]

observeOn()方法将会在指定的调度器上返回结果：如例子中的UI线程。onBackpressureBuffer()方法将告诉Observable发射的数据如果比观察者消费的数据要更快的话，它必须把它们存储在缓存中并提供一个合适的时间给它们。做完这些工作之后，如果我们运行App，就会出现已安装的程序列表。

总结：

RxJava为此提供了极其实用的工具：调度器。调度器以及不同应用场景下的优化方案一起，将我们从StrictMode中的不合法操作以及阻塞I/O的方法中解放出来。我们现在可以用简单的，响应式的，并在整个App中保持一致的方式来访问本地存储和网络。

总结

我们的旅程结束了。相信你已经准备好将你的Java应用带到一个新的代码质量水平。你可以享受一个新的编程模式并把更流畅的思维方式应用到日常编程生活中。RxJava提供了一种以面向时序的方式考虑数据的机会：所有事情都是持续变化的，数据在更新，事件在触发，然后你就可以创建事件响应式的、灵活的、运行流畅的App。

刚开始切换到RxJava看起来困难并且耗时，但我们已经体验到了如何通过响应式的方式有效地处理日常问题。现在你可以把你的旧代码迁移到RxJava上:给这些同步getters一种新的响应式。

RxJava是一个正在不断发展和扩大的世界。还有许多方法我们还没有去探索。有些方法甚至还没有，通过RxJava，你可以创建你自己的操作符并把他们发展地更远。

Android是一个好玩的地方，但是它也有局限性。作为一个Android开发者，你可以用RxJava和RxAndroid克服其中的许多。我们用AndroidScheduler只简单提了下RxAndroid,除了在最后一章，你了解了ViewObservable。RxAndroid给了你许多：例如，WidgetObservable，LifecycleObservable。往后将它发展地更长远的任务就取决于你了。

谨记可观测序列就像一条河：它们是流动的。你可以“过滤”(filter)一条河，你可以“转换”(transform)一条河，你可以将两条河合并(combine)成一个，然后依然畅流如初。最后，它就成了你想要的那条河。

“Be Water，my friend”

            --Bruce Lee
Soon_苏大强
关注
专栏目录
RxJava详解
tectrol的专栏
12-05 260
  RxJava 到底是什么 一个词：异步。 RxJava 在 GitHub 主页上的自我介绍是 "a library for composing asynchronous and event-based programs using observable sequences for the Java VM"（一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库）。这就...
RxJava2极速入门——Rxjava操作符详解之创建操作符
易庞宙的博客
03-22 1118
目录 RxJava操作符——创建操作符 create操作符 defer操作符 from操作符 fromArray操作符 fromIterable操作符 fromFuture操作符 interval操作符 just操作符 range操作符 repeat操作符 repeat操作符分析 repeatWhen操作符 repeatUntil操作符 timer操作符 empty...
从零开始的RxJava2.0教程(一)基础
宇不语的博客
11-06 2万+
1. 为什么写这篇文章RxJava这些年越来越流行，而上月末(2016.10.29)发布了2.0正式版，但网上大部分关于RxJava的教程都是1.x的。关于2.0的教程基本是介绍1.x和2.x的区别，对于RxJava的老用户来说，自然看看和1.x的区别就大致会用了，但是对于新手来说，就不得不先学1.x。这样来说，学习成本就提高了，本身RxJava就不容易上手。为了让年轻的司机可以直接从2.0开始学习
RxJava用法
06-13 135
首先导入依赖: implementation 'io.reactivex.rxjava2:rxjava:2.2.9'implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'Rxjava使用观察者模式实现异步操作,主要和Retrofit配合使用 RxJava 有四个基本概念：Observable (可观察者，即被观察者)、...
RxJava中的Single使用简介
最新发布
Leon_Jinhai_Sun的博客
09-18 384
RxJava中的Single使用简介
深入浅出RxJava（一：基础篇）
热门推荐
大头鬼Bruce
12-09 35万+
响应式函数编程框架RxJava入门，RxAndroid使用
RxJava 方法备忘录
Knight-ZXW的博客
01-25 703
RxJava 方法过滤相关 RxJava提供了filter()方法来过滤我们观测序列中不想要的值 当我们不需要整个序列时，而是只想取开头或结尾的几个元素，我们可以用take()或takeLast() 一个可观测序列会在出错时重复发射或者被设计成重复发射。distinct()和distinctUntilChanged()函数可以方便的让我们处理这种重复问题。(它会记录以及发射的值来过
【Android】RxJava的使用（一）基本用法
linder_qzy的专栏
08-02 404
转自：http://www.jianshu.com/p/19cac3c5b106 前言 最近经常看到RxJava这个字眼，也看到很多人在博客中推荐使用RxJava。好奇的我怎么能错过，于是Google了一下，说RxJava好用的和说RxJava难用的都有，于是自己也亲自尝试了一下（感觉不容易上手）。写博客记录下学习的过程，一方面作为巩固，另一方面希望能帮助到初学者。 （第一篇只介绍了
Android性能优化之利用Rxlifecycle解决RxJava内存泄漏详解
08-31
Rxlifecycle可以通过Gradle依赖添加到项目中，具体依赖项如下： ```gradle compile 'com.trello:rxlifecycle:1.0' compile 'com.trello:rxlifecycle-components:1.0' ``` 使用Rxlifecycle，开发者需要让Activity或...
RxJava2极速入门——Rxjava操作符详解之合并操作符
易庞宙的博客
05-17 1331
RxJava2极速入门——Rxjava操作符详解之合并操作符Rxjava操作符详解合并操作符MergemergemergeWithmerge总结ZipzipzipWithzip总结combineLatestwithLatestFromjoinstartWith总结 Rxjava操作符详解合并操作符 最近公司事务比较繁忙，导致文章更新晚了，尽量保证在6月底的时候更新完RxJava2相关的东西。 好了...
RXJava 背压策略 详解
MissGentlemen的博客
01-31 1017
我们学习了FLowable的一些基本知识, 同时也挖了许多坑, 这一节就让我们来填坑吧. 正题 在上一节中最后我们有个例子, 当上游一次性发送128个事件的时候是没有任何问题的, 一旦超过128就会抛出MissingBackpressureException异常, 提示你上游发太多事件了, 下游处理不过来, 那么怎么去解决呢? 我们先来思考一下, 发送128个事件没有问题是因为FLowable内部
RxJava的基本使用方法
Near的博客
10-26 859
现在才来了解RxJava可能有点晚。。。当初第一次看到这个东西，觉得也就是观察者模式的延伸而已，没怎么在意。后来发现许多项目中，都引用了该框架。所以趁着项目间隙，来归纳学习一下RxJava这个热门框架。 1.RxJava介绍： RxJava是用java实现Reactive Extensions(异步操作)，可观测的序列来组成异步的、基于事件的程序的库。他扩展了观察者模式来支持数据/事件序列，而
RxJava 常用的几种方法 。
weixin_34223655的博客
07-14 214
2019独角兽企业重金招聘Python工程师标准>>> ...
9章 RxJava混合实战
点击置顶文章查看博客目录（全站式导航）
12-27 676
本篇文章已授权微信公众号 YYGeeker 独家发布转载请标明出处 CSDN学院课程地址 RxJava2从入门到精通-初级篇:https://edu.csdn.net/course/detail/10036 RxJava2从入门到精通-中级篇:https://edu.csdn.net/course/detail/10037 RxJava2从入门到精通-进阶篇:https://edu.csdn....
MVP+Retrofit+Rxjava实战
XiNanHeiShao的专栏
07-07 9468
文章背景在刚接触Android开始起，很长一段时间都在使用MVC模式开发项目，MVC模式很适合小项目的开发，简单方便。但当我们的项目越来越大时，MVC就显得力不从心，Activty或者Fragment中代码也会越来越多，导致项目的维护变的越来越复杂，业务剥离和复用难度大，一个新的框架或技术的出现必定是来解决前有的框架的缺陷，所以MVP的出现很优雅的解决了MVC中存在缺陷或不足。文章目标MVP在And
RxJava 实例
xiaowang_lj的博客
10-20 613
三种方式：Observable.create、Observable.just、Observable.fromArray@Override}});}使用observer或者subscriber@Override}@Override}@Override}@Override}};特别注意：2种方法的区别，即Subscriber 抽象类与Observer 接口的区别。
RxJava的基本用法
GL_MINE_CSDN的博客
03-24 393
一、什么是Rxjava ? a library for composing asynchronous and event-based programs using observable sequences for the Java VM 一个在 Java VM 上使用的、可观测的序列、来组成异步的、基于事件的程序的库。         其实对于RxJava的总结就一个词：  异步 二、为什
RxJava中几个常用但初学介绍不多的方法介绍
weixin_34344677的博客
06-30 124
自己学习RxJava的知识点的总结，看了很多篇文章，到现在也算是略有心得；推荐大家如果想了解的可以看看这篇文章，RxJava综合教程（系列版） 不过再详细的讲解还是会有说的不到的地方，比如我最近在做安卓的课设，坑的老师，一开始说没有，最后几天在说，真的是加班加点的干。不过也算是总结吧，之前一段时间的学习知识点...
RxJava的使用基本用法
Agnoi丶军
04-09 354
一.RxJava是一个实现异步操作的库 二.观察者模式     观察者：监视着被观察者的行为，当被观察者某个状态改变的时候会通知观察者，观察者会执行对应的操作；     被观察者：被监视的对象，当某个状态改变的时候会通知观察者；     订阅（或注册）：将观察者和被观察者建立联系。 常用的例子：点击Button后触发OnClickListener中的onClick()事件。在这个事件中他...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值