Skip to content

feat(open-multi-domain-api): Allow use any domain as source or destination #139

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 3 commits into from
Apr 10, 2025
Merged

feat(open-multi-domain-api): Allow use any domain as source or destination #139

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
7d36549
feat(open-multi-domain-api): Allow use any domain as source or destin…
juancgalvis Apr 10, 2025
df21cf9
feat(open-multi-domain-api): add unit tests
juancgalvis Apr 10, 2025
d782a11
feat(open-multi-domain-api): add unit tests
juancgalvis Apr 10, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
122 changes: 86 additions & 36 deletions async/async-commons-api/src/main/java/org/reactivecommons/async/api/HandlerRegistry.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -11,26 +11,29 @@
import org.reactivecommons.async.api.handlers.DomainEventHandler;
import org.reactivecommons.async.api.handlers.QueryHandler;
import org.reactivecommons.async.api.handlers.QueryHandlerDelegate;
import org.reactivecommons.async.api.handlers.RawCommandHandler;
import org.reactivecommons.async.api.handlers.RawEventHandler;
import org.reactivecommons.async.api.handlers.registered.RegisteredCommandHandler;
import org.reactivecommons.async.api.handlers.registered.RegisteredDomainHandlers;
import org.reactivecommons.async.api.handlers.registered.RegisteredEventListener;
import org.reactivecommons.async.api.handlers.registered.RegisteredQueryHandler;

import java.lang.reflect.ParameterizedType;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;

