java - 链观察

我有一组对象，称它们为 obj 。他们有一个 act() 方法。 act() 方法最终会导致 event() 上的 o observable 调用 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();
    }
}

然后在消费代码中:

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

最佳答案

如果我理解正确，您的对象具有这种签名:

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

所以如果他们像这样填写:

public class Item {

    private final String data;
    private final Observable<ReturnType> event;

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

        event = Observable
                .fromCallable(this::act);
    }

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

    public ReturnType act() {
        System.out.println("Item.act: " + data);
        return new ReturnType();
    }
}

然后可以像这样链接它们:

Item item1 = new Item("a");
Item item2 = new Item("b");
Item item3 = new Item("c");

item1.event()
        .concatWith(item2.event())
        .concatWith(item3.event())
        .subscribe();

结果:

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();

选择

更像您的情况的替代方案可能是:

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();

但它不会在第 2 项之后使用 event()。

关于java - 链观察，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/41416149/