LG

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
Ici, le pattern utilisé est un peu plus complet, notamment par l'ajout d'une clé dans chaque ''Handle'' permettant de trouver simplement l%%'%%''EventHandler'' correspondant.

{{:helloworld:design_pattern:reactor:java:reactor.png|Diagramme UML version Java}}

Liste des différents types d'événements.
<file java EnumEventType.java>
package reactor;

public enum EnumEventType {
  MessageEvent, ClickEvent
}
</file>

Classe ''Handle'' qui contient l'événement et sa clé de reconnaissance.
<file java Handle.java>
package reactor;

import java.util.EventObject;

public class Handle {
  private String key;
  private EventObject event;

  public EventObject getEvent() {
    return event;
  }

  public String getKey() {
    return key;
  }

  public void setKey(String key) {
    this.key = key;
  }

  public void setEvent(EventObject event) {
    this.event = event;
  }
}
</file>

Interface que doivent implémenter chaque traitement d'événement.
<file java EventHandler.java>
package reactor;

public interface EventHandler {
  public void handleEvent();
  public Handle getHandle();
  public void setHandle(Handle h);
}
</file>

C'est la classe qui s'occupe de faire la correspondance entre l'événement et le traitement.
<file java SynchronousEventDemultplexer.java>
package reactor;

import java.util.ArrayList;

public class SynchronousEventDemultplexer {

  public SynchronousEventDemultplexer() {
    super();
  }

  public EventHandler select(Handle h, ArrayList<EventHandler> list) {
    if (h == null)
    {
      return null;
    }
    for (EventHandler eventHandler : list) {
      if (eventHandler.getHandle().getKey().equals(h.getKey())) {
        eventHandler.setHandle(h);
        return eventHandler;
      }
    }
    
    return null;
  }
}
</file>

Le ''Reactor'' reçoit les événements, les stockent puis les traitent.
<file java Reactor.java>
package reactor;

import java.util.ArrayList;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;

public class Reactor extends Thread {
  private Queue<Handle> receivedHandle;
  private SynchronousEventDemultplexer sync;
  private ArrayList<EventHandler> listEventHandler;

  public Reactor(SynchronousEventDemultplexer sync) {
    super();
    receivedHandle = new ConcurrentLinkedQueue<Handle>();
    listEventHandler = new ArrayList<EventHandler>();
    this.sync = sync;
  }

  public void registerHandler(EventHandler e) {
    listEventHandler.add(e);
  }

  public void removeHandler(EventHandler e) {
    listEventHandler.remove(e);
  }

  public void startHandleEvents() {
    System.out.println("Class = Reactor, Methode = startHandleEvents :: Attente événements...");
    EventHandler retour = sync.select(receivedHandle.poll(), listEventHandler);
    if (retour != null) {
      retour.handleEvent();
    }
  }

  public void receive(Handle h) {
    System.out.println("Class = Reactor, Methode = receive :: réception d'un événement !!! " + h.getEvent().getSource());
    receivedHandle.add(h);
  }

  public void run() {
    while (true) {
      startHandleEvents();
      try {
        Thread.sleep(1000);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }
}
</file>

Environnement pour simuler des événements à transmettre au ''Reactor''.
<file java Environment.java>
package reactor;

import java.util.EventObject;

public class Environment extends Thread {
  Reactor reactor;

  public Environment(Reactor reactor) {
    this.reactor = reactor;
  }

  @Override
  public synchronized void run() {
    int compteurClickEvent = 1;
    int compteurMessageEvent = 1;
    for (int i = 0; i < 5; i++) {
      synchronized (reactor) {
        Handle handleClick = new Handle();
        handleClick.setEvent(new EventObject(EnumEventType.ClickEvent + "_" + compteurClickEvent));
        handleClick.setKey(EnumEventType.ClickEvent.toString());
        reactor.receive(handleClick);
        compteurClickEvent++;
      }
      synchronized (reactor) {
        Handle handleMaessage = new Handle();
        handleMaessage.setEvent(new EventObject(EnumEventType.MessageEvent + "_" + compteurMessageEvent));
        handleMaessage.setKey(EnumEventType.MessageEvent.toString());
        reactor.receive(handleMaessage);
        compteurMessageEvent++;
      }
      try {
        Thread.sleep(5000);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }
}
</file>

Une première implémentation possible d'un traitement d'événement.
<file java MessageHandler.java>
package reactor;

public class MessageHandler implements EventHandler {
  private Handle handle;

  @Override
  public void handleEvent() {
    System.out.println("Class = reactor.MessageHandler, Methode = handleEvent :: traitement evenement " + handle.getEvent().getSource());
  }

  @Override
  public Handle getHandle() {
    return handle;
  }

  @Override
  public void setHandle(Handle h) {
    handle = h;
  }
}
</file>

Une deuxième implémentation possible d'un traitement d'événement.
<file java ClickHandler.java>
package reactor;

public class ClickHandler implements EventHandler {
  private Handle handle;

  @Override
  public void handleEvent() {
    System.out.println("Class = reactor.ClickHandler, Methode = handleEvent :: traitement evenement " + handle.getEvent().getSource());
  }

  @Override
  public Handle getHandle() {
    return handle;
  }

  @Override
  public void setHandle(Handle h) {
    handle = h;
  }
}
</file>

Le programme principal qui lie tout le monde entre eux.
<file java Main.java>
package reactor;

public class Main {
  public static void main(String[] args) {
    try {
      Reactor reactor = new Reactor(new SynchronousEventDemultplexer());
      EventHandler messageHandler = new MessageHandler();
      messageHandler.setHandle(new Handle());
      messageHandler.getHandle().setKey(EnumEventType.MessageEvent.toString());
      reactor.registerHandler(messageHandler);
      EventHandler clickHandler = new ClickHandler();
      clickHandler.setHandle(new Handle());
      clickHandler.getHandle().setKey(EnumEventType.ClickEvent.toString());
      reactor.registerHandler(clickHandler);
      Thread threadReactor = new Thread(reactor);
      Environment environment = new Environment(reactor);
      threadReactor.start();
      environment.start();
      threadReactor.join();
      environment.join();
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }
}
</file>