轮询的一种解决方案（RxJava）

*本篇文章已授权微信公众号 guolin_blog （郭霖）独家发布

轮询的功能很常见了，之前Android中比较常用的方式就是通过Handler来实现，发送一个Deley消息，在handlerMessage再根据条件发送消息，这种方式需要小心内存泄漏，需要自己处理这个问题。这个不是我们今天的重点，今天来看下另外一种轮询的实现方式，通过RxJava来实现。有下面两个特点：

1 自动解除轮询和订阅关系，没有内存泄漏的风险；
2 可以跟Activity或者Fragment生命周期绑定，自动停止轮询

涉及到的RxJava知识点：

1.Subject
2.takeUntil
3 filter
4 compose

因为后面很多逻辑用到上面的操作符，所以先简单看下这几个操作符，热热身。

1.Subject

从代码可以看出来Subject既可以当观察者也可以当被观察者。

public abstract class Subject<T> extends Observable<T> implements Observer<T>

所以可以在生命周期中通过Subject发送事件然后又自己接收，从而根据事件类型做相应的操作。

Subject总共有四种类型

1 AsyncSubject
2 BehaviorSubject
3 PublishSubject
4 ReplaySubject

今天我们就说下第二种类型BehaviorSubject,它可以给订阅者发送订阅前最近的事件和订阅后发送的事件：

图中橙色的就是订阅前最近发送的事件，在订阅后也可以收到。文字解释始终太苍白，我们来看下代码：

BehaviorSubject<Integer> behaviorSubject = BehaviorSubject.create();        behaviorSubject.onNext(1);        behaviorSubject.onNext(2);        behaviorSubject.subscribe(new Consumer<Integer>() {            @Override            public void accept(Integer integer) throws Exception {                Timber.tag(TAG).d("running num : " + integer);            }        });        behaviorSubject.onNext(3);        behaviorSubject.onNext(4);

上面代码运行结果就是收到2， 3，4

2.takeUntil

这是一个操作符，可以这样用

AObservable.takeUntil(BObservable)

可以AObservable监听另外一个BObservable，如果BObservable开始发送数据，AObservable就不再发送数据。
看一下官方的图片解释,B发送0数据后，A就停止发送数据了。

talk is cheap, show me the code:

Observable.interval(1, TimeUnit.SECONDS).           subscribeOn(Schedulers.io()).           takeUntil(Observable.timer(5, TimeUnit.SECONDS)).           subscribe(new Consumer<Long>() {                @Override                public void accept(Long num) throws Exception {                    Timber.tag(TAG).d("running num : " + num);                }            });

上面代码的意思就是从0开发每隔1秒发送一个数据，5s时停止发送，看下运行结果，和我们的预期完美一致：

3.filter

filter操作符就是过滤的意思，只有事件满足过滤条件时被观察者才会发送给观察者。看下官方的解释图，很清晰明了我就不做解释了哈。

看一下怎么用,这个代码的意思还是每个1s发送数据，但是会进行过滤只发送偶数，也是5秒后停止发送：

Observable.interval(1, TimeUnit.SECONDS).                subscribeOn(Schedulers.io()).                filter(new Predicate<Long>() {                    @Override                    public boolean test(Long aLong) throws Exception {                        return aLong % 2 == 0;                    }                }).                takeUntil(Observable.timer(5, TimeUnit.SECONDS)).                subscribe(new Consumer<Long>() {                    @Override                    public void accept(Long num) throws Exception {                        Timber.tag(TAG).e("running num : " + num);                    }                });

上面代码的运行效果，确实是只收到了偶数。

4.compose

compose操作符是用来对Observable进行转换操作的，并且可以保证调用链不被破坏。
比如我们经常这样用：

Observable.interval(1,TimeUnit.SECONDS)                .subscribeOn(Schedulers.io()).                observeOn(AndroidSchedulers.mainThread())；

这部分代码经常写，怎么进行封装呢？可能有的小伙伴立马就想到下面的方法：

private Observable composeObservable(Observable observable){        return observable.subscribeOn(Schedulers.io()).                        observeOn(AndroidSchedulers.mainThread());}

但是上面这样用就破坏了调用链了，因为你肯定得这样调用,这样就会变得怪怪的，不是Observable开头了，变成函数开头。

composeObservable(Observable.interval(1,TimeUnit.SECONDS)).subscribe(new Consumer<Long>() {            @Override            public void accept(Long aLong) throws Exception {            }});

这个问题用compose就可以完美解决：

Observable.interval(1, TimeUnit.SECONDS).                compose(bindUntil(5)).                subscribe(new Consumer<Long>() {                    @Override                    public void accept(Long num) throws Exception {                        Timber.tag(TAG).d("running num : " + num);                    } });private ObservableTransformer<Long, Long> bindUntil(final long deleyTime) {        return new ObservableTransformer<Long, Long>() {            @Override            public ObservableSource<Long> apply(Observable<Long> upstream) {                return upstream.subscribeOn(Schedulers.io()).takeUntil(Observable.timer(deleyTime, TimeUnit.SECONDS));            }        };}

