JarCasting
mmm-event
The module io.github.mmm.event (artifactId mmm-event) provides a generic event infrastructure. Sending and receiving events is a very common things. This module implements eventing as a generic pattern and provides a simple but powerful API and base implementation that saves you from a lot of work. It is designed minimalistic and has no external dependencies.
Features
This library offers the following features:
-
Highly optimized
e.g. if you want to create many objects that can have event listeners. Maybe lots of them do not have any listener registered. Hence, the shall not allocate expensive
Listinstances and sending events should be a no-op. -
Highly customizable
Any object can be an event. You are free to create your own custom event or send existing types (event
String) as event. You create your own custom listener event and simply derive it from theEventListener<E>interface from this library, where you bind<E>to your custom event. See examples below for further details. -
Prevent Memory Leaks
You may create objects that have an event listener registered to some event source. Now, the event source typically holds a strong reference to that listener preventing it from being garbage collected. So if you do not remove the listener when the owning object is disposed, you quickly end up with memory leaks. This library allows to add an event listener such that internally a
WeakReferenceis used preventing memory leaks without additional programming effort. -
Single and Multi-Threaded
The library provides implementations optimized for different usage scenarios. You may have a simple single-threaded use-case where you want the best performance with no overhead or you may need concurrency and thread-safeness.
-
Event Bus
For eventing between loosely coupled components you may want to use the
EventBusthat acts as a central hub where listeners are registered and events are send. This way a component only needs to subscribe for a particular type of event without knowing who the sender(s) of such events actually are.
Usage
Maven Dependency:
<dependency>
<groupId>io.github.m-m-m</groupId>
<artifactId>mmm-event</artifactId>
</dependency>
Module Dependency:
requires transitive io.github.mmm.event;
Example
Create your event as interface, class, or enum:
public class MyEvent {
private final String message;
public MyEvent(String message) {
this.message = message;
}
public String getMessage() {
return this.message;
}
}
Create your event listener interface:
@FunctionalInterface
public interface MyEventListener extends EventListener<MyEvent> {
}
Create your component capable to send events:
public interface MyComponent extends EventSource<MyEvent, MyEventListener> {
void doSomething();
}
public class MyComponentImpl extends AbstractEventSource<MyEvent, MyEventListener> implements MyComponent {
public void doSomething() {
fireEvent(new MyEvent("Hello World"));
}
}
Putting it all together:
public class MyDemo {
public static void main(String[] args) {
MyComponent component = new MyComponentImpl();
component.addListener((e) -> System.out.println(e.getMessage()));
component.doSomething();
}
}
