RxJava 初探

最新推荐文章于 2025-12-11 10:50:13 发布

原创最新推荐文章于 2025-12-11 10:50:13 发布 · 460 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#响应式 #rxjava

rxjava 专栏收录该内容

2 篇文章

订阅专栏

1.RxJava 简介

Rx(reactive extensions)，是响应式编程的意思，是以观察者（Observer）和被观察者（Observable）为基础的异步响应的。一个观察者(Observer)订阅一个可观察对象(Observable)。观察者对Observable发射的数据或数据序列作出响应。

2.基本概念

RxJava有四个基本概念：Observable（被观察者）、Observer（观察者）、subscribe（订阅）、事件。

2.1 创建Observer

Observer 即是观察者，它决定事件触发的时候将有怎么样的行为。

2.2 创建Observable

Observable 它决定什么时候触发事件以及触发什么样的事件。RxJava使用create()方法来创建一个Observable，并定义触发规则。

2.3 Subscribe（订阅）

创建了Observable 和Observer之后，再用subscribe() 方法将两者关联起来。订阅方法subscribe() 除了 subscribe(Subscriber) 以外，还可以自定义自己的Action(RxJava中的一个接口，它只有一个无参call（）方法，且无返回值）

3.Demo

简单的Demo

import rx.Observable;
import rx.Observer;
import rx.Subscriber;


/**
 * Created by hsc on 17/1/7.
 */
public class Demo {
    public static void main(String[] args) {

        //被观察者
        Observable<String> observable=Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                //如果还是订阅关系
                if(!subscriber.isUnsubscribed())
                {
                    subscriber.onNext("hello world");
                    subscriber.onCompleted();
                }
            }
        });
        //观察者
        Observer<String> observer=new Observer<String>() {
            @Override
            public void onCompleted() {

                System.out.println("task is end");
            }

            @Override
            public void onError(Throwable e) {
                System.out.println("task exception"+e);
            }

            @Override
            public void onNext(String data) {
                System.out.println(data);
            }
        };
        //二者产生关联
        observable.subscribe(observer);
    }
}

或者写成下面这样

import rx.Observable;
import rx.Observer;
import rx.Subscriber;


/**
 * Created by hsc on 17/1/7.
 */
public class Demo {
    public static void main(String[] args) {

        //被观察者
        Observable<String> observable=Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                //如果还是订阅关系
                if(!subscriber.isUnsubscribed())
                {
                    subscriber.onNext("hello world");
                    subscriber.onCompleted();
                }
            }
        });
        //观察者 Subscriber 是个抽象类其实现了Observer接口
        Subscriber<String> subscriber=new Subscriber<String>() {
            @Override
            public void onCompleted() {
                System.out.println("task is end");
            }

            @Override
            public void onError(Throwable e) {
                System.out.println("task exception"+e);
            }

            @Override
            public void onNext(String data) {
                System.out.println(data);
            }
        };
        //二者产生关联
        observable.subscribe(subscriber);
    }
}

Observable#subscribe方法

    public final Subscription subscribe(final Observer<? super T> observer) {
        if (observer instanceof Subscriber) {
            return subscribe((Subscriber<? super T>)observer);
        }
        return subscribe(new Subscriber<T>() {

            @Override
            public void onCompleted() {
                observer.onCompleted();
            }

            @Override
            public void onError(Throwable e) {
                observer.onError(e);
            }

            @Override
            public void onNext(T t) {
                observer.onNext(t);
            }

        });
    }

从源码中可以看出subscribe 过程中，Observer 也总是会先被转换成一个 Subscriber 再使用。
Observable.subscribe(Subscriber) 的内部实现是这样的（部分核心代码）：

    public final Subscription subscribe(Subscriber<? super T> subscriber) {
        subscriber.onStart();
//做一个保护调用
        if (!(subscriber instanceof SafeSubscriber)) 
            subscriber = new SafeSubscriber<T>(subscriber);
        }

            hook.onSubscribeStart(observable, observable.onSubscribe).call(subscriber);
            return hook.onSubscribeReturn(subscriber);
    }

可以看到，subscriber() 做了以下几件事
1.调用 Subscriber.onStart() ，可以在消息还未发射前调用。（默认调用不执行任何操作）代码块高亮
2.做一个保护调用，使用SafeSubscriber 对subscriber进行了包装。
3.调用 Observable 中的 OnSubscribe.call(Subscriber) 。在这里，事件发送的逻辑开始运行。从这也可以看出，在 RxJava 中， Observable 并不是在创建的时候就立即开始发送事件，而是在它被订阅的时候，即当 subscribe() 方法执行的时候。RxJavaObservableExecutionHook中针对RxJava的subscribe流程进行注入,方便自己更改相关逻辑, 当然对于默认的RxJavaObservableExecutionHook,你会发现他并没有做任何处理,如果你想自己实现可以调用RxJavaPlugin.getInstance() 设置自定义Hook。
4.将传入的 Subscriber 作为 Subscription 返回。这是为了方便 unsubscribe().

Rxjava 还提供了一系列的操作from、just等，将其它种类的对象和数据类型转换为Observable。

public class DemoFrom {
    public static void main(String[] args) {
        Integer [] data={1 ,2 ,3};
        Observable observable=Observable.from(data);
        //会依次将数据发送出去
        /**
         *    subscriber.onNext(1);
         *    subscriber.onNext(2);
         *    subscriber.onNext(3);
         */
        observable.subscribe(new Action1() {
            @Override
            public void call(Object o) {
                System.out.println(o.toString());
            }
        });
    }
}

4.总结

总结：其实说了这么多，你会发现上面给出的实例都是同步的，并不是异步调用的。要想实现异步调用要借助RxJava提供Scheduler。
异步调用简单demo：

package com.hsc;

import rx.Observable;
import rx.Subscriber;
import rx.schedulers.Schedulers;


/**
 * Created by hsc on 17/1/7.
 */
public class Demo {
    public static void main(String[] args) throws Exception{

        //被观察者
        Observable<String> observable=Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                //如果还是订阅关系
                if(!subscriber.isUnsubscribed())
                {
                    try {
                        Thread.sleep(2000);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    subscriber.onNext("hello world");
                    subscriber.onCompleted();;
                }
            }
        }).subscribeOn(Schedulers.io()); //使用调用器线程执行

        Subscriber<String> subscriber=new Subscriber<String>() {
            @Override
            public void onCompleted() {
                System.out.println("task is end");
            }

            @Override
            public void onError(Throwable e) {
                System.out.println("task exception"+e);
            }

            @Override
            public void onNext(String data) {
                System.out.println(data);
            }
            @Override
            public void onStart()
            {
                System.out.println("注意观察者开始观察了");
            }
        };
        //二者产生关联
        observable.subscribe(subscriber);
        System.out.println("start");
        Thread.sleep(3000);
        System.out.println("over");
    }
}