@org.springframework.context.event.EventListener

@EventListener
public void logEvent() {
}

@EventListener
public void onApplicationEvent(IceInstanceChangeEvent event) {
    String instanceName = event.getSource().toString();
    this.deadQueueKey = "ice:dead_queue:" + instanceName;
}

@EventListener
public void onApplicationEvent(IceInstanceChangeEvent event) {
    String instanceName = event.getSource().toString();
    this.delayBucketKey = "ice-delay-bucket:" + instanceName;
}

@EventListener
public void configListener(DelegatingEnvironmentChangeEvent event) {
    // 键没有修改，直接返回
    if (CollectionUtils.isEmpty(event.getKeys())) {
        return;
    }
    refresh();
}

@EventListener
public void onGuildLeave(final GuildLeaveEvent event) {
    postAllStats(event.getJDA());
}

@EventListener
public void onGuildMemberJoin(final GuildMemberJoinEvent event) {
    getAllManagedRooms().forEach(room -> room.onGuildMemberJoin(event));
}

@EventListener
public void onInstanceRegistered(InstanceRegisteredEvent<?> event) {
    discover();
}

@EventListener
public void onInstanceRegistered(InstanceRegisteredEvent<?> event) {
    Object source = event.getSource();
    if (source instanceof MossEurekaAutoServiceRegistration) {
        MossEurekaAutoServiceRegistration eurekaAutoServiceRegistration = (MossEurekaAutoServiceRegistration) source;
        cloudEurekaClient.set(eurekaAutoServiceRegistration.getRegistration().getEurekaClient());
        discover();
        cloudEurekaClient.remove();
    }
}

@EventListener
public void onApplicationEvent(ServletWebServerInitializedEvent event) {
    if (properties.isOpenHomePageAfterStart()) {
        int port = event.getWebServer().getPort();
        BrowserHomePageOpener.open("http://localhost:" + port);
    }
}

@EventListener
public void subscriptionDeleted(WampSubscriptionDeletedEvent evt) {
    this.methodCounter.computeIfAbsent("subscriptionDeleted", k -> new ArrayList<>()).add(evt);
}

@EventListener
public void sessionEstablished(WampSessionEstablishedEvent evt) {
    this.methodCounter.computeIfAbsent("sessionEstablished", k -> new ArrayList<>()).add(evt);
}

@EventListener
public void unsubscribed(WampSubscriptionUnsubscribedEvent evt) {
    this.methodCounter.computeIfAbsent("unsubscribed", k -> new ArrayList<>()).add(evt);
}

@EventListener
public void disconnected(WampDisconnectEvent evt) {
    this.methodCounter.computeIfAbsent("disconnected", k -> new ArrayList<>()).add(evt);
}

@EventListener
public void subscribed(WampSubscriptionSubscribedEvent evt) {
    this.methodCounter.computeIfAbsent("subscribed", k -> new ArrayList<>()).add(evt);
}

@EventListener
public void subscriptionCreated(WampSubscriptionCreatedEvent evt) {
    this.methodCounter.computeIfAbsent("subscriptionCreated", k -> new ArrayList<>()).add(evt);
}

@EventListener
public void procedureUnregistered(WampProcedureUnregisteredEvent evt) {
    this.methodCounter.computeIfAbsent("procedureUnregistered", k -> new ArrayList<>()).add(evt);
}

@EventListener
public void procedureRegistered(WampProcedureRegisteredEvent evt) {
    this.methodCounter.computeIfAbsent("procedureRegistered", k -> new ArrayList<>()).add(evt);
}

