在开发有时候会通过很多方式处理事件防抖效果，比如计时器，时间差，今天采用自定义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 <T> Observable<T> create(ObservableOnSubscribe<T> source) {
ObjectHelper.requireNonNull(source, "source is null");
return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
}
在create()方法中传入了ObservableOnSubscribe对象 自定义资源对象，而ObservableCreate对象持有sourced对象的引用，继续往下看：
ObservableOnSubscribe
@Override
protected void subscribeActual(Observer<? super T> observer) {
CreateEmitter<T> parent = new CreateEmitter<T>(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<T>
extends AtomicReference<Disposable>
implements ObservableEmitter<T>, 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<in Any?>) {
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<Any> { name ->
Log.d("TAG", "name=: $name")
})
通过点击ImageView2s中之内发送一次姓名为张三的事件：
结果.png
