All Classes and Interfaces
Class
Description
This data structure is optimized for non-blocking reads even when write operations occur.
The base class for all message bus implementations.
The base implementation for subscription context aware objects (mightily obvious :)
The base class for all message bus implementations with support for asynchronous message dispatch
This invocation will schedule the wrapped (decorated) invocation to be executed asynchronously
Message bus implementations potentially vary in the features they provide and consequently in the components and properties
they expose.
Configuration errors represent specific invalid configurations of a feature in a
IBusConfiguration
An invalid feature configuration is assumed to render the bus dysfunctional and as such is thrown as an unchecked exception.Respond to a
ConfigurationError with any kind of action.The dead message event is published whenever no message
handlers could be found for a given message publication.
A delegating dispatcher wraps additional logic around a given delegate.
A filter that will use a expression from the handler annotation and
parse it as EL.
Configure a handler to receive an enveloped message as a wrapper around the source
message.
The enveloped dispatcher will wrap published messages in an envelope before
passing them to their configured dispatcher.
Publication errors may occur at various points of time during message delivery.
A feature defines the configuration of a specific functionality of a message bus.
The filter annotation is used to add filters to message listeners.
A filtered message event is published when there have been matching subscriptions for a given
message publication but configured filters prevented the message from being delivered to
any of the handlers.
A dispatcher that implements message filtering based on the filter configuration
of the associated message handler.
A set of standard filters for common use cases.
This filter will only accept messages of the exact same type
as specified for the handler.
This filter will only accept messages that are real subtypes
of the specified message types handled by the message handler.
This interface is meant to be implemented by different bus implementations to offer a consistent way
to plugin different methods of message publication.
Mark any method of any class(=listener) as a message handler and configure the handler
using different properties.
This is the base class for handler invocations that already implements all context related methods only leaving the implementation of the actual invocation mechanism to the concrete subclass.
The configuration of message bus instances is feature driven, e.g.
A collection of properties commonly used by different parts of the library.
A handler invocation encapsulates the logic that is used to invoke a single
message handler to process a given message.
A message bus offers facilities for publishing messages to the message handlers of registered listeners.
A message dispatcher provides the functionality to deliver a single message
to a set of listeners.
Message filters can be used to control what messages are delivered to a specific message handler.
A message publication is created for each asynchronous message dispatch.
The include filters directive can be used to add multiple
Filters to
a single annotation type.This type of publication error is used to communicate technical/library related errors as opposed to errors in client code, i.e.
Created with IntelliJ IDEA.
Created with IntelliJ IDEA.
A publication command is used as an intermediate object created by a call to the message bus' post method.
Publication error handlers are provided with a publication error every time an
error occurs during message publication.
The default error handler will simply log to standard out and
print the stack trace if available.
Todo: Add javadoc
This interface marks components that have access to the subscription context.
Configure how the listener is referenced in the event bus.
The universal exception type for message bus implementations.
Standard implementation for direct, unfiltered message delivery.
A message envelope is used to wrap messages of arbitrary type such that a handler
my receive messages of different types.
Any method in any class annotated with the @Handler annotation represents a message handler.
All instances of any class defining at least one message handler @link MessageHandler are message listeners.
A message publication is created for each asynchronous message dispatch.
The meta data reader is responsible for parsing and validating message handler configurations.
This exception is thrown when a property value that is unavailable at runtime is accessed.
Publication errors are used to communicate exceptions that occur during message publication.
A wrapped event is created when various conditions are matched (these depend on the concrete
(sub)type of wrapped event).
This interface defines the very basic message publication semantics according to the publish subscribe pattern.
Uses reflection to invoke a message handler for a given message.
Each message bus provides a runtime object to access its dynamic features and runtime configuration.
This ELContext implementation provides support for standard BeanEL resolution in conditional message handlers.
This implementation uses strong references to the elements.
A subscription is a thread-safe container that manages exactly one message handler of all registered
message listeners of the same class, i.e.
The subscription context holds all (meta)data/objects that are relevant to successfully publish
a message within a subscription.
The subscription factory is used to create an empty subscription for specific message handler.
The subscription managers responsibility is to consistently handle and synchronize the message listener subscription process.
This post command provides access to standard synchronous and asynchronous dispatch
A handler marked with this annotation is guaranteed to be invoked in a thread-safe manner, that is, no
other running message publication will be able to invoke this or any other synchronized handler of the same
listener until the handler completed.
Synchronizes message handler invocations for all handlers that specify @Synchronized
A message bus implementation that offers only synchronous message publication.
This implementation uses weak references to the elements.