慕课网_《RxJava与RxAndroid基础入门》学习总结

头像
妙手空空
    阅读 24 分钟
    4

    时间：2017年10月16日星期一
    说明：本文部分内容均来自慕课网。@慕课网：http://www.imooc.com
    教学源码：无
    学习源码：https://github.com/zccodere/s...

    第一章：课程简介

    1-1 课程介绍

    本门课程的主要内容

    RxJava是什么
RxAndroid是什么
RxJava常用操作符（重点、难点）
怎样在项目中使用RxJava和RxAndroid

    如何学习RxJava与RxAndroid

    总体总体章节，有初步了解
跟着讲解自己动手实际去敲代码
GitHub上RxJava项目Wiki文档
看RxJava相关博客和优秀文章

    为什么学RxJava与RxAndroid

    RxJava能提高工作效率
RxJava能优雅解决复杂业务场景
RxJava使用越来越流行
RxJava的优秀特性

    本门课程能够学到什么

    了解什么是响应式编程
了解RxJava和RxAndroid到底是什么
了解RxJava历史来源
清除RxJava与RxAndroid关系
学会在项目中使用RxJava和RxAndroid

    相关资源

    RxJava英文文档：https://github.com/ReactiveX/RxJava/wiki
RxJava中文文档：https://mcxiaoke.gitbooks.io/rxdocs/content/
RxJava经典资料：https://github.com/lzyzsd/Awesome-RxJava

    1-2 响应式编程

    什么是响应式编程

    定义：是一种基于异步数据流概念的编程模式
关键概念：事件
使用场景：UI（通用）

    第二章：基本概述

    2-1 RxJava概述

    RxJava是什么

    异步数据处理库
扩展的观察者模式

    RxJava历史来源

    Netflix公司遇到问题
目标：重构当前架构来减少REST调用的次数
尝试：微软RX迁移到JVM

    RxJava特点

    jar包小于1MB
轻量级框架
支持Java8 lambda
支持Java6及Android 2.3以上
支持异步和同步

    扩展的观察者模式

    onCompleted()事件：通知完毕事件
onError()事件：通知异常事件
使用组合而不是嵌套，避免陷入回调地狱

    2-2 RxAndroid概述

    RxAndroid是什么

    是RxJava针对Android平台的一个扩展，用于Android开发
提供响应式扩展组件快速、易于开发Android应用程序

    Schedulers（调度器）

    解决Android主线程问题：针对Android
解决多线程问题

    Schedulers示例

    clipboard.png

    2-3 RxJava扩展

    观察者模式四大要素

    Observable被观察者
Observer观察者
Subscribe订阅
事件

    观察者模式图示

    clipboard.png

    RxJava扩展的观察者模式图示

    clipboard.png

    第三章：使用详解

    3-1 入门案例

    创建名为myrxjava的maven工程pom如下

    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.myimooc</groupId>
  <artifactId>myrxjava</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>myrxjava</name>
  <url>http://maven.apache.org</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
    </properties>

  <dependencies>
    <dependency>
        <groupId>io.reactivex</groupId>
        <artifactId>rxjava</artifactId>
        <version>1.3.2</version>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
</project>

    1.编写HelloWorld类

    package com.myimooc.myrxjava;

import rx.Observable;
import rx.Observable.OnSubscribe;
import rx.Subscriber;

/**
 * @title HelloWorld类
 * @describe 3-1 入门案例HelloWorld
 * @author zc
 * @version 1.0 2017-10-16
 */
public class HelloWorld 
{
    @SuppressWarnings({ "deprecation", "rawtypes", "unchecked" })
    public static void main( String[] args )
    {
        
        // 1.创建被观察者
        Observable myObservable = Observable.create(new OnSubscribe<String>(){
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("hello World!");
                throw new NullPointerException("出错啦");
            }
        });
        
        // 2.创建观察者
        Subscriber mySubscriber = new Subscriber<String>(){
            @Override
            public void onCompleted() {
                System.out.println("onCompleted()");
            }
            @Override
            public void onError(Throwable arg0) {
                System.out.println("onError()");
            }
            @Override
            public void onNext(String str) {
                System.out.println("onNext() " + str);
            }
        };
        
