Android 行为主体处理中的行为主体

场景 我有一个区域的列表，我想从服务器上获取每个区域中的所有项目。因此，我决定使用

行为主体

进行尝试。我不知道我是不是疯了。这就是我所做的：

private Observable<ItemListResponse> getItemByTerritory() {

    List<String> territories = PrefUtils.getUserTerritories(context);

    BehaviorSubject<Integer> territoryControl = BehaviorSubject.<Integer>create(0);
    Observable<ItemListResponse> territoryRet = territoryControl.asObservable().concatMap(integer -> {

        if (integer != territories.size()) {

            BehaviorSubject<Integer> ret = BehaviorSubject.create(1);
            return ret.asObservable().concatMap(integer1 -> {

                if (integer > 0) {
                    return bakeryAPI.getBakeries("Bearer " + PrefUtils.getToken(context), integer1, 21, territories.get(integer))
                            .subscribeOn(Schedulers.io())
                            .observeOn(AndroidSchedulers.mainThread())
                            .doOnNext(itemListRespont -> {
                                if (itemListRespont.getItemResponse().getMeta().getPage() != itemListRespont.getItemResponse().getMeta().getPageCount() && itemListRespont.getItemResponse().getMeta().getPageCount() > 0) {
                                    ret.onNext(integer1 + 1);
                                } else {
                                    ret.onNext(-1);
                                    territoryControl.onNext(integer + 1);
                                }
                            });
                } else {
                    return Observable.<ItemListResponse>empty().doOnCompleted(ret::onCompleted);
                }
            });
        } else {
            return Observable.<ItemListResponse>empty().doOnCompleted(territoryControl::onCompleted);
        }
    });
    return Observable.defer(() -> territoryRet);
}

private observeable getItemByTerritory（）{
List Territions=PrefUtils.getUserTerritions（上下文）；
BehaviorSubject territoryControl=BehaviorSubject.create（0）；
Observable territoryRet=territoryControl.asObservable（）.concatMap（整数->{
if（整数！=territions.size（））{
BehaviorSubject ret=BehaviorSubject.create（1）；
返回ret.asObservable（）.concatMap（整数1->{
如果（整数>0）{
返回bakeryAPI.getBakeries（“Bearer”+PrefUtils.getToken（上下文）、integer1、21、territies.get（整数））
.subscribeOn（Schedulers.io（））
.observeOn（AndroidSchedulers.mainThread（））
.doOnNext（项目列表响应->{
如果（itemListRespont.getItemResponse（）.getMeta（）.getPage（）！=itemListRespont.getItemResponse（）.getMeta（）.getPageCount（）&&itemListRespont.getItemResponse（）.getMeta（）.getPageCount（）>0）{
ret.onNext（整数1+1）；
}否则{
ret.onNext（-1）；
territoryControl.onNext（整数+1）；
}
});
}否则{
返回Observable.empty（）.doOnCompleted（ret:：onCompleted）；
}
});
}否则{
返回Observable.empty（）.doOnCompleted（territoryControl:：onCompleted）；
}
});
返回可观察延迟（（）->territoryRet）；
}

它所做的只是挂起，就像我这样做的时候什么都没有运行一样

public void getItemByTerritory(APIRequestListener apiRequestListener){
    realm.executeTransaction(realm1 -> realm1.where(RealmItem.class).findAll().deleteAllFromRealm());

    getItemByTerritory().subscribe(new Subscriber< ItemListResponse >() {
        @Override
        public void onCompleted() {
            Log.e(TAG, "Completed Bakery");
            apiRequestListener.completed();
            unsubscribe();
        }

        @Override
        public void onError(Throwable e) {
            e.printStackTrace();
            apiRequestListener.handleError(e);
        }

        @Override
        public void onNext(ItemListResponse itemListRespont) {
        }
    });
}

public void getItemByTerritory（APIRestListener APIRestListener）{
realm.executeTransaction（realm1->realm1.where（RealmItem.class）.findAll（）.deleteAllFromRealm（））；
getItemByTerritory（）.subscribe（新订阅者（）{
@凌驾
未完成的公共无效（）{
Log.e（标签“已完成的面包店”）；
apiRequestListener.completed（）；
取消订阅（）；
}
@凌驾
公共无效申报人（可丢弃的e）{
e、 printStackTrace（）；
apiRequestListener.handleError（e）；
}
@凌驾
public void onNext（ItemListResponse itemListRespont）{
}
});
}

如果我理解正确，并且您所追求的是获取

getBakeries

响应的页面，那么下面的递归函数调用应该可以做到这一点：

private Observable<ItemListResponse> getItemByTerritory() {
    List<String> territories = PrefUtils.getUserTerritories(context);
    return Observable.from(territories).flatMap(territory -> fetchTerritoryPage(territory, 0));
}

private Observable<ItemListResponse> fetchTerritoryPage(String territory, int page) {
    System.out.println("Fetch territory page " + page);
    return bakeryAPI.getBakeries("Bearer " + PrefUtils.getToken(context), page, 21, territory).flatMap(response
            -> {
        final ItemListResponse.ItemResponse.Meta meta = response.getItemResponse().getMeta();
        final Observable<ItemListResponse> thisPage = Observable.just(response);
        if (page < meta.getPageCount()) {
            final Observable<ItemListResponse> nextPage = fetchTerritoryPage(territory, page + 1);
            return thisPage.concatWith(nextPage);
        } else {
            return thisPage;
        }
    });
}

private observeable getItemByTerritory（）{
List Territions=PrefUtils.getUserTerritions（上下文）；
返回可观察的。从（区域）.flatMap（区域->获取区域页面（区域，0））；
}
私有可观察fetchTerritoryPage（字符串区域，int页）{
System.out.println（“获取区域页面”+页面）；
返回bakeryAPI.getBakeries（“Bearer”+PrefUtils.getToken（上下文），第21页，territory）.flatMap（响应
-> {
final ItemListResponse.ItemResponse.Meta=response.getItemResponse（）.getMeta（）；
最终可观察到此页面=可观察。仅（响应）；
如果（页面

---

请注意

fetchTerritoryPage

如何递归调用自身以获取下一页。

我现在正在测试它。但是，看看代码，它对于我正在尝试做的事情是非常有意义的。有多个地区。每个地区都有多个页面的面包店。哪个

getItemByTerritory（）

使用

Observable.from（territory）.flatMap（territory->fetchTerritoryPage（territory，0））

和

这个页面来解决。concatWith（nextPage）

页面抓取我已经重构了代码以使用

行为子对象

，但是

尾部递归

拖累了巨大的负载