Spring事件

// Observer（观察者）
public interface Observer {
    void update(Observable o, Object arg);
}

// Observable（被观察者）
public class Observable {
    private boolean changed = false;
    private Vector<Observer> obs;

    public Observable() {
        obs = new Vector<>();
    }

    public synchronized void addObserver(Observer o) {
        if (o == null)
            throw new NullPointerException();
        if (!obs.contains(o)) {
            obs.addElement(o);
        }
    }
   
    public synchronized void deleteObserver(Observer o) {
        obs.removeElement(o);
    }
    
    protected synchronized void setChanged() {
        changed = true;
    }

    /**
     * If this object has changed, as indicated by the
     * <code>hasChanged</code> method, then notify all of its observers
     * and then call the <code>clearChanged</code> method to indicate
     * that this object has no longer changed.
     * <p>
     * Each observer has its <code>update</code> method called with two
     * arguments: this observable object and the <code>arg</code> argument.
     */
    public void notifyObservers(Object arg) {
        Object[] arrLocal;
        synchronized (this) {
            if (!changed)
                return;
            arrLocal = obs.toArray();
            clearChanged();
        }

        for (int i = arrLocal.length-1; i>=0; i--)
            ((Observer)arrLocal[i]).update(this, arg);
    }

    // ....
}

/**
 * 事件类，封装事件源和一些与事件相关的参数
 */
public class DoorEvent extends EventObject {

    /**
     * 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 interface DoorListener extends EventListener {

    /**
     * 处理事件
     * @param doorEvent 事件
     */
    void onDoorEvent(DoorEvent doorEvent);

}

/**
 * 事件监听器的实现类
 */
public class BellRangDoorListener implements DoorListener {

    @Override
    public void onDoorEvent(DoorEvent doorEvent) {
        System.out.println("门铃响了");
    }
}

/**
 * 门铃响事件源
 * 事件发生的地方，由于事件源的某项属性或状态发生了改变引发某项事件发生
 */
public class DoorSourceObject {

    private boolean state;

    // 监听器
    private Set<DoorListener> doorListenerSet = new HashSet<>();

    // 给事件添加监听器
    public void addDoorListener(DoorListener doorListener) {
        this.doorListenerSet.add(doorListener);
    }

    /**
     * 通知
     */
    private void notifyListener() {
        Iterator<DoorListener> iterable = this.doorListenerSet.iterator();
        while (iterable.hasNext()) {
            DoorListener doorListener = iterable.next();
            doorListener.onDoorEvent(new DoorEvent(this));
        }
    }

    /**
     * 状态变化
     * @param state
     */
    public void setState(boolean state) {
        this.state = state;
        notifyListener();
    }
}

public class Demo {

    /**
     * 模拟客户端
     * @param args
     */
    public static void main(String[] args) {
        DoorSourceObject doorSourceDemo = new DoorSourceObject();
        doorSourceDemo.addDoorListener(new BellRangDoorListener());
        // 状态变化
        doorSourceDemo.setState(true);
    }

}

/**
 * 自定义spring事件
 * @see ApplicationEvent
 */
public class MySpringEvent extends ApplicationEvent {

    /**
     * 创建一个事件
     * @param message：消息
     */
    public MySpringEvent(String message) {
        super(message);
    }

    @Override
    public String getSource() {
        return (String) super.getSource();
    }

    public String getMessage() {
        return getSource();
    }
}

/**
 * 自定义Spring 事件监听器
 * @see ApplicationListener
 * @see MySpringEvent
 */
public class MySpringEventListener implements ApplicationListener<MySpringEvent> {

    @Override
    public void onApplicationEvent(MySpringEvent event) {
        System.out.printf("[线程 ：%s] MySpringEventListener - 监听到 Spring 事件：%s \n", Thread.currentThread().getName(), event);
    }

}

/**
 * 自定义事件处理示例
 * @see AnnotationConfigApplicationContext
 * @see MySpringEventListener
 */
public class CustomSpringEventDemo {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();