        // 3.订阅事件
        myObservable.subscribe(mySubscriber);
    }
}

    3-2 创建操作

    操作符的分类

    Creating Observables（创建Observable：创建操作）
Transforming Observables（转换Observable：转换操作）
Filtering Observables（过滤Observable：过滤操作）
Combining Observables（组合Observable：组合操作）
Error Handling Operators（处理错误）

    Creating Observables（创建Observable）

    Create
Just
From
Defer
Empty/Never/Throw
Interval
Range
Repeat
Start
Timer

    代码编写

    1.编写CreatingObservables类

    package com.myimooc.myrxjava;

import java.util.ArrayList;
import java.util.List;

import rx.Observable;
import rx.Observable.OnSubscribe;
import rx.functions.Func0;
import rx.Subscriber;

/**
 * @title 创建操作符
 * @describe 创建操作符演示
 * @author zc
 * @version 1.0 2017-10-16
 */
@SuppressWarnings("unused")
public class CreatingObservables {
    
    public static void main(String[] args) {
//        create();
//        just();
//        from();
//        defer();
        repeat();
    }
    
    /**
     * repeat操作符
     */
    @SuppressWarnings({ "unchecked", "rawtypes" })
    private static void repeat() {
        Observable observable= Observable.range(1,5).repeat(2);
        observable.subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                System.out.println("onCompleted()");
            }
            @Override
            public void onError(Throwable arg0) {
                System.out.println("onError()");
            }
            @Override
            public void onNext(Integer str) {
                System.out.println("onNext(): " + str);
            }
        });
    }
    
    /**
     * range操作符
     */
    @SuppressWarnings({ "unchecked", "rawtypes" })
    private static void range() {
        Observable observable= Observable.range(1,5);
        observable.subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                System.out.println("onCompleted()");
            }
            @Override
            public void onError(Throwable arg0) {
                System.out.println("onError()");
            }
            @Override
            public void onNext(Integer str) {
                System.out.println("onNext(): " + str);
            }
        });
    }

    private static String deferStr = "default";
    /**
     * defer操作符
     */
    @SuppressWarnings({ "unchecked", "rawtypes" })
    private static void defer() {
        Observable observable= Observable.defer(new Func0<Observable<String>>() {
            @Override
            public Observable<String> call() {
                return Observable.just(deferStr);
            }
        });
        deferStr = "RxJava";
        observable.subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {
                System.out.println("onCompleted()");
            }
            @Override
            public void onError(Throwable arg0) {
                System.out.println("onError()");
            }
            @Override
            public void onNext(String str) {
                System.out.println("onNext(): " + str);
            }
        });
    }

    /**
     * from操作符
     */
    private static void from() {
        List<Integer> nums = new ArrayList<Integer>();
        nums.add(1);
        nums.add(2);
        nums.add(3);
        nums.add(4);
        nums.add(5);
        Observable.from(nums).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                System.out.println("onCompleted()");
            }
            @Override
            public void onError(Throwable arg0) {
                System.out.println("onError()");
            }
            @Override
            public void onNext(Integer str) {
                System.out.println("onNext(): " + str);
            }
        });
    }

    /**
     * just操作符
     */
    private static void just() {
        Observable.just("RxJava").subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {
                System.out.println("onCompleted()");
            }
            @Override
            public void onError(Throwable arg0) {
                System.out.println("onError()");
            }
            @Override
            public void onNext(String str) {
                System.out.println("onNext(): " + str);
            }
        });
    }

    /**
     * Create操作符
     */
    private static void create() {
        Observable.unsafeCreate(new OnSubscribe<String>(){
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("RxJava");
            }
        }).subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {
                System.out.println("onCompleted()");
            }
            @Override
            public void onError(Throwable arg0) {
                System.out.println("onError()");
            }
            @Override
            public void onNext(String str) {
                System.out.println("onNext(): " + str);
            }
        });
    }
}

    3-3 转换操作

    Transforming Observables（转换Observable）

    Map
