La création d'un simple événement driven architecture

Avoir un peu de mal avec un projet pour le moment. Je mets en place un jeu et j'aimerais avoir piloté par les événements.

Pour l'instant j'ai un Gestionnaire d'événements de classe qui a une surcharge de la méthode en fonction du type d'événement est généré(PlayerMove, Contact, Attack, etc)

Je vais avoir le jeu de conducteur ou de la catégorie de générer des événements. Ma question est comment puis-je gérer efficacement les événements sans étroitement couplage de l'événement générant des classes pour le gestionnaire d'événements et de rendre l'utilisation de l'EDA redondant?

Je veux concevoir mon propre simple de gestionnaire et de ne pas utiliser le haut-Java un pour ce

Est votre application multi-thread ou si vous souhaitez utiliser le même fil conducteur pour la génération de/la gestion des événements?
Ainsi, faire la même chose que ce que l'AWT: il utilise des interfaces pour les gestionnaires d'événements (appelé auditeurs dans AWT).
Merci les gars, c'est monothread. Je suis à la recherche d'une belle simplifié de code avec des explications sur la façon de mettre en œuvre ce que l'AWT fait, auriez-vous un lien vers quelque chose comme cela?
C'est surtout le concept que je vais avoir des ennuis avec ici. Dois-je avoir une statique gestionnaire d'événements qui, chaque événement sera l'appel à l'aide de son événement - par exemple dans les ennemi si j'ai une attaque() méthode qui appelle Gestionnaire d'événements.HandleEvent(Attaque). Aurais-je une catégorie distincte de la définition de l'Attaque de l'événement - Gestionnaire d'événements.HandleEvent(nouveau AttackEvent(données, cible))
Voici un de plus haut niveau de l'architecture exemple: medium.com/@wrong.about/... et ici, c'est plus de niveau inférieur: medium.com/@wrong.about/...

OriginalL'auteur SMC | 2012-11-20

  1. 9

    Si vous voulez avoir un seul EventHandler classe avec des méthodes surchargées et vos types d'événements n'ont pas toutes les sous-classes, alors ce simple code, qui utilise la réflexion, devrait fonctionner:

    public class EventHandler {
    public void handle (final PlayerMove move) {
       //... handle
    }

    public void handle (final Contact contact) {
       //... handle
    }

    public void handle (final Attack attack) {
       //... handle
    }
}

public void sendEvent (final EventHandler handler, final Object event) {
    final Method method = EventHandler.class.getDeclaredMethod ("handle", new Class[] {event.getClass ()});
    method.invoke (handler, event);
}

    Toutefois, si vous voulez avoir séparé EventHandlerpour les différents événements, les éléments suivants seraient mieux.

    public interface EventHandler<T extends Event> {
    void handle (T event);
}

public class PlayerMoveEventHandler implements EventHandler<PlayerMove> {
    @Override
    public void handle (final PlayerMove event) {
        //... handle
    }
}

public class EventRouter {
    private final Map<Class, EventHandler> eventHandlerMap = new HashMap<Class, EventHandler> ();

    public void sendEvent (final Event event) {
        eventHandlerMap.get (event.getClass ()).handle (event);
    }

    public void registerHandler (final Class eventClass, final EventHandler handler) {
        eventHandlerMap.put (eventClass, handler);
    }
}
    Super, merci pour l'aide
    Le deuxième exemple ne fonctionne pas. Vous ne pouvez pas passer une Event à une méthode attend un PlayerMove. Vous devrez utiliser la réflexion pour utiliser le routeur pour passer les différents types à des gestionnaires différents si les gestionnaires s'attendent sous-types. Aussi, Class et EventHandler ne devraient pas être utilisés comme matières premières tapé dans EventRouter.

    OriginalL'auteur ShyJ