/**
 * 抽象觀察者角色
 * @author sec
 **/
public abstract class AbstractObserver {
  /**
   * 接收消息
   * @param context 消息內(nèi)容
   */
  public abstract void receiveMsg(String context);
}

/**
 * 抽象主題（抽象被觀察者角色）
 * @author sec
 **/
public abstract class AbstractSubject {
  /**
   * 持有所有抽象觀察者角色的集合引用
   */
  private final List<AbstractObserver> observers = new ArrayList<>();
  /**
   * 添加一個觀察者
   * @param observer 觀察者
   */
  public void addObserver(AbstractObserver observer){
    observers.add(observer);
  }
  /**
   * 移除一個觀察者
   * @param observer 觀察者
   */
  public void removeObserver(AbstractObserver observer){
    observers.remove(observer);
  }
  /**
   * 通知所有的觀察者，執(zhí)行觀察者更新方法
   * @param context 通知內(nèi)容
   */
  public void notifyObserver(String context){
    observers.forEach(observer -> observer.receiveMsg(context));
  }
}

/**
 * 具體被觀察者
 * @author sec
 **/
public class ConcreteSubject extends AbstractSubject{
  /**
   * 被觀察者發(fā)送消息
   * @param context 消息內(nèi)容
   */
  public void sendMsg(String context){
    System.out.println("具體被觀察者角色發(fā)送消息: " + context);
    super.notifyObserver(context);
  }
}

/**
 * 具體觀察者角色實現(xiàn)類
 * @author sec
 **/
public class ConcreteObserver extends AbstractObserver{
  @Override
  public void receiveMsg(String context) {
    System.out.println("具體觀察者角色接收消息: " + context);
  }
}

public class ObserverPatternTest {
  public static void main(String[] args) {
    ConcreteSubject subject = new ConcreteSubject();
    subject.addObserver(new ConcreteObserver());
    subject.sendMsg("Hello World!");
  }
}

/**
 * 事件對象
 *
 * @author sec
 **/
public class DoorEvent extends EventObject {
  private int state;
  /**
   * Constructs a prototypical Event.
   *
   * @param source The object on which the Event initially occurred.
   * @throws IllegalArgumentException if source is null.
   */
  public DoorEvent(Object source) {
    super(source);
  }
  public DoorEvent(Object source, int state) {
    super(source);
    this.state = state;
  }
  // 省略getter/setter方法 
}

/**
 * 事件監(jiān)聽器接口
 *
 * @author sec
 **/
public interface DoorListener extends EventListener {
  /**
   * 門處理事件
   * @param doorEvent 事件
   */
  void doorEvent(DoorEvent doorEvent);
}

public class CloseDoorListener implements DoorListener{
  @Override
  public void doorEvent(DoorEvent doorEvent) {
    if(doorEvent.getState() == -1){
      System.out.println("門關(guān)上了");
    }
  }
}
public class OpenDoorListener implements DoorListener{
  @Override
  public void doorEvent(DoorEvent doorEvent) {
    if(doorEvent.getState() == 1){
      System.out.println("門打開了");
    }
  }
}

public class EventSource {
  //監(jiān)聽器列表，監(jiān)聽器的注冊則加入此列表
  private Vector<DoorListener> listenerList = new Vector<>();
  //注冊監(jiān)聽器
  public void addListener(DoorListener eventListener) {
    listenerList.add(eventListener);
  }
  //撤銷注冊
  public void removeListener(DoorListener eventListener) {
    listenerList.remove(eventListener);
  }
  //接受外部事件
  public void notifyListenerEvents(DoorEvent event) {
    for (DoorListener eventListener : listenerList) {
      eventListener.doorEvent(event);
    }
  }
}

public class EventTest {
  public static void main(String[] args) {
    EventSource eventSource = new EventSource();
    eventSource.addListener(new CloseDoorListener());
    eventSource.addListener(new OpenDoorListener());
    eventSource.notifyListenerEvents(new DoorEvent("關(guān)門事件", -1));
    eventSource.notifyListenerEvents(new DoorEvent("開門時間", 1));
  }
}

public abstract class ApplicationEvent extends EventObject {
  /** use serialVersionUID from Spring 1.2 for interoperability. */
  private static final long serialVersionUID = 7099057708183571937L;
  /** System time when the event happened. */
  private final long timestamp;
  /**
   * Create a new {@code ApplicationEvent}.
   * @param source the object on which the event initially occurred or with
   * which the event is associated (never {@code null})
   */
  public ApplicationEvent(Object source) {
    super(source);
    this.timestamp = System.currentTimeMillis();
  }
  /**
   * Return the system time in milliseconds when the event occurred.
   */
  public final long getTimestamp() {
    return this.timestamp;
  }
}

@FunctionalInterface
public interface ApplicationEventPublisher {
  default void publishEvent(ApplicationEvent event) {
    publishEvent((Object) event);
  }
  void publishEvent(Object event);
}

@FunctionalInterface
public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {
  /**
   * Handle an application event.
   * @param event the event to respond to
   */
  void onApplicationEvent(E event);
}

public class MyEvent extends ApplicationEvent {
  /**
   * Create a new {@code ApplicationEvent}.
   *
   * @param source the object on which the event initially occurred or with
   *               which the event is associated (never {@code null})
   */
  public MyEvent(Object source) {
    super(source);
  }
  private String context;
  public MyEvent(Object source, String context){
    super(source);
    this.context = context;
  }
  public String getContext() {
    return context;
  }
  public void setContext(String context) {
    this.context = context;
  }
}

@Component
public class MyApplicationListener implements ApplicationListener<MyEvent> {
  @Override
  public void onApplicationEvent(MyEvent event) {
    // 監(jiān)聽到具體事件，處理對應(yīng)具體邏輯
    System.out.println("event.getContext() = " + event.getContext());
  }
}

@Component
public class MyApplicationListener{
    // 通過注解實現(xiàn)監(jiān)聽器
    @EventListener
    public void handleMyEvent(MyEvent event){
        // 監(jiān)聽到具體事件，處理對應(yīng)具體邏輯
        System.out.println("event.getContext() = " + event.getContext());
    }
}

@Slf4j
@SpringBootTest
public class SpringEventTest {
  @Autowired
  private ApplicationEventPublisher eventPublisher;
  @Test
  void testEvent() {
    eventPublisher.publishEvent(new MyEvent("自定義事件", "Hello World！"));
  }
}

@Component
@Async
public class MyApplicationListener implements ApplicationListener<MyEvent> {
  @Override
  public void onApplicationEvent(MyEvent event) {
    // 監(jiān)聽到具體事件，處理對應(yīng)具體邏輯
    System.out.println("event.getContext() = " + event.getContext());
  }
}

@SpringBootApplication
@EnableAsync
public class SpringBootMainApplication {
  public static void main(String[] args) {
    SpringApplication.run(SpringBootMainApplication.class, args);
  }
}