package com.example.controller;

import com.alibaba.fastjson.JSON;
import com.example.SpringbootRedisApplication;
import lombok.Data;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.EventListener;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.stereotype.Component;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.Objects;

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = SpringbootRedisApplication.class)
@Slf4j
@EnableAsync
public class PublishEventDemo {
    /**
     * 事件機制：
     * 需要自定義一個事件類繼承ApplicationEvent；
     * 需要自定義一個監(jiān)聽器類實現ApplicationListener接口，或普通類的方法中使用@EventListener注解；
     * 使用默認發(fā)布器ApplicationEventPublisher發(fā)布即可；
     * 事件類不需要注入到IOC；監(jiān)聽器需要注入到IOC；ApplicationEventPublisher用Autowired注入進來即可；
     */


    /**
     * 事件發(fā)布器
     */
    @Autowired
    private ApplicationEventPublisher eventPublisher;

    /**
     * 測試類
     */
    @Test
    public void publishTest() throws InterruptedException {
        Task task = new Task();
        task.setId(1L);
        task.setTaskName("測試任務");
        task.setTaskContext("任務內容");
        task.setFinish(false);
        MyEvent event = new MyEvent(task);
        log.info("開始發(fā)布任務");
        eventPublisher.publishEvent(event);
        //applicationContext.publishEvent(event);
        log.info("結束發(fā)布任務");
        Thread.sleep(10000);
    }
}

/**
 * 任務類
 * 任務就是一個普通的類，用來保存你要發(fā)布事件的內容。這個沒有特殊限制，可以根據自己業(yè)務隨意設置。
 */
@Data
class Task {

    private Long id;

    private String taskName;

    private String taskContext;

    private boolean finish;
}

/**
 * 事件類
 * 事件類需要繼承org.springframework.context.ApplicationEvent，這樣發(fā)布的事件才能被Spring所識別
 */
@Slf4j
class MyEvent<T> extends ApplicationEvent {

    private Task task;

    public MyEvent(Task task) {
        super(task);
        this.task = task;
    }

    public Task getTask() {
        return task;
    }
}

/**
 * 事件監(jiān)聽類
 * 事件的監(jiān)聽器需要實現org.springframework.context.ApplicationListener,并且需要注入到容器之中。
 */
@Component
@Slf4j
class MyEventListenerA implements ApplicationListener<MyEvent> {
    /**
     * 監(jiān)聽方式1：實現ApplicationListener接口，重寫onApplicationEvent方法
     * 需要使用Component注入IOC
     */
    @SneakyThrows
    @Async
    @Override
    public void onApplicationEvent(MyEvent MyEvent) {
        Thread.sleep(5000);
        if (Objects.isNull(MyEvent)) {
            return;
        }
        Task task = MyEvent.getTask();
        log.info("監(jiān)聽器A接收任務：{}", JSON.toJSONString(task));
        task.setFinish(true);
        log.info("監(jiān)聽器A此時完成任務");

    }
}

@Component
@Slf4j
class MyEventListenerB implements ApplicationListener<MyEvent> {
    /**
     * 監(jiān)聽方式2：接口和注解混合使用
     * 但此時 @EventListener不能與注解@Async在同一個類中使用，會報錯，至于為什么，不知道；
     * 需要使用Component注入IOC
     */
    //@Async//加上這個，@EventListener的方法就會報java.lang.IllegalStateException: Failed to load ApplicationContext
    @SneakyThrows
    @Override
    public void onApplicationEvent(MyEvent MyEvent) {
        Thread.sleep(1000);
        if (Objects.isNull(MyEvent)) {
            return;
        }
        Task task = MyEvent.getTask();
        log.info("監(jiān)聽器B接收任務：{}", JSON.toJSONString(task));
        task.setFinish(true);
        log.info("監(jiān)聽器B此時完成任務");
    }

    @EventListener
    public void someMethod(MyEvent event) throws InterruptedException {
        Thread.sleep(1000);
        log.info("監(jiān)聽器@EventListenerB收到={}", event.getTask());
    }
}


@Component
@Slf4j
class MyEventListennerC {
    /**
     * 監(jiān)聽方式3：注解@EventListener的監(jiān)聽器不需要實現任何接口
     * 需要使用Component注入IOC
     */
    @EventListener
    public void someMethod(MyEvent event) throws InterruptedException {
        Thread.sleep(1000);
        log.info("監(jiān)聽器@EventListenerC收到={}", event.getTask());
    }
}

package com.example.controller;

import ch.qos.logback.classic.Logger;
import com.example.SpringbootRedisApplication;
import lombok.ToString;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ApplicationContextEvent;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.web.bind.annotation.RestController;

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = SpringbootRedisApplication.class)
@RestController
@Slf4j
public class PublishEventDemo2 {
    /**
     * 使用ApplicationContext發(fā)布事件
     */
    @Autowired
    ApplicationContext applicationContext;

    @Test
    public void send() {
        MyEvent2 myEvent2 = new MyEvent2(applicationContext);
        myEvent2.setData("數據");
        log.info("開始發(fā)送事件");
        applicationContext.publishEvent(myEvent2);
        log.info("結束發(fā)送事件");
    }
}

/**
 * 監(jiān)聽器類
 */
@Slf4j
@Component
class MyEventListener2 implements ApplicationListener<MyEvent2> {
    @Override
    public void onApplicationEvent(MyEvent2 event) {
        log.info("監(jiān)聽器MyEventListener2收到={}", event);
    }

    @EventListener
    public void someMethod(MyEvent2 event) {
        log.info("監(jiān)聽器MyEventListener2@EventListener收到={}", event);
    }
}

/**
 * 監(jiān)聽器類
 */
@Slf4j
@Component
class MyEventListenner1 {
    @EventListener
    public void someMethod(MyEvent2 event) {
        log.info("監(jiān)聽器MyEventListenner1收到={}", event);
    }
}

/**
 * 事件類
 *
 * @param <T>
 */
@ToString
class MyEvent2<T> extends ApplicationContextEvent {
    private T data;

    public MyEvent2(ApplicationContext source) {
        super(source);
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }
}