Gestionnaire d'événements personnalisé GWT
Quelqu'un peut-il me donner un exemple de création d'un ensemble personnalisé d'un événement et d'un gestionnaire. Supposons que vous ayez un objet Personne que vous souhaitez que vos widgets sachent s'il a été mis à jour.
Vous créez un HandlerManager et vous devez maintenant créer un événement et un gestionnaire. Comment définiriez-vous ces classes afin de pouvoir vous abonner et déclencher des événements?
La plupart des événements sont basés sur DOM, alors que je veux créer des événements et des gestionnaires personnalisés que je peux déclencher en dehors de tout événement basé sur un navigateur.
Voici un exemple assez complet de création d'un événement personnalisé, extrait textuellement du GwtEventSystem Wiki (lorsque le système d'événements était encore dans l'incubateur de GWT).
Il s'agit d'un événement qui se déclenche lorsque l'utilisateur est satisfait.
Définissez une nouvelle classe d'événements. Vous pouvez ajouter des métadonnées arbitraires dans la classe d'événements. Par souci de simplicité, nous n'en inclurons pas ici cependant.
public class HappyEvent extends GwtEvent {
...
}
Définissez une nouvelle interface de gestionnaire et de marqueur pour la classe d'événements.
interface HappyHandler extends EventHandler {
public void onHappiness(HappyEvent event);
}
interface HasHappyEvents {
public HandlerRegistration addHappyHandler(HappyHandler handler);
}
Ajouter un type d'événement unique
class HappyEvent extends AbstractEvent{
public static AbstractEvent.Key KEY = new AbstractEvent.Key(){...}
public GwtEvent.Key getKey(){
return KEY;
}
...
}
Câblez la méthode d'incendie du gestionnaire
class HappyEvent extends GwtEvent {
static Key<HappyEvent,HappyHandler> KEY = new Key<HappyEvent,HappyHandler>(){
protected void fire(HappyHandler handler, HappyEvent event) {
handler.onHappiness(event);
};
...
}
Merci pour toutes les réponses. Zakness est venu le plus près de me donner la réponse dont j'avais besoin, cependant, j'ai trouvé un modèle légèrement plus simple.
Mon objectif principal était d'éviter d'utiliser une variable statique dans ma structure de données principale. J'ai également rencontré le problème d'essayer de déterminer si cette structure de données principale a été récupérée avec succès de la base de données au moment où vous essayez d'y accéder et que faire quand elle ne l'est pas (c'est-à-dire lorsqu'elle est nulle).
Après avoir regardé la vidéo Google Web Toolkit Architecture: Best Practices For Architecting Your GWT App de Google IO, l'idée du bus d'événements semblait parfaite.
Je posterai ma solution ici au cas où cela aiderait quelqu'un d'autre.
Créez d'abord la classe Handler. Notez déjà la référence à la classe Event:
public interface CategoryChangeHandler extends EventHandler {
void onCategoryChange(CategoryChangeEvent event);
}
Passons maintenant à la classe Event. Cela m'a donné le plus de mal:
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;
}
}
Maintenant, je suis capable d'utiliser ces classes de gestionnaire et d'événement comme ceci lorsque cette structure de données principale est rechargée:
Ce code a obtenu la structure des données et souhaite informer tous ceux qui écoutent qu'il a été mis à jour:
CategoryChangeEvent event = new CategoryChangeEvent(result);
eventBus.fireEvent(event);
Ce code est une implémentation de l'événement
public class PopulateCategoryHandler implements CategoryChangeHandler {
@Override
public void onCategoryChange(CategoryChangeEvent event) {
tearDownCategories();
List<Category> categories = event.getCategories();
populateCategories(categories);
}
}
Voici n exemple de cela sur le blog d'Alex Reid, y compris un lien vers un exemple de code opérationnel . L'exemple remplit certains des bits flous et, avec l'exemple de Nick ici, aide à clarifier les premiers pas avec l'architecture d'un bus d'événements dans votre application gwt.
Je pense que l'exemple le plus complet et le plus détaillé se trouve dans cet article
Il contient également un exemple de projet qui montre exactement comment utiliser correctement les événements personnalisés de définition et utiliser la classe HandlerManager de GWT.
Un commentaire supplémentaire: si vous essayez de faire quelque chose de similaire pour réagir dans une application principale à un événement déclenché à partir d'un composant GUI personnalisé (comme un composite, etc.), je pense que vous devez câbler l'application principale explicitement pour gérer l'événement du composant:
yourComponent.addHandler(this, YourEvent.TYPE);
où "this" est la classe qui implémente votre interface de gestionnaire personnalisé.
Créer des événements GWT personnalisés à l'aide de HandlerManger ne devrait pas être aussi difficile, jetez un œil à l'exemple GwtEventBus @ NingZhang.info c'est vraiment intuitif. Les classes clés utilisées sont:
- com.google.gwt.event.shared.HandlerManager
- com.google.gwt.event.shared.GwtEvent
- com.google.gwt.event.shared.EventHandler
Vous voudrez peut-être jeter un œil aux ValueChangeHandler et ValueChangeEvent dans GWT 1.6. Cela pourrait fonctionner pour ce que vous essayez de faire.
On dirait que vous voulez le support de PropertyChange *. Jetez un oeil à gwtx . Google "gwt PropertyChange" et vous obtiendrez plusieurs blogs qui expliquent comment l'utiliser.