Java 链式观测

我有一组对象，称它们为

obj

。他们有一个

act（）

方法。

act（）

方法最终将导致在

o

上可观察到的

事件（）调用
onComplete

什么是链接这些的好方法

也就是说，调用
o.act（）
，等待
o.event（）.onComplete
，然后调用下一个
o2.act（）
，以此类推，以获取集合中无限数量的
o

所以签名是这样的：

public class Item {
    final protected PublishSubject<Object> event = PublishSubject.create();

    public Observable<ReturnType> event() {
        return event;
    }

    public void act() {
        // do a bunch of stuff
        event.onComplete();
    }
}

公共类项目{
最终受保护的PublishSubject事件=PublishSubject.create（）；
公共可观测事件（）{
返回事件；
}
公共无效法{
//做一堆事情
event.onComplete（）；
}
}

然后在消费代码中：

Collection<Item> items...
foreach item in items
  item.act -> await item.event().onComplete() -> call next item.act() -> so on

收集项目。。。
项目中的每个项目
item.act->wait item.event（）.onComplete（）->调用下一个item.act（）->依此类推
如果我理解正确，您的对象具有此类签名：

public class Item {
    public Observable<ReturnType> event()...
    public ReturnType act()...
}

结果:

Item.act: a
Item.act: b
Item.act: c

然后，如果您有一个
Iterable
集合，您可以使用
flatMap
：

Iterable<Item> items = Arrays.asList(item1, item2, item3);

Observable.from(items)
        .flatMap(Item::event)
        .subscribe();

Iterable items=Arrays.asList（item1、item2、item3）；
可观察。来自（项目）
.flatMap（项：：事件）
.subscribe（）；

可供替代的
与您的案例更相似的替代方案可能是：

public class Item {
    private final PublishSubject<Void> event = PublishSubject.create();

    private final String data;

    public Item(String data) {
        this.data = data;
    }

    public Observable<Void> event() {
        return event;
    }

    public Void act() {
        System.out.println("Item.act: " + data);
        // do a bunch of stuff
        event.onCompleted();
        return null;
    }
}

公共类项目{
private final PublishSubject事件=PublishSubject.create（）；
私有最终字符串数据；
公共项（字符串数据）{
这个数据=数据；
}
公共可观测事件（）{
返回事件；
}
公共无效法{
System.out.println（“Item.act:+数据”）；
//做一堆事情
event.onCompleted（）；
返回null；
}
}

用法：

Iterable<Item> iterable = Arrays.asList(item2, item3);

item1.event().
        concatWith(Observable.from(iterable)
                .map(Item::act))
        .subscribe();

item1.act();

Iterable Iterable=Arrays.asList（item2，item3）；
item1.event（）。
concatWith（可观察的，从可观察的）
.map（项目：：act））
.subscribe（）；
项目1.act（）；

但它不在第2项之后的项目上使用
事件（）
。
是否需要在o2.act（）中返回o.act（）？如果不是，你能异步运行所有这些吗？@Sebas o2、o3等。每一个都可能取决于前一次执行的副作用（但不是实际的返回值），因此，顺序很重要，对吗？@Sebas-order matters，是的，那么检查一下，这可能会有所帮助-似乎
switchmap
会阻止您的观察对象在前一个结果完成之前发出它们的结果。这真的很接近，抱歉，这里的详细信息太少了。我使用您的Item类更新了问题。谢谢你想通过调用第一个
act
来启动这一切吗？没错，是的！我认为，如果没有观察者，不做工作是更好的模式。这就是为什么工作通常在订阅时开始。第一个项目以一种方式启动，后续项目以另一种方式启动，似乎有异味。有什么原因需要这样做吗？
item.act（）
中的活动本质上是“热”的系统进程。前面的过程可能会创建后续过程所依赖的目录。
public class Item {
    private final PublishSubject<Void> event = PublishSubject.create();

    private final String data;

    public Item(String data) {
        this.data = data;
    }

    public Observable<Void> event() {
        return event;
    }

    public Void act() {
        System.out.println("Item.act: " + data);
        // do a bunch of stuff
        event.onCompleted();
        return null;
    }
}

Iterable<Item> iterable = Arrays.asList(item2, item3);

item1.event().
        concatWith(Observable.from(iterable)
                .map(Item::act))
        .subscribe();

item1.act();