@Getter
@NoArgsConstructor(access = AccessLevel.PACKAGE)
public final class HandlerRegistry {
public static final String DEFAULT_DOMAIN = "app";
private final Map<String, List<RegisteredEventListener<?, ?>>> domainEventListeners = new ConcurrentHashMap<>();
private final List<RegisteredEventListener<?, ?>> dynamicEventHandlers = new CopyOnWriteArrayList<>();
private final List<RegisteredEventListener<?, ?>> eventNotificationListener = new CopyOnWriteArrayList<>();
private final List<RegisteredQueryHandler<?, ?>> handlers = new CopyOnWriteArrayList<>();
private final List<RegisteredCommandHandler<?, ?>> commandHandlers = new CopyOnWriteArrayList<>();
private final RegisteredDomainHandlers<RegisteredEventListener<?, ?>> domainEventListeners =
new RegisteredDomainHandlers<>();
private final RegisteredDomainHandlers<RegisteredEventListener<?, ?>> dynamicEventHandlers =
new RegisteredDomainHandlers<>();
private final RegisteredDomainHandlers<RegisteredEventListener<?, ?>> eventNotificationListener =
new RegisteredDomainHandlers<>();
private final RegisteredDomainHandlers<RegisteredQueryHandler<?, ?>> handlers = new RegisteredDomainHandlers<>();
private final RegisteredDomainHandlers<RegisteredCommandHandler<?, ?>> commandHandlers =
new RegisteredDomainHandlers<>();


public static HandlerRegistry register() {
Expand All @@ -39,90 +42,136 @@ public static HandlerRegistry register() {
return instance;
}

//events: DomainEvent
public <T> HandlerRegistry listenEvent(String eventName, DomainEventHandler<T> handler, Class<T> eventClass) {
return listenDomainEvent(DEFAULT_DOMAIN, eventName, handler, eventClass);
}

public <T> HandlerRegistry listenDomainEvent(String domain, String eventName, DomainEventHandler<T> handler,
Class<T> eventClass) {
domainEventListeners.computeIfAbsent(domain, ignored -> new CopyOnWriteArrayList<>())
.add(new RegisteredEventListener<>(eventName, handler, eventClass));
domainEventListeners.add(domain, new RegisteredEventListener<>(eventName, handler, eventClass));
return this;
}

public HandlerRegistry listenDomainCloudEvent(String domain, String eventName, CloudEventHandler handler) {
domainEventListeners.computeIfAbsent(domain, ignored -> new CopyOnWriteArrayList<>())
.add(new RegisteredEventListener<>(eventName, handler, CloudEvent.class));
return this;
// events: CloudEvent
public HandlerRegistry listenCloudEvent(String eventName, CloudEventHandler handler) {
return listenDomainCloudEvent(DEFAULT_DOMAIN, eventName, handler);
}

public HandlerRegistry listenDomainRawEvent(String domain, String eventName, RawEventHandler<?> handler) {
domainEventListeners.computeIfAbsent(domain, ignored -> new CopyOnWriteArrayList<>())
.add(new RegisteredEventListener<>(eventName, handler, RawMessage.class));
public HandlerRegistry listenDomainCloudEvent(String domain, String eventName, CloudEventHandler handler) {
domainEventListeners.add(domain, new RegisteredEventListener<>(eventName, handler, CloudEvent.class));
return this;
}

public <T> HandlerRegistry listenEvent(String eventName, DomainEventHandler<T> handler, Class<T> eventClass) {
domainEventListeners.computeIfAbsent(DEFAULT_DOMAIN, ignored -> new CopyOnWriteArrayList<>())
.add(new RegisteredEventListener<>(eventName, handler, eventClass));
return this;
// events: RawMessage
public HandlerRegistry listenRawEvent(String eventName, RawEventHandler<?> handler) {
return listenDomainRawEvent(DEFAULT_DOMAIN, eventName, handler);
}

public HandlerRegistry listenCloudEvent(String eventName, CloudEventHandler handler) {
domainEventListeners.computeIfAbsent(DEFAULT_DOMAIN, ignored -> new CopyOnWriteArrayList<>())
.add(new RegisteredEventListener<>(eventName, handler, CloudEvent.class));
public HandlerRegistry listenDomainRawEvent(String domain, String eventName, RawEventHandler<?> handler) {
domainEventListeners.add(domain, new RegisteredEventListener<>(eventName, handler, RawMessage.class));
return this;
}

// notifications: DomainEvent
public <T> HandlerRegistry listenNotificationEvent(String eventName, DomainEventHandler<T> handler,
Class<T> eventClass) {
eventNotificationListener.add(new RegisteredEventListener<>(eventName, handler, eventClass));
return listenNotificationEvent(DEFAULT_DOMAIN, eventName, handler, eventClass);
}

public <T> HandlerRegistry listenNotificationEvent(String domain, String eventName, DomainEventHandler<T> handler,
Class<T> eventClass) {
eventNotificationListener.add(domain, new RegisteredEventListener<>(eventName, handler, eventClass));
return this;
}

// notifications: CloudEvent
public HandlerRegistry listenNotificationCloudEvent(String eventName, CloudEventHandler handler) {
eventNotificationListener.add(new RegisteredEventListener<>(eventName, handler, CloudEvent.class));
return listenNotificationCloudEvent(DEFAULT_DOMAIN, eventName, handler);
}

public HandlerRegistry listenNotificationCloudEvent(String domain, String eventName, CloudEventHandler handler) {
eventNotificationListener.add(domain, new RegisteredEventListener<>(eventName, handler, CloudEvent.class));
return this;
}

// notifications: RawMessage
public HandlerRegistry listenNotificationRawEvent(String eventName, RawEventHandler<?> handler) {
return listenNotificationRawEvent(DEFAULT_DOMAIN, eventName, handler);
}

public HandlerRegistry listenNotificationRawEvent(String domain, String eventName, RawEventHandler<?> handler) {
eventNotificationListener.add(domain, new RegisteredEventListener<>(eventName, handler, RawMessage.class));
return this;
}

// dynamic: DomainEvent supported only for default domain
public <T> HandlerRegistry handleDynamicEvents(String eventNamePattern, DomainEventHandler<T> handler,
Class<T> eventClass) {
dynamicEventHandlers.add(new RegisteredEventListener<>(eventNamePattern, handler, eventClass));
dynamicEventHandlers.add(DEFAULT_DOMAIN, new RegisteredEventListener<>(eventNamePattern, handler, eventClass));
return this;
}

// dynamic: CloudEvent supported only for default domain
public HandlerRegistry handleDynamicCloudEvents(String eventNamePattern, CloudEventHandler handler) {
dynamicEventHandlers.add(new RegisteredEventListener<>(eventNamePattern, handler, CloudEvent.class));
dynamicEventHandlers.add(DEFAULT_DOMAIN, new RegisteredEventListener<>(eventNamePattern, handler,
CloudEvent.class));
return this;
}

// commands: Command
public <T> HandlerRegistry handleCommand(String commandName, DomainCommandHandler<T> fn, Class<T> commandClass) {
commandHandlers.add(new RegisteredCommandHandler<>(commandName, fn, commandClass));
return handleCommand(DEFAULT_DOMAIN, commandName, fn, commandClass);
}

public <T> HandlerRegistry handleCommand(String domain, String commandName, DomainCommandHandler<T> fn,
Class<T> commandClass) {
commandHandlers.add(domain, new RegisteredCommandHandler<>(commandName, fn, commandClass));
return this;
}

// commands: CloudEvent
public HandlerRegistry handleCloudEventCommand(String commandName, CloudCommandHandler handler) {
commandHandlers.add(new RegisteredCommandHandler<>(commandName, handler, CloudEvent.class));
return handleCloudEventCommand(DEFAULT_DOMAIN, commandName, handler);
}

public HandlerRegistry handleCloudEventCommand(String domain, String commandName, CloudCommandHandler handler) {
commandHandlers.add(domain, new RegisteredCommandHandler<>(commandName, handler, CloudEvent.class));
return this;
}

// commands: RawMessage
public HandlerRegistry handleRawCommand(String commandName, RawCommandHandler<?> handler) {
return handleRawCommand(DEFAULT_DOMAIN, commandName, handler);
}

public HandlerRegistry handleRawCommand(String domain, String commandName, RawCommandHandler<?> handler) {
commandHandlers.add(domain, new RegisteredCommandHandler<>(commandName, handler, RawMessage.class));
return this;
}

// queries: Query
public <T, R> HandlerRegistry serveQuery(String resource, QueryHandler<T, R> handler, Class<R> queryClass) {
handlers.add(new RegisteredQueryHandler<>(resource, (ignored, message) ->
handlers.add(DEFAULT_DOMAIN, new RegisteredQueryHandler<>(resource, (ignored, message) ->
handler.handle(message), queryClass
));
return this;
}

public <R> HandlerRegistry serveQuery(String resource, QueryHandlerDelegate<Void, R> handler, Class<R> queryClass) {
handlers.add(new RegisteredQueryHandler<>(resource, handler, queryClass));
handlers.add(DEFAULT_DOMAIN, new RegisteredQueryHandler<>(resource, handler, queryClass));
return this;
}

public <R> HandlerRegistry serveCloudEventQuery(String resource, QueryHandler<R, CloudEvent> handler) {
handlers.add(new RegisteredQueryHandler<>(resource, (ignored, message) ->
handlers.add(DEFAULT_DOMAIN, new RegisteredQueryHandler<>(resource, (ignored, message) ->
handler.handle(message), CloudEvent.class
));
return this;
}

public <R> HandlerRegistry serveCloudEventQuery(String resource, QueryHandlerDelegate<Void, CloudEvent> handler) {
handlers.add(new RegisteredQueryHandler<>(resource, handler, CloudEvent.class));
public HandlerRegistry serveCloudEventQuery(String resource, QueryHandlerDelegate<Void, CloudEvent> handler) {
handlers.add(DEFAULT_DOMAIN, new RegisteredQueryHandler<>(resource, handler, CloudEvent.class));
return this;
}

Expand All @@ -139,7 +188,8 @@ public <T> HandlerRegistry handleDynamicEvents(String eventNamePattern, DomainEv

@Deprecated(forRemoval = true)
public <T> HandlerRegistry handleCommand(String commandName, DomainCommandHandler<T> handler) {
commandHandlers.add(new RegisteredCommandHandler<>(commandName, handler, inferGenericParameterType(handler)));
commandHandlers.add(DEFAULT_DOMAIN, new RegisteredCommandHandler<>(commandName, handler,
inferGenericParameterType(handler)));
return this;
}

Expand Down
6 changes: 6 additions & 0 deletions ...c-commons-api/src/main/java/org/reactivecommons/async/api/handlers/RawCommandHandler.java
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,6 @@
package org.reactivecommons.async.api.handlers;

import org.reactivecommons.api.domain.RawMessage;

public interface RawCommandHandler<T extends RawMessage> extends CommandHandler<T> {
}
18 changes: 18 additions & 0 deletions ...main/java/org/reactivecommons/async/api/handlers/registered/RegisteredDomainHandlers.java
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,18 @@
package org.reactivecommons.async.api.handlers.registered;

import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;

public class RegisteredDomainHandlers<T> extends ConcurrentHashMap<String, List<T>> {
private static final String DEFAULT_DOMAIN = "app";

public RegisteredDomainHandlers() {
super();
put(DEFAULT_DOMAIN, new CopyOnWriteArrayList<>());
}

public void add(String domain, T handler) {
computeIfAbsent(domain, ignored -> new CopyOnWriteArrayList<>()).add(handler);
}
}
Loading