Android 在发出observable之前，检查observable是否符合某些标准

假设我有一个事件总线：

public class MessageEventBus {
    private static MessageEventBus INSTANCE;
    private PublishSubject<Message> bus = PublishSubject.create();

    private MessageEventBus() {};

    public static MessageEventBus instance() {
        if (INSTANCE == null) {
            INSTANCE = new MessageEventBus();
        }
        return INSTANCE;
    }

    public void send(Message message) {
        bus.onNext(message);
    }

    public Observable<Message> toObservable() {
        return bus;
    }

    public boolean hasObservers() {
        return bus.hasObservers();
    }
}

MessageEventBus bus = MessageEventBus.instance();
bus.toObservable()
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(message -> {
            if (message.userId == userId) {
                view.messageReceived(message);        
            }
        });

这里是（在MVP演示者中）我将观察员连接到事件总线的点：

public class MessageEventBus {
    private static MessageEventBus INSTANCE;
    private PublishSubject<Message> bus = PublishSubject.create();

    private MessageEventBus() {};

    public static MessageEventBus instance() {
        if (INSTANCE == null) {
            INSTANCE = new MessageEventBus();
        }
        return INSTANCE;
    }

    public void send(Message message) {
        bus.onNext(message);
    }

    public Observable<Message> toObservable() {
        return bus;
    }

    public boolean hasObservers() {
        return bus.hasObservers();
    }
}

MessageEventBus bus = MessageEventBus.instance();
bus.toObservable()
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(message -> {
            if (message.userId == userId) {
                view.messageReceived(message);        
            }
        });

如何将

if（message.userId==userId）

检查从演示者移动到服务？或者将该检查移动到事件总线本身？类似于服务中的以下伪代码：

MessageEventBus bus = MessageEventBus.instance();
Message message = new Message(userId, text);
if (bus.hasObservers() && message.userId == theUserIdInThePresenter) {
    bus.send(message);
}

public class MessageEventBus {
    private static MessageEventBus INSTANCE;
    private PublishSubject<Message> bus = PublishSubject.create();

    private MessageEventBus() {};

    public static MessageEventBus instance() {
        if (INSTANCE == null) {
            INSTANCE = new MessageEventBus();
        }
        return INSTANCE;
    }

    public void send(Message message) {
        bus.onNext(message);
    }

    //filter here
    public Observable<Message> toFilteredObservable(int userId) {
        return bus
                .filter(message -> message.userId == userId)
                ;
    }

    public Observable<Message> toObservable() {
        return bus;
    }

    public boolean hasObservers() {
        return bus.hasObservers();
    }
}

---

或者换句话说，在实际发出某个观察对象之前，我如何检查附加到该观察对象的观察者是否满足某些标准？

在观察者可观察模式中，观察者不应该关心订阅它们的观察者。 它们的目的是发出数据。 不过，您可以使用更优雅的方式进行过滤。您有两种可能：

1-将筛选器放入演示者中：

        MessageEventBus bus = MessageEventBus.instance();
        bus.toObservable()
            .filter(message.userId == userId)
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(message -> {
               //you will only received message which match id
            });

2-将过滤器投入使用：

MessageEventBus bus = MessageEventBus.instance();
Message message = new Message(userId, text);
if (bus.hasObservers() && message.userId == theUserIdInThePresenter) {
    bus.send(message);
}

public class MessageEventBus {
    private static MessageEventBus INSTANCE;
    private PublishSubject<Message> bus = PublishSubject.create();

    private MessageEventBus() {};

    public static MessageEventBus instance() {
        if (INSTANCE == null) {
            INSTANCE = new MessageEventBus();
        }
        return INSTANCE;
    }

    public void send(Message message) {
        bus.onNext(message);
    }

    //filter here
    public Observable<Message> toFilteredObservable(int userId) {
        return bus
                .filter(message -> message.userId == userId)
                ;
    }

    public Observable<Message> toObservable() {
        return bus;
    }

    public boolean hasObservers() {
        return bus.hasObservers();
    }
}

---

PS：如果您想让可观察对象遵守观察者标准，您应该手动实现该模式

在观察者可观察模式中，观察者不应该关心订阅它们的观察者。 它们的目的是发出数据。 不过，您可以使用更优雅的方式进行过滤。您有两种可能：

1-将筛选器放入演示者中：

        MessageEventBus bus = MessageEventBus.instance();
        bus.toObservable()
            .filter(message.userId == userId)
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(message -> {
               //you will only received message which match id
            });

2-将过滤器投入使用：

MessageEventBus bus = MessageEventBus.instance();
Message message = new Message(userId, text);
if (bus.hasObservers() && message.userId == theUserIdInThePresenter) {
    bus.send(message);
}

public class MessageEventBus {
    private static MessageEventBus INSTANCE;
    private PublishSubject<Message> bus = PublishSubject.create();

    private MessageEventBus() {};

    public static MessageEventBus instance() {
        if (INSTANCE == null) {
            INSTANCE = new MessageEventBus();
        }
        return INSTANCE;
    }

    public void send(Message message) {
        bus.onNext(message);
    }

    //filter here
    public Observable<Message> toFilteredObservable(int userId) {
        return bus
                .filter(message -> message.userId == userId)
                ;
    }

    public Observable<Message> toObservable() {
        return bus;
    }

    public boolean hasObservers() {
        return bus.hasObservers();
    }
}

PS：如果您想让可观察对象遵守观察者标准，您应该手动实现该模式