松散耦合的观察者模式

Question

我意识到这个话题已经被掩盖了，但我仍然在挣扎，并且可以通过一些具体的帮助来做。

我的目标是在某种可观察对象（比如说狗）和某种侦听器（比如说所有者）之间实现一个简单的观察者模式。

最终，在 MVC 范例中，所有者将是一个“视图”，而狗是一个“模型”。我使用 Dog 和 Owner 只是为了尝试简化这里的事情。

我尝试使用 Java 内置的 Observer/Observable 类，但已经意识到 Observers update() 方法有多糟糕 - 它接收一个 POJO，我需要在 update() 方法中检查/强制转换该 POJO。我更希望我的 'update()' 方法收到它可以期待的东西。

所以，我遵循了一些教程，包括这个以 Dog/Owner 为例的教程：

http://www.youtube.com/watch?v=qw0zZAte66A

这里已经向我展示了如何滚动我自己的 Observer/Observed 类。在伪代码中，我现在拥有的是：

Dog/Model {

    List listeners;

    public fireDogHungryEvent() {

        foreach listener {
            listener.onDogHungry(this);
        }
    }

    public fireDogPeeEvent() {

        foreach listener {
            listener.onDogNeedsToPee(this);
        }
    }

    public getHungerLevel() { return hungerLevel; }
    public getBladderCapacity() { return bladderCapacity; }
}

Owner/View {

    public onDogHungry(model) {
        println(model.getHungerLevel());
    }

    public onDogNeedsToPee(model) {
        println(model.getBladderCapacity());
    }
}

所以现在我有处理特定事件的方法，而不是一个 update() 方法。杰出的。我目前对 Owner/view 类很满意。它知道 Dog/model 的方法，这很好（我认为）。

我不喜欢的是 Dog/model 引用了 Owner/view 中的方法。我已经阅读了无数次并且完全同意模型不应该与其视图紧密耦合，例如它似乎在上面。我也不热衷于 Dog/model 中的所有“火”方法做几乎相同的事情；循环遍历它的所有监听器，并在每个监听器上调用不同的方法。

是否可以进一步解耦这种关系并且不让 Dog/model 调用特定的方法？如果是这样，将狗/模型数据接收到所有者/视图并适当使用它的最佳方法是什么？

谢谢

Answer 1

您应该interface 远离Observer 和Observable 的具体实现知识

public enum EventType {

    HUNGRY,
    PEE;
}

public interface DogEvent {

    EventType getType();
}

public interface DogListener {

    void fireEvent(DogEvent event);
}

public class Dog {

    private final Set<DogListener> listeners = new CopyOnWriteArraySet<DogListener>();

    public void register(final DogListener dogListener) {
        listeners.add(dogListener);
    }

    public void unregister(final DogListener dogListener) {
        listeners.remove(dogListener);
    }

    public void firePeeEvent() {
        fireEvent(new DogEvent() {
            @Override
            public EventType getType() {
                return EventType.PEE;
            }
        });
    }

    public void fireHungryEvent() {
        fireEvent(new DogEvent() {
            @Override
            public EventType getType() {
                return EventType.HUNGRY;
            }
        });
    }

    private void fireEvent(final DogEvent dogEvent) {
        for (final DogListener listener : listeners) {
            listener.fireEvent(dogEvent);
        }
    }
}

public class Owner implements DogListener {

    @Override
    public void fireEvent(DogEvent event) {
        switch (event.getType()) {
            case PEE:
                System.out.println("Someone take the dog out");
                break;
            case HUNGRY:
                System.out.println("I can't believe the dog is hungry _again_!");
                break;
        }
    }
}

在这种情况下，Dog 不知道Owner 的实现，它只知道Owner 是DogListener。

另一方面，Owner 不知道Dog，它只知道它有一个传入的DogEvent。

Answer 2

出于 MVC 目的（尤其是 MVP），我收集了有关事件库编程的良好经验。因此，您需要一个供 Dog 和 Owner 使用的 EventBus。所有者将订阅某些事件类，例如 HungerLevelIncrease，而狗将触发此类事件。对于您的 Dog Owner 示例，这会有点奇怪，因为 Owner 不认识他的狗，但对于 GUI 编程，这是一个很好且简单的解决方案，尤其是在其他控制器之间解耦。

您可以轻松地自己创建总线，也可以使用来自google guava 的总线。

这是我所知道的创建真正松散耦合的最佳方法。