Question

我正在努力熟悉RxJava。这是我想要实现的用例：

我的屏幕上有一个按钮，我正在尝试收集水龙头的数量。因此，如果用户点击按钮，则会注册单击并生成日志。现在，如果用户单击按钮两次，则会记录两次点击，收集它们并输出2而不是1。

基本上，我试图在一段时间内累积点击次数，然后吐出最终结果。我猜“buffer”是我需要使用的方法。我在Android中编写了一个快速示例（代码如下），但缓冲方法似乎并不像收集所有事件输入和吐出集合那么简单。

public class DemoFragment
    extends Fragment {

    private int _tapCount = 0;
    private Observable<List<Integer>> _bufferedObservable;
    private Observer<List<Integer>> _observer;

    @Override
    public void onActivityCreated(@Nullable Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        _setupLogger();

        _bufferedObservable = _getBufferedObservable();
        _observer = _getObserver();
    }


    // the library butterknife allows this
    @OnClick(R.id.btn_start_operation)
    public void onButtonTapped() {
        _log("GOT A TAP");
        _bufferedObservable.subscribeOn(Schedulers.io())
                         .observeOn(AndroidSchedulers.mainThread())
                         .subscribe(_observer);
    }

    private Observable<List<Integer>> _getBufferedObservable() {
        return Observable.create(new Observable.OnSubscribe<Integer>() {


            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                subscriber.onNext(1);   // send one tap here
            }

        }).buffer(2, TimeUnit.SECONDS); // collect all taps in the last 2s
    }

    private Observer<List<Integer>> _getObserver() {
        return new Observer<List<Integer>>() {


            @Override
            public void onCompleted() {
                _log(String.format("%d taps", _tapCount));
                _tapCount = 0; // reset tap count
            }

            @Override
            public void onError(Throwable e) {}

            @Override
            public void onNext(List<Integer> integers) {
                if (integers.size() > 0) {
                    for (int i : integers) {
                        _tapCount += i;
                    }
                    onCompleted();
                } else {
                    _log("No taps received");
                }
            }
        };
    }

    // ... other method that help wiring up the example (irrelevant to RxJava)
}

有人能帮助我理解我的理解中的错误观念吗？

问题1 ：我希望_getObserver()的{{1}}向我发送一个包含累计点击次数的列表。因此，如果按钮被击中5次，那么我期待一个包含5个项目的List，每个项目的值都为“1”。使用现有代码，我总是得到一个空列表。

问题2 ：如果通过检查onNext大小没有收到任何事件，我基本上会执行控制台日志。如果list不为空，我会抛出一个控制台日志，说“没有收到点击”。似乎Observable永远不会停止。它几乎就像一个计时器，即使没有注册按钮水龙头，它也会不断地继续运行。如果在过去10年没有注册任何事件，是否有办法停止Observable？

问题3 ：发出的数量似乎几乎呈指数级增长。它几乎就像它以前所有时间收集按钮空水龙头一样。

Answer 1

这是一个代码，显示我将如何做（假设您的按钮的ID为R.id.rx_button）：

private Subscription mSubscription;

@Override
protected void onResume() {
    super.onResume();
    mSubscription = Observable.create(new OnSubscribe<Integer>() {
        @Override
        public void call(Subscriber<? super Integer> subscriber) {
            findViewById(R.id.rx_button).setOnClickListener(new OnClickListener() {
                @Override
                public void onClick(View v) {
                    subscriber.onNext(1);
                }
            });
        }
    }).buffer(2, TimeUnit.SECONDS)
            .subscribe(new Action1<List<Integer>>() {
                @Override
                public void call(List<Integer> integers) {
                    Log.i("TAG", String.valueOf(integers.size()));
                }
            });
}

@Override
protected void onPause() {
    super.onPause();
    mSubscription.unsubscribe();
}

简单地说，只需关闭OnClickListener方法上的call实施，这样您就可以使用其中的subscriber对象。

使用lambdas看onResume会更好看（看看Retrolambda项目）：

@Override
protected void onResume() {
    super.onResume();
    mSubscription = Observable.create((Subscriber<? super Integer> subscriber) ->
            findViewById(R.id.rx_button).setOnClickListener(view ->
                    subscriber.onNext(1))).buffer(2, TimeUnit.SECONDS)
            .subscribe(integers -> Log.i("TAG", String.valueOf(integers.size())));
}

Answer 2

我认为最好使用真棒rx-binding库。我认为解决方案更清洁，特别是对于lambda。我使用过滤器运算符，所以我只在onNext（）中得到结果，用户在给定的2秒内按下了5次以上。

我基于（RxJava-Android-Samples）的一个示例，它使用旧的rx绑定依赖项。

@Override
public void onResume() {
    super.onResume();
    mClickSubscription = getBufferedSubscription();
}

@Override 
public void onPause() {
    super.onPause();
    mClickSubscription.unsubscribe();
} 

private Subscription getBufferedSubscription() {
    return RxView.clicks(rx_button)
            .map(aVoid -> 1)
            .buffer(2, TimeUnit.SECONDS)
            .filter(integers -> integers.size() > 5)
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Observer<List<Integer>>() {

                @Override
                public void onCompleted() {
                    // fyi: you'll never reach here
                }

                @Override
                public void onError(Throwable e) {
                    SLog.i("Dang error! check your logs");
                }

                @Override
                public void onNext(List<Integer> integers) {
                    SLog.i(String.format("%d taps", integers.size()));

                }
            });
}

Answer 3

尝试以下代码：

public class BufferExampleActivity extends AppCompatActivity {

    private static final String TAG = BufferExampleActivity.class.getSimpleName();
    Button btn;
    TextView textView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_example);
        btn = (Button) findViewById(R.id.btn);
        textView = (TextView) findViewById(R.id.textView);

        btn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                doSomeWork();
            }
        });
    }

    /*
     * simple example using buffer operator - bundles all emitted values into a list
     */
    private void doSomeWork() {

        Observable<List<String>> buffered = getObservable().buffer(3, 1);

        // 3 means,  it takes max of three from its start index and create list
        // 1 means, it jumps one step every time
        // so the it gives the following list
        // 1 - one, two, three
        // 2 - two, three, four
        // 3 - three, four, five
        // 4 - four, five
        // 5 - five

        buffered.subscribe(getObserver());
    }

    private Observable<String> getObservable() {
        return Observable.just("one", "two", "three", "four", "five");
    }

    private Observer<List<String>> getObserver() {
        return new Observer<List<String>>() {

            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, " onSubscribe : " + d.isDisposed());
            }

            @Override
            public void onNext(List<String> stringList) {
                textView.append(" onNext size : " + stringList.size());
                textView.append(AppConstant.LINE_SEPARATOR);
                Log.d(TAG, " onNext : size :" + stringList.size());
                for (String value : stringList) {
                    textView.append(" value : " + value);
                    textView.append(AppConstant.LINE_SEPARATOR);
                    Log.d(TAG, " : value :" + value);
                }

            }

            @Override
            public void onError(Throwable e) {
                textView.append(" onError : " + e.getMessage());
                textView.append(AppConstant.LINE_SEPARATOR);
                Log.d(TAG, " onError : " + e.getMessage());
            }

            @Override
            public void onComplete() {
                textView.append(" onComplete");
                textView.append(AppConstant.LINE_SEPARATOR);
                Log.d(TAG, " onComplete");
            }
        };
    }
}

RxJava中对缓冲区的理解不正确

3 个答案: