Java 如何从Callable内部的循环运行Completable？

我需要将一个具有树结构的数据类保存到数据库中。因为我不必在UI上反映任何结果，所以我选择Completable。当我创建父对象时，第一个

mergeWith

可以正常工作。我可以看到为家长和孩子创建的数据表

然后我需要为每个

Kid

创建一个孙子列表，但是我没有看到

create孙子的任何日志，数据库中也没有数据。我尝试使用
mergeArray
和
flatMapIterable
，但没有成功

当然，我可以在一个完整表中创建所有实例，但每个实例都可以单独创建

    private Completable runCompletableFromCallable(String s, Callable<Object> callable) {
        long start = System.currentTimeMillis();
        return Completable.fromCallable(callable).doOnComplete(
                () -> LOGGER.info(s + " took: {} mSec", (System.currentTimeMillis() - start)));
    }

    public Completable createParent(@Nonnull final Parent parent) {
        return runCompletableFromCallable("createParent", () -> {
            mParentDao.create(parent);
            return parent;
         // This works fine
        }).mergeWith(createKids(parent));
    }

    private Completable createKids(final Parent parent) {
        return runCompletableFromCallable("createKids", () -> {
            Collection<Kid> kids = parent.getKids();
            if (kids != null) {
                for (Kid kid : kids) {
                    kid.setParent(testPlan);
                    mKidDao.create(kid);
                    // The issue: grandchildren never created
                    createGrandchildren(kid);
                }
            }
            return kids;
        });
    }

    private Completable createGrandchildren(final Kid kid) {
        return runCompletableFromCallable("createConfigurations", () -> {
            Collection<Grandchild> grandchildren = kid.getGrandchildren();
            if (grandchildren != null) {
                for (Grandchild grandchild : grandchildren) {
                    grandchild.setKid(kid);
                    mGrandchildDao.create(grandchild);
                    // And so on.
                    createToysOrSmthElse(grandchild);
                }
            }
            return grandchildren;
        });
    }

private Completable runCompletableFromCallable（字符串s，Callable Callable）{
长启动=System.currentTimeMillis（）；
返回Completable.fromCallable（callable）.doOnComplete(
（）->LOGGER.info（s+“take:{}mSec”，（System.currentTimeMillis（）-start））；
}
公共可完成createParent（@Nonnull final Parent）{
返回runCompletableFromCallable（“createParent”，（）->{
mParentDao.create（父级）；
返回父母；
//这个很好用
}).mergeWith（createKids（parent））；
}
私有可完成createKids（最终父级）{
返回runCompletableFromCallable（“createKids”，（）->{
Collection kids=parent.getKids（）；
if（kids！=null）{
用于（儿童：儿童）{
kid.setParent（测试计划）；
mKidDao.create（kid）；
//问题是：孙辈从来没有创造过
孙辈（小孩）；
}
}
归还孩子；
});
}
私人可完成Create孙辈（最终子女）{
返回runCompletableFromCallable（“createConfigurations”，（）->{
集合孙子=kid.get孙子（）；
if（孙辈！=null）{
用于（孙子孙女：孙子孙女）{
孙子。塞吉德（基德）；
mGrandchildDao.create（孙子）；
//等等。
创建Toysorsmthelse（孙子）；
}
}
还孙子；
});
}
我终于找到了解决办法。我刚开始使用
可观察的

...

    private <T> Observable<T> runObservableFromCallable(String opName, Callable<T> callable) {
        long start = System.currentTimeMillis();
        return Observable.fromCallable(callable)
                         .doOnComplete(() -> LOGGER
                                 .info(opName + " took: {} mSec", (System.currentTimeMillis() - start)));
    }

    public Completable createParent(@Nonnull final Parent parent) {
        return runObservableFromCallable("createParent", () -> {
            mParentDao.create(parent);
            return parent;
        }).flatMapCompletable(this::createKids);
    }

    private Completable createKids(final Parent parent) {
        return runObservableFromCallable("createKids", () -> {
            Collection<Kid> kids = parent.getKids();
            if (kids != null) {
                for (Kid kid : kids) {
                    kid.setParent(testPlan);
                    mKidDao.create(kid);
                }
            }
            return kids;
        }).flatMapIterable(kids -> kids).flatMapCompletable(this:: createGrandchildren);
    }
...

。。。
私有可观察runObservableFromCallable（字符串opName，Callable Callable）{
长启动=System.currentTimeMillis（）；
返回可观察。从可调用（可调用）
.doOnComplete（（）->LOGGER
.info（opName+“take:{}mSec”，（System.currentTimeMillis（）-start））；
}
公共可完成createParent（@Nonnull final Parent）{
返回runObservableFromCallable（“createParent”，（）->{
mParentDao.create（父级）；
返回父母；
}).flatMapCompletable（此：：createKids）；
}
私有可完成createKids（最终父级）{
返回runObservableFromCallable（“createKids”，（）->{
Collection kids=parent.getKids（）；
if（kids！=null）{
用于（儿童：儿童）{
kid.setParent（测试计划）；
mKidDao.create（kid）；
}
}
归还孩子；
}).flatmapetable（kids->kids）.flatMapCompletable（this:：create孙子）；
}
...