@EventListener
public void handleEvent(SseEvent event) {
    try {
        String convertedValue = null;
        if (!(event.data() instanceof String)) {
            convertedValue = this.convertObject(event);
        }
        if (event.clientIds().isEmpty()) {
            for (Client client : this.clients.values()) {
                if (!event.excludeClientIds().contains(client.getId()) && this.subscriptionRegistry.isClientSubscribedToEvent(client.getId(), event.event())) {
                    ClientEvent clientEvent = new ClientEvent(client, event, convertedValue);
                    this.sendQueue.put(clientEvent);
                    this.listener.afterEventQueued(clientEvent, true);
                }
            }
        } else {
            for (String clientId : event.clientIds()) {
                if (this.subscriptionRegistry.isClientSubscribedToEvent(clientId, event.event())) {
                    ClientEvent clientEvent = new ClientEvent(this.clients.get(clientId), event, convertedValue);
                    this.sendQueue.put(clientEvent);
                    this.listener.afterEventQueued(clientEvent, true);
                }
            }
        }
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
}

@EventListener
void handleAppDetailReadyToBeRetrieved(AppDetailReadyToBeRetrievedEvent event) {
    if (appDetailReadyToBeCollectedDecider.isDecided()) {
        collect(appDetailReadyToBeCollectedDecider.getSpaces());
        appDetailReadyToBeCollectedDecider.reset();
    }
}

@EventListener
public void onSend(SentApplicationEvent event) {
    this.repository.add(getSentTrace(event));
}

@EventListener
public void onAck(AckRemoteApplicationEvent event) {
    this.repository.add(getReceivedTrace(event));
}

@EventListener
public void handleUserUpdate(UpdatedUserEvent event) {
    userServiceCache.clearUserCache(event.getLogin());
}

@EventListener
void on(AbstractEvent<?> event) {
    events.save(event);
}

@EventListener
void on(PriceChanged event) {
    this.priceChanged = event;
}

@EventListener
void on(ProductAdded event) {
    this.productAdded = event;
}

@EventListener
void on(Object event) {
    log.info("Received application event: {}", event);
}

@EventListener
void on(Object event) {
    log.info("Received application event: " + event);
}

@EventListener
void on(SomeEventA event) {
}

@EventListener
public void greeting(ScoringPerformed event) throws Exception {
    this.template.convertAndSend("/topic/greetings", new WebSocketMessage(event.getApplicationNumber() + " has been scored with " + event.getPoints() + " and final result " + event.getScoreColor()));
}

@EventListener
public void onPayloadApplicationEvent(PayloadApplicationEvent<String> event) {
    println("onPayloadApplicationEvent - 接收到 Spring PayloadApplicationEvent：" + event);
}

/**
 * 服务实例续约事件
 * @param event
 */
@EventListener
public void listen(EurekaInstanceRenewedEvent event) {
// log.info("服务实例[{}]续约成功", event.getInstanceInfo().getAppName());
}

/**
 * Eureka Server启动事件
 * @param event
 */
@EventListener
public void listen(EurekaServerStartedEvent event) {
    log.info("Eureka Server在[{}]启动成功", event.getTimestamp());
}

/**
 * Eureka Registry启动事件
 * @param event
 */
@EventListener
public void listen(EurekaRegistryAvailableEvent event) {
    log.info("Eureka Registry在[{}]启动成功", event.getTimestamp());
}

@EventListener
public void listen(InstanceRegisteredEvent<EurekaInstanceConfigBean> event) {
    log.info("实例[{}]注册事件", event.getConfig().getAppname());
}

@EventListener
public void onApplicationEvent(InMemoryRestoredEvent inMemoryRestoredEvent) {
    startListen();
}

@org.springframework.context.event.EventListener
public void onApplicationEvent(InMemoryFailedEvent inMemoryFailedEvent) {
    stopListen();
}

@org.springframework.context.event.EventListener
public void onApplicationEvent(ApplicationReadyEvent applicationReadyEvent) {
    synchronized (listenerManagementLock) {
        if (defaultQuorum == null || defaultQuorum.isPresent()) {
            startListen();
        }
    }
}

@org.springframework.context.event.EventListener
public void onApplicationEvent(InMemoryRestoredEvent inMemoryRestoredEvent) {
    startListen();
}

@EventListener
public void handleEvent(EnreplacedyDeletedEvent<NotifySubscriberEnreplacedy> enreplacedy) {
    enreplacedy.getEnreplacedy().forEach(e -> {
        e.setState(SubscribeState.disabled);
        doNotifyChange(e);
    });
}

@EventListener
public void handleEvent(EnreplacedyCreatedEvent<NotifySubscriberEnreplacedy> enreplacedy) {
    enreplacedy.getEnreplacedy().forEach(this::doNotifyChange);
}

@EventListener
public void handleEvent(EnreplacedySavedEvent<NotifySubscriberEnreplacedy> enreplacedy) {
    enreplacedy.getEnreplacedy().forEach(this::doNotifyChange);
}

@EventListener
public void handleEvent(EnreplacedyModifyEvent<NotifySubscriberEnreplacedy> enreplacedy) {
    enreplacedy.getAfter().forEach(this::doNotifyChange);
}

@EventListener
public void handleTemplateDelete(EnreplacedyDeletedEvent<NotifyTemplateEnreplacedy> event) {
    event.async(reloadTemplate(event.getEnreplacedy()));
}

@EventListener
public void handleConfigModify(EnreplacedyModifyEvent<NotifyConfigEnreplacedy> event) {
    event.async(reloadConfig(event.getBefore()));
}

@EventListener
public void handleTemplateSave(EnreplacedySavedEvent<NotifyTemplateEnreplacedy> event) {
    event.async(reloadTemplate(event.getEnreplacedy()));
}

@EventListener
public void handleConfigDelete(EnreplacedyDeletedEvent<NotifyConfigEnreplacedy> event) {
    event.async(reloadConfig(event.getEnreplacedy()));
}

@EventListener
public void handleConfigSave(EnreplacedySavedEvent<NotifyConfigEnreplacedy> event) {
    event.async(reloadConfig(event.getEnreplacedy()));
}

@EventListener
public void handleTemplateModify(EnreplacedyModifyEvent<NotifyTemplateEnreplacedy> event) {
    event.async(reloadTemplate(event.getBefore()));
}

@EventListener
public void handle(PatientMergedEvent patientMergedEvent) {
    this.patientMergedEvent = patientMergedEvent;
    if (shouldFail) {
        throw new RuntimeException("failure testing");
    }
}

@EventListener
public void onContextRefreshedEvent(ContextRefreshedEvent aEvent) {
    init();
}

See More Examples