Package dev.comfast.events

Class EventsManager<T>

java.lang.Object
dev.comfast.events.EventsManager<T>
Type Parameters:
T - Context class which will be passed in every event.
All Implemented Interfaces:
EventsNotifier<T>, SubscriberManager<T>
public class EventsManager<T> extends Object implements SubscriberManager<T>, EventsNotifier<T>
Manager for events. You are responsible for creating and managing instance of this class.

e.g. It can be static final field or be managed by Dependency injection

Implements 2 interfaces: SubscriberManager for add/remove subscribers and EventsNotifier for notify subscribers.

Example:



 class MyObservable {
     // here, keeps manager as static final field
     public static final EventsManager<AnyClass> myEvents = EventsManager<>();

     public void click() {
         AnyClass context = null; // context is optional

         myEvents.action(new BeforeEvent<>(context, "click"), () -> {
         // do something
         });
     }
 }


 /// CLIENT (OBSERVER) CODE
 // Optionally typed as SubscriberManager reduces API to only subscriber methods.
 SubscriberManager<AnyClass> myEvents = MyObservable.myEvents;

 //1st example, short one: listener implemented inline, as lambda
 myEvents.on("click", event -> log.info(event)); // will be called after 'click' event


 //2nd example, more flexible: listener implemented as class
 myEvents.subscribe("myListener", new MyListener());

 //Where MyListener is:
 class MyListener implements EventListener<AnyClass> {
    @Override public void before(BeforeEvent<AnyClass> event) { // will be called before every event
        log.info("attempt to run " event.actionName)
    }

    @Override public void before(AfterEvent<AnyClass> event) { // will be called after every event
       log.info("action '{}' finished with result: '{}' in {}", event.actionName, event.result, event.time);
       //if context is set by the caller, it  is available here as well
       event.context.methodFromAnyClass();
   }
 }

See EventsNotifier - notify listeners (subscribers)

See SubscriberManager - add/remove listeners

See EventListener - listener actions

  • Method Details

    • subscribe

      public void subscribe​(String key, EventListener<T> listener)
      Add listener to this manager.
      Specified by:
      subscribe in interface SubscriberManager<T>
      Parameters:
      key - Unique key to access / remove listener
      listener - Listener instance

    • unsubscribe

      public void unsubscribe​(String key)
      Remove listener by its key
      Specified by:
      unsubscribe in interface SubscriberManager<T>
      Parameters:
      key - identifies given Listener

    • notifyBefore

      public void notifyBefore​(BeforeEvent<T> e)
      Notify all event listeners about failed event. 
      
 manager.notifyBefore(new BeforeEvent<>(null, "someAction"));
 // do someAction()
      Specified by:
      notifyBefore in interface EventsNotifier<T>

    • notifyAfter

      public void notifyAfter​(AfterEvent<T> e)
      Notify all event listeners about failed event. 
      
 var beforeEvent = new BeforeEvent<>(null, "someAction");
 manager.notifyBefore(beforeEvent);
 var someResult = someAction();
 manager.notifyAfter(beforeEvent.passed(someResult));
      Specified by:
      notifyAfter in interface EventsNotifier<T>