Skip to content

Commit 51d4c21

Browse files
juancgalvisjuancgalvis
authored
feat(open-multi-domain-api): Allow use any domain as source or destination (#139)
* feat(open-multi-domain-api): Allow use any domain as source or destination * feat(open-multi-domain-api): add unit tests
1 parent ac9291a commit 51d4c21

File tree

16 files changed

+357
-277
lines changed

16 files changed

+357
-277
lines changed

‎async/async-commons-api/src/main/java/org/reactivecommons/async/api/HandlerRegistry.java

+86-36
Original file line numberDiff line numberDiff line change
@@ -11,26 +11,29 @@
1111
import org.reactivecommons.async.api.handlers.DomainEventHandler;
1212
import org.reactivecommons.async.api.handlers.QueryHandler;
1313
import org.reactivecommons.async.api.handlers.QueryHandlerDelegate;
14+
import org.reactivecommons.async.api.handlers.RawCommandHandler;
1415
import org.reactivecommons.async.api.handlers.RawEventHandler;
1516
import org.reactivecommons.async.api.handlers.registered.RegisteredCommandHandler;
17+
import org.reactivecommons.async.api.handlers.registered.RegisteredDomainHandlers;
1618
import org.reactivecommons.async.api.handlers.registered.RegisteredEventListener;
1719
import org.reactivecommons.async.api.handlers.registered.RegisteredQueryHandler;
1820

1921
import java.lang.reflect.ParameterizedType;
20-
import java.util.List;
21-
import java.util.Map;
22-
import java.util.concurrent.ConcurrentHashMap;
2322
import java.util.concurrent.CopyOnWriteArrayList;
2423

2524
@Getter
2625
@NoArgsConstructor(access = AccessLevel.PACKAGE)
2726
public final class HandlerRegistry {
2827
public static final String DEFAULT_DOMAIN = "app";
29-
private final Map<String, List<RegisteredEventListener<?, ?>>> domainEventListeners = new ConcurrentHashMap<>();
30-
private final List<RegisteredEventListener<?, ?>> dynamicEventHandlers = new CopyOnWriteArrayList<>();
31-
private final List<RegisteredEventListener<?, ?>> eventNotificationListener = new CopyOnWriteArrayList<>();
32-
private final List<RegisteredQueryHandler<?, ?>> handlers = new CopyOnWriteArrayList<>();
33-
private final List<RegisteredCommandHandler<?, ?>> commandHandlers = new CopyOnWriteArrayList<>();
28+
private final RegisteredDomainHandlers<RegisteredEventListener<?, ?>> domainEventListeners =
29+
new RegisteredDomainHandlers<>();
30+
private final RegisteredDomainHandlers<RegisteredEventListener<?, ?>> dynamicEventHandlers =
31+
new RegisteredDomainHandlers<>();
32+
private final RegisteredDomainHandlers<RegisteredEventListener<?, ?>> eventNotificationListener =
33+
new RegisteredDomainHandlers<>();
34+
private final RegisteredDomainHandlers<RegisteredQueryHandler<?, ?>> handlers = new RegisteredDomainHandlers<>();
35+
private final RegisteredDomainHandlers<RegisteredCommandHandler<?, ?>> commandHandlers =
36+
new RegisteredDomainHandlers<>();
3437

3538

3639
public static HandlerRegistry register() {
@@ -39,90 +42,136 @@ public static HandlerRegistry register() {
3942
return instance;
4043
}
4144

45+
//events: DomainEvent
46+
public <T> HandlerRegistry listenEvent(String eventName, DomainEventHandler<T> handler, Class<T> eventClass) {
47+
return listenDomainEvent(DEFAULT_DOMAIN, eventName, handler, eventClass);
48+
}
49+
4250
public <T> HandlerRegistry listenDomainEvent(String domain, String eventName, DomainEventHandler<T> handler,
4351
Class<T> eventClass) {
44-
domainEventListeners.computeIfAbsent(domain, ignored -> new CopyOnWriteArrayList<>())
45-
.add(new RegisteredEventListener<>(eventName, handler, eventClass));
52+
domainEventListeners.add(domain, new RegisteredEventListener<>(eventName, handler, eventClass));
4653
return this;
4754
}
4855

49-
public HandlerRegistry listenDomainCloudEvent(String domain, String eventName, CloudEventHandler handler) {
50-
domainEventListeners.computeIfAbsent(domain, ignored -> new CopyOnWriteArrayList<>())
51-
.add(new RegisteredEventListener<>(eventName, handler, CloudEvent.class));
52-
return this;
56+
// events: CloudEvent
57+
public HandlerRegistry listenCloudEvent(String eventName, CloudEventHandler handler) {
58+
return listenDomainCloudEvent(DEFAULT_DOMAIN, eventName, handler);
5359
}
5460

55-
public HandlerRegistry listenDomainRawEvent(String domain, String eventName, RawEventHandler<?> handler) {
56-
domainEventListeners.computeIfAbsent(domain, ignored -> new CopyOnWriteArrayList<>())
57-
.add(new RegisteredEventListener<>(eventName, handler, RawMessage.class));
61+
public HandlerRegistry listenDomainCloudEvent(String domain, String eventName, CloudEventHandler handler) {
62+
domainEventListeners.add(domain, new RegisteredEventListener<>(eventName, handler, CloudEvent.class));
5863
return this;
5964
}
6065

61-
public <T> HandlerRegistry listenEvent(String eventName, DomainEventHandler<T> handler, Class<T> eventClass) {
62-
domainEventListeners.computeIfAbsent(DEFAULT_DOMAIN, ignored -> new CopyOnWriteArrayList<>())
63-
.add(new RegisteredEventListener<>(eventName, handler, eventClass));
64-
return this;
66+
// events: RawMessage
67+
public HandlerRegistry listenRawEvent(String eventName, RawEventHandler<?> handler) {
68+
return listenDomainRawEvent(DEFAULT_DOMAIN, eventName, handler);
6569
}
6670

67-
public HandlerRegistry listenCloudEvent(String eventName, CloudEventHandler handler) {
68-
domainEventListeners.computeIfAbsent(DEFAULT_DOMAIN, ignored -> new CopyOnWriteArrayList<>())
69-
.add(new RegisteredEventListener<>(eventName, handler, CloudEvent.class));
71+
public HandlerRegistry listenDomainRawEvent(String domain, String eventName, RawEventHandler<?> handler) {
72+
domainEventListeners.add(domain, new RegisteredEventListener<>(eventName, handler, RawMessage.class));
7073
return this;
7174
}
7275

76+
// notifications: DomainEvent
7377
public <T> HandlerRegistry listenNotificationEvent(String eventName, DomainEventHandler<T> handler,
7478
Class<T> eventClass) {
75-
eventNotificationListener.add(new RegisteredEventListener<>(eventName, handler, eventClass));
79+
return listenNotificationEvent(DEFAULT_DOMAIN, eventName, handler, eventClass);
80+
}
81+
82+
public <T> HandlerRegistry listenNotificationEvent(String domain, String eventName, DomainEventHandler<T> handler,
83+
Class<T> eventClass) {
84+
eventNotificationListener.add(domain, new RegisteredEventListener<>(eventName, handler, eventClass));
7685
return this;
7786
}
7887

88+
// notifications: CloudEvent
7989
public HandlerRegistry listenNotificationCloudEvent(String eventName, CloudEventHandler handler) {
80-
eventNotificationListener.add(new RegisteredEventListener<>(eventName, handler, CloudEvent.class));
90+
return listenNotificationCloudEvent(DEFAULT_DOMAIN, eventName, handler);
91+
}
92+
93+
public HandlerRegistry listenNotificationCloudEvent(String domain, String eventName, CloudEventHandler handler) {
94+
eventNotificationListener.add(domain, new RegisteredEventListener<>(eventName, handler, CloudEvent.class));
95+
return this;
96+
}
97+
98+
// notifications: RawMessage
99+
public HandlerRegistry listenNotificationRawEvent(String eventName, RawEventHandler<?> handler) {
100+
return listenNotificationRawEvent(DEFAULT_DOMAIN, eventName, handler);
101+
}
102+
103+
public HandlerRegistry listenNotificationRawEvent(String domain, String eventName, RawEventHandler<?> handler) {
104+
eventNotificationListener.add(domain, new RegisteredEventListener<>(eventName, handler, RawMessage.class));
81105
return this;
82106
}
83107

108+
// dynamic: DomainEvent supported only for default domain
84109
public <T> HandlerRegistry handleDynamicEvents(String eventNamePattern, DomainEventHandler<T> handler,
85110
Class<T> eventClass) {
86-
dynamicEventHandlers.add(new RegisteredEventListener<>(eventNamePattern, handler, eventClass));
111+
dynamicEventHandlers.add(DEFAULT_DOMAIN, new RegisteredEventListener<>(eventNamePattern, handler, eventClass));
87112
return this;
88113
}
89114

115+
// dynamic: CloudEvent supported only for default domain
90116
public HandlerRegistry handleDynamicCloudEvents(String eventNamePattern, CloudEventHandler handler) {
91-
dynamicEventHandlers.add(new RegisteredEventListener<>(eventNamePattern, handler, CloudEvent.class));
117+
dynamicEventHandlers.add(DEFAULT_DOMAIN, new RegisteredEventListener<>(eventNamePattern, handler,
118+
CloudEvent.class));
92119
return this;
93120
}
94121

122+
// commands: Command
95123
public <T> HandlerRegistry handleCommand(String commandName, DomainCommandHandler<T> fn, Class<T> commandClass) {
96-
commandHandlers.add(new RegisteredCommandHandler<>(commandName, fn, commandClass));
124+
return handleCommand(DEFAULT_DOMAIN, commandName, fn, commandClass);
125+
}
126+
127+
public <T> HandlerRegistry handleCommand(String domain, String commandName, DomainCommandHandler<T> fn,
128+
Class<T> commandClass) {
129+
commandHandlers.add(domain, new RegisteredCommandHandler<>(commandName, fn, commandClass));
97130
return this;
98131
}
99132

133+
// commands: CloudEvent
100134
public HandlerRegistry handleCloudEventCommand(String commandName, CloudCommandHandler handler) {
101-
commandHandlers.add(new RegisteredCommandHandler<>(commandName, handler, CloudEvent.class));
135+
return handleCloudEventCommand(DEFAULT_DOMAIN, commandName, handler);
136+
}
137+
138+
public HandlerRegistry handleCloudEventCommand(String domain, String commandName, CloudCommandHandler handler) {
139+
commandHandlers.add(domain, new RegisteredCommandHandler<>(commandName, handler, CloudEvent.class));
140+
return this;
141+
}
142+
143+
// commands: RawMessage
144+
public HandlerRegistry handleRawCommand(String commandName, RawCommandHandler<?> handler) {
145+
return handleRawCommand(DEFAULT_DOMAIN, commandName, handler);
146+
}
147+
148+
public HandlerRegistry handleRawCommand(String domain, String commandName, RawCommandHandler<?> handler) {
149+
commandHandlers.add(domain, new RegisteredCommandHandler<>(commandName, handler, RawMessage.class));
102150
return this;
103151
}
104152

153+
// queries: Query
105154
public <T, R> HandlerRegistry serveQuery(String resource, QueryHandler<T, R> handler, Class<R> queryClass) {
106-
handlers.add(new RegisteredQueryHandler<>(resource, (ignored, message) ->
155+
handlers.add(DEFAULT_DOMAIN, new RegisteredQueryHandler<>(resource, (ignored, message) ->
107156
handler.handle(message), queryClass
108157
));
109158
return this;
110159
}
111160

112161
public <R> HandlerRegistry serveQuery(String resource, QueryHandlerDelegate<Void, R> handler, Class<R> queryClass) {
113-
handlers.add(new RegisteredQueryHandler<>(resource, handler, queryClass));
162+
handlers.add(DEFAULT_DOMAIN, new RegisteredQueryHandler<>(resource, handler, queryClass));
114163
return this;
115164
}
116165

117166
public <R> HandlerRegistry serveCloudEventQuery(String resource, QueryHandler<R, CloudEvent> handler) {
118-
handlers.add(new RegisteredQueryHandler<>(resource, (ignored, message) ->
167+
handlers.add(DEFAULT_DOMAIN, new RegisteredQueryHandler<>(resource, (ignored, message) ->
119168
handler.handle(message), CloudEvent.class
120169
));
121170
return this;
122171
}
123172

124-
public <R> HandlerRegistry serveCloudEventQuery(String resource, QueryHandlerDelegate<Void, CloudEvent> handler) {
125-
handlers.add(new RegisteredQueryHandler<>(resource, handler, CloudEvent.class));
173+
public HandlerRegistry serveCloudEventQuery(String resource, QueryHandlerDelegate<Void, CloudEvent> handler) {
174+
handlers.add(DEFAULT_DOMAIN, new RegisteredQueryHandler<>(resource, handler, CloudEvent.class));
126175
return this;
127176
}
128177

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

140189
@Deprecated(forRemoval = true)
141190
public <T> HandlerRegistry handleCommand(String commandName, DomainCommandHandler<T> handler) {
142-
commandHandlers.add(new RegisteredCommandHandler<>(commandName, handler, inferGenericParameterType(handler)));
191+
commandHandlers.add(DEFAULT_DOMAIN, new RegisteredCommandHandler<>(commandName, handler,
192+
inferGenericParameterType(handler)));
143193
return this;
144194
}
145195

‎async/async-commons-api/src/main/java/org/reactivecommons/async/api/handlers/RawCommandHandler.java

+6
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,6 @@
1+
package org.reactivecommons.async.api.handlers;
2+
3+
import org.reactivecommons.api.domain.RawMessage;
4+
5+
public interface RawCommandHandler<T extends RawMessage> extends CommandHandler<T> {
6+
}

‎async/async-commons-api/src/main/java/org/reactivecommons/async/api/handlers/registered/RegisteredDomainHandlers.java

+18
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,18 @@
1+
package org.reactivecommons.async.api.handlers.registered;
2+
3+
import java.util.List;
4+
import java.util.concurrent.ConcurrentHashMap;
5+
import java.util.concurrent.CopyOnWriteArrayList;
6+
7+
public class RegisteredDomainHandlers<T> extends ConcurrentHashMap<String, List<T>> {
8+
private static final String DEFAULT_DOMAIN = "app";
9+
10+
public RegisteredDomainHandlers() {
11+
super();
12+
put(DEFAULT_DOMAIN, new CopyOnWriteArrayList<>());
13+
}
14+
15+
public void add(String domain, T handler) {
16+
computeIfAbsent(domain, ignored -> new CopyOnWriteArrayList<>()).add(handler);
17+
}
18+
}

0 commit comments

Comments
 (0)