使用RxJava从多个数据源获取数据

开发 后端
试想,需要一些动态数据的时候,只要每次都请求网络就可以了。但是,更有效率的做法是,把联网得到的数据,缓存到磁盘或内存。

试想,需要一些动态数据的时候,只要每次都请求网络就可以了。但是,更有效率的做法是,把联网得到的数据,缓存到磁盘或内存。

具体的说,计划如下:

  1. 偶尔的联网操作,只为获取***数据。

  2. 尽可能快的读取到数据(通过获取之前缓存的网络数据)。

我将通过使用 RxJava ,来实现这个计划。

使用RxJava从多个数据源获取数据

基本模式

为每一个数据源(网络,磁盘和内存)创建Observable,使用concat()和first()操作符,构造一个简单的实现方式。

concat() 操作符持有多个Observable对象,并将它们按顺序串联成队列。 first() 操作符只从串联队列中取出并发送***个事件。因此,如果使用concat().first(),无论多少个数据源,只有***个事件会被检索出并发送。

 

  1. // Our sources (left as an exercise for the reader) 
  2. Observable memory = ...;  
  3. Observable disk = ...;  
  4. Observable network = ...; 
  5.  
  6. // Retrieve the first source with data 
  7. Observable source = Observable  
  8.   .concat(memory, disk, network) 
  9.   .first(); 
  10.  
  11. // Our sources (left as an exercise for the reader) 
  12. Observablememory = ...;   
  13. Observabledisk = ...;   
  14. Observablenetwork = ...; 
  15.  
  16. // Retrieve the first source with data 
  17. Observablesource = Observable   
  18.   .concat(memory, disk, network) 
  19.   .first(); 

这种模式的关键在于concat()操作符只有需要数据的时候才会订阅所有的Observable数据源。由于first()操作符会较早的停止检 索队列,所以,如果存在缓存数据,就没有必要访问较慢的数据源。 也就是说,如果memory返回结果,就不必担心disk和network会被访问。相反地,如果内存和磁盘都没有数据,才执行网络请求。

注意concat()所持有的Observable数据源,是按照一个接一个的顺序被检索的。

持久化数据

很明显,下一步是缓存数据。如果不把网络请求后的结果缓存到磁盘,磁盘访问后的结果缓存到内存,那么这根本不就不叫缓存。接下来要写的代码就是,网络数据的持久化操作。

我的解决方案是,让每个数据源在发送完事件后,都保存或者缓存数据。

 

  1. Observable networkWithSave = network.doOnNext(new Action1() { 
  2. @Override public void call(Data data) { 
  3. saveToDisk(data); 
  4. cacheInMemory(data); 
  5. }); 
  6.  
  7. Observable diskWithCache = disk.doOnNext(new Action1() { 
  8. @Override public void call(Data data) { 
  9.   cacheInMemory(data); 
  10. }); 
  11.  
  12.  ObservablenetworkWithSave = network.doOnNext(new Action1() { 
  13. @Overridepublic void call(Datadata) { 
  14. saveToDisk(data); 
  15. cacheInMemory(data); 
  16. }); 
  17.  
  18. ObservablediskWithCache = disk.doOnNext(new Action1() { 
  19. @Overridepublic void call(Datadata) { 
  20.   cacheInMemory(data); 
  21. }); 

现在,如果你使用networkWithSave和diskWithCache,数据将会在加载后自动保存。

(这個策略的另一个优势在于networkWithSave和diskWithCache可以在任何地方被使用,不局限于我们的多数据模式下。)

陈旧的数据

不幸的,现在我们保存数据的那些代码,执行的有点过头了。无论数据是否过时,它总是返回相同的数据。我们希望做到,偶尔连接服务器抓取***的数据。

解决方法在于,使用first()操作符进行过滤。就是设置它拒绝接收毫无价值的数据。

 

  1. Observable source = Observable 
  2.     .concat(memory, diskWithCache, networkWithSave) 
  3.     .first(new Func1() { 
  4.       @Override public Boolean call(Data data) { 
  5.         return data.isUpToDate(); 
  6.       } 
  7.     }); 
  8.  
  9. Observablesource = Observable 
  10.     .concat(memory, diskWithCache, networkWithSave) 
  11.     .first(new Func1() { 
  12.       @Overridepublic Boolean call(Datadata) { 
  13.         return data.isUpToDate(); 
  14.       } 
  15.     }); 

现在,我们只需要发送被断定为***数据的事件就OK了。因此,只要有一个数据源的数据过期,就继续检索下一个数据源,直到找到***数据为止。

first()和takeFirst()操作符的比较

对于这种设计模式,first()和takeFirst()操作符可以二选其一。

两种调用方式的区别在于,如果所有数据源的数据均过期,没有任何的有效数据作为事件发送,first()会抛出 NoSuchElementException异常(译者注:first()操作符均return false),而takeFirst()操作符则直接调用完成操作,不会抛出任何异常。

使用哪个操作符,完全取决于是否需要明确处理缺失的数据。

代码示例

可以从这里检出,以上所有代码的实现示例: https://github.com/dlew/rxjava-multiple-sources-sample

如果需要一个真实示例,检出 Gfycat App ,它在获取数据的时候使用了这种模式。项目并没有使用以上展示的所有功能(因为不需要),但是,示范了concat().first()的基本用法。

 

责任编辑:王雪燕 来源: 小鄧子的简书
相关推荐

2013-06-09 10:15:09

2013-06-07 10:05:18

2014-11-20 09:47:06

Java

2010-12-27 09:59:11

ODBC数据源

2009-06-15 13:24:46

JBoss数据源

2012-06-17 13:04:45

2023-11-27 09:16:53

Python数据源类型

2017-09-04 14:52:51

Tomcat线程数据源

2017-06-14 23:42:27

大数据数据源架构

2012-09-04 13:48:57

云计算数据源Odata API

2009-08-14 10:26:27

ibatis多数据源

2015-08-21 10:06:09

rxjava数据

2009-09-15 17:15:33

Linq排序

2009-09-08 11:09:39

LINQ数据源

2021-10-18 06:54:47

数据源数据预处理

2017-02-05 19:09:30

大数据API百度

2017-01-22 19:57:42

大数据数据源

2009-07-21 17:41:58

JDBC数据源

2023-09-07 08:39:39

copy属性数据源

2009-12-28 14:19:51

WPF更新数据源
点赞
收藏

51CTO技术栈公众号