rxJava学习

1. rxJava的核心是异步，最终目的是实现后台处理，前台回调的异步机制;
2. rxJava的四个基本概念：Observable(可观察者，即被观察者)，Observer或者Subscriber(观察者)，subscribe(订阅)，事件；Observable.subscribe(Observer)，由此两者之间实现订阅关系；
   代码解析订阅关系是如何实现的：

           //被观察对象
           Observable observable = Observable.create(new Observable.OnSubscribe<String>() {
               @Override
               public void call(Subscriber<? super String> subscriber) {
                   subscriber.onNext("你好");
               }
           });
           //观察者
           Subscriber<String> subscriber = new Subscriber<String>() {
               @Override
               public void onCompleted() {
   
               }
   
               @Override
               public void onError(Throwable e) {
   
               }
   
               @Override
               public void onNext(String s) {
                   Log.i(TAG, s);
               }
           };
           //确立订阅关系
           observable.subscribe(subscriber);

   
   
   
   
3. observable.subscribe(subscriber);的内部实现是这样的（仅核心代码）：

   // 注意：这不是 subscribe() 的源码，而是将源码中与性能、兼容性、扩展性有关的代码剔除后的核心代码。
   public Subscription subscribe(Subscriber subscriber) {
       subscriber.onStart();
       onSubscribe.call(subscriber);
       return subscriber;
   }

   可以看到，传入的subscriber被作为Observable的call的参数，而call方法里面，subscriber调用了自身的onNext方法，因此会打印出“你好”。至此，便可以理解，观察者订阅被观察者后，被观察者有所动作（实际就是调用观察者的方法）就会通知到观察者了。
4. 操作符

          map(): 可以将一个对象进行加工处理，转换成另一种对象

                Observable.just("images/logo.png") // 输入类型 String
                .map(new Func1<String, Bitmap>() {
                    @Override
                    public Bitmap call(String filePath) { // 参数类型 String
                        return getBitmapFromPath(filePath); // 返回类型 Bitmap
                    }
                })
                .subscribe(new Action1<Bitmap>() {
                    @Override
                    public void call(Bitmap bitmap) { // 参数类型 Bitmap
                        showBitmap(bitmap);
                    }
                });

           flatMap()：非常好用的一个操作符，它可以返回任何它想返回的Observale对象，用于类似多层嵌套网络请求的情况再好不过了。     

       @GET("/token")
        public void getToken(Callback<String> callback);

        @GET("/user")
        public void getUser(@Query("token") String token, @Query("userId") String userId, Callback<User> callback);

        ...

        getToken(new Callback<String>() {
            @Override
            public void success(String token) {
                getUser(token, userId, new Callback<User>() {
                    @Override
                    public void success(User user) {
                        userView.setUser(user);
                    }

                    @Override
                    public void failure(RetrofitError error) {
                        // Error handling
                        ...
                    }
                };
            }

            @Override
            public void failure(RetrofitError error) {
                // Error handling
                ...
            }
        });

               顺便说一下 Observable.from()方法， 它接收一个集合作为输入，然后每次输出一个元素给subscriber。