Refactor the EventBus example polishing out some minor details:

* Use immutable `Set` instead of `List` as the subscribers collection while instantiating the `ReactorEventBus`: We don't need to guarantee the subscribers order (in fact, we should avoid depending on it in order to avoid creating dependencies between subscribers based on execution order)
* Rename `VideoCreated` semantics by `VideoPublished` in order to bring more domain related language to the code instead of a CRUDy language
* Rename `DomainEvent#domainEventName` to `DomainEvent#fullQualifiedEventName`. This way we are being explicit about using a FQEN naming convention (which has been also introduced in this commit: `vendor.bounded_context.subdomain.[event|command|query].version.resource.event_occured`)
* Modify the `DomainEventSubscriber#subscribedTo` method return type from `String` to `Class<EventType extends DomainEvent>`. This way we gain a robuster contract avoiding possible mistakes returning any random string instead of the actual event we want to subscribe to.
    * This also has allowed us to not having to expose as public the constant with the event name and access it from the event bus implementation. That is, now we're having a really modullar implementation Open/Closed Principle compliant.
    * Set the FQEN constant as private and only expose as public the `DomainEvent#fullQualifiedEventName` method. This way we ensure by the `DomainEvent` interface that all subclasses will have the needed information in order to deal with them while serializing and so on (previously we were depending on the constant which isn't declared in the interface). I've left this `DomainEvent#fullQualifiedEventName` in order to use it when we publish the events to some distributed message broker.
* Renamed the `EventBus#notify` method to `EventBus#publish`, and `DomainEventSubscriber#react` to `DomainEventSubscriber#consume`. This way we're respecting the same semantics we use while talking about Domain Events (subscribing, publishing, and consuming) without being polluted by the semantics of Java Reactor (`react`)
* Refactor the `ReactorEventBus` class in order to use `Set#forEach` method and lambda functions extracted into their own methods in order to make it easier to read

Author: JavierCane

src/main/java/tv/codely/Starter.java

@@ -1,17 +1,26 @@
 package tv.codely;
 
-import tv.codely.context.notification.module.push.application.create.SendPushToSubscribersOnVideoCreated;
-import tv.codely.context.video.module.video.domain.VideoCreated;
+import tv.codely.context.notification.module.push.application.create.SendPushToSubscribersOnVideoPublished;
+import tv.codely.context.video.module.video.domain.VideoPublished;
+import tv.codely.shared.application.DomainEventSubscriber;
+import tv.codely.shared.domain.EventBus;
 import tv.codely.shared.infrastructure.bus.ReactorEventBus;
 
-import java.util.Arrays;
+import java.util.Set;
 
 public class Starter {
     public static void main(String[] args) {
-        var sendPushToSubscribersOnVideoCreated = new SendPushToSubscribersOnVideoCreated();
+        final Set<DomainEventSubscriber> subscribers = Set.of(
+            new SendPushToSubscribersOnVideoPublished()
+        );
 
-        var eventBus = new ReactorEventBus(Arrays.asList(sendPushToSubscribersOnVideoCreated));
+        final EventBus eventBus = new ReactorEventBus(subscribers);
 
-        eventBus.notify(new VideoCreated("Llegamos a 1M de subscribers!", "CodelyTV es una gran plataforma, CREMITA!"));
+        final var videoPublished = new VideoPublished(
+            "\uD83C\uDF89 New youtube.com/CodelyTV video title",
+            "This should be the video description \uD83D\uDE42"
+        );
+
+        eventBus.publish(videoPublished);
     }
 }

src/main/java/tv/codely/context/notification/module/push/application/create/SendPushToSubscribersOnVideoCreated.java renamed to src/main/java/tv/codely/context/notification/module/push/application/create/SendPushToSubscribersOnVideoPublished.java

@@ -1,20 +1,20 @@
 package tv.codely.context.notification.module.push.application.create;
 
-import tv.codely.context.video.module.video.domain.VideoCreated;
+import tv.codely.context.video.module.video.domain.VideoPublished;
 import tv.codely.shared.application.DomainEventSubscriber;
 
-public class SendPushToSubscribersOnVideoCreated implements DomainEventSubscriber<VideoCreated> {
+public class SendPushToSubscribersOnVideoPublished implements DomainEventSubscriber<VideoPublished> {
     @Override
-    public String subscribedTo() {
-        return VideoCreated.NAME;
+    public Class<VideoPublished> subscribedTo() {
+        return VideoPublished.class;
     }
 
     @Override
-    public void react(VideoCreated event) {
+    public void consume(VideoPublished event) {
         System.out.println(
             String.format(
                 "Hey! There is a new video with title <%s> and description <%s>",
-                event.name(),
+                event.title(),
                 event.description()
             )
         );

src/main/java/tv/codely/context/video/module/video/domain/VideoCreated.java

@@ -0,0 +1,27 @@
+package tv.codely.context.video.module.video.domain;
+
+import tv.codely.shared.domain.DomainEvent;
+
+public final class VideoPublished implements DomainEvent {
+    private static final String FULL_QUALIFIED_EVENT_NAME = "codelytv.video.video.event.1.video.published";
+
+    private final String title;
+    private final String description;
+
+    public VideoPublished(String title, String description) {
+        this.title = title;
+        this.description = description;
+    }
+
+    public String fullQualifiedEventName() {
+        return FULL_QUALIFIED_EVENT_NAME;
+    }
+
+    public String title() {
+        return title;
+    }
+
+    public String description() {
+        return description;
+    }
+}

src/main/java/tv/codely/context/video/module/video/domain/VideoPublished.java

@@ -2,8 +2,8 @@
 
 import tv.codely.shared.domain.DomainEvent;
 
-public interface DomainEventSubscriber<Event extends DomainEvent> {
-    String subscribedTo();
+public interface DomainEventSubscriber<EventType extends DomainEvent> {
+    Class<EventType> subscribedTo();
 
-    void react(Event event);
+    void consume(EventType event);
 }

src/main/java/tv/codely/shared/application/DomainEventSubscriber.java

@@ -1,5 +1,5 @@
 package tv.codely.shared.domain;
 
 public interface DomainEvent {
-    String domainEventName();
+    String fullQualifiedEventName();
 }

src/main/java/tv/codely/shared/domain/DomainEvent.java

@@ -1,5 +1,5 @@
 package tv.codely.shared.domain;
 
 public interface EventBus {
-    void notify(DomainEvent event);
+    void publish(DomainEvent event);
 }

src/main/java/tv/codely/shared/domain/EventBus.java

@@ -2,30 +2,42 @@
 
 import reactor.bus.Event;
 import reactor.bus.EventBus;
+import reactor.bus.selector.Selector;
+import reactor.fn.Consumer;
 import tv.codely.shared.application.DomainEventSubscriber;
 import tv.codely.shared.domain.DomainEvent;
 
-import java.util.List;
+import java.util.Set;
 
 import static reactor.bus.selector.Selectors.$;
 
 public class ReactorEventBus implements tv.codely.shared.domain.EventBus {
     private final EventBus bus;
 
-    public ReactorEventBus(List<DomainEventSubscriber> subscribers) {
-        this.bus = EventBus.create();
+    public ReactorEventBus(final Set<DomainEventSubscriber> subscribers) {
+        bus = EventBus.create();
 
-        for (DomainEventSubscriber subscriber : subscribers)
-        {
-            this.bus.on(
-                $(subscriber.subscribedTo()),
-                reactorEvent -> subscriber.react((DomainEvent) reactorEvent.getData())
-            );
-        }
+        subscribers.forEach(this::registerOnEventBus);
     }
 
     @Override
-    public void notify(DomainEvent event) {
-        this.bus.notify(event.domainEventName(), Event.wrap(event));
+    public void publish(final DomainEvent event) {
+        Class<? extends DomainEvent> eventIdentifier = event.getClass();
+        Event<DomainEvent> wrappedEvent = Event.wrap(event);
+
+        bus.notify(eventIdentifier, wrappedEvent);
+    }
+
+    private void registerOnEventBus(final DomainEventSubscriber subscriber) {
+        final Selector eventIdentifier = $(subscriber.subscribedTo());
+
+        bus.on(eventIdentifier, eventConsumer(subscriber));
+    }
+
+    private Consumer<Event> eventConsumer(final DomainEventSubscriber subscriber) {
+        return (Event reactorEvent) -> {
+            DomainEvent unwrappedEvent = (DomainEvent) reactorEvent.getData();
+            subscriber.consume(unwrappedEvent);
+        };
     }
 }