java - GWT Custom Event Handler

events javascript-events

Question

¿Puede alguien darme un ejemplo de cómo crear un conjunto personalizado de un evento y un controlador? Digamos que tiene un objeto Persona que quiere que sus widgets sepan si se actualizó.

Crea un HandlerManager y ahora tiene que crear un evento y un controlador. ¿Cómo definirías esas clases para que puedas suscribirte y disparar eventos?

La mayoría de los eventos están basados ​​en DOM, mientras que deseo crear algunos eventos y controladores personalizados que pueda activar fuera de cualquier evento basado en navegador.

Answer 1

Aquí hay un ejemplo de esto en el blog de Alex Reid, que incluye un enlace a un ejemplo de código operativo . El ejemplo rellena algunos de los bits difusos y, junto con el ejemplo de Nick aquí, ayuda a aclarar cómo empezar a diseñar un bus de eventos en su aplicación gwt.

Answer 2

Crear eventos GWT personalizados utilizando HandlerManger no debería ser tan difícil, eche un vistazo al ejemplo GwtEventBus @ NingZhang.info es realmente intuitivo. Las clases clave utilizadas son:

• com.google.gwt.event.shared.HandlerManager
• com.google.gwt.event.shared.GwtEvent
• com.google.gwt.event.shared.EventHandler

Answer 3

Creo que el ejemplo más completo y detallado es en este artículo

Contiene también un proyecto de ejemplo que muestra exactamente cómo usar correctamente definir eventos personalizados y usar la clase HandlerManager de GWT.

Answer 4

Es posible que desee echar un vistazo a ValueChangeHandler y ValueChangeEvent en GWT 1.6. Esos podrían funcionar para lo que estás tratando de hacer.

Answer 5

Este es un ejemplo bastante completo de cómo crear un evento personalizado, tomado textualmente de la wiki de GwtEventSystem (cuando el sistema de eventos todavía estaba en la incubadora de GWT).

Este es un evento que se desencadena cuando el usuario se vuelve feliz.

Definir una nueva clase de evento. Puede agregar metadatos arbitrarios en la clase de evento. Por simplicidad, no incluiremos ninguno aquí.

public class HappyEvent extends GwtEvent {
  ...
}

Defina un nuevo controlador y una interfaz de marcador para la clase de evento.

interface HappyHandler extends EventHandler {
  public void onHappiness(HappyEvent event);
}

interface HasHappyEvents {
  public HandlerRegistration addHappyHandler(HappyHandler handler);
}

Agregar un tipo de evento único

class HappyEvent extends AbstractEvent{
  public static AbstractEvent.Key KEY = new AbstractEvent.Key(){...}

  public GwtEvent.Key getKey(){
    return KEY; 
  }
  ...
}

Conecta el método de disparo del controlador

class HappyEvent extends GwtEvent {
  static Key<HappyEvent,HappyHandler> KEY = new Key<HappyEvent,HappyHandler>(){
    protected void fire(HappyHandler handler, HappyEvent event) {
       handler.onHappiness(event);
    };
   ...
}

Answer 6

Gracias por todas las respuestas. Zakness fue lo más cercano a darme la respuesta que necesitaba, sin embargo, se me ocurrió un modelo un poco más simple.

Mi objetivo principal era evitar el uso de una variable estática para mi estructura de datos principal. También abordé el problema de tratar de averiguar si esa estructura de datos principal se recuperó con éxito de la base de datos al momento de intentar acceder a ella y qué hacer cuando no (es decir, cuando es nula).

Después de ver la Arquitectura de Google Web Toolkit: Mejores prácticas para diseñar su video de la aplicación GWT de Google IO, la idea de Event Bus parecía perfecta.

Voy a publicar mi solución aquí en caso de que ayude a alguien más.

Primero, crea la clase Handler. Tenga en cuenta la referencia a la clase Event ya:

public interface CategoryChangeHandler extends EventHandler {
    void onCategoryChange(CategoryChangeEvent event);
}

Ahora a la clase de eventos. Esto me dio más problemas:

public class CategoryChangeEvent extends GwtEvent<CategoryChangeHandler> {

    private final List<Category> category;

    public CategoryChangeEvent(List<Category> category) {
        super();
        this.category = category;
    }

    public static final Type<CategoryChangeHandler> TYPE = new Type<CategoryChangeHandler>();

    @Override
    protected void dispatch(CategoryChangeHandler handler) {
        handler.onCategoryChange(this);
    }

    @Override
    public com.google.gwt.event.shared.GwtEvent.Type<CategoryChangeHandler> getAssociatedType() {
        return TYPE;
    }

    public List<Category> getCategories(){
        return category;
    }

}

Ahora puedo usar estas clases de Controlador y Evento de forma similar cuando esta estructura de datos principal se vuelve a cargar:

Este código tiene la estructura de datos y desea notificar a todos los que están escuchando que se actualizó:

CategoryChangeEvent event = new CategoryChangeEvent(result);
eventBus.fireEvent(event);

Este código es una implementación del evento

public class PopulateCategoryHandler implements CategoryChangeHandler {

    @Override
    public void onCategoryChange(CategoryChangeEvent event) {
        tearDownCategories();

        List<Category> categories = event.getCategories();
        populateCategories(categories); 
    }

}

Answer 7

Parece que quieres el soporte de PropertyChange *. Eche un vistazo a gwtx . Google ''gwt PropertyChange'' y obtendrá múltiples blogs que explican cómo usarlo.

Answer 8

Un comentario adicional: si intenta hacer algo similar para reaccionar en una aplicación principal a un evento disparado desde un componente GUI personalizado (como un compuesto, etc.), creo que tiene que conectar la aplicación principal explícitamente para manejar el evento del componente:

yourComponent.addHandler(this, YourEvent.TYPE);

donde "this" es la clase que implementa su interfaz de controlador personalizado.