events - preparado - Eventos personalizados GWT
google tag manager (4)
Eventos en general:
Los eventos siempre se envían para informar sobre algo (por ejemplo, un cambio de estado). Tomemos su ejemplo con un hombre y una pared. Aquí podemos imaginar que hay un juego donde un usuario puede caminar como un hombre en un laberinto. Cada vez que un usuario golpea la pared, se le debe informar acerca de la colisión para que pueda reaccionar (por ejemplo, una pared puede presentarse como una pared destruida). Esto se puede lograr enviando un evento de colisión cada vez que se detecta una colisión con una pared. Este evento es enviado por un hombre y cada objeto en el sistema interesado en el evento lo recibe y puede reaccionar en consecuencia. Los objetos que desean recibir eventos deben registrarse como interesados con el evento.
Así es como funcionan los eventos en general en cada sistema o marco (no solo en GWT). Para enviar y recibir eventos en dichos sistemas, debe definir:
- Qué se envía (cómo se ven los eventos)
- Quién recibe eventos (receptores de eventos)
- Quién envía eventos (remitentes de eventos)
Entonces tú puedes:
- Registrar receptores de eventos que desean recibir eventos
- Enviar eventos
Eventos en GWT:
Aquí mostraré un ejemplo del uso de eventos personalizados en GWT. Utilizaré un ejemplo de un sistema que es responsable de verificar un buzón e informar a un usuario si hay correos nuevos. Supongamos que en el sistema hay al menos 2 componentes:
- corrector de mensajes responsable de verificar el buzón y
- visualizador de mensaje responsable de mostrar nuevos correos
El verificador de mensajes envía eventos cuando se recibe un nuevo correo y el visualizador de mensajes recibe estos eventos.
Paso 1: definir eventos
La información sobre un nuevo correo se enviará como una instancia de la clase MessageReceivedEvent . La clase contiene un nuevo correo (por simplicidad supongamos que es solo una String ).
El código fuente completo de esta clase se presenta a continuación (el comentario está debajo del código fuente).
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 es una interfaz que representa los receptores de eventos. No te preocupes por eso en este momento, esto se discutirá más adelante.
Cada clase que representa un evento GWT tiene que extender la clase GwtEvent . Esta clase contiene dos métodos abstractos que deben implementarse: getAssociatedType y dispatch . Sin embargo, en cada clase de evento, generalmente se implementan de una manera muy similar.
La clase almacena información sobre un mensaje recibido (ver constructor). Cada receptor de eventos puede obtenerlo usando el método getMessage .
Paso 2: definir receptores de eventos
Cada tipo de evento en GWT está asociado a una interfaz que representa receptores de este tipo de evento. En los receptores GWT se llaman manejadores. En el ejemplo, una interfaz de receptor de eventos para MessageReceivedEvent se llamará MessageReceivedEventHandler . El código fuente está a continuación:
public interface MessageReceivedEventHandler extends EventHandler {
void onMessageReceived(MessageReceivedEvent event);
}
Cada controlador debe extender la interfaz EventHandler . También debe definir un método que se invocará cuando se produzca un evento (debe tomar al menos un parámetro, un evento). Aquí el método se llama onMessageReceived . Cada receptor puede reaccionar en un evento implementando este método.
El único receptor de eventos en el ejemplo es el componente MessageDisplayer :
public class MessageDisplayer implements MessageReceivedEventHandler {
@Override
public void onMessageReceived(MessageReceivedEvent event) {
String newMessage = event.getMessage();
// display a new message
// ...
}
}
Paso 3: definir remitentes de eventos
En el ejemplo, el único remitente del evento es un componente responsable de verificar los correos electrónicos - 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);
}
}
Cada remitente de evento debe implementar la interfaz HasHandlers .
El elemento más importante aquí es un campo HandlerManager . En GWT HandlerManager como el nombre sugiere gestiona los controladores de eventos (receptores de eventos). Como se dijo al principio, cada receptor de eventos que quiera recibir eventos debe registrarse como interesado. Esto es para lo que son los gerentes de controladores. Permiten registrar los controladores de eventos y pueden enviar un evento en particular a cada controlador de eventos registrado.
Cuando se crea un HanlderManager , toma un argumento en su constructor. Cada evento tiene una fuente de origen y este parámetro se usará como fuente para todos los eventos enviados por este administrador de controladores. En el ejemplo, esto es this porque la fuente de los eventos es MessageChecker .
El método fireEvent se define en la interfaz HasHandlers y es responsable de enviar eventos. Como puede ver, solo usa un administrador de controlador para enviar (disparar) y evento.
addMessageReceivedEventHandler es utilizado por los receptores de eventos para registrarse como interesados en recibir eventos. De nuevo, el administrador de manejadores se usa para esto.
Paso 4: enlazar receptores de eventos con remitentes de eventos
Cuando todo está definido, los receptores de eventos deben registrarse en los remitentes de eventos. Esto generalmente se hace durante la creación de objetos:
MessageChecker checker = new MessageChecker();
MessageDisplayer displayer = new MessageDisplayer();
checker.addMessageReceivedEventHandler(displayer);
Ahora todos los eventos enviados por el checker serán recibidos por el displayer .
Paso 5: Enviar eventos
Para enviar un evento, MessageChecker debe crear una instancia de evento y enviarlo utilizando el método fireEvent . Este bastón se realizará en el método newMailReceived :
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);
}
}
Espero que esté claro y ayude :)
Hola, tengo un problema para entender cómo funcionan los manipuladores personalizados de eventos GWT. He leído bastante sobre el tema y todavía es algo confuso. He leído los hilos aquí en Stackoverflow como este GWT Custom Event Handler . ¿Podría alguien explicarlo en un mannar aplicado como el siguiente.
Tengo 2 clases por bloque y una clase de hombre. Cuando el hombre colisiona con el bloque, el hombre dispara un evento (onCollision ()) y luego la clase de bloque escucha ese evento.
Gracias
Creé mi propio widget ampliando la clase Compuesta de GWT. Quería crear mi propio evento personalizado en esta clase. Quería que los eventos estuvieran accesibles para el Editor WindowBuilder de GWT.
Aprendí mucho de las respuestas en esta página, pero tuve que hacer algunos cambios.
Quería comenzar con la respuesta de Hilbrand Bouwkamp, porque era más reciente. Pero me encontré con un par de problemas. 1) Esa respuesta hizo referencia al autobús del evento. El bus par es una variable global propiedad del programa principal. No está claro cómo una biblioteca de widgets podría tener acceso a eso. 2) No empecé de cero. Estaba ampliando el código de la biblioteca GWT. Para que funcione, tuve que comenzar desde la clase GwtEvent, en lugar de la clase Event.
La respuesta de Piotr es esencialmente correcta, pero fue muy larga. Mi clase (indirectamente) amplía la clase de Widget de GWT. Widget se encarga de muchos detalles, como la creación de un objeto HandlerManager. (Miré a través del código fuente, y así es exactamente como funcionan los Widgets estándar, no usando un EventBus).
Solo tuve que agregar dos cosas a mi clase de widget para agregar un controlador de eventos personalizado. Esos se muestran aquí:
public class TrackBar extends Composite {
public HandlerRegistration addValueChangedHandler(TrackBarEvent.Handler handler)
{
return addHandler(handler, TrackBarEvent.TYPE);
}
private void fireValueChangedEvent()
{
final TrackBarEvent e = new TrackBarEvent(value);
fireEvent(e);
}
Mi nuevo evento es casi exactamente igual a la clase de evento de Piotr, que se muestra arriba. Una cosa vale la pena señalar. Empecé con getValue (), basado en ese ejemplo. Más tarde agregué getTrackBar () para dar mucha más información. Si comenzara de cero, me centraría en lo último, no en lo primero. La clase de evento completa se muestra a continuación.
import com.google.gwt.event.shared.EventHandler;
import com.google.gwt.event.shared.GwtEvent;
public class TrackBarEvent extends GwtEvent< TrackBarEvent.Handler >
{
public interface Handler extends EventHandler {
void onTrackBarValueChanged(TrackBarEvent event);
}
static final Type<TrackBarEvent.Handler> TYPE =
new Type<TrackBarEvent.Handler>();
private final int value;
public TrackBarEvent(int value) {
this.value = value;
}
@Override
public Type<TrackBarEvent.Handler> getAssociatedType() {
return TYPE;
}
public int getValue() {
return value;
}
public TrackBar getTrackBar()
{
return (TrackBar)getSource();
}
@Override
protected void dispatch(Handler handler) {
handler.onTrackBarValueChanged(this);
}
}
Dado que esta pregunta y la respuesta de Piotr GWT han agregado soporte para una forma ligeramente diferente de crear eventos personalizados. La implementación de este evento es una compilación específica para ser utilizada con EventBus de GWT en el paquete com.google.web.bindery.event.shared . Un ejemplo sobre cómo crear un evento personalizado para GWT 2.4:
import com.google.web.bindery.event.shared.Event;
import com.google.web.bindery.event.shared.EventBus;
import com.google.web.bindery.event.shared.HandlerRegistration;
/**
* Here is a custom event. For comparison this is also a MessageReceivedEvent.
* This event extends the Event from the web.bindery package.
*/
public class MessageReceivedEvent extends Event<MessageReceivedEvent.Handler> {
/**
* Implemented by methods that handle MessageReceivedEvent events.
*/
public interface Handler {
/**
* Called when an {@link MessageReceivedEvent} event is fired.
* The name of this method is whatever you want it.
*
* @param event an {@link MessageReceivedEvent} instance
*/
void onMessageReceived(MessageReceivedEvent event);
}
private static final Type<MessageReceivedEvent.Handler> TYPE =
new Type<MessageReceivedEvent.Handler>();
/**
* Register a handler for MessageReceivedEvent events on the eventbus.
*
* @param eventBus the {@link EventBus}
* @param handler an {@link MessageReceivedEvent.Handler} instance
* @return an {@link HandlerRegistration} instance
*/
public static HandlerRegistration register(EventBus eventBus,
MessageReceivedEvent.Handler handler) {
return eventBus.addHandler(TYPE, handler);
}
private final String message;
public MessageReceivedEvent(String message) {
this.message = message;
}
@Override
public Type<MessageReceivedEvent.Handler> getAssociatedType() {
return TYPE;
}
public String getMessage() {
return message;
}
@Override
protected void dispatch(Handler handler) {
handler.onMessageReceived(this);
}
}
El evento se usa de la siguiente manera:
Para registrar su controlador para este evento con eventbus llame al método de registro estático en la clase MessageReceivedEvent:
MessageReceivedEvent.register(eventbus, new MessageReceivedEvent.Handler() {
public void onMessageReceived(MessageReceivedEvent event) {
//...do something usefull with the message: event.getMessage();
}
});
Ahora para iniciar el evento en el evento llame a fireEvent con un evento de nueva construcción:
eventBus.fireEvent(new MessageReceivedEvent("my message"));
Se puede encontrar otra implementación en la propia clase de evento EntityProxyChange GWT. Esa implementación usa una opción alternativa de EventBus. Utiliza la capacidad de agregar controladores que están vinculados a una fuente específica, a través de addHandlerToSource y se puede activar a través de eventBus.fireEventFromSource .
La implementación del evento aquí presentada también es más adecuada cuando se trabaja con las Activities de GWT.