综合开源框架之RxJava/RxAndroid

* 一种帮助做异步的框架. 类似于 AsyncTask. 但其灵活性和扩展性远远强于前者.
* 主页: https://github.com/ReactiveX/RxJava

* 中文资料:
* https://github.com/lzyzsd/Awesome-RxJava

* https://www.zhihu.com/question/35511144

* 用途:
* 异步操作
* 在程序逻辑异常复杂的情况下,仍然可以让代码的逻辑保持简洁

* 配置: 添加依赖:
* compile 'io.reactivex:rxjava:1.1.3'
* compile 'io.reactivex:rxandroid:1.1.0'

---

基本概念:
1. 被观察者: Observable
　　* 作用: 决定什么时候触发事件以及触发怎样的事件
　　* 创建方法:
　　　　* Observable.just(T...) 参数为单个的
　　　　* Observable.from(T[]) / Observable.from(Iterable<? extends T>) 参数为数组或Iterable
2. 观察者: Observer
　　* 作用: 当事件触发的时候将有怎样的行为
　　* 实现类有Observer / Subscriber
3. 订阅: subscribe
　　* 作用: 把Observable和Observer关联起来
　　* 方法:
　　　　* observable.subscribe(observer);
　　　　* observable.subscribe(subscriber);
4. 事件:
　　* onNext()：普通事件
　　* onCompleted():事件队列完结
　　* onError(): 事件队列异常
　　* 需要注意的是onCompleted()和onError()是互斥的.调用了其中一个就不应该触发另一个.

---

1、创建Observable对象

 Observable<String> myObservable = Observable.create(  
  new Observable.OnSubscribe<String>() {  
   @Override  
   public void call(Subscriber<? super String> sub) {  
    sub.onNext("Hello, world!"); //通知订阅者
    sub.onCompleted();  
   }  
  }  
 );

2、创建一个Subscriber来处理Observable对象发出的字符串
 

Subscriber<String> mySubscriber = new Subscriber<String>() {  
  @Override  
  public void onNext(String s) { System.out.println(s); }  
   
  @Override  
  public void onCompleted() { }  
   
  @Override  
  public void onError(Throwable e) { }  
}; 

3、将定义的myObservable对象和mySubscriber对象关联起来，这样就完成了subscriber对observable的订阅。

myObservable.subscribe(mySubscriber);

简化版：

Observable<String> myObservable = Observable.just("Hello, world!");
 Action1<String> onNextAction = new Action1<String>() {  
  @Override  
  public void call(String s) {  
   System.out.println(s);  
  }  
 }; 
 myObservable.subscribe(onNextAction); 

最终简化版：

 Observable.just("Hello, world!")  
     .subscribe(new Action1<String>() {  
     @Override  
     public void call(String s) {  
        System.out.println(s);  
     }  
 });

---

示例代码:

1. 现有一个数组 String[] arr ={"afdsa", "bfdsa", "cfda"}, 把其中以字母"a"开头的字符串找出来并加上"from Alpha",最后打印出新的字符串的长度

Observable
        .from(arr)
        .filter(new Func1<String, Boolean>() {
            @Override
            public Boolean call(String s) {
                return s.startsWith("a");
            }
        })
        .map(new Func1<String, String>() {
            @Override
            public String call(String s) {
                return s + " from Alpha";
            }
        })
        .subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                System.out.println("Rxjava:" + s.length());
            }
        });
//原始Java代码
for (int i = 0; i < arr.length; i++) {
    String temp = arr[i];
    if (temp.startsWith("a")) {
        temp += " from Alpha";
        System.out.println("Normal:" + temp.length());
    }

}

 由指定的一个 drawable 文件 id 取得图片，并显示在 ImageView 中，并在出现异常的时候打印 Toast 报错：

ImageView iv = (ImageView) findViewById(R.id.imageView);
    Observable.just(R.mipmap.ic_launcher)
            .subscribeOn(Schedulers.io()) //运行在子线程中
            .map(new Func1<Integer, Drawable>() {
                @Override
                public Drawable call(Integer integer) {
                    return getResources().getDrawable(integer);
                }
            })
            .observeOn(AndroidSchedulers.mainThread()) //运行在主线程中
            .subscribe(new Action1<Drawable>() {
                @Override
                public void call(Drawable drawable) {
                    iv.setImageDrawable(drawable);
                }
            });
}

6. Scheduler
* 作用: 控制线程.指定某一段代码在那个线程里运行.
* 内置的Scheduler:
* Schedulers.immediate(): 直接在当前线程运行，相当于不指定线程。这是默认的 Scheduler。
* Schedulers.newThread(): 总是启用新线程，并在新线程执行操作。
* Schedulers.io(): I/O 操作（读写文件、读写数据库、网络信息交互等）所使用的 Scheduler。行为模式和 newThread() 差不多，区别在于 io() 的内部实现是是用一个无数量上限的线程池，可以重用空闲的线程，因此多数情况下 io() 比 newThread() 更有效率。不要把计算工作放在 io() 中，可以避免创建不必要的线程。
* Schedulers.computation(): 计算所使用的 Scheduler。这个计算指的是 CPU 密集型计算，即不会被 I/O 等操作限制性能的操作，例如图形的计算。这个 Scheduler 使用的固定的线程池，大小为 CPU 核数。不要把 I/O 操作放在 computation() 中，否则 I/O 操作的等待时间会浪费 CPU。

* AndroidSchedulers.mainThread(): Android专用,它指定的操作将在 Android 主线程运行。

* 指定线程的方法:
* Observable.subscribeOn():指定 subscribe() 所发生的线程。
subscribeOn(Schedulers.io())
* Observable.observeOn():指定 Subscriber 所运行在的线程。
observeOn(AndroidSchedulers.mainThread())

7. 数据变换:
* 作用: 就是将事件序列中的对象或整个序列进行加工处理，转换成不同的事件或事件序列
* Observable.map: 一对一的转换

private void simpleDemo() {
           Observable
                   .just(R.mipmap.ic_launcher)
                   .map(new Func1<Integer, Drawable>() {
                       @Override
                       public Drawable call(Integer integer) {
                           return getResources().getDrawable(integer);
                       }
                   })
                   .subscribe(new Action1<Drawable>() {
                       @Override
                       public void call(Drawable drawable) {
                           imageView.setImageDrawable(drawable);
                       }
                   });
       }

---