操作符就到这了，需要详细了解的小伙伴可以自行参考官方文档哈。下面进入我们的正文，首先看下怎么使用。

5.使用

目前有两种使用方式

1.bindIntervalEvent就是绑定事件进行轮询，事件发生时将停止轮询
2.bindLifeCycle,就是绑定生命周期，在指定生命周期发生时停止轮询

在开始之前我们先定义事件Event,其中FragmentEvent对应Fragment的生命周期，ActivityEvent 对应Activity的生命周期，BizEvent对应我们自定义的事件：

INTERVAL就是对应RxJava中的interval操作符产生的周期事件，可以制定轮询间隔；
TIMER就是对应的timer事件，可以制定多长事件后产生一个事件；
STOP就是停止事件，这个是自定义的；
ALL可以匹配所有事件。

public interface Event {    enum FragmentEvent implements EventInterface{        ATTACH,        CREATE,        CREATE_VIEW,        START,        RESUME,        PAUSE,        STOP,        DESTROY_VIEW,        DESTROY,        DETACH    }    enum ActivityEvent implements EventInterface{        CREATE,        START,        RESUME,        PAUSE,        STOP,        DESTROY    }    enum BizEvent implements EventInterface{        INTERVAL,        TIMER,        STOP,        ALL    }}

talk is cheap, show me the code, 使用起来也很简单，首先看下第一种的使用,在Activity中添加两个按钮，一个开始轮询，一个停止轮询，布局太简单了就不贴代码了哈，看下重点代码：

private static final String TAG = MainActivity.class.getSimpleName() + "_POLLING";//开启轮询PollingManager.getInstance().bindIntervalEvent(1, TAG, Event.BizEvent.INTERVAL, null);//停止轮询PollingManager.getInstance().stopPolling(TAG, Event.BizEvent.INTERVAL);

看下日志打印情况，接收到INTERVAL事件后就停止轮询了。

接着看下第二种使用方式，有两个步骤：

1.继承BaseActivity,其中接口LifeInterface需要自己实现

public abstract class BaseActivity extends Activity implements  LifeInterfacepublic interface LifeInterface {    void bindLife();    String getTag();}

2.在需要轮询的Activity实现接口LifeInterface的两个方法，看下例子：

@Overridepublic String getTag() {     return TAG;}@Overridepublic void bindLife() {     PollingManager.getInstance().bindLifeCycle(getTag(), Event.ActivityEvent.PAUSE); }

上面这个例子监听PAUSE事件，在Activity进入onPause时会停止轮询，看下日志打印情况：

完全符合我们的预期哈。
下面我们来看下代码实现。

6.PollingManager

主要逻辑在PollingManager中，这个是这个工具的门面，有点类似于外观模式。

首先是单例模式,activeSubjectMap是Subject的仓库，所有注册的轮询Model保存的地方。

    private HashMap<String, SubjectModel<EventInterface>> activeSubjectMap;    private static PollingManager manager;    private PollingManager() {        activeSubjectMap = new HashMap<>();    }    public static PollingManager getInstance() {        if (null == manager) {            synchronized (PollingManager.class) {                if (null == manager) {                    manager = new PollingManager();                }            }        }        return manager;    }

对上面的轮询Model进行下说明，每个Model封装了轮询器，RxJava订阅关系disposable和Subject。disposable就是用来停止轮询的时候解除订阅关系防止内存泄漏。

    //Subject    private BehaviorSubject<T> behaviorSubject;    //订阅关系    private Disposable disposable;    //轮询器    private PollingRequest pollingRequest;    public void clearSubject(){        if (null == disposable || disposable.isDisposed()) return;        disposable.dispose();    }

每个轮询需要做的工作可以抽象出来就是上面的PollingRequest,注释比较清楚就不说了，每个PollingRequest对外接口就是execute，其中doAction是在每个轮询到的时候会进行调用。