FlatMap
GroupBy
Buffer
Scan
Window

    代码编写

    1.编写TransformingObservables类

    package com.myimooc.myrxjava;

import java.util.List;

import rx.Observable;
import rx.Observer;
import rx.Subscriber;
import rx.functions.Func1;
import rx.functions.Func2;
import rx.observables.GroupedObservable;

/**
 * @title 转换操作符
 * @describe 转换操作符演示
 * @author zc
 * @version 1.0 2017-10-16
 */
@SuppressWarnings("unused")
public class TransformingObservables {
    
    public static void main(String[] args) {
//        transformMap();
//        transformFlatMap();
//        transformGroupBy();
//        transformBuffer();
        transformScan();
    }

    /**
     * Scan操作符:对数据进行累加
     */
    private static void transformScan() {
        Observable.range(1,5).scan(new Func2<Integer, Integer, Integer>() {
            
            @Override
            public Integer call(Integer sum, Integer num) {
                return sum + num;
            }
            
        }).subscribe(new Observer<Integer>() {
            @Override
            public void onCompleted() {
                System.out.println("onCompleted()");
            }
            @Override
            public void onError(Throwable arg0) {
                System.out.println("onError()");
            }
            @Override
            public void onNext(Integer str) {
                System.out.println("onNext(): " + str);
            }
        });
    }

    /**
     * Buffer操作符:分批读取数据
     */
    private static void transformBuffer() {
        Observable.range(1,5).buffer(2).subscribe(new Observer<List<Integer>>() {
            @Override
            public void onCompleted() {
                System.out.println("onCompleted()");
            }
            @Override
            public void onError(Throwable arg0) {
                System.out.println("onError()");
            }
            @Override
            public void onNext(List<Integer> str) {
                System.out.println("onNext(): " + str);
            }
        });
    }

    /**
     * GroupBy操作符：对数据进行分组操作
     */
    private static void transformGroupBy() {
        Observable.just(1,2,3,4,5).groupBy(new Func1<Integer,Integer>(){

            @Override
            public Integer call(Integer data) {
                return data % 2;
            }
            
        }).subscribe(new Observer<GroupedObservable<Integer,Integer>>() {
            @Override
            public void onCompleted() {
            }
            @Override
            public void onError(Throwable arg0) {
            }
            @Override
            public void onNext(final GroupedObservable<Integer, Integer> groupedObservable) {
                groupedObservable.subscribe(new Subscriber<Integer>() {

                    @Override
                    public void onCompleted() {
                    }
                    @Override
                    public void onError(Throwable arg0) {
                    }
                    @Override
                    public void onNext(Integer data) {
                        System.out.println("group:" + groupedObservable.getKey() + " data:" + data);
                    }
                });
            }
        });
    }

    /**
     * FlatMap操作符：一个对象转换为多个对象
     */
    private static void transformFlatMap() {
        
        Observable.just(1,2,3,4,5).flatMap(new Func1<Integer,Observable<? extends String>>(){

            @Override
            public Observable<? extends String> call(Integer num) {
                return Observable.just(String.valueOf(num));
            }
            
        }).subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {
                System.out.println("onCompleted()");
            }
            @Override
            public void onError(Throwable arg0) {
                System.out.println("onError()");
            }
            @Override
            public void onNext(String str) {
                System.out.println("onNext(): " + str);
            }
        });
    }

    /**
     * Map操作符：一个对象转换为另一个对象
     */
    private static void transformMap() {
        
        Observable.just(123).map(new Func1<Integer,String>(){

            @Override
            public String call(Integer num) {
                return String.valueOf(num);
            }
            
        }).subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {
                System.out.println("onCompleted()");
            }
            @Override
            public void onError(Throwable arg0) {
                System.out.println("onError()");
            }
            @Override
            public void onNext(String str) {
                System.out.println("onNext(): " + str);
            }
        });
    }
    
    
}

    3-4 过滤操作

    Filtering Observables（过滤Observable）

    Debounce
