All Classes Interface Summary Class Summary Enum Summary Exception Summary Annotation Types Summary
Class |
Description |
AbstractConcurrentSet<T> |
This data structure is optimized for non-blocking reads even when write operations occur.
|
AbstractConcurrentSet.Entry<T> |
|
AbstractPubSubSupport<T> |
The base class for all message bus implementations.
|
AbstractSubscriptionContextAware |
The base implementation for subscription context aware objects (mightily obvious :)
|
AbstractSyncAsyncMessageBus<T,P extends ISyncAsyncPublicationCommand> |
The base class for all message bus implementations with support for asynchronous message dispatch
|
AsynchronousHandlerInvocation |
This invocation will schedule the wrapped (decorated) invocation to be executed asynchronously
|
BusConfiguration |
BusRuntime |
Message bus implementations potentially vary in the features they provide and consequently in the components and properties
they expose.
|
ConfigurationError |
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.
|
ConfigurationErrorHandler |
|
DeadMessage |
The dead message event is published whenever no message
handlers could be found for a given message publication.
|
DelegatingMessageDispatcher |
A delegating dispatcher wraps additional logic around a given delegate.
|
ElFilter |
A filter that will use a expression from the handler annotation and
parse it as EL.
|
ElFilter.ExpressionFactoryHolder |
|
Enveloped |
Configure a handler to receive an enveloped message as a wrapper around the source
message.
|
EnvelopedMessageDispatcher |
The enveloped dispatcher will wrap published messages in an envelope before
passing them to their configured dispatcher.
|
ErrorHandlingSupport |
Publication errors may occur at various points of time during message delivery.
|
Feature |
A feature defines the configuration of a specific functionality of a message bus.
|
Feature.AsynchronousHandlerInvocation |
|
Feature.AsynchronousMessageDispatch |
|
Feature.SyncPubSub |
|
Filter |
The filter annotation is used to add filters to message listeners.
|
FilteredMessage |
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.
|
FilteredMessageDispatcher |
A dispatcher that implements message filtering based on the filter configuration
of the associated message handler.
|
Filters |
A set of standard filters for common use cases.
|
Filters.RejectSubtypes |
This filter will only accept messages of the exact same type
as specified for the handler.
|
Filters.SubtypesOnly |
This filter will only accept messages that are real subtypes
of the specified message types handled by the message handler.
|
GenericMessagePublicationSupport<T,P extends IPublicationCommand> |
This interface is meant to be implemented by different bus implementations to offer a consistent way
to plugin different methods of message publication.
|
Handler |
Mark any method of any class(=listener) as a message handler and configure the handler
using different properties.
|
HandlerInvocation<HANDLER,MESSAGE> |
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.
|
IBusConfiguration |
The configuration of message bus instances is feature driven, e.g.
|
IBusConfiguration.Properties |
A collection of properties commonly used by different parts of the library.
|
IHandlerInvocation<HANDLER,MESSAGE> |
A handler invocation encapsulates the logic that is used to invoke a single
message handler to process a given message.
|
IMessageBus<T,P extends ISyncAsyncPublicationCommand> |
A message bus offers facilities for publishing messages to the message handlers of registered listeners.
|
IMessageDispatcher |
A message dispatcher provides the functionality to deliver a single message
to a set of listeners.
|
IMessageFilter<M> |
Message filters can be used to control what messages are delivered to a specific message handler.
|
IMessagePublication |
A message publication is created for each asynchronous message dispatch.
|
IncludeFilters |
The include filters directive can be used to add multiple Filter s to
a single annotation type .
|
InternalPublicationError |
This type of publication error is used to communicate technical/library related errors as opposed to errors in client code, i.e.
|
Invoke |
Created with IntelliJ IDEA.
|
IPredicate<T> |
Created with IntelliJ IDEA.
|
IPublicationCommand |
A publication command is used as an intermediate object created by a call to the message bus' post method.
|
IPublicationErrorHandler |
Publication error handlers are provided with a publication error every time an
error occurs during message publication.
|
IPublicationErrorHandler.ConsoleLogger |
The default error handler will simply log to standard out and
print the stack trace if available.
|
ISetEntry<T> |
Todo: Add javadoc
|
ISubscriptionContextAware |
This interface marks components that have access to the subscription context.
|
ISubscriptionManagerProvider |
|
ISyncAsyncPublicationCommand |
|
ISyncMessageBus<T,P extends IPublicationCommand> |
|
Listener |
Configure how the listener is referenced in the event bus.
|
MBassador<T> |
|
MessageBusException |
The universal exception type for message bus implementations.
|
MessageDispatcher |
Standard implementation for direct, unfiltered message delivery.
|
MessageEnvelope |
A message envelope is used to wrap messages of arbitrary type such that a handler
my receive messages of different types.
|
MessageHandler |
Any method in any class annotated with the @Handler annotation represents a message handler.
|
MessageHandler.Properties |
|
MessageListener<T> |
All instances of any class defining at least one message handler @link MessageHandler are message listeners.
|
MessagePublication |
A message publication is created for each asynchronous message dispatch.
|
MessagePublication.Factory |
|
MessagePublication.State |
|
MetadataReader |
The meta data reader is responsible for parsing and validating message handler configurations.
|
MissingPropertyException |
This exception is thrown when a property value that is unavailable at runtime is accessed.
|
PublicationError |
Publication errors are used to communicate exceptions that occur during message publication.
|
PublicationEvent |
A wrapped event is created when various conditions are matched (these depend on the concrete
(sub)type of wrapped event).
|
PubSubSupport<T> |
This interface defines the very basic message publication semantics according to the publish subscribe pattern.
|
References |
|
ReflectionUtils |
|
ReflectiveHandlerInvocation |
Uses reflection to invoke a message handler for a given message.
|
RuntimeProvider |
Each message bus provides a runtime object to access its dynamic features and runtime configuration.
|
StandardELResolutionContext |
This ELContext implementation provides support for standard BeanEL resolution in conditional message handlers.
|
StrongConcurrentSet<T> |
This implementation uses strong references to the elements.
|
StrongConcurrentSet.StrongEntry<T> |
|
Subscription |
A subscription is a thread-safe container that manages exactly one message handler of all registered
message listeners of the same class, i.e.
|
SubscriptionContext |
The subscription context holds all (meta)data/objects that are relevant to successfully publish
a message within a subscription.
|
SubscriptionFactory |
The subscription factory is used to create an empty subscription for specific message handler.
|
SubscriptionManager |
The subscription managers responsibility is to consistently handle and synchronize the message listener subscription process.
|
SubscriptionManagerProvider |
|
SyncAsyncPostCommand<T> |
This post command provides access to standard synchronous and asynchronous dispatch
|
Synchronized |
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.
|
SynchronizedHandlerInvocation |
Synchronizes message handler invocations for all handlers that specify @Synchronized
|
SyncMessageBus<T> |
A message bus implementation that offers only synchronous message publication.
|
WeakConcurrentSet<T> |
This implementation uses weak references to the elements.
|
WeakConcurrentSet.WeakEntry<T> |
|