spring events

In the official spring documentation, spring events are essentially a standard observer pattern.

Spring events were refactored in Spring 4.2.

system event

system event	describe
ContextRefreshedEvent	The event published when the application container (ApplicationContext) is initialized or refreshed. For example, the event will be published when the refresh() method of ConfigurableApplicationContext is called.
ContextStartedEvent	The event published when the application container is started by calling the start() method of ConfigurableApplicationContext
ContextStoppedEvent	The event that is published when the stop() method of the ConfigurableApplicationContext interface is called.
ContextClosedEvent	The event that is published when the close() method of the ConfigurableApplicationContext interface is called.
RequestHandledEvent	Message event sent after Http request is completed. This event takes effect in the DispatcherServlet of Spring
ServletRequestHandledEvent	Subclass of RequestHandledEvent, which is used for specific Servlet context information.

Custom event

Declare event

Take the event of adding friends as an example:

public class AddFriendEvent extends ApplicationEvent {
    private String userId;
    private String friendId;
    private String terminal;
    public AddFriendEvent(Object source,String userId,String friendId,String terminal) {
        super(source);
        this.userId = userId;
        this.friendId = friendId;
        this.terminal = terminal;
    }
}

Publish event

The publishEvent () method of ApplicationEventPublisher is used to publish events. In the example of the official document, the object publishing events implements the ApplicationEventPublisherAware interface, in which the ApplicationEventPublisher object can be used to send events directly. However, it is too complex to use. The two methods are as follows:

    @Autowired
    private ApplicationEventPublisher publisher;

spring official example:

public class EmailService implements ApplicationEventPublisherAware {
  private List<String> blockedList;
  private ApplicationEventPublisher publisher;
  public void setBlockedList(List<String> blockedList) {
  this.blockedList = blockedList;
  }
  public void setApplicationEventPublisher(ApplicationEventPublisher publisher) {
  this.publisher = publisher;
  }
  public void sendEmail(String address, String content) {
  if (blockedList.contains(address)) {
  publisher.publishEvent(new BlockedListEvent(this, address, content));
  return;
  }
  }
}

When spring configures beans, the spring container will automatically scan the code of the beans that implement the ApplicationEventPublisherAware interface, and automatically call the setApplicationEventPublisher() method to complete the set injection of ApplicationEventPublisher.

Listening events

Spring provides a variety of ways to implement event listening, which is implemented in spring 5 X mainly implements the applicationlister interface and uses @ EventListener annotation.

Implement the ApplicationListener interface

To receive Spring events, you need to create an object to implement the ApplicationListener interface and register it as a Spring bean. The code example is as follows:

public class BlockedListNotifier implements ApplicationListener<BlockedListEvent> {
  private String notificationAddress;
  public void setNotificationAddress(String notificationAddress) {
  this.notificationAddress = notificationAddress;
  }
  public void onApplicationEvent(BlockedListEvent event) {
  // notify appropriate parties via notificationAddress...
  }
}

To create an event listener, you need to implement a generic (custom Spring event) applicationlister interface. After the event is issued, onApplicationEvent() method will be called, and the event processing logic can be written in this method.

@EventListener annotation.

Listening for messages using annotations

public class BlockedListNotifier {
  private String notificationAddress;
  public void setNotificationAddress(String notificationAddress) {
  this.notificationAddress = notificationAddress;
  }
  @EventListener
  public void processBlockedListEvent(BlockedListEvent event) {
  // notify appropriate parties via notificationAddress...
  }
}

Asynchronous message listening:

Asynchronous message listening can be realized by using @ Async

@EventListener
@Async
public void processBlockedListEvent(BlockedListEvent event) {
  // BlockedListEvent is processed in a separate thread
}

Sequential listening:

Use @ Order(42) to realize sequential message listening

@EventListener
@Order(42)
public void processBlockedListEvent(BlockedListEvent event) {
  // notify appropriate parties via notificationAddress...
}

General message

Declare generic message events

public class EntityCreatedEvent<T> extends ApplicationEvent implements ResolvableTypeProvider {
  public EntityCreatedEvent(T entity) {
  	super(entity);
  }
  @Override
  public ResolvableType getResolvableType() {
  	return ResolvableType.forClassWithGenerics(getClass(),
	ResolvableType.forInstance(getSource()));
  }
}

Listen for general message events

@EventListener
public void onPersonCreated(EntityCreatedEvent<Person> event) {
  // ...
}