org.reactivecommons.async.api.HandlerRegistry Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of async-commons-api Show documentation
Abstract your broker with semantic async messages
The newest version!
package org.reactivecommons.async.api;

import io.cloudevents.CloudEvent;
import lombok.AccessLevel;
import lombok.Getter;
import lombok.NoArgsConstructor;
import org.reactivecommons.async.api.handlers.CloudCommandHandler;
import org.reactivecommons.async.api.handlers.CloudEventHandler;
import org.reactivecommons.async.api.handlers.DomainCommandHandler;
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.registered.RegisteredCommandHandler;
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 class HandlerRegistry {
    public static final String DEFAULT_DOMAIN = "app";
    private final Map>> domainEventListeners = new ConcurrentHashMap<>();
    private final List> dynamicEventHandlers = new CopyOnWriteArrayList<>();
    private final List> eventNotificationListener = new CopyOnWriteArrayList<>();
    private final List> handlers = new CopyOnWriteArrayList<>();
    private final List> commandHandlers = new CopyOnWriteArrayList<>();


    public static HandlerRegistry register() {
        HandlerRegistry instance = new HandlerRegistry();
        instance.domainEventListeners.put(DEFAULT_DOMAIN, new CopyOnWriteArrayList<>());
        return instance;
    }

    public  HandlerRegistry listenDomainEvent(String domain, String eventName, DomainEventHandler handler, Class eventClass) {
        domainEventListeners.computeIfAbsent(domain, ignored -> new CopyOnWriteArrayList<>())
                .add(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;
    }

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

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

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

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

    public  HandlerRegistry handleDynamicEvents(String eventNamePattern, DomainEventHandler handler, Class eventClass) {
        dynamicEventHandlers.add(new RegisteredEventListener<>(eventNamePattern, handler, eventClass));
        return this;
    }

    public HandlerRegistry handleDynamicCloudEvents(String eventNamePattern, CloudEventHandler handler) {
        dynamicEventHandlers.add(new RegisteredEventListener<>(eventNamePattern, handler, CloudEvent.class));
        return this;
    }

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

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

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

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

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

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


    @Deprecated(forRemoval = true)
    public  HandlerRegistry listenEvent(String eventName, DomainEventHandler handler) {
        return listenEvent(eventName, handler, inferGenericParameterType(handler));
    }

    @Deprecated(forRemoval = true)
    public  HandlerRegistry handleDynamicEvents(String eventNamePattern, DomainEventHandler handler) {
        return handleDynamicEvents(eventNamePattern, handler, inferGenericParameterType(handler));
    }

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

    @Deprecated(forRemoval = true)
    public  HandlerRegistry serveQuery(String resource, QueryHandler handler) {
        return serveQuery(resource, handler, inferGenericParameterType(handler));
    }

    @Deprecated(forRemoval = true)
    @SuppressWarnings("unchecked")
    private  Class inferGenericParameterType(QueryHandler handler) {
        try {
            ParameterizedType genericSuperclass = (ParameterizedType) handler.getClass().getGenericInterfaces()[0];
            return (Class) genericSuperclass.getActualTypeArguments()[1];
        } catch (Exception e) {
            throw new RuntimeException("Fail to infer generic Query class, please use serveQuery(path, handler, " +
                    "class) instead");
        }
    }

    @Deprecated(forRemoval = true)
    @SuppressWarnings("unchecked")
    private  Class inferGenericParameterType(DomainCommandHandler handler) {
        try {
            ParameterizedType genericSuperclass = (ParameterizedType) handler.getClass().getGenericInterfaces()[0];
            return (Class) genericSuperclass.getActualTypeArguments()[0];
        } catch (Exception e) {
            throw new RuntimeException("Fail to infer generic Command class, please use handleCommand(path, handler, " +
                    "class) instead");
        }
    }

    @Deprecated(forRemoval = true)
    private  Class inferGenericParameterType(DomainEventHandler handler) {
        try {
            ParameterizedType genericSuperclass = (ParameterizedType) handler.getClass().getGenericInterfaces()[0];
            return (Class) genericSuperclass.getActualTypeArguments()[0];
        } catch (Exception e) {
            throw new RuntimeException("Fail to infer generic Query class, please use listenEvent(eventName, handler," +
                    " class) instead");
        }
    }
}