I've created a lightweight, high-performance event-driven library for JVM! It works perfectly for Java but it's written in Kotlin.

I originally built this for a Minecraft modding project, but it turned out to be flexible enough to be a general-purpose library instead. It focuses on zero boilerplate, automatic handler discovery, structured exception handling, and fast invocation using LambdaMetafactory, with reflective fallback when needed.

The concept is simple:  
1. Create an event `Bus`.  
2. Create a class that inherits Event. Add whatever you want to the class.  
3. Create functions annotated with `@EventHandler` to process the events.  
4. Create functions annotated with `@ExceptionHandler` to handle any exceptions.  
5. Register the classes that contain these `@EventHandler` and `@ExceptionHandler` classes with `subscribe` on the `Bus` you made.  
6. Call `post` on the `Bus` you made and pass as instance of the event you created.

It supports:  
1. Handler methods of all visibilities (even private).  
2. Handler prioritization (A handle with a priority of 10 will run earlier than a handler with a priority of 0).  
3. Cancelable events - If an event is cancelable, `@EventHandler`s can mark it as canceled. How cancellation affects remaining handlers depends on the `CancelMode` used when calling `post`: in `IGNORE` mode all handlers run, in `RESPECT` mode only handlers with `runIfCanceled = true` continue running, and in `ENFORCE` mode no further handlers run once the event is canceled.
4. Modifiable events - Events can be marked as modified. This simply indicates the event was modified in some way.

Here's a simple example:
```java
// 1. Define an event.
//    Java doesn't support delegation like Kotlin, so we just extend helpers.
public class MessageEvent implements Event, Cancelable, Modifiable {
    private final String text;
    private boolean canceled = false;
    private boolean modified = false;

    public MessageEvent(String text) {
        this.text = text;
    }

    public String getText() {
        return text;
    }

    // Cancelable implementation
    @Override
    public boolean isCanceled() {
        return canceled;
    }

    @Override
    public void markCanceled() {
        this.canceled = true;
    }

    // Modifiable implementation
    @Override
    public boolean isModified() {
        return modified;
    }

    @Override
    public void markModified() {
        this.modified = true;
    }
}

// 2. Create a subscriber with event handlers and exception handlers.
public class MessageSubscriber {

    // High-priority handler (runs first)
    @EventHandler(priority = 10)
    private void onMessage(MessageEvent event) {
        System.out.println("Handling: " + event.getText());

        String text = event.getText().toLowerCase();

        if (text.contains("stop")) {
            event.markCanceled();
            return;
        }

        if (text.contains("boom")) {
            throw new IllegalStateException("Boom!");
        }

        event.markModified();
    }

    // Lower-priority handler (runs only if not canceled, unless runIfCanceled=true)
    @EventHandler(priority = 0)
    private void afterMessage(MessageEvent event) {
        System.out.println("After handler: " + event.getText());
    }

    // Exception handler for specific event + throwable type
    @ExceptionHandler(priority = 5)
    private void onMessageFailure(MessageEvent event, IllegalStateException t) {
        System.out.println("Message failed: " + t.getMessage());
    }

    // Fallback exception handler for any exception on this event type
    @ExceptionHandler
    private void onAnyMessageFailure(MessageEvent event) {
        System.out.println("A MessageEvent failed with some exception.");
    }
}

// 3. Wire everything together.
public class Main {
    public static void main(String[] args) {
        Bus bus = Bus.create();                // Create the event bus
        MessageSubscriber sub = new MessageSubscriber();

        bus.subscribe(sub);                    // Register subscriber

        MessageEvent event = new MessageEvent("Hello, boom world");

        bus.post(event);                       // Dispatch event

        System.out.println("Canceled?  " + event.isCanceled());
        System.out.println("Modified? " + event.isModified());
    }
}

```

Check out the project's README.md for more detailed information and let me know what you think!

Event Library - A lightweight, zero boilerplate, high performance event bus for JVM