@Target(value={METHOD,ANNOTATION_TYPE}) @Retention(value=RUNTIME) @Documented public @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 classes
 attribute. See the classes() javadoc for further details.
 
Events can be ApplicationEvent instances as well as arbitrary
 objects.
 
Processing of @EventListener annotations is performed via
 the internal EventListenerMethodProcessor bean which gets
 registered automatically when using Java config or manually via the
 <context:annotation-config/> or <context:component-scan/>
 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
 UndeclaredThrowableException
 since the event publisher can only handle runtime exceptions.
 
If you want a particular listener to process events asynchronously, you
 can use Spring's @Async
 support, but be aware of the following limitations when using asynchronous events.
 
AsyncUncaughtExceptionHandler for more details.ApplicationEventPublisher
 to 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
 @Order annotation
 alongside this event listener annotation.
EventListenerMethodProcessor| Modifier and Type | Optional Element and Description | 
|---|---|
| Class<?>[] | classesThe event classes that this listener handles. | 
| String | conditionSpring Expression Language (SpEL) expression used for making the event
 handling conditional. | 
| Class<?>[] | valueAlias for  classes(). | 
@AliasFor(value="value") public abstract Class<?>[] classes
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.
public abstract String condition
The event will be handled if the expression evaluates to boolean
 true or one of the following strings: "true", "on",
 "yes", or "1".
 
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:
#root.event or event for references to the
 ApplicationEvent#root.args or args for references to the method
 arguments array#root.args[0], args[0],
 #a0, or #p0.