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

Go to download
package org.reactivecommons.async.api;

import lombok.AccessLevel;
import lombok.Getter;
import lombok.NoArgsConstructor;
import org.reactivecommons.async.api.handlers.CommandHandler;
import org.reactivecommons.async.api.handlers.EventHandler;
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 reactor.core.publisher.Mono;

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

@Getter
@NoArgsConstructor(access = AccessLevel.PACKAGE)
public class HandlerRegistry {

    private final List handlers = new CopyOnWriteArrayList<>();
    private final List eventListeners = new CopyOnWriteArrayList<>();
    private final List commandHandlers = new CopyOnWriteArrayList<>();
    private final List eventNotificationListener = new CopyOnWriteArrayList<>();

    public static HandlerRegistry register() {
        return new HandlerRegistry();
    }

    public  HandlerRegistry listenEvent(String eventName, EventHandler fn, Class eventClass) {
        eventListeners.add(new RegisteredEventListener<>(eventName, fn, eventClass));
        return this;
    }

    public  HandlerRegistry listenEvent(String eventName, EventHandler handler) {
        eventListeners.add(new RegisteredEventListener<>(eventName, handler, inferGenericParameterType(handler)));
        return this;
    }

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

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

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

    public  HandlerRegistry serveQuery(String resource, QueryHandler handler) {
        return serveQuery(resource, handler, inferGenericParameterType(handler));
    }

    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;
    }


    @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");
        }
    }

    @SuppressWarnings("unchecked")
    private  Class inferGenericParameterType(CommandHandler 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");
        }
    }

    private  Class inferGenericParameterType(EventHandler 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");
        }
    }
}