开刷RxJava(1)

     终于要开始学习Rxjava 和 Retrofit 了，心里有点有点小激动，感觉自己终于开始学一点赶潮流的东西了。自己还是个Android新手，目前还在Android 外围打转，但我相信，凭借自己的毅力一定可以把Android学透的。本篇blog是自己学习Rxjava 的一些感悟和笔记。讲的并不是太详细，有兴趣的大神，可以稍微浏览一下，就当复习。想我一样，对Rxjava不是太知道的同学，可以把代码敲一下。

之前闲扯一下，进入正题。

一、什么是Rxjava 

         两个字：异步

二、简单使用：

   1.Observable 、Observer和Subscribe的使用

//Observable 作为一个被观察者,可以通过Observable的create()方法创建 在里传入一个OnSubscible抽象类，通过Call 方法响应事件
        // onNext产生一个事件,OnCompleted代表事件产生完成
        Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("Hello RxJava");
                subscriber.onNext("Welcom RxJava");
                subscriber.onCompleted();
            }
        });

        //创建一个Observer,作为一个观察者，用于监听Observable的事件。
        Observer<String> observer = new Observer<String>() {
            @Override
            public void onCompleted() {
                Log.d(TAG, "onCompleted() called");
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError() called with: e = [" + e + "]");
            }

            @Override
            public void onNext(String s) {
                Log.d(TAG, "onNext() called with: s = [" + s + "]");
            }
        };

        //订阅事件 通过subscribe
        observable.subscribe(observer);
    }</span>

  也可以这样使用

//just里面传入一个参数列表
        Observable.just("Hello RxJava","Welocome RxJava")
                .subscribe(new Observer<String>() {
                    @Override
                    public void onCompleted() {
                        Log.d(TAG, "onCompleted() called");
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "onError() called with: e = [" + e + "]");
                    }

                    @Override
                    public void onNext(String s) {
                        Log.d(TAG, "onNext() called with: s = [" + s + "]");
                    }
                });</span>

代码输出：

 D/MainActivity: onNext() called with: s = [Hello RxJava]
 D/MainActivity: onNext() called with: s = [Welocome RxJava]
 D/MainActivity: onCompleted() called</span>

  2、 Action1的使用

  subscribe方法有一个重载版本，接受三个Action1类型的参数，分别对应OnNext，OnComplete， OnError函数。

所以代码也可以写成这样：

 Observable.just("RxJava","Welocome RxJava")  
    .subscribe(new Action1<String>() {  
        @Override  
        public void call(String s) {  
             Log.m(TAG,s) //输出时一样的
        }  
    });  </span>

3、变换 

让我们做一些更有趣的事情吧！
比如我想在hello world中加上我的签名，你可能会想到去修改Observable对象：

[java]  view plain  copy

1. Observable.just("Hello, world! -Dan")  
2.     .subscribe(s -> System.out.println(s));  

如果你能够改变Observable对象，这当然是可以的，但是如果你不能修改Observable对象呢？比如Observable对象是第三方库提供的？比如我的Observable对象被多个Subscriber订阅，但是我只想在对某个订阅者做修改呢？
那么在Subscriber中对事件进行修改怎么样呢？比如下面的代码：

[java]  view plain  copy

1. Observable.just("Hello, world!")  
2.     .subscribe(s -> System.out.println(s + " -Dan"));  

这种方式仍然不能让人满意，因为我希望我的Subscribers越轻量越好，因为我有可能会在mainThread中运行subscriber。另外，根据响应式函数编程的概念，Subscribers更应该做的事情是“响应”，响应Observable发出的事件，而不是去修改。如果我能在某些中间步骤中对“Hello World！”进行变换是不是很酷？

操作符（Operators）

操作符就是为了解决对Observable对象的变换的问题，操作符用于在Observable和最终的Subscriber之间修改Observable发出的事件。RxJava提供了很多很有用的操作符。
比如map操作符，就是用来把把一个事件转换为另一个事件的。

[java]  view plain  copy

1. Observable.just("Hello, world!")  
2.   .map(new Func1<String, String>() {  
3.       @Override  
4.       public String call(String s) {  
5.           return s + " -Dan";  
6.       }  
7.   })  
8.   .subscribe(s -> System.out.println(s));  

使用lambda可以简化为

[java]  view plain  copy

1. Observable.just("Hello, world!")  
2.     .map(s -> s + " -Dan")  
3.     .subscribe(s -> System.out.println(s));  

是不是很酷？map()操作符就是用于变换Observable对象的，map操作符返回一个Observable对象，这样就可以实现链式调用，在一个Observable对象上多次使用map操作符，最终将最简洁的数据传递给Subscriber对象。

map操作符进阶

map操作符更有趣的一点是它不必返回Observable对象返回的类型，你可以使用map操作符返回一个发出新的数据类型的observable对象。
比如上面的例子中，subscriber并不关心返回的字符串，而是想要字符串的hash值

[java]  view plain  copy

1. Observable.just("Hello, world!")  
2.     .map(new Func1<String, Integer>() {  
3.         @Override  
4.         public Integer call(String s) {  
5.             return s.hashCode();  
6.         }  
7.     })  
8.     .subscribe(i -> System.out.println(Integer.toString(i)));  

很有趣吧？我们初始的Observable返回的是字符串，最终的Subscriber收到的却是Integer，当然使用lambda可以进一步简化代码：

[java]  view plain  copy

1. Observable.just("Hello, world!")  
2.     .map(s -> s.hashCode())  
3.     .subscribe(i -> System.out.println(Integer.toString(i)));  

前面说过，Subscriber做的事情越少越好，我们再增加一个map操作符

[java]  view plain  copy

1. Observable.just("Hello, world!")  
2.     .map(s -> s.hashCode())  
3.     .map(i -> Integer.toString(i))  
4.     .subscribe(s -> System.out.println(s));  

     今天就到这吧！

给出两个学习RxJava的网址

http://blog.csdn.net/lzyzsd/article/details/41833541/

http://gank.io/post/560e15be2dca930e00da1083#toc_1