public abstract class PollingRequest {    //每个Subject的唯一标识    protected String tag;    //事件接口    protected EventInterface eventInterface;    //轮询动作    protected PollingAction pollingAction;    public PollingRequest(String tag, EventInterface eventInterface, PollingAction pollingAction) {        this.tag = tag;        this.eventInterface = eventInterface;        this.pollingAction = pollingAction;    }    public abstract Disposable execute(PollingManager pollingManager);    public String getTag() {        return tag;    }    public EventInterface getEventInterface() {        return eventInterface;    }}public interface PollingAction {    void doAction(Object accept);}

看下IntervalPolling的实现方式,逻辑也比较简单，就是每隔intevals进行轮询，轮询间隔会调用doAction完成动作。

public class IntervalPolling extends PollingRequest {    private int inteval;    public IntervalPolling(int interval, String tag, EventInterface eventInterface, PollingAction action) {        super(tag, eventInterface, action);        this.inteval = interval;    }    @Override    public Disposable execute(PollingManager manager) {        return Observable.interval(inteval, TimeUnit.SECONDS).                compose(manager.composeEvent(tag, eventInterface)).                observeOn(AndroidSchedulers.mainThread()).                doOnNext(new Consumer<Long>() {                    @Override                    public void accept(Long aLong) throws Exception {                        Timber.tag(Constants.TAG).d("emit interval polling, Tag = " + tag + ", num = " + aLong);                    }                }).                subscribe(new Consumer<Long>() {                    @Override                    public void accept(Long num) throws Exception {                        if (null != pollingAction) {                            pollingAction.doAction(num);                        }                        Timber.tag(Constants.TAG).d("running interval polling, Tag = " + tag + ", num = " + num);                    }                });    }}

上面可能比较费解的逻辑就是这一行：

compose(manager.composeEvent(tag, eventInterface))

调用PollingManager中的composeEvent方法，跟进去看看：

public ObservableTransformer<Long, Long> composeEvent(final String tag, final EventInterface outEvent) {        BehaviorSubject<EventInterface> subject = getSubject(tag);        if (null == subject) {            Timber.tag(Constants.TAG).e("subject = null");            return new EmptyObservableTransformer();        }        final Observable observable = subject.filter(new Predicate<EventInterface>() {            @Override            public boolean test(EventInterface event) throws Exception {                Timber.tag(Constants.TAG).i("receive event: %s", event);                boolean filter = outEvent == event || event == ALL;                if (filter) clearSubject(tag);                return filter;            }        });        return new ObservableTransformer<Long, Long>() {            @Override            public ObservableSource<Long> apply(Observable<Long> upstream) {                return upstream.subscribeOn(Schedulers.io()).takeUntil(observable);            }        };}

首先就是takeUntil操作符，当Subject发送数据时， IntervalPolling就会停止轮询；
Subject什么时候发送数据？就是在subject.filter返回真的时候。Subject会根据接收到的Event和订阅时的Event进行相等，或者接收到的事件是ALL都会返回真。

其实上面的逻辑需要对RxJava有一定的了解，这个不在本文的范围，小伙伴们自行网上查阅哈。

轮询器，Model和触发条件都有了，剩下的问题就是创建启动和销毁的问题了，先看下创建。

7.创建启动

先看下第一种绑定事件的创建方式：

public BehaviorSubject<EventInterface> bindIntervalEvent(int interval, @NonNull String tag, @NonNull EventInterface eventInterface, PollingAction action){        //1.创建轮询器        IntervalPolling intervalPolling = new IntervalPolling(interval, tag, eventInterface, action);        //2.创建Subject        createSubject(intervalPolling);        //3.启动轮询        startPolling(tag);        //4.返回Subject        return activeSubjectMap.get(tag).getBehaviorSubject();    }

逻辑比较简单哈，其中第二步创建Subject时会将Subject和轮询器缓存到HashMap<String, SubjectModel<EventInterface>> activeSubjectMap;,其中key就是Subject的唯一标识tag。

生命周期的创建方式也是一样的四个步骤，唯一不一样的就是这里轮询器是生命周期轮询器。

public BehaviorSubject<EventInterface> bindLifeCycle(@NonNull String tag,@NonNull EventInterface eventInterface){        //1.创建轮询器        PollingRequest request = new LifePolling(tag, eventInterface, null);        //2.创建Subject        createSubject(request);        //3.启动轮询        startPolling(tag);        //4.返回Subject        return activeSubjectMap.get(tag).getBehaviorSubject();}

创建分析完了，就看下怎么停止轮询了。

8.停止

停止的逻辑其实就是发射事件给Subject，这样Subject自己可以接收到，然后进入Filter的逻辑进行判断，和创建的时候注册事件或者ALL事件一致就会停止轮询了。

public boolean stopPolling(String tag, EventInterface event) {        BehaviorSubject<EventInterface> subject = getSubject(tag);        if (null == subject) {            Timber.tag(Constants.TAG).e("can not find subject according to the %s", tag);            return false;        }        subject.onNext(event);        Timber.tag(Constants.TAG).i("Stop Polling SubjectTag =  " + tag + ", Event = " + event.toString());        return true;}

最后再补充一点就是发射事件的逻辑，会扫描activeSubjectMap中的所有Subject，然后发射事件：

public void emitEvent( @NonNull EventInterface event){        if (null == activeSubjectMap) return;        for (Map.Entry<String, SubjectModel<EventInterface>> next : activeSubjectMap.entrySet()) {            BehaviorSubject<EventInterface> behaviorSubject = next.getValue().getBehaviorSubject();            if (null == behaviorSubject) return;            behaviorSubject.onNext(event);        }}

9.总结

到这里基本涉及的逻辑都分析完了，希望能提供给到家另外一种轮询的实现方式，如果有什么问题欢迎留言哈，谢谢！

我的博客主页juexingzhe欢迎关注哈。

祝大家越码越开心。