        // 将引导类 ApplicationListenerDemo 作为 Configuration Class
        context.register(CustomSpringEventDemo.class);

        // 1、添加自定义事件监听器
        context.addApplicationListener(new MySpringEventListener());
        context.addApplicationListener(new MyApplicationListener());

        // 2、启动 应用上下文，会初始化 ApplicationEventMulticaster，发布ContextRefreshedEvent事件
        context.refresh();

        // 3、发布事件
        context.publishEvent(new MySpringEvent("hello kz"));

        // 4、关闭上下文，会发布ContextClosedEvent事件
        context.close();
    }


    static class MyApplicationListener implements ApplicationListener<ContextRefreshedEvent> {
        @Override
        public void onApplicationEvent(ContextRefreshedEvent event) {
            println("MyApplicationListener - 监听到 Spring 事件：" + event);
        }
    }

    @EventListener
    @Order(2)
    public void onApplicationEvent(ContextRefreshedEvent event) {
        println("@EventListener(onApplicationEvent) - 接收到 Spring ContextRefreshedEvent");
    }

    private static void println(Object msg) {
        System.out.printf("[线程 ：%s] %s \n", Thread.currentThread().getName(), msg);
    }
}

/**
 * 异步事件处理器
 * @see GenericApplicationContext
 * @see SimpleApplicationEventMulticaster
 * @see org.springframework.util.ErrorHandler
 */
public class AsyncEventHandlerDemo {

    public static void main(String[] args) {
        GenericApplicationContext context = new GenericApplicationContext();

        // 1、添加自定义事件监听器
        context.addApplicationListener(new MySpringEventListener());

        // 2、启动 应用上下文
        // 会初始化 ApplicationEventMulticaster，发布ContextRefreshedEvent事件
        context.refresh();

        // 获取ApplicationEventMulticaster
        ApplicationEventMulticaster applicationEventMulticaster = context.getBean(AbstractApplicationContext.APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
        if (applicationEventMulticaster instanceof SimpleApplicationEventMulticaster) {
            SimpleApplicationEventMulticaster simpleApplicationEventMulticaster =
                    (SimpleApplicationEventMulticaster) applicationEventMulticaster;
            // 同步转异步
            ExecutorService taskExecutor = Executors.newSingleThreadExecutor(new CustomizableThreadFactory("my-spring-event-thread-pool "));
            simpleApplicationEventMulticaster.setTaskExecutor(taskExecutor);

            // 添加异常处理
            simpleApplicationEventMulticaster.setErrorHandler(e -> {
                System.err.println("spring 事件异常，原因：" + e.getMessage());
            });
        }

        // 故意抛出异常，监听器
        context.addApplicationListener((ApplicationListener<MySpringEvent>) event -> {
            throw new RuntimeException("监听器抛出异常");
        });

        // 3、发布事件
        context.publishEvent(new MySpringEvent("hello kz"));

        // 4、关闭上下文，会发布ContextClosedEvent事件
        context.close();
    }


}

/**
 * spring事件顺序示例
 * @see AnnotationConfigApplicationContext
 */
public class SpringEventOrderDemo {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();

        // 添加自定义事件监听器
        context.addApplicationListener(new ApplicationEventListener());

        // 启动 Spring 应用上下文
        context.refresh(); // ContextRefreshedEvent
        // 启动 Spring 上下文
        context.start();  // ContextStartedEvent
        // 停止 Spring 上下文
        context.stop();  // ContextStoppedEvent
        // 关闭 Spring 应用上下文
        context.close(); // ContextClosedEvent
    }


    static class ApplicationEventListener implements ApplicationListener<ApplicationEvent> {
        @Override
        public void onApplicationEvent(ApplicationEvent event) {
            System.out.println("事件：" + event);
        }
    }

}

// 在spring启动项目的main函数中增加

SpringApplication springApplication = new SpringApplication(Application.class);
springApplication.addListeners((ApplicationListener<ApplicationEvent>) event -> {
    System.out.println(event);
});
springApplication.run(args);