事件驱动模型的原理不再赘述，Swing是不错的实现。别人也有不错的博文来说明原理。
本文的目的是提供一种简单的，可供参考的简短代码，用来帮助理解该模型。
Project Navigator
Event
事件通用接口：
package org.joshua.event.events;
public interface Event {
}
Click事件:
package org.joshua.event.events;
public class ClickEvent implements Event {
}
Double click事件：
package org.joshua.event.events;
public class DblClickEvent implements Event {
}
Listener
事件监听器通用接口：
package org.joshua.event.listener;
import org.joshua.event.events.Event;
public interface EventListener<T extends Event> {
public void handleEvent(T event);
}
Click事件监听器：
package org.joshua.event.listener;
import org.joshua.event.events.ClickEvent;
public interface ClickEventHandler extends EventListener<ClickEvent> {
}
Double Click事件监听器：
package org.joshua.event.listener;
import org.joshua.event.events.DblClickEvent;
public interface DblClickEventHandler extends EventListener<DblClickEvent> {
}
Event Source
事件源通用接口：
package org.joshua.event.source;
import org.joshua.event.events.Event;
import org.joshua.event.listener.EventListener;
public interface EventSource {
void addEventListener(EventListener<? extends Event> listener);
void removeEventListener(EventListener<? extends Event> listener);
void notifyListeners(Event event);
}
模拟的按钮控件：
package org.joshua.event.source;
import java.util.LinkedList;
import java.util.List;
import org.joshua.event.events.Event;
import org.joshua.event.listener.EventListener;
public class Button implements EventSource {
protected List<EventListener<? extends Event>> listeners = new LinkedList<EventListener<? extends Event>>();
@Override
public void addEventListener(EventListener<? extends Event> listener) {
listeners.add(listener);
}
@Override
public void removeEventListener(EventListener<? extends Event> listener) {
listeners.remove(listener);
}
@Override
public void notifyListeners(Event event) {
for (EventListener listener : listeners) {
try {
listener.handleEvent(event);
} catch (ClassCastException e) {
}
}
}
}
Client
package org.joshua.event;
import org.joshua.event.events.ClickEvent;
import org.joshua.event.events.DblClickEvent;
import org.joshua.event.events.Event;
import org.joshua.event.listener.ClickEventHandler;
import org.joshua.event.listener.DblClickEventHandler;
import org.joshua.event.source.Button;
import org.junit.Before;
import org.junit.Test;
public class Client {
private Event currentEvent;
private Button button;
@Before
public void initComponent() {
button = new Button();
button.addEventListener(new ClickEventHandler() {
@Override
public void handleEvent(ClickEvent event) {
System.out.println("Button was clicked!");
}
});
button.addEventListener(new DblClickEventHandler() {
@Override
public void handleEvent(DblClickEvent event) {
System.out.println("Button was double clicked!");
}
});
}
@Test
public void testCommonEvents() {
currentEvent = new ClickEvent();
button.notifyListeners(currentEvent);
currentEvent = new DblClickEvent();
button.notifyListeners(currentEvent);
}
}
Button类中的notifyListener方法实现起来虽方便，利用了一把异常机制，但着实不推荐大家在项目中这样做。且不说性能问题，Listener的handleEvent方法里所有抛出的ClassCastException都需要重新包装。当然，我们可以使用annotation、限定类名等方式相对优雅地解决event和对应listener的mapping问题。
多线程事件处理机制
思路是用队列暂存事件，然后若干个事件分发器将事件分发给指定数量的事件处理线程处理。
package com.joshua.test.event;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import com.joshua.test.event.event.Event;
import com.joshua.test.event.event.EventType;
import com.joshua.test.event.handler.CreateEventHandler;
public class EventManager {
private static final int EVENT_QUEUE_LENGTH = 1000;
private static final int DISPATCHER_NUM = 2;
private static final int EVENT_HANDLER_NUM = 10;
public BlockingQueue<Event> eventQueue = new LinkedBlockingQueue<Event>(EVENT_QUEUE_LENGTH);
private ExecutorService eventHandlerPool;
protected EventDispatcher createDispatcher() {
EventDispatcher dispatcher = new EventDispatcher(this.eventQueue, this.eventHandlerPool);
dispatcher.register(EventType.CREATE, CreateEventHandler.class);
return dispatcher;
}
public void init() {
eventHandlerPool = Executors.newFixedThreadPool(EVENT_HANDLER_NUM);
}
public void start() {
for (int i = 0; i < DISPATCHER_NUM; i++) {
createDispatcher().start();
}
}
public void notify(Event event) {
try {
eventQueue.put(event);
} catch (InterruptedException e) {
}
}
}
package com.joshua.test.event;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import com.joshua.test.event.event.Event;
import com.joshua.test.event.event.EventType;
import com.joshua.test.event.handler.EventHandler;
@SuppressWarnings("rawtypes")
public class EventDispatcher {
private final BlockingQueue<Event> eventQueue;
private final ExecutorService eventHandlerPool;
protected final Map<EventType, Class<? extends EventHandler>> eventDispatchers = new HashMap<EventType, Class<? extends EventHandler>>();
private Thread eventHandlingThread;
private volatile boolean stopped = false;
public EventDispatcher(BlockingQueue<Event> eventQueue, ExecutorService eventHandlerPool) {
this.eventQueue = eventQueue;
this.eventHandlerPool = eventHandlerPool;
System.out.println("Event dispatcher starting...");
}
Runnable createThread() {
return new Runnable() {
@Override
public void run() {
while (!stopped && !Thread.currentThread().isInterrupted()) {
Event event;
try {
event = eventQueue.take();
} catch (InterruptedException ie) {
if (!stopped) {
System.out.println("Dispatcher thread interrupted");
ie.printStackTrace();
}
return;
}
if (event != null) {
dispatch(event);
}
}
}
};
}
@SuppressWarnings("unchecked")
protected void dispatch(Event event) {
EventType type = event.getType();
try {
Class<? extends EventHandler> handlerClazz = eventDispatchers
.get(type);
if (handlerClazz != null) {
EventHandler handler = handlerClazz.newInstance();
handler.setEvent(event);
eventHandlerPool.submit(handler);
} else {
throw new Exception("No handler for registered for " + type);
}
} catch (Throwable t) {
System.err.println("Error in dispatcher thread");
t.printStackTrace();
System.exit(-1);
}
}
public void register(EventType eventType,
Class<? extends EventHandler> handler) {
Class<? extends EventHandler> registeredHandler = eventDispatchers
.get(eventType);
System.out.println("Registering " + eventType + " for "
+ handler);
if (registeredHandler == null) {
eventDispatchers.put(eventType, handler);
}
}
public void start() {
eventHandlingThread = new Thread(createThread());
eventHandlingThread.setName("AsyncDispatcher event handler");
eventHandlingThread.start();
System.out.println("Event dispatcher started!");
}
public void stop() {
stopped = true;
if (eventHandlingThread != null) {
eventHandlingThread.interrupt();
try {
eventHandlingThread.join();
} catch (InterruptedException ie) {
System.out.println("Interrupted Exception while stopping");
ie.printStackTrace();
}
}
}
}
相关推荐
下面是一个基于事件驱动模型的简单实现： ```java import javax.swing.*; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; public class EventDrivenExample { public static void ...
下面我们将通过一个具体的例子来说明如何在Java Swing中实现事件驱动模型。假设我们有一个简单的按钮，当用户点击这个按钮时，界面上会显示一条消息。 ```java import javax.swing.*; import java.awt.event....
Spring框架是Java开发中广泛应用的一个开源框架，它提供了一种事件驱动模型来增强应用程序的组件之间的通信。在本文中，我们将深入探讨Spring事件驱动模型，理解其工作原理，并通过源码分析来深化认识。 首先，...
事件驱动模型是一种软件设计模式，它基于异步通信和消息传递的概念来构建应用程序。在这种模型中，系统的行为是由发生的事件来触发的，而不是由预先设定的顺序执行的指令。事件可以是用户操作、硬件状态改变、定时器...
这个Java实现的DEMO将帮助我们理解如何在编程环境中构建和应用ARIMA模型进行时间序列预测。以下是关于ARIMA模型和Java实现的相关知识点： 1. **ARIMA模型介绍**： - **自回归项（AR）**：ARIMA模型基于历史观测值...
- **自定义事件和监听器**：除了内置的事件和监听器，开发者还可以根据需求自定义事件类和监听器接口，以扩展事件驱动模型。 在实际编程中，我们可以通过以下步骤实现事件驱动： 1. 创建事件源，如按钮、文本框等...
例如，Java NIO（非阻塞I/O）库就使用了事件驱动模型，通过Selector监听多个通道上的事件，实现高效的I/O操作。 总的来说，Java事件驱动编程是构建交互式应用程序的关键技术，通过分离事件生成和事件处理，使程序...
总结来说，"（本科毕业设计）解释结构模型的Java实现"是一项综合运用面向对象编程、事件驱动编程、设计模式和用户界面设计的实践项目。通过这个项目，学生可以深入理解软件工程的多个方面，包括系统建模、代码组织、...
在Spring框架中，事件驱动模型主要由三部分组成：事件（Event）、事件监听器（EventListener）和事件发布者（EventPublisher）。当某个组件发生特定事件时，它会创建一个事件对象并将其发布给感兴趣的监听器，这些...
在编程领域，事件驱动风格和观察者模式是两种常见的设计模式，它们在Java开发中有着广泛的应用。这两种模式主要用于处理异步数据处理和组件之间的通信，使得程序更加灵活且易于维护。 事件驱动风格是一种编程范式，...
在本示例中，我们将深入探讨如何使用Java驱动实现与MongoDB的交互。 首先，确保已经在项目中引入了MongoDB的Java驱动依赖。通常，这可以通过Maven或Gradle完成。在Maven的`pom.xml`文件中，添加以下依赖： ```xml ...
在Java编程环境中实现ARIMA模型，可以为各种业务场景提供数据驱动的决策支持，例如销售预测、股票市场分析等。 自回归（AR）部分是指模型利用过去一定期数的值来预测未来的值，这些历史值以线性组合的形式出现在...
模型驱动下的Java代码自动生成 模型驱动下的Java代码自动生成是指通过模型驱动的方法来生成Java代码，这种方法可以提高软件开发的效率和质量。在这种方法中，领域专家可以使用元建模工具来建立领域模型，然后通过...
标题中的“模拟Java事件驱动”指的是创建一个小型的Java程序，该程序通过模拟实际应用中的事件处理流程，展示了如何在Java环境中实现事件驱动机制。这个程序可能包括事件源（如按钮）、事件监听器（用于监听事件）...
2. **领域事件**（Domain Event）：在源码中，可能会发现领域事件的实现，这是一种记录系统中重要业务变化的方式，常用于解耦不同的领域服务或实现异步处理。 3. **应用服务**：应用服务层是DDD架构中的一个重要...
在实现过程中，可以使用Java的事件驱动模型，如`java.util.EventObject`和`java.util.EventListener`，或者使用观察者模式来构建消息总线的基础设施。此外，Java的并发库（如`java.util.concurrent`包）将有助于处理...
如果您习惯于传递在事件驱动编程模型中调用的函数指针，则您会喜欢本技巧。 熟悉MS-Windows和X Window System事件驱动编程模型的开发人员，习惯于传递在某种事件发生时调用（即“回调”）的函数指针。Java的面向...
4. **事件驱动编程**：在司机抢单的逻辑中，可能采用了事件驱动的设计模式。比如，当有新的打车请求到达时，会触发一个事件，司机端接收到这个事件后进行抢单操作。这可能涉及到Java的Observer设计模式或者发布/订阅...
4. 该机制使软件开发人员能够直观地使用Java语言标准语法实现面向对象模型，与采用try-catch结构实现事件驱动程序模型相比，本文的消息传递机制与人们所习惯的Visual Studio中的framework的消息机制相似，便于在事件...
4. **事件驱动编程**：电风扇程序可能使用事件驱动模型，比如当用户点击控制按钮时触发事件，事件处理器负责更新电风扇状态。Java Swing或JavaFX等库提供了丰富的GUI组件和事件处理机制。 5. **线程池**：为了提高...