java 自定义操作符_RxJava2自定义操作符

在开发有时候会通过很多方式处理事件防抖效果，比如计时器，时间差，今天采用自定义RxJava操作符和时间差分别进行处理。

传统处理方式：

public abstract class OnMultiClickListener implements View.OnClickListener {

public static final int MIN_CLICK_DELAY_TIME = 1000;

private long lastClickTime = 0;

@Override

public void onClick(View v) {

long currentTime = Calendar.getInstance().getTimeInMillis();

if (currentTime - lastClickTime > MIN_CLICK_DELAY_TIME) {

lastClickTime = currentTime;

onMultiClick(v);

}

}

public abstract void onMultiClick(View v);

}

获取系统时间，第一次可以点击，后续要加上时间间隔判断，大于设定的时间间隔再执行点击，很简洁。

先看RxJava中的操作符是怎么实现，就以create操作符为例，其实create就是RxJava中的方法，先瞅瞅：

@CheckReturnValue

@SchedulerSupport(SchedulerSupport.NONE)

public static Observable create(ObservableOnSubscribe source) {

ObjectHelper.requireNonNull(source, "source is null");

return RxJavaPlugins.onAssembly(new ObservableCreate(source));

}

在create()方法中传入了ObservableOnSubscribe对象 自定义资源对象，而ObservableCreate对象持有sourced对象的引用，继续往下看：

ObservableOnSubscribe

@Override

protected void subscribeActual(Observer super T> observer) {

CreateEmitter parent = new CreateEmitter(observer);

observer.onSubscribe(parent);

try {

source.subscribe(parent);

} catch (Throwable ex) {

Exceptions.throwIfFatal(ex);

parent.onError(ex);

}

}

代码中出现CreateEmitter对象持有Observer对象，并调用observer.onSubscribe(parent);最后我们在揭开CreateEmitter真明目:

static final class CreateEmitter

extends AtomicReference

implements ObservableEmitter, Disposable {

final Observer super T> observer;

@Override

public void onNext(T t) {

if (t == null) {

onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));

return;

}

if (!isDisposed()) {

observer.onNext(t);

}

}

@Override

public void onError(Throwable t) {

if (!tryOnError(t)) {

RxJavaPlugins.onError(t);

}

}

@Override

public void onComplete() {

if (!isDisposed()) {

try {

observer.onComplete();

} finally {

dispose();

}

}

}

public void dispose() {

DisposableHelper.dispose(this);

}

@Override

public boolean isDisposed() {

return DisposableHelper.isDisposed(get());

}

}

上述代码片段中CreateEmitter对象中提供了5个方法，onNext(), onError(),onComplete(),dispose(),isDisposed(),分别是拿到最终的结果值，在事件的执行过成功出现异常，提交完毕，事件中断，事件是否中断等一些列方法，上述是create操作符的一个大致流程，在事件的传递过程中，上游发出的事件进行层层封装，那么同时Observer在上游包装的同时也会层层封装，两者一一对应，如图所示：

image.png

RxJava处理方式：

刚刚对create操作符流程进行分析，现在开始自定义的操作：clicks操作符

RxView

companion object{

fun clicks(view: View): ViewClickObservable {

return ViewClickObservable(view)

}

}

RxView类中就只有一个静态方法，click()与create()类似。

ViewClickObservable

override fun subscribeActual(observer: Observer) {

val myListener = MyListener(mView!!, observer)

observer!!.onSubscribe(myListener)

mView!!.setOnClickListener(myListener)

}

ViewClickObservable继承Observable，复写subscribeActual(),将传递observer对象进行封装，最后附上MyListener类片段：

override fun dispose() {

// 如果没有中断过，才有资格， cas机制

if(isDisposable.compareAndSet(false,true)){

//判断是否是主线程

if (Looper.getMainLooper()== Looper.myLooper()){

mView!!.setOnClickListener(null)

}else{

//则需要从子线程切换到主线程

//1、通过创建handler的方式进行切换线程

/*object : Handler(Looper.getMainLooper()) {

override fun handleMessage(msg: Message) {

super.handleMessage(msg)

mView!!.setOnClickListener(null)

}

}

*/

//2、通过RxJava的源码分析 AndroidSchedulers.mainThread() 也是从子线程中去切换回到主线程

AndroidSchedulers.mainThread().scheduleDirect(object:Runnable{

override fun run() {

mView!!.setOnClickListener(null)

}

})

}

}

}

dispose()法特别强调一点，中断事件，其实就是让View没有点击事件，那么我在这儿将view的点击事件设置为null， mView!!.setOnClickListener(null)，但是得注意一点，要在主线程中对view进行操作，于是乎就有了代码中的两种切换线程的方式，第一种：就是我们平时在码代码中的new Handler对象，在handler中进行View的事件设置，Handler(Looper.getMainLooper()) ?? 那在Handler中传入Looper.getMainLooper()干啥呢？这个其实就是为了确保一定是在主线程中，那又有很多同学会问handler不就是用于子线程和主线程之间进行通讯的嘛，没错，但是handler 不仅可以用于主线程和子线程之间的通讯，也可以用于子线程与子线程之间的通讯，比如：

private Handler childHandler;

private void test(){

new Thread(new Runnable() {

@Override

public void run() {

String msg;

Looper.prepare();

childHandler = new Handler() {

@Override

public void handleMessage(Message msg) {

super.handleMessage(msg);

System.out.println("这个消息是从-->>" + msg.obj+ "过来的，在" + "btn的子线程当中" + "中执行的");

}

};

Looper.loop();//开始轮循

}

}).start();

new Thread(new Runnable() {

@Override

public void run() {

Looper loop = Looper.myLooper();

Message msg = childHandler.obtainMessage();

msg.obj = "btn2当中子线程";

childHandler.sendMessage(msg);

}

}).start();

}

开发中很多小伙伴都不会才用这种方式进行写代码，只是想确保Handler一定是在主线程中，第二种方式，在RxJava中很多时候都是采用第二种方式进行线程的切换。最后我们测试一下：

//自定义RxJava操作符

RxView.clicks(imageView!!)

.throttleFirst(2000, TimeUnit.MILLISECONDS) // 2秒钟之内 响应你一次

.flatMap { Observable.just("张三") }

.observeOn(Schedulers.io())

.observeOn(AndroidSchedulers.mainThread()) // 给下面切换 主线程

.subscribe(Consumer { name ->

Log.d("TAG", "name=: $name")

})

通过点击ImageView2s中之内发送一次姓名为张三的事件：

结果.png

PS : 以上只是一种实现思路，有更好的方法希望可以告诉我，抛砖引玉一下。喜欢的点个赞哦！