Annotation Interface EventListener
If an annotated method supports a single event type, the method may
declare a single parameter that reflects the event type to listen to.
If an annotated method supports multiple event types, this annotation
may refer to one or more supported event types using the
attribute. See the
classes() javadoc for further details.
Events can be
ApplicationEvent instances as well as arbitrary
@EventListener annotations is performed via
EventListenerMethodProcessor bean which gets
registered automatically when using Java config or manually via the
element when using XML config.
Annotated methods may have a non-
void return type. When they
do, the result of the method invocation is sent as a new event. If the
return type is either an array or a collection, each element is sent
as a new individual event.
This annotation may be used as a meta-annotation to create custom composed annotations.
While it is possible for an event listener to declare that it
throws arbitrary exception types, any checked exceptions thrown
from an event listener will be wrapped in an
since the event publisher can only handle runtime exceptions.
If you want a particular listener to process events asynchronously, you
can use Spring's
support, but be aware of the following limitations when using asynchronous events.
- If an asynchronous event listener throws an exception, it is not propagated
to the caller. See
AsyncUncaughtExceptionHandlerfor more details.
- Asynchronous event listener methods cannot publish a subsequent event by returning a
value. If you need to publish another event as the result of the processing, inject an
ApplicationEventPublisherto publish the event manually.
It is also possible to define the order in which listeners for a
certain event are to be invoked. To do so, add Spring's common
alongside this event listener annotation.
- Stephane Nicoll, Sam Brannen
- See Also:
Optional Element SummaryModifier and TypeOptional ElementDescription
Class<?>The event classes that this listener handles.Spring Expression Language (SpEL) expression used for making the event handling conditional.An optional identifier for the listener, defaulting to the fully-qualified signature of the declaring method (e.g.
classesThe event classes that this listener handles.
If this attribute is specified with a single value, the annotated method may optionally accept a single parameter. However, if this attribute is specified with multiple values, the annotated method must not declare any parameters.
conditionString conditionSpring Expression Language (SpEL) expression used for making the event handling conditional.
The event will be handled if the expression evaluates to boolean
trueor one of the following strings:
The default expression is
"", meaning the event is always handled.
The SpEL expression will be evaluated against a dedicated context that provides the following metadata:
eventfor references to the
argsfor references to the method arguments array
- Method arguments can be accessed by index. For example, the first
argument can be accessed via
- Method arguments can be accessed by name (with a preceding hash tag) if parameter names are available in the compiled byte code.
idString idAn optional identifier for the listener, defaulting to the fully-qualified signature of the declaring method (e.g. "mypackage.MyClass.myMethod()").
- See Also: