Spring的自带的消息监听机制

一 @EventListener 注解

1.1 简介

@EventListener 是 Spring提供的消息监听注解。通过建立事件对象，当事件发布者发布了消息，监听对应事件对象的监听器就能监听到并消费到消息，该消息相当于广播消息，可以实例当中所有的对应事件监听器都听到。

1.2 应用实例

1.2.1 事件对象

public class MyApplicationEvent extends ApplicationEvent {


    private final String str;

    public MyApplicationEvent(Object source, String str) {
        super(source);
        this.str = str;
    }

    public String getStr() {
        return str;
    }
}

1.2.2 监听器

@Component
@Slf4j
public class MyApplicationEventListener{


//    @Override
//    public void onApplicationEvent(MyApplicationEvent event) {
//        log.info("进入onApplicationEvent，实现接口方式，我输出就完事了，{}", JSON.toJSONString(event));
//    }

    @EventListener
    public void eventListenerHandle(MyApplicationEvent event) {
        log.info("进入eventListenerHandle，注解方式，我输出就完事了，{}", JSON.toJSONString(event));
    }
}

1.2.3 事件发布者

@Slf4j
@Component
public class MyApplicationEventPublisher implements ApplicationEventPublisherAware {


    private static ApplicationEventPublisher myEventPublisher;

    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
        log.info("这波是MyApplicationEventPublisherAware进来哈哈哈哈哈哈");
        myEventPublisher = applicationEventPublisher;
    }

    public void publisherEvent(MyApplicationEvent event){
        myEventPublisher.publishEvent(event);
    }
}

1.2.4 测试

    @Test
    public void publisherEvent() {
        myApplicationEventPublisher.publisherEvent(new MyApplicationEvent(this
                , "lbwnb!!"));
    }

1.2.5 结果

1.3 结论

可以看到消息监听者可以在事件发布者发布消息之后，做出回应。
除了通过@EventListener 注解实现，还可以通过继承ApplicationListener<E extends ApplicationEvent>来实现对事件的监听。两种方式我都是做过实践，发现若是通过实现来监听事件，对事件监听做出的响应一般都在注解实现方式之前。

二 @TransactionalEventListener 注解

1 简介

@TransactionalEventListener 同样是Spring提供的事件监听注解，该注解可以实现和@EventListener，但是其基于 @Transactional 注解下的事件发起者。能够实现用户在其事务完成之后再对事件做出响应。

2 应用实例

事件对象和事件发布者的处理和@EventListener注解下是一样的，只是测试时调用事件发布时，具体的调用方法需要被@Transactional修饰

2.1 监听器

@Slf4j
@Component
public class MyTransactionalApplicationEventListener {


    @TransactionalEventListener
    public void transactionalEventListenerHandle(MyApplicationEvent event) {
        log.info("进入transactionalEventListenerHandle，注解方式，我输出就完事了，{}", JSON.toJSONString(event));
    }
}

2.2 测试

 @Transactional(rollbackFor = Exception.class)
    public void myTransactionalApplicationEventPublisherTest() {
        myApplicationEventPublisher.publisherEvent(new MyApplicationEvent(this, "事务拉"));


        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("当前线程运行结束");
    }

2.3 结果

2.3 结论

可以看到@Transactional修饰的方法的线程执行结束之后，监听器才做出响应。
其实这里就有点问题，并不是事务提交之后监听做出响应处理，而且当前事件发出的线程执行结束之后，监听器才做出响应。其实还可以通过TransactionalApplicationListener<E extends ApplicationEvent>接口实现来实现事件监听。
不过通过我实践之后，通过TransactionalApplicationListener<E extends ApplicationEvent>接口实现来实现事件监听是不能做到事务提交后或是线程执行结束之后才做出响应，而是事件发生后就可以直接做出响应，相当于 @EventListener 注解