GWT自定义事件 [英] GWT Custom Events
问题描述
我有2个班和一个班级。当男人与块碰撞时，该人触发一个事件（onCollision（）），然后阻止类侦听该事件。
谢谢
一般事件：
事件始终被发送以通知某事（例如，州）。我们来看一个男人和一个墙上的例子。在这里我们可以想象，有一个游戏，用户可以作为一个迷宫中的人走路。每当用户撞到墙壁时，应该通知碰撞，以便它可以对其进行反应（例如，墙壁可以将其自身视为破坏的墙壁）。这可以通过在每次与墙壁发生碰撞时发送碰撞事件来实现。这个事件是由一个人发送的，并且系统感兴趣的系统中的每个对象接收到它，并且可以相应地对其进行反应。想要接收事件的对象必须注册自己对事件感兴趣。
这是事件在每个系统或框架（不仅在GWT中）一般工作的方式。为了在这样的系统中发送和接收事件，您必须定义：
- 发送什么（事件看起来如何）
- 谁收到事件（事件接收者）
- 谁发送事件（事件发送者）
然后你可以：
- 注册要接收事件的活动接收者
- 发送活动
GWT中的活动：
这里我将展示一个在GWT中使用自定义事件的例子。我将使用一个负责检查邮箱并通知用户是否有新邮件的系统的示例。我们假设在系统中至少有两个组件：
- 消息检查器负责检查邮箱和
- 负责显示新邮件的消息显示器
消息检查器在收到新邮件时发送事件，消息显示接收到这些事件
步骤1：定义事件
有关新邮件的信息将作为 MessageReceivedEvent class。该类包含一个新的邮件（为了简单，我们假设它只是一个 String ）。
此类的完整源代码如下（其注释在源代码下面）。
public class MessageReceivedEvent extends GwtEvent< MessageReceivedEventHandler> {
public static Type< MessageReceivedEventHandler> TYPE = new Type< MessageReceivedEventHandler>（）;
private final String message;
public MessageReceivedEvent（String message）{
this.message = message;
}
@Override
public Type< MessageReceivedEventHandler> getAssociatedType（）{
return TYPE;
}
@Override
protected void dispatch（MessageReceivedEventHandler handler）{
handler.onMessageReceived（this）;
}
public String getMessage（）{
return message;
}
}
MessageReceivedEventHandler 是表示事件接收器的接口。不要在此刻麻烦，这将在后面讨论。
每个代表GWT事件的类必须扩展 GwtEvent 类。该类包含两个必须实现的抽象方法： getAssociatedType 和 dispatch 。然而，在每个事件类中，它们通常以非常类似的方式实现。
该类存储有关接收到的消息的信息（请参阅构造函数）。每个事件接收者都可以使用 getMessage 方法获取它。
步骤2：定义事件接收器
GWT中的每个事件类型与表示此事件类型的接收器的接口相关联。在GWT接收器中称为处理程序。在该示例中， MessageReceivedEvent 的事件接收器界面将被命名为 MessageReceivedEventHandler 。源代码如下：
public interface MessageReceivedEventHandler扩展EventHandler {
void onMessageReceived（MessageReceivedEvent event）;
}
每个处理程序必须扩展 EventHandler 界面。它还应该定义一个在事件发生时调用的方法（它应该至少需要一个参数 - 一个事件）。这里的方法名为 onMessageReceived 。每个接收者可以通过实现此方法对事件做出反应。
示例中唯一的事件接收者是 MessageDisplayer ：
public class MessageDisplayer实现MessageReceivedEventHandler {
@Override
public void onMessageReceived（MessageReceivedEvent event）{
String newMessage = event.getMessage（）;
//显示新消息
// ...
}
}
步骤3：定义事件发送者
在示例中，唯一的事件发件人是负责检查邮件的组件 - EventChecker ：
public class MessageChecker实现HasHandlers {
私人HandlerManager handlerManager;
public MessageChecker（）{
handlerManager = new HandlerManager（this）;
}
@Override
public void fireEvent（GwtEvent<？> event）{
handlerManager.fireEvent（event）;
}
public HandlerRegistration addMessageReceivedEventHandler（
MessageReceivedEventHandler handler）{
return handlerManager.addHandler（MessageReceivedEvent.TYPE，handler）;
}
}
每个事件发送者必须实现 HasHandlers 接口。
这里最重要的元素是一个 HandlerManager 字段。在GWT HandlerManager 中，建议管理事件处理程序（事件接收器）。正如开头所说，每个想要接收事件的事件接收者都必须注册自己感兴趣。这是处理程序管理员所用的。他们可以注册事件处理程序，他们可以向每个注册的事件处理程序发送一个特定的事件。
当一个 HanlderManager 创建它在其构造函数中需要一个参数。每个事件都有源代码，此参数将被用作此处理程序管理器发送的所有事件的源。在这个例子中，它是这个，因为事件的来源是 MessageChecker 。
fireEvent 在 HasHandlers 界面中定义，并负责发送事件。正如你所看到的，只是使用一个处理程序管理器发送（fire）和事件。
addMessageReceivedEventHandler 事件接收者注册自己感兴趣接收事件。再次，处理程序管理器用于此。
步骤4：绑定事件接收者与事件发送者
定义的事件接收器必须在事件发送器中注册自己。这通常在创建对象期间完成：
MessageChecker checker = new MessageChecker（）;
MessageDisplayer displayer = new MessageDisplayer（）;
checker.addMessageReceivedEventHandler（displayer）;
现在由 checker 发送的所有事件都将
步骤5：发送事件
要发送一个事件， MessageChecker 必须创建一个事件实例并使用 fireEvent 方法发送。这个手杖可以在 newMailReceived 方法中完成：
public class MessageChecker实现HasHandlers {
// ...不重要的东西省略
public void newMailReceived（）{
String mail =; //从邮箱获取新邮件
MessageReceivedEvent event = new MessageReceivedEvent（mail）;
fireEvent（event）;
}
}
我希望很清楚，帮助：）
Hey I have a problem getting my head around how custom GWT event Handlers work. I have read quite a bit about the topic and it still is some what foggy. I have read threads here on Stackoverflow like this one GWT Custom Event Handler. Could someone explain it in an applied mannar such as the following.
I have 2 classes a block and a man class. When the man collides with the block the man fires an event ( onCollision() ) and then the block class listens for that event.
Thanks
Events in general:
Events are always sent to inform about something (e.g. a change of state). Let's take your example with a man and a wall. Here we can imagine that there is a game where a user can walk as a man in a labyrinth. Every time a user hits the wall it should be informed about the collision so that it can react to it (e.g. a wall can render itself as a destroyed wall). This can be achieved by sending a collision event every time the collision with a wall is detected. This event is sent by a man and every object in the system interested in the event receives it and can react to it accordingly. Objects which want to receive events must register themselves as interested with event.
This is how events work in general in every system or framework (not only in GWT). In order to send and receive events in such systems you have to define:
- What is sent (what do events look like)
- Who receives events (event receivers)
- Who sends events (event senders)
Then you can:
- Register event receivers which want to receive events
- Send events
Events in GWT:
Here I will show an example of using custom events in GWT. I will use an example of a system which is responsible for checking a mailbox and inform a user if there are new mails. Let's assume that in the system there are at least 2 components:
- message checker responsible for checking the mailbox and
- message displayer responsible for displaying new mails
Message checker sends events when a new mail is received and message displayer receives these events.
Step 1: Define events
Information about a new mail will be sent as an instance of MessageReceivedEvent class. The class contains a new mail (for the simplicity let's assume it is just a String).
Full source code of this class is presented below (the comment for it is below the source code).
public class MessageReceivedEvent extends GwtEvent<MessageReceivedEventHandler> {
public static Type<MessageReceivedEventHandler> TYPE = new Type<MessageReceivedEventHandler>();
private final String message;
public MessageReceivedEvent(String message) {
this.message = message;
}
@Override
public Type<MessageReceivedEventHandler> getAssociatedType() {
return TYPE;
}
@Override
protected void dispatch(MessageReceivedEventHandler handler) {
handler.onMessageReceived(this);
}
public String getMessage() {
return message;
}
}
MessageReceivedEventHandler is an interface that represents event receivers. Don't bother with it at the moment, this will be discussed later.
Every class representing a GWT event has to extend GwtEvent class. This class contains two abstract methods which must be implemented: getAssociatedType and dispatch. However in every event class they are usually implemented in a very similar way.
The class stores information about a received message (see constructor). Every event receiver can get it using getMessage method.
Step 2: Define event receivers
Each event type in GWT is associated to an interface representing receivers of this event type. In GWT receivers are called handlers. In the example an event receiver interface for MessageReceivedEvent will be named MessageReceivedEventHandler. The source code is below:
public interface MessageReceivedEventHandler extends EventHandler {
void onMessageReceived(MessageReceivedEvent event);
}
Each handler has to extend EventHandler interface. It should also define a method which will be invoked when an event occurs (it should take at least one parameter - an event). Here the method is named onMessageReceived. Each receiver can react on an event by implementing this method.
The only event receiver in the example is MessageDisplayer component:
public class MessageDisplayer implements MessageReceivedEventHandler {
@Override
public void onMessageReceived(MessageReceivedEvent event) {
String newMessage = event.getMessage();
// display a new message
// ...
}
}
Step 3: Define event senders
In the example the only event sender is a component responsible for checking mails - EventChecker:
public class MessageChecker implements HasHandlers {
private HandlerManager handlerManager;
public MessageChecker() {
handlerManager = new HandlerManager(this);
}
@Override
public void fireEvent(GwtEvent<?> event) {
handlerManager.fireEvent(event);
}
public HandlerRegistration addMessageReceivedEventHandler(
MessageReceivedEventHandler handler) {
return handlerManager.addHandler(MessageReceivedEvent.TYPE, handler);
}
}
Every event sender has to implement HasHandlers interface.
The most important element here is a HandlerManager field. In GWT HandlerManager as the name suggest manages event handlers (event receivers). As it was said at the beginning every event receiver that wants to receive events must register itself as interested. This is what handler managers are for. They make it possible to register event handlers an they can send a particular event to every registered event handler.
When a HanlderManager is created it takes one argument in its constructor. Every event has a source of origin and this parameter will be used as a source for all events send by this handler manager. In the example it is this as the source of events is MessageChecker.
The method fireEvent is defined in HasHandlers interface and is responsible for sending events. As you can see it just uses a handler manager to send (fire) and event.
addMessageReceivedEventHandler is used by event receivers to register themselves as interested in receiving events. Again handler manager is used for this.
Step 4: Bind event receivers with event senders
When everything is defined event receivers must register themselves in event senders. This is usually done during creation of objects:
MessageChecker checker = new MessageChecker();
MessageDisplayer displayer = new MessageDisplayer();
checker.addMessageReceivedEventHandler(displayer);
Now all events sent by checker will be received by displayer.
Step 5: Send events
To send an event, MessageChecker must create an event instance and send it using fireEvent method. This cane be done in newMailReceived method:
public class MessageChecker implements HasHandlers {
// ... not important stuff omitted
public void newMailReceived() {
String mail = ""; // get a new mail from mailbox
MessageReceivedEvent event = new MessageReceivedEvent(mail);
fireEvent(event);
}
}
I hope it is clear and will help :)
这篇关于GWT自定义事件的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
