Android：在多实例项中注册回调并将OneEvents返回实例回调的最佳方法是什么？

背景：

• 没什么特别的，我在用Java做Android

问题:

• 我希望允许我的用户创建一个对象的多个实例，并在每个实例中注册一个回调接口（想想错误回调）
• 该对象有多个子对象/子对象/等。。。每个子级都可以返回此事件
• 我预计在应用程序的整个生命周期中会有1-10个实例
• 我试图避免使用单例/静态事件侦听器

可能的解决方案（以及不使用它们的原因）：

1） 在每个父对象实例中注册一个BroadcastReceiver，并允许每个孙子在意图级别上通知事件。这应该允许主对象将事件通知我的用户。 问题是多个实例将需要多个广播接收器，我预计这些接收器会很重或不太理想

2） 注册一个BroadcastReceiver并找到一种方法，让它决定应该通知对象的哪个实例一个事件，并实际将其发送给它。问题是我不确定如何通知对象本身

3） 让回调接口作为参数从父级传递给每个子级/grandchilren/etc。。。但这会很混乱

4） 使用类似EventBus库的东西（据我所知，它与BroadcastReceiver相同，只是基于反射，因此速度较慢）

---

5） 还有什么吗？

我不知道这是否是您的最佳解决方案，但我认为如果我正确理解您的需求，它会起作用

public class Listener extends Observable implements Observer {

    private List<Observer> clients = new ArrayList<>();

    public void addClient(Observer client){
        clients.add(client);
    }

    @Override
    public void update(Observable o, Object arg) {
        for(Observer client : clients){
            client.update(o, arg); // Or whatever you need to do
        }
    }

    public class DataSource extends Observable {

        private Observer observer;

        public DataSource(Observer o){
            observer = o;
        }

        // Notify observer of changes at appropriate time

    }

    public class Consumer implements Observer {

        public Consumer(){
            Listener listener = ...;
            listener.addClient(this);
        }

        @Override
        public void update(Observable o, Object arg) {
            // Handle appropriately
        }
    }
}

public类监听器扩展了Observable实现了Observable{
private List clients=new ArrayList（）；
公共无效添加客户端（观察者客户端）{
客户。添加（客户）；
}
@凌驾
公共无效更新（可观察o，对象arg）{
对于（观察者客户端：客户端）{
update（o，arg）；//或您需要执行的任何操作
}
}
公共类数据源扩展了可观察的{
私人观察员；
公共数据源（o）{
观察者=o；
}
//在适当的时候通知观察员变更
}
公共类使用者实现观察器{
公众消费者（）{
侦听器=。。。；
addClient（this）；
}
@凌驾
公共无效更新（可观察o，对象arg）{
//妥善处理
}
}
}

---

<> >代码>数据源<代码>是你的“子对象”，<代码>消费者>代码>是事件的最终客户端，而<>代码>监听器<代码>是中间的类。我不知道为什么客户端不能直接用“子对象”注册事件，但这就是你说的！为了简单起见，这里将其建模为内部类，但我假设您不会这样做。

我不知道这是否是适合您的最佳解决方案，但我认为如果我正确理解您的需求，它会起作用

public class Listener extends Observable implements Observer {

    private List<Observer> clients = new ArrayList<>();

    public void addClient(Observer client){
        clients.add(client);
    }

    @Override
    public void update(Observable o, Object arg) {
        for(Observer client : clients){
            client.update(o, arg); // Or whatever you need to do
        }
    }

    public class DataSource extends Observable {

        private Observer observer;

        public DataSource(Observer o){
            observer = o;
        }

        // Notify observer of changes at appropriate time

    }

    public class Consumer implements Observer {

        public Consumer(){
            Listener listener = ...;
            listener.addClient(this);
        }

        @Override
        public void update(Observable o, Object arg) {
            // Handle appropriately
        }
    }
}

public类监听器扩展了Observable实现了Observable{
private List clients=new ArrayList（）；
公共无效添加客户端（观察者客户端）{
客户。添加（客户）；
}
@凌驾
公共无效更新（可观察o，对象arg）{
对于（观察者客户端：客户端）{
update（o，arg）；//或您需要执行的任何操作
}
}
公共类数据源扩展了可观察的{
私人观察员；
公共数据源（o）{
观察者=o；
}
//在适当的时候通知观察员变更
}
公共类使用者实现观察器{
公众消费者（）{
侦听器=。。。；
addClient（this）；
}
@凌驾
公共无效更新（可观察o，对象arg）{
//妥善处理
}
}
}

---

<> >代码>数据源<代码>是你的“子对象”，<代码>消费者>代码>是事件的最终客户端，而<>代码>监听器<代码>是中间的类。我不知道为什么客户端不能直接用“子对象”注册事件，但这就是你说的！为了简单起见，这里将其建模为内部类，但我假设您不会这样做。

我不完全清楚您在做什么，但Observer/Observable呢？就我所知，Observer和Obsr。模式用于多个对象侦听一个对象。我需要一个对象来区分多个子对象中的事件，并通知多个侦听器对象中的一个。我不完全清楚您在做什么，但Observer/Observable呢？就我所知，Obser和Obsr。模式用于多个对象侦听一个对象。我需要一个对象来识别来自多个子对象的事件，并通知多个侦听器对象中的一个。