事件监听机制（五）再话Jdk事件监听到Spring框架事件监听-蒲公英云

事件监听机制（五）再话Jdk事件监听到Spring框架事件监听

背景

熟悉Spring 框架的同学都清楚，Spring容器启动到销毁事件监听机制始终贯穿，那么Jdk中是否也存在相应的监听机制呢，我们一起进行深入的学习和研究。

概念

事件源

事件对象的产生者，任何一个事件都有一个来源。

事件监听器注册表

当事件框架或组件收到一个事件后，需要通知所有相关的事件监听器来进行处理，这个时候就需要有个存储监听器的地方，也就是事件监听器注册表。

事件广播器

事件广播器在整个事件机制中扮演一个中介的角色，当事件发布者发布一个事件后，就需要通过广播器来通知所有相关的监听器对该事件进行处理。

Jdk实现

用户实体

public class User { 
    private Long id;
    private String name;
    public Long getId() { return id;}
    public void setId(Long id) { this.id = id;}
    public String getName() { return name;}
    public void setId(String name) { this.name= name;}
    public User(Long id, String name) { this.id = id;this.name= name;}
}

用户事件

public class UserEvent extends EventObject { 
    public UserEvent(Object source) { super(source);}
}

消息事件

public class MsgEvent extends UserEvent{ 
    public MsgEvent(Object source) { super(source);}
}

用户监听器

public interface UserListener extends EventListener { 
    // 处理用户注册事件
    void onRegister(UserEvent event);
}

消息监听器

public class MsgListener implements UserListener { 
    @Override
    public void onRegister(UserEvent event) { 
        if (event instanceof MsgEvent){ 
            User user = (User) event.getSource();
            System.out.println("向User id: " + user.getId() + "User name: " + user.getName() + "的用户发送消息");
        }
    }
}

用户服务

public class UserService { 
    // 监听器列表
    private final List<UserListener> listeners = new ArrayList<>();
    // 添加监听器
    public void addListener(UserListener userListener){ 
        this.listeners.add(userListener);
    }
    // 注册用户并发布用户注册事件
    public void register(User user){ 
        System.out.println("注册用户，id为：" + user.getId());
        publishEvent(new MsgEvent(user));
    }
    // 广播用户注册事件
    private void publishEvent(UserEvent event){ 
        for (UserListener listener : listeners) { 
            listener.onRegister(event);
        }
    }
    public static void main(String[] args) { 
        UserService userService = new UserService();
        User user = new User(1L,sxs);
        userService.addListener(new MsgListener());
        userService.register(user);
    }
}
// 注册用户，id为：1
// 向User id: 1 User name: sxs的用户发送消息

Spring实现

ApplicationEvent

是Spring事件的顶层抽象类，代表事件本身，继承自JDK的EventObject。Spring提供了一些内置事件，如ContextClosedEvent、ContextStartedEvent、ContextRefreshedEvent、ContextStopedEvent等。

ApplicationListener

是Spring事件监听器顶层接口，所有的监听器都实现该接口，继承自JDK的 EventListener
Spring提供了一些易扩展的接口，如SmartApplicationListener、GenericApplicationListener
ApplicationEventPublisher是Spring的事件发布接口，事件源通过该接口的publishEvent方法发布事件，所有的应用上下文都具备事件发布能力，因为ApplicationContext继承了该接口。

ApplicationEventMulticaster

是Spring事件机制中的事件广播器，它默认提供一个SimpleApplicationEventMulticaster实现，如果用户没有自定义广播器，则使用默认的（初始化逻辑见AbstractApplicationContext#refresh方法）。它通过父类AbstractApplicationEventMulticaster#getApplicationListeners方法从事件注册表中获取事件监听器，并且通过invokeListener方法执行监听器的具体逻辑。

执行逻辑

默认的广播器是同步调用监听器的执行逻辑，但是可以通过为广播器配置Executor实现监听器的异步执行。

事件广播器

在Spring中通常是ApplicationContext本身担任监听器注册表的角色，在其子类AbstractApplicationContext中就聚合了事件广播器ApplicationEventMulticaster和事件监听器ApplicationListnener，并且提供注册监听器的addApplicationListnener方法。

事件发布

当一个事件源产生事件时，它通过事件发布器ApplicationEventPublisher发布事件，然后事件广播器ApplicationEventMulticaster会去事件注册表ApplicationContext中找到事件监听器ApplicationListnener，并且逐个执行监听器的onApplicationEvent方法，从而完成事件监听器的逻辑。

MailSendEvent

public class MailSendEvent extends ApplicationContextEvent { 
    private String to;  //目的地
    public MailSendEvent(ApplicationContext source, String to) { 
        super(source);
        this.to = to;
    }
    public String getTo(){ 
        return this.to;
    }
}

MailSendListener

@Component
public class MailSendListener implements ApplicationListener<MailSendEvent>{ 
    @Override
    public void onApplicationEvent(MailSendEvent mailSendEvent) { 
        MailSendEvent event = mailSendEvent;
        System.out.println("MailSender向"+ event.getTo()+ "发送了邮件");
    }
}

MailSender