Distinct
ElementAt
Filter
First
IgnoreElements
Last
Sample
Skip
SkipLast
Take
TakeLast

    代码编写

    1.编写FilteringObservables类

    package com.myimooc.myrxjava;

import java.util.concurrent.TimeUnit;

import rx.Observable;
import rx.Observable.OnSubscribe;
import rx.Observer;
import rx.Subscriber;
import rx.functions.Func1;
import rx.functions.Func2;

/**
 * @title 过滤操作符
 * @describe 过滤操作符演示
 * @author zc
 * @version 1.0 2017-10-17
 */
@SuppressWarnings("unused")
public class FilteringObservables {
    
    public static void main(String[] args) {
//        filterDebounce();
//        filterDistinct();
//        filterElementAt();
//        filterFilter();
//        filterIgnoreElements();
//        filterLast();
//        filterSample();
//        filterSkip();
        filterTake();
    }

    /**
     * Take操作符:取对应数据项
     */
    private static void filterTake() {
        Observable.just(1,2,3,4).takeLast(2).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                System.out.println("onCompleted()");
            }
            @Override
            public void onError(Throwable arg0) {
                System.out.println("onError()");
            }
            @Override
            public void onNext(Integer str) {
                System.out.println("onNext(): " + str);
            }
        });
    }

    /**
     * Skip操作符:跳过数据项
     */
    private static void filterSkip() {
        Observable.just(1,2,3,4).skipLast(2).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                System.out.println("onCompleted()");
            }
            @Override
            public void onError(Throwable arg0) {
                System.out.println("onError()");
            }
            @Override
            public void onNext(Integer str) {
                System.out.println("onNext(): " + str);
            }
        });
    }

    /**
     * Sample操作符:取样
     */
    private static void filterSample() {
        Observable.unsafeCreate(new OnSubscribe<Integer>(){
            @Override
            public void call(Subscriber<? super Integer> arg) {
                try{
                    for (int i=0;i<10;i++){
                        Thread.sleep(1000);
                        arg.onNext(i);
                    }
                    arg.onCompleted();
                }catch (Exception e) {
                    arg.onError(e);
                }
            }
        }).sample(4, TimeUnit.SECONDS).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                System.out.println("onCompleted()");
            }
            @Override
            public void onError(Throwable arg0) {
                System.out.println("onError()" + arg0.getMessage());
            }
            @Override
            public void onNext(Integer str) {
                System.out.println("onNext(): " + str);
            }
        });
    }

    /**
     * Last操作符:取数据项最后一个数据
     */
    private static void filterLast() {
        Observable.just(1,2,3,2,3).last().subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                System.out.println("onCompleted()");
            }
            @Override
            public void onError(Throwable arg0) {
                System.out.println("onError()");
            }
            @Override
            public void onNext(Integer str) {
                System.out.println("onNext(): " + str);
            }
        });
    }

    /**
     * IgnoreElements操作符:忽略掉指定元素，直接回调onCompleted或onError方法
     */
    private static void filterIgnoreElements() {
        Observable.unsafeCreate(new OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> arg) {
                arg.onNext(123);
                arg.onCompleted();
//                throw new NullPointerException();
            }
        }).ignoreElements().subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                System.out.println("onCompleted()");
            }
            @Override
            public void onError(Throwable arg0) {
                System.out.println("onError()" + arg0.getMessage());
            }
            @Override
            public void onNext(Integer str) {
                System.out.println("onNext(): " + str);
            }
        });
    }

    /**
     * Filter操作符:过滤
     */
    private static void filterFilter() {
        Observable.just(1,2,3,2,3).distinct().filter(new Func1<Integer, Boolean>() {
            @Override
            public Boolean call(Integer arg) {
                return arg > 1;
            }
        }).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                System.out.println("onCompleted()");
            }
            @Override
            public void onError(Throwable arg0) {
                System.out.println("onError()");
            }
            @Override
            public void onNext(Integer str) {
                System.out.println("onNext(): " + str);
            }
        });
    }

    /**
     * ElementAt操作符:取出指定位置的元素
     */
    private static void filterElementAt() {
        Observable.just(1,2,3,2,3).elementAt(3).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                System.out.println("onCompleted()");
            }
            @Override
            public void onError(Throwable arg0) {
                System.out.println("onError()");
            }
            @Override
            public void onNext(Integer str) {
                System.out.println("onNext(): " + str);
            }
        });
    }

    /**
     * Distinct操作符:去重操作符
     */
    private static void filterDistinct() {
        Observable.just(1,2,3,2,3).distinct().subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                System.out.println("onCompleted()");
            }
            @Override
            public void onError(Throwable arg0) {
                System.out.println("onError()");
            }
            @Override
            public void onNext(Integer str) {
                System.out.println("onNext(): " + str);
            }
        });
    }

    /**
     * Debounce操作符:在操作后指定时间内无操作时响应
     */
    private static void filterDebounce() {
        Observable.unsafeCreate(new OnSubscribe<Integer>(){
            @Override
            public void call(Subscriber<? super Integer> arg) {
                try{
                    for (int i=0;i<10;i++){
                        Thread.sleep(2000);
                        arg.onNext(i);
                    }
                    arg.onCompleted();
                }catch (Exception e) {
                    arg.onError(e);
                }
            }
        }).debounce(1,TimeUnit.SECONDS).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                System.out.println("onCompleted()");
            }
            @Override
            public void onError(Throwable arg0) {
                System.out.println("onError()");
            }
            @Override
            public void onNext(Integer str) {
                System.out.println("onNext(): " + str);
            }
        });
    }
    
    

}

    3-5 组合操作

    Combining Observables（组合Observable）

    Zip
