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.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.concurrent.CopyOnWriteArrayList;

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

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

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

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

    @SuppressWarnings("unchecked")
    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, 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");
        }
    }




}