@Component("mailSender")
public class MailSender { 
    @Autowired
    private ApplicationContext applicationContext;  //容器事件由容器触发
    public void sendMail(String to){ 
        System.out.println("MailSender开始发送邮件");
        MailSendEvent event = new MailSendEvent(applicationContext,to);
        applicationContext.publishEvent(event);
    }
}

SpringEventTest

public class SpringEventTest { 
    public static void main(String[] args) { 
        // method1
        ApplicationContext context = new ClassPathXmlApplicationContext("web/WEB-INF/applicationContext.xml");
        context .refresh();
        MailSender sender  = (MailSender)context.getBean("mailSender");
        sender.sendMail("上海");
        // method2
AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
        ctx.register(AppConfig.class);
        ctx.refresh();
        MailSender sender  = (MailSender)ctx.getBean("mailSender");
        sender.sendMail("石庄");
    }
}

SpringBoot实现

SpringApplicationEvent是SpringBoot事件的顶层抽象类，且SpringBoot内置了7个事件：

ApplicationStartingEvent

SpringBoot启动开始的时候发布的事件。

ApplicationEnvironmentPreparedEvent

SpringBoot对应Environment准备完毕时发布的事件，此时上下文还没有创建，该事件中可以获取配置信息。通过监听该事件可以修改默认的配置信息，配置中心就是借助该事件完成将远端配置放入应用中。

ApplicationContextInitializedEvent

当准备好上下文，并且在加载任何Bean之前发布的事件。该事件可以获取上下文信息。

ApplicationPreparedEvent

上下文创建完成时发布的事件，此时的Bean还没有完全加载完成，只是加载了部分特定Bean。该事件可以获取上下文信息，但是无法获取自定义Bean，因为还没有被加载。

ApplicationStartedEvent

上下文刷新（完成所有Bean的加载）之后，但是还没有调用任何ApplicationRunner 和CommandLineRunner运行程序之前发布的事件。该事件同样可以获取上下文信息，并且可以获取自定义的Bean。

ApplicationReadyEvent

完成ApplicationRunner和CommandLineRunner运行程序调用之后发布的事件，此时的SpringBoot已全部启动完成。该事件同样可以获取上下文信息。

ApplicationFailedEvent

SpringBoot启动异常时发布的事件。该事件可以获取上下文信息和异常信息，通过该事件可以友好地完成资源的回收。

程序入口

SpringApplication.run(......)
SpringBoot的生命周期如下接口所示，会在各个生命周期广播响应的事件，调用实际的监听器。

public interface SpringApplicationRunListener { 
    // ApplicationStartingEvent
    default void starting() { 
    }
    // ApplicationEnvironmentPreparedEvent
    default void environmentPrepared(ConfigurableEnvironment environment) { 
    }
    // ApplicationContextInitializedEvent
    default void contextPrepared(ConfigurableApplicationContext context) { 
    }
    // ApplicationPreparedEvent
    default void contextLoaded(ConfigurableApplicationContext context) { 
    }
    // ApplicationStartedEvent
    default void started(ConfigurableApplicationContext context) { 
    }
    // ApplicationReadyEvent
    default void running(ConfigurableApplicationContext context) { 
    }
    // ApplicationFailedEvent
    default void failed(ConfigurableApplicationContext context, Throwable exception) { 
    }
}

上述接口提供了唯一的实现类EventPublishingRunListener，该类聚合了SpringApplication和SimpleApplicationEventMulticaster，前4个事件的发布由广播器完成，后3个委托ApplicationContext完成发布，其实最终都是由广播器负责发布。

监听器使用方式
1、通过SPI机制配置
在resources目录下新建META-INF目录，并创建名为spring.factories的文件，在文件中声明以ApplicationListener接口全路径为键的配置，配置内容为ApplicationListener实现类的全路径，若有多个以逗号间隔，示例如下：

org.springframework.context.ApplicationListener=\
com.lyentech.bdc.tuya.listener.HunterApplicationContextInitializedListener,\
com.lyentech.bdc.tuya.listener.HunterApplicationEnvironmentPreparedListener,\
com.lyentech.bdc.tuya.listener.HunterApplicationFailedListener,\
com.lyentech.bdc.tuya.listener.HunterApplicationPreparedListener,\
com.lyentech.bdc.tuya.listener.HunterApplicationReadyListener,\
com.lyentech.bdc.tuya.listener.HunterApplicationStartedListener,\
com.lyentech.bdc.tuya.listener.HunterApplicationStartingListener

Spring在启动的时候会加载spring.factories中配置的监听器实现类，并在合适的阶段通过发布事件触发相应监听器的逻辑。此方式可以实现针对任何事件（SpringBoot内置7个事件都支持）监听器的成功加载。
2、注解实现

@Component
public class CustomizeListener { 
    @EventListener
    public void listenerApplicationStartingEvent(ApplicationStartingEvent event){ 
        System.err.println("ApplicationStartingEvent事件");
    }
    @Async  // 异步支持，需要开启@EnableAsync
    @EventListener
    public void listenerApplicationStartedEvent(ApplicationStartedEvent event){ 
        System.err.println("ApplicationStartedEvent事件");
    }
    @EventListener
    public void listenerApplicationReadyEvent(ApplicationReadyEvent event){ 
        System.err.println("ApplicationReadyEvent事件");
    }
}