Android 在'；高流量'；密码？

我最近刚刚开始探索RxJava，并将其应用于我项目的一小部分。事实证明，这个部分很小，但具有“高流量”：它经常被其他组件调用。例如，一个网络客户机被反复调用以获取远程数据，对响应应用一些转换，然后触发回调事件。假设这些转换是轻量级的，所以我可以在主线程上进行：

restService.getData() // retrofit interface that returns Observable<T>
    .observeOn(AndroidSchedulers.mainThread())
    .map(data -> someMapping(data))
    .map(data -> someOtherMapping(data))
    .subscribe(this::fireResponseCallback, this::fireErrorCallback)

restService.getData（）//改装返回可观察数据的接口
.observeOn（AndroidSchedulers.mainThread（））
.map（数据->某些映射（数据））
.map（数据->其他映射（数据））
.subscribe（this:：fireResponseCallback，this:：fireErrorCallback）

现在，没有RxJava也可以做到这一点：

restService.getData() // retrofit interface that returns Call<T>
    .enqueue(new Callback<T>() {
        @Override
        public void onResponse(Call<T> call, Response<T> response) {
            T data = response.body();
            data = someMapping(data);
            data = someOtherMapping(data);
            fireResponseCallback(data);
        }

        @Override
        public void onFailure(Call<T> call, Throwable t) {
            fireErrorCallback(t);
        }
    });

restService.getData（）//改装返回调用的接口
.enqueue（新的回调函数（）{
@凌驾
公共void onResponse（调用、响应）{
T data=response.body（）；
数据=一些映射（数据）；
数据=其他映射（数据）；
fireResponseCallback（数据）；
}
@凌驾
失败时公共无效（调用调用，可丢弃的t）{
firerrorcallback（t）；
}
});

---

我观察到RxJava在内存中创建了更多的对象。对于上面的示例，每次执行通过4个lambda表达式，每个表达式对匿名类进行1次实例化（

Func1

或

Action1

）。没有RxJava，您只有一个匿名类的实例化（

回调

）。当同一逻辑被多次触发时，这种差异会迅速扩大。我想知道这是否是我在使用RxJava时应该注意的事情？如果是，那么什么是保持对象数量小的好做法呢？

是的，RxJava 1.x分配的对象比反应序列理论上需要的多（由于一些设计选择），但它不应该那么激烈。对于同步本地序列，它的分配速率变得明显，但对于基于网络的序列，它的分配速率很少

如果您的操作和Func lambda是纯的，那么您可以在成员字段中预先分配它们，并在lambda中重用它们的引用。此外，如果多次使用

restService.getData（）

，您可以将整个链保存到一个字段中，并在需要时调用

subscribe

class DataAccess {
    final RestService restService;

    final Observable<T> call = restService.getData()
        .observeOn(AndroidSchedulers.mainThread())
        .map(data -> someMapping(data))
        .map(data -> someOtherMapping(data));

    final Action1<T> consumer = this::fireResponseCallback;

    final Action1<Throwable> errorHandler = this::fireErrorCallback;

    DataAccess(RestService restService) {
        this.restService = restService;
    }

    void doDataAccess() {
        call.subscribe(consumer, errorHandler);
    }
}

类数据访问{
最终恢复服务恢复服务；
最终可观察调用=restService.getData（）
.observeOn（AndroidSchedulers.mainThread（））
.map（数据->某些映射（数据））
.map（数据->其他映射（数据））；
最终行动1消费者=此：：fireResponseCallback；
最终操作1 errorHandler=this:：fireErrorCallback；
数据访问（RestService RestService）{
this.restService=restService；
}
void doDataAccess（）{
call.subscribe（消费者、errorHandler）；
}
}