关于RxJAVA的一下理解

1.被观察者的几种创建放肆

1.Observable  observable = Observable.create(new Observable.OnSubscibe<Object>(){

public void call(Subscriber<? super String> subscriber){

subscriber.onNext(“”);

subscriber.onCompleted();

}

});

2.Observable observable = Observable.just(“aa”,”vv”,”cc”);

3.String[] words = {“sd”,”ds”,”ds};

Observable observable = Observable.from(words);

4.订阅方式创建：Observable.subscribe(Observer); Observable.subscribe(Subscriber);

5.除了订阅方式创建：还支持不完整的定义回调：

Observabler observable = null;

1.Action1<String> onNextAction = new Action1<String>(){

public void call(String s){

}

}

2.Action1<Throwable> onErrorAction  = new Action1<Throwable>{

public void call(Throwable){}

}

3.Action0 onCompleteAction = new Action0(){

public void call(){}

}

observable.subscribe(onNextAction);

observable.subscribe(onNextAction,onErrorAction,onCompleteAction);

// 自动创建 Subscriber ，并使用 onNextAction 和 onErrorAc tion 来定义 onNext() 和 onError()

2.在Observable上添加线程控制让耗时操作放在io线程中。操作ui的放在主线程中

Observable.just(1, 2, 3, 4)

    .subscribeOn(Schedulers.io()) // 指定 subscribe() 发生在 IO 线程

    .observeOn(AndroidSchedulers.mainThread()) // 指定 Subscriber 的回调发生在主线程

    .subscribe(new Action1<Integer>() {

        @Override

        public void call(Integer number) {

            Log.d(tag, "number:" + number);

        }

    });

**在使用线程操作的时候。我们可以在执行subscribe之后调用执行者subscribeOn(Schedulers.io())，在操作结束后让观察者操作的时候调用observeOn(AndroidSchedulers.mainThread());

3.在被观察者把要处理的事件交给观察者时，我们可以做在中间做一些其他的操作。那就是变换的过程。

1.map的例子

1.比如被观察者传过来的是一个图片的路径，我们可以在中间做一下操作，把传来的路径。转换成bitmap形式，再传给观察者

如：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);

        }

    });

可以从上面看出，这里出现了一个Func1的类，它和Action1非常相似。但又完全不同。他有返回值。

2.第二种变换方式flatMap();

1.这是一个很有用但非常难理解的变换，因此我决定花多些篇幅来介绍它。 首先假设这么一种需求：假设有一个数据结构『学生』，现在需要打印出一组学生的名字。实现方式很简单

Student[] students = ...;

Subscriber<String> subscriber = new Subscriber<String>() {

    @Override

    public void onNext(String name) {

        Log.d(tag, name);

    }

    ...

};

Observable.from(students)

    .map(new Func1<Student, String>() {

        @Override

        public String call(Student student) {

            return student.getName();

        }

    })

    .subscribe(subscriber);

2.很简单。那么再假设：如果要打印出每个学生所需要修的所有课程的名称呢？（需求的区别在于，每个学生只有一个名字，但却有多个课程。）首先可以这样实现：

Student[] students = ...;

Subscriber<Student> subscriber = new Subscriber<Student>() {

    @Override

    public void onNext(Student student) {

        List<Course> courses = student.getCourses();

        for (int i = 0; i < courses.size(); i++) {

            Course course = courses.get(i);

            Log.d(tag, course.getName());

        }

    }

    ...

};

Observable.from(students)

    .subscribe(subscriber);

3.依然很简单。那么如果我不想在 Subscriber 中使用 for 循环，而是希望 Subscriber 中直接传入单个的 Course 对象呢（这对于代码复用很重要）？用 map() 显然是不行的，因为 map() 是一对一的转化，而我现在的要求是一对多的转化。那怎么才能把一个 Student 转化成多个 Course 呢？

这个时候，就需要用 flatMap() 了：

Student[] students = ...;

Subscriber<Course> subscriber = new Subscriber<Course>() {

    @Override

    public void onNext(Course course) {

        Log.d(tag, course.getName());

    }

    ...

};

Observable.from(students)

    .flatMap(new Func1<Student, Observable<Course>>() {

        @Override

        public Observable<Course> call(Student student) {

            return Observable.from(student.getCourses());

        }

    })

    .subscribe(subscriber);

解释一下：他就是相当于把获取的student[]数组然后分开，然后在转换成一个集合的形式，即课程的集合。然后让subscribe观者者先执行每个课程的打印，这样就形成了上面的for循环。让代码看起来更简单了

4.当然我们现在要举个小例子了。在Android中要如何才能更好的使用呢。

  1.与retrofit的结合使用

1.传统的使用方式：retrofit提供了一个传统的CallBack的方法我们可以平常是这样使用的

@Get(“/User”)

public void getUser(@Query(“userId”) String userId,CallBack<User> callBack);

然后我们在程序中调用肯定是这样的，传一个userId然后是先他里面的借口

getUser(userId, new Callback<User>() {

    @Override

    public void success(User user) {

        userView.setUser(user);

    }

    @Override

    public void failure(RetrofitError error) {

        // Error handling

        ...

    }

};

2.用RxJava的使用方式

@Get(“/User”)

public Observable<User> getUser(@Query(“UserId” String userId));

这样我们调用的时候就少了回调接口 了

getUser（userId）

.observenOn(AndroidSchedulers.mainThread())

.Subscribe(new Observer<User>(){

public void onNext(User user){}

public void onCompleted(){}

})

这样是不是使用起来就比较简单了呢！！！！