Merge
StartWith
CombineLatest
Join
SwitchOnNext

    代码编写

    1.编写CombiningObservables类

    package com.myimooc.myrxjava;

import rx.Observable;
import rx.Subscriber;
import rx.functions.Func2;

/**
 * @title 组合操作符
 * @describe 组合操作符演示
 * @author zc
 * @version 1.0 2017-10-17
 */
@SuppressWarnings("unused")
public class CombiningObservables {
    
    public static void main(String[] args) {
//        combiningZip();
//        combiningMerge();
//        combiningStartWith();
        combiningCombineLatest();
    }
    
    /**
     * 用于将两个Observable最近传递的数据通过Func2函数的规则进行组合
     */
    @SuppressWarnings("static-access")
    private static void combiningCombineLatest() {
        Observable<Integer> first = Observable.just(1,3,5);
        Observable<Integer> second = Observable.just(2,4,6);
        
        first.combineLatest(first,second,new Func2<Integer,Integer,Integer>(){
            @Override
            public Integer call(Integer num1, Integer num2) {
                System.out.println("num1 = "+num1 + " num2 = "+num2);
                return num1 + num2;
            }
        }).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                System.out.println("onCompleted()");
            }
            @Override
            public void onError(Throwable arg0) {
                System.out.println("onError()");
            }
            @Override
            public void onNext(Integer str) {
                System.out.println("onNext(): " + str);
            }
        });
    }

    /**
     * 用于在源Observable传递的数据前增加数据
     * 使用startWith(Iterable<T>)，还可以在源Observable传递的数据前增加Iterable
     */
    private static void combiningStartWith() {
        Observable<Integer> first = Observable.just(1,3,5);
        Observable<Integer> second = Observable.just(2,4,6);
        
        first.startWith(second).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                System.out.println("onCompleted()");
            }
            @Override
            public void onError(Throwable arg0) {
                System.out.println("onError()");
            }
            @Override
            public void onNext(Integer str) {
                System.out.println("onNext(): " + str);
            }
        });
    }

    /**
     * 将两个Observable通知的事件序列合并成一个事件序列，就行是一个Observable通知的一样
     * 可以简单的将它理解为两个Observable合并成了一个Observable
     */
    private static void combiningMerge() {
        Observable<Integer> observable1 = Observable.just(1,3,5);
        Observable<Integer> observable2 = Observable.just(2,4,6);
        
        Observable.merge(observable1,observable2).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                System.out.println("onCompleted()");
            }
            @Override
            public void onError(Throwable arg0) {
                System.out.println("onError()");
            }
            @Override
            public void onNext(Integer str) {
                System.out.println("onNext(): " + str);
            }
        });
    }

    /**
     * 用来合并两个Observable传递的数据项，根据Func2函数生成一个新的值并传递出去
     * 当其中一个Observable传递数据结束或者出现异常后，另一个Observable也将停止传递数据
     */
    private static void combiningZip() {
        Observable<Integer> observable1 = Observable.just(10,20,30);
        Observable<Integer> observable2 = Observable.just(4,8,12,16);
        
        Observable.zip(observable1,observable2, new Func2<Integer,Integer,Integer>(){
            @Override
            public Integer call(Integer integer1, Integer integer2) {
                return integer1 + integer2;
            }
        }).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                System.out.println("onCompleted()");
            }
            @Override
            public void onError(Throwable arg0) {
                System.out.println("onError()");
            }
            @Override
            public void onNext(Integer str) {
                System.out.println("onNext(): " + str);
            }
        });
        
    }

    
    
}

    3-6 处理错误

    Error Handling Operators（处理错误）

    Catch
