composición impulsada por eventos de primavera

La unidad de eventos de primavera consta de 3 partes

1. ApplicationEvent: indica el evento en sí, los eventos personalizados deben heredar esta clase. Se usa para definir eventos

2. ApplicationEventPublisherAware: remitente del evento, necesita implementar esta interfaz. Se utiliza principalmente para publicar eventos. ApplicationContext también implementa esta interfaz, que se puede utilizar para publicar eventos.

Después de Spring 4.2, ApplicationEventPublisher se inyecta automáticamente en el contenedor y se puede obtener usando Autowired.

3. ApplicationListener: interfaz de escucha de eventos. La clase de escucha puede implementar el método onApplicationEvent en ApplicationListener.

Después de la primavera 4.2, podemos monitorear el lanzamiento de eventos de una manera más concisa. Para monitorear eventos, ya no necesitamos implementar la interfaz ApplicationListener, simplemente agregue la anotación @EventListener al método.

Pasos de uso

Usar eventos en Spring es muy simple, solo se requieren los siguientes pasos:

Definir eventos, heredar ApplicationEvent
Para definir el oyente, implemente la interfaz ApplicationListener o agregue la anotación @EventListener al método
Para publicar un evento, llame a ApplicationContext.publishEvent () o ApplicationEventPublisher.publishEvent ();

Definir evento

public class OrderCreateEvent extends ApplicationEvent {
    
    

    private final Order order;

    public OrderCreateEvent(Object source, Order order) {
    
    
        super(source);
        this.order = order;
    }

    public Order getOrder() {
    
    
        return order;
    }
}

Enviar evento: método publishEvent ()

    @Autowired
    private ApplicationEventPublisher applicationEventPublisher;

    public void save(Order order) {
    
    
        //生成订单号
        String orderNo = getOrderNo();
        order.setOrderNo(orderNo);
        log.info("订单保存成功：" + order);
        //发布订单创建事件
        applicationEventPublisher.publishEvent(new OrderCreateEvent(this, order));
    }

Hay 2 formas de darse cuenta del observador

La primera forma: implementar la interfaz ApplicationListener

@Component
public class OrderCreateEventListener implements ApplicationListener<OrderCreateEvent> {
    
    
    @Override
    public void onApplicationEvent(OrderCreateEvent event) {
    
    
        System.out.printf("实现ApplicationListener接口,监听OrderCreateEvent事件");
    }
}

La segunda forma: a través de la anotación @EventListener, monitoreará automáticamente la liberación del evento correspondiente según el tipo de parámetro del método.

@Component
@Slf4j
public class OrderCreateEventListener3 {

    @EventListener (classes = {OrderCreateEvent.class}) //classes属性指定处理事件的类型
    @Async //异步监听
    @Order(0)//使用order指定顺序，越小优先级越高
    public void eventListener(OrderCreateEvent event) {
        log.info("通过注解@EventListener和@Async,异步监听OrderCreateEvent事件,orderId:" + event.getOrder().getOrderNo());
    }
}

Si desea monitorear el lanzamiento de múltiples tipos de eventos, puede especificarlo en @EventListener (classes = {FaceEvent.class, ArmEvent.class}). Spring llamará a este método varias veces para manejar múltiples eventos. Pero tenga en cuenta que en este momento, no puede haber varios parámetros de método; de lo contrario, se producirá una excepción de conversión. Puede usar la clase principal de varios eventos como el único parámetro de método para recibir y procesar eventos, pero no se recomienda supervisar la publicación de varios eventos a menos que sea necesario .

Si hay varios oyentes escuchando el mismo evento, podemos usar la anotación @order de Spring en el método para definir el orden de varios oyentes. Cuanto menor sea el orden, mayor será la prioridad.

@EventListener también tiene un atributo.Las expresiones SPEL se pueden usar en condition () para filtrar y escuchar eventos, es decir, solo aquellos que cumplan con una determinada condición recibirán procesamiento. como:

@EventListener(condition = "event.message == 'message'")

Monitorear múltiples eventos:

    @EventListener({
    
    FaceEvent.class,ArmEvent.class})
    public void onApplicationEvent3(Object event) {
    
    

        if(event instanceof FaceEvent){
    
    
            LOGGER.info("===> B 收到人脸事件:  {}",((FaceEvent) event).getEventData());
        }else if(event instanceof ArmEvent){
    
    
            ArmEvent armEvent = (ArmEvent) event;
            LOGGER.info("===> B 收到臂膀事件:  {}",armEvent.getEventData());
        }
    }

Precauciones

Se descartarán los oyentes que no sean controlados por el evento.
Un evento puede ser monitoreado y procesado por múltiples clases de procesamiento de monitores al mismo tiempo.
De forma predeterminada, el evento es sincrónico, es decir, después de que se publique el evento, esperará a que el Listener lo procese. Si hay una transacción en el negocio donde se publica el evento, el procesamiento del oyente también estará en la misma transacción.
Si no desea verse afectado por el procesamiento de eventos, puede agregar @Async al método onApplicationEvent para admitir asincrónico o agregar @Async al método de anotación con @EventListener. Nota: @EnableAsync debe agregarse a la clase de inicio al mismo tiempo

Use @TransactionalEventListener para lograr el aislamiento de transacciones al monitorear eventos

En muchos casos, publicaremos el evento correspondiente procesando otra lógica solo después de que se envíe la transacción, como enviar correos electrónicos o SMS después de que el usuario se registre. En este momento, puede usar la anotación @TransactionalEventListener.

Tanto @TransactionalEventListener como @EventListener pueden monitorear eventos, pero el primero puede realizar cierto aislamiento transaccional al publicar eventos y escuchar eventos .

@TransactionalEventListener es una extensión de @EventListener, lo que permite que los oyentes de eventos estén vinculados a una determinada etapa de la transacción. Puede estar vinculado a las siguientes fases de transacción:

AFTER_COMMIT (predeterminado), después de que se confirma la transacción
AFTER_ROLLBACK, después de revertir la transacción
AFTER_COMPLETION, la transacción se completa, incluso después de la confirmación y la reversión
BEFORE_COMMIT, antes de que se confirme la transacción

@TransactionalEventListener significa que no está en la misma transacción que el método que publica el evento. El método que publica el evento solo ejecutará este método de supervisión después de que finalice la transacción . Una excepción en la lógica de escucha no revertirá la transacción del método de publicación del evento .

@TransactionalEventListener tiene un atributo de fallbackExecution, el valor predeterminado es falso , lo que significa que cuando el método de publicación de eventos no tiene control de transacciones, el oyente no escucha los eventos, ¡esta es la situación predeterminada! fallbackExecution = true, significa que cuando el método de publicación del evento no tiene control de transacciones, el método de escucha aún puede escuchar el evento para procesarlo.

Explicación detallada impulsada por eventos de Springboot

Directorio de artículos