Event.java

public interface Event {
}

EventHandler.java

import java.lang.annotation.*;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface EventHandler {
}

EventManager.java

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @author leNic
 * @version 1.0
 * Completely Thread-Safe
 */
public class EventManager {
  
    private static Map<Class<? extends Event>, Map<Listener, Method>> listeners = new ConcurrentHashMap<>();
    
    /**
     * Add a new event class
     * @param event Class object of the event
     */
    public static void addEvent(Class<? extends Event> event){
        listeners.putIfAbsent(event, new ConcurrentHashMap<>());
    }
    
    /**
     * Dispatch an event globally
     * @param event Instance of the event
     * @return Returns whether the event was dispatched successfully
     */
    public static boolean dispatchEvent(Event event){
        final Map<Listener, Method> methods = listeners.get(event.getClass());
        if(methods == null || methods.size() == 0)
            return false;
        try {
            for (Map.Entry<Listener, Method> entry : methods.entrySet())
                entry.getValue().invoke(entry.getKey(), event);
            return true;
        } catch (IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
            return false;
        }
    }
    
    /**
     * Register new event listener
     * @param listener
     */
    public static void registerListener(Listener listener){
        for(Method method : listener.getClass().getMethods()){
            if(!method.isAnnotationPresent(EventHandler.class))
                continue;
            final Class<?>[] parameters = method.getParameterTypes();
            if(parameters.length != 1)
                continue;
            listeners.keySet().forEach(event -> {
                if(parameters[0].isAssignableFrom(event))
                    listeners.get(event).putIfAbsent(listener, method);
            });
        }
    }
}

Listener.java

public interface Listener {
}