greenrobot/EventBus
EventBus
EventBus is a publish-subscribe messaging library designed to facilitate decoupled communication between components in Java applications. It functions as a central hub where producers dispatch events that are routed to subscribers based on the class type of the payload. By using annotation-based markers, the system maps event handlers to specific data types, allowing different parts of an application to exchange information without requiring direct references between classes.
The library distinguishes itself through a focus on performance and execution control. It utilizes a compile-time indexing mechanism that generates static lookup tables, replacing slow runtime reflection with direct method calls to accelerate message routing. Furthermore, it provides a thread-aware dispatcher that allows developers to configure whether event handlers execute on the main interface thread, in background pools, or synchronously within the posting thread.
Beyond basic routing, the system supports advanced messaging patterns including priority-ordered delivery and sticky events. Sticky events maintain a memory-based cache of recent data, ensuring that late-registering subscribers automatically receive the most current state upon initialization. The library also offers granular control over the event lifecycle, enabling developers to cancel event propagation or manage custom thread pools and error handling strategies to maintain application responsiveness.
Features
- Event Bus Systems - Uses method markers to identify and map event handler functions to specific event types during the registration process.
- Message Buses - A central communication channel that decouples event producers from consumers to facilitate asynchronous data exchange across different application components.
- Event Messaging Systems - Sorts subscribers by assigned weight values to ensure that event delivery follows a specific sequence across the messaging system.
- Message Bus Systems - Enabling different parts of an application to exchange information without requiring direct references or tight coupling between classes.
- Asynchronous Event Dispatchers - The Event Bus library supports executing event handlers in a separate thread from a managed pool to handle long-running tasks without blocking the application.
- Compile-Time Optimization Tools - Generates a static lookup table during the build process to replace slow runtime reflection with direct method calls.
- Event Bus Management - The Event Bus library enables manual retrieval or removal of stored events to control their lifecycle and prevent delivery to new subscribers after processing.
- Event Dispatchers - A message routing engine that manages execution context by directing event delivery to specific threads based on subscriber configuration.
- Event Dispatching Systems - Provides mechanisms to enqueue and deliver events on the main thread for ordered execution.
- Event-Driven Architectures - Building modular systems where components react to specific occurrences or data changes triggered by other parts of the application.
- Type-Safe Routing Systems - Matches dispatched data objects to registered subscribers by comparing the class type of the payload against the handler signature.
- Advanced Development Frameworks - Optimized event bus for component communication.
- Android Libraries - Event-based communication library for Android components.
- Event Bus - Simplifies communication between app components using an event-based model.
- Messaging - Simple publish/subscribe event bus.
- ProGuard Configurations - Provides event-driven communication configuration rules.
- Concurrency Management Utilities - Routes event delivery to specific execution contexts like background pools or the main thread based on subscriber configuration.
- Event State Persistence - The Event Bus library supports storing events in memory so that new subscribers receive the most recent state update automatically upon registration.
- Build-Time Optimizers - Replaces runtime reflection with generated lookup tables to accelerate subscriber registration and message delivery.
- Asynchronous Task Orchestration - Managing background operations and thread switching to keep the user interface responsive while performing heavy data processing tasks.
- Event Bus Priority Systems - The Event Bus library supports assigning priority values to subscribers during registration to control the specific order in which handlers receive and process dispatched events.
- Message Routing Engines - Improving application speed by using pre-compiled indexing to handle event delivery efficiently without relying on slow runtime reflection.
- Event Stores - A memory-based persistence mechanism that caches recent events to ensure late-joining subscribers receive the latest state updates upon registration.
- In-Memory Event Caches - Maintains a cache of the most recent events in memory to immediately deliver state updates to late-registering subscribers.
- Asynchronous Task Orchestrators - The Event Bus library allows configuring custom thread pools, event buses, and error handling scopes to manage background task execution and failure recovery within application logic.
- Background Thread Dispatchers - The Event Bus library enables executing event handlers in a background thread to ensure heavy processing tasks do not interfere with main application interface responsiveness.
- State Synchronization Utilities - Ensuring that new components receive the most recent application data immediately upon registration to maintain consistent state across views.
- Main Thread Dispatchers - The Event Bus library supports executing event handlers on the main interface thread to ensure visual updates occur safely without blocking the application.
