java - 松散耦合的观察者模式

Question

我意识到这个主题已经被掩盖了，但我仍在挣扎，需要一些具体的帮助。

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

最终，Owner 将成为 MVC 范例中的“ View ”，而 Dog 将成为“模型”。我使用 Dog 和 Owner 只是为了尝试简化这里的事情。

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

因此，我学习了一些教程，包括这个以狗/主人为例的教程:

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() 方法。杰出的。我目前对所有者/ View 类感到满意。它知道狗/模型的方法，这很好(我认为)。

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

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

谢谢

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。