Java中的事件通知

在java中，我对观察者模式或JMS感到非常困惑。我想使用下面的事件通知让我们忘掉那些JMS或观察家吧，你认为这是可能的还是可行的？如果是，如何完成

newSalesOrder = new SalesOrder();
newSalesOrder.notified("new SalesOrder order ID="+orderId);

EventRegister.bindEvent(SalesOrder.class, Delivery.class);
EventRegister.bindEvent(SalesOrder.class, Warehouse.class);

////////////
Delivery delivery = new Delivery();
delivery.listerning(new Event(source){
  if(source == SalesOrder.class){

  }  
});

//////////
Warehouse warehouse = new Warehouse();
warehouse.listerning(new Event(source){
  if(source == SalesOrder.class){

  }  
});

///////////
EventRegister{
    static bindEvent(Class source, Class destination){
      //???
    }
}

您需要注册（绑定）对象而不是类。您可以在EventRegister中保持注册列表的静态，但我认为最好在SalesOrder中将它们作为实例。因此，这将是：

import java.util.ArrayList;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        SalesOrder mySalesOrder = new SalesOrder();

        Warehouse myWarehouse = new Warehouse();
        mySalesOrder.addListener(myWarehouse);

        Delivery myDelivery = new Delivery();
        mySalesOrder.addListener(myDelivery);

        Event myEvent = new Event();
        // Now 'myDelivery' and 'myWarehouse' objects will receive 'myEvent'
        // object on their 'onEvent(Event event)' method
        System.out.println("Event to be published: " + myEvent);
        mySalesOrder.publishEvent(myEvent);
    }
}

interface Listener {
    public void onEvent(Event event);
}

class Event {
    // Add reqired detail here!
}

class SalesOrder {
    private List<Listener> listeners = new ArrayList<Listener>();

    public void addListener(Listener listener) {
        listeners.add(listener);
    }

    public void removeListener(Listener listener) {
        listeners.remove(listener);
    }

    // Use proper access modifier
    public void publishEvent(Event event) {
        System.out.println(this + " is goint to publish " + event
                + " to " + listeners + " listeners.");
        for (Listener listener : listeners) {
            listener.onEvent(event);
        }
    }

    // ...
}

class Warehouse implements Listener {
    public void onEvent(Event event) {
        // Do something when event received
        System.out.println(event + " received at " + this);
    }
    // ...
}

class Delivery implements Listener {
    public void onEvent(Event event) {
        // Do something when event received
        System.out.println(event + " received at " + this);
    }
    // ...
}

import java.util.ArrayList；
导入java.util.List；
公开课考试{
公共静态void main（字符串[]args）{
SalesOrder mySalesOrder=新SalesOrder（）；
仓库myWarehouse=新仓库（）；
mySalesOrder.addListener（myWarehouse）；
交货期myDelivery=新交货期（）；
mySalesOrder.addListener（myDelivery）；
Event myEvent=新事件（）；
//现在“myDelivery”和“myWarehouse”对象将接收“myEvent”
//对象的“onEvent（Event）”方法上的
System.out.println（“要发布的事件：+myEvent”）；
mySalesOrder.publishEvent（myEvent）；
}
}
接口侦听器{
公共无效事件（事件）；
}
班级活动{
//在此添加所需的详细信息！
}
类销售订单{
私有列表侦听器=新的ArrayList（）；
公共void addListener（侦听器侦听器）{
添加（侦听器）；
}
公共void RemovelListener（侦听器侦听器）{
删除（侦听器）；
}
//使用适当的访问修饰符
公共事件（事件）{
System.out.println（此+“将发布”+事件
+“到”+侦听器+“侦听器”）；
for（侦听器：侦听器）{
onEvent（事件）；
}
}
// ...
}
类仓库实现侦听器{
公共无效事件（事件）{
//收到事件后做某事
System.out.println（事件+”在“+此”接收）；
}
// ...
}
类传递实现侦听器{
公共无效事件（事件）{
//收到事件后做某事
System.out.println（事件+”在“+此”接收）；
}
// ...
}

如果您运行它，它将打印如下内容：

待公布的活动：Event@190d11

SalesOrder@a90653即将出版Event@190d11到[Warehouse@de6ced, Delivery@c17164]听众

Event@190d11在收到Warehouse@de6ced

Event@190d11在收到Delivery@c17164

---

这是一个琐碎的例子，在实际的用例中，你可以考虑使用线程安全的实现和重构，使用构图或继承从Suffice订单中注册。

你还没有真正描述你想要的东西。您刚刚给出了一些方法签名，但没有真正表明您希望从它们那里获得的行为（甚至您的“事件”来自何处）……为什么不允许使用观察者模式这一看似武断的限制？