Retry

    第四章：线程控制

    4-1 Java调度器

    Schedulers（调度器）

    调度器（Schedulers）是RxJava以一种及其简单的方式来解决多线程问题机制

    Schedulers（调度器）种类

    io()
    IO相关的操作
    这个调度器用于IO操作
computation()
    进行计算的操作
    这个是计算工作默认的调度器，与IO操作无关
    例如：buffer()、debounce()、delay()、interval()、sample()、skip()
immediate()
    立即执行的操作
    这个调度器允许你立即在当前线程执行你指定的工作
    例如：timeout()、timeInterval()、timestamp()
newThread()
    创建一个新的线程
    它为指定任务启动一个新的线程
trampoline()
    按照顺序进行处理
    调度器会按序处理队列，并运行队列中每一个任务
    例如：repeat()、retry()

    4-2 Android调度器

    AndroidSchedulers

    AndroidSchedulers是RxAndroid库提供在安卓平台的调度器（指定观察者在主线程）

    代码示例

    clipboard.png

    4-3 非阻塞IO操作

    非阻塞IO操作：图片保存

    clipboard.png

    阻塞与非阻塞IO操作比较

    clipboard.png

    4-4 指定线程

    SubscribeOn

    RxJava提供了subscribeOn()方法来用于每个Observable对象

    ObserveOn

    RxJava提供了observeOn()方法来用于每个Subscriber(Observer)对象

    网络请求实例

    clipboard.png

    第五章：课程总结

    5-1 课程总结

    课程总结

    理解响应式编程
清楚RxJava和RxAndroid是什么
了解RxJava各种操作符
了解RxJava扩展的观察者模式与一般观察者模式的区别
了解RxJava线程调度器（Schedulers）
    javarxjava
    本文系转载，阅读原文
    http://www.imooc.com/article/20708
    妙手空空
    1.3k 声望368 粉丝

    博观而约取，厚积而薄发

    « 上一篇
    慕课网_《使用Google Guice实现依赖注入》学习总结
    下一篇 »
    记录_使用JSR303规范进行数据校验

    引用和评论

    推荐阅读
    头像
    基于云效使用Docker实现持续交付（下）

    妙手空空赞 2阅读 5.4k评论 1

    头像
    在Java程序中监听mysql的binlog

    huan1993赞 7阅读 1k

    头像
    Activiti7实战笔记

    Corwien赞 4阅读 11k

    头像
    Just for fun——迅速写完快速排序

    ufdf赞 3阅读 2.3k

    头像
    Java自定义注解实现简单的权限认证

    kexb赞 5阅读 829

    头像
    Spring 实现 3 种异步流式接口，干掉接口超时烦恼

    程序员小富赞 3阅读 1k

    头像
    Bitmap 和 布隆过滤器傻傻分不清？你这不应该啊

    程序员小富赞 5阅读 752

    0 条评论
    得票最新