Spring源码学习笔记（十、Spring启动流程解析：初始化事件广播 ）

目录：

• 事件广播源码
• 观察者模式
• Java事件机制
• Spring事件驱动机制
• 容器生命周期

事件广播源码

Spring初始化事件广播的源码很简单，和上一节初始化消息源的逻辑非常相似，我把代码贴在这。

protected void initApplicationEventMulticaster() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    // 检查配置中是否有applicationEventMulticaster的Bean定义
    if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
        // 如果有则获取（实例化Bean）
        this.applicationEventMulticaster =
            beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
        if (logger.isDebugEnabled()) {
            logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
        }
    }
    else {
        // 如果没有手动创建SimpleApplicationEventMulticaster的实例
        this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
        // 把创建的SimpleApplicationEventMulticaster注册到BeanFactory
        beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
        if (logger.isDebugEnabled()) {
            logger.debug("Unable to locate ApplicationEventMulticaster with name '" +
                         APPLICATION_EVENT_MULTICASTER_BEAN_NAME +
                         "': using default [" + this.applicationEventMulticaster + "]");
        }
    }
}

观察者模式

要想了解Spring和Java的事件机制你就得先了解下什么是观察者模式。我在这里简述下，观察者模式中主要分为三个元素，事件、观察者、被观察者，也可以叫做事件对象、事件源、监听器。

我你举个例方便你理解，就以最简单且常见的吃饭排号来说吧：

• 你一天中午去吃黄焖鸡，点完餐后服务员把你的排号给到了你，当你的黄焖鸡做好了后服务员便会大喊，多少号的黄焖鸡做好了，请到前台取餐之类的话术。
• 此时你听到叫到你的号了，便会去前台取餐。
• 在这个场景中：
  • 取餐便是事件。
  • 观察者是服务员，当黄焖鸡做好了后就会通知被观察者。
  • 被观察者则是食客，也就是你，听到服务员（观察者）叫号后便去取餐（接收观察者的消息通知）。

具体代码实现如下：

https://www.cnblogs.com/bzfsdr/p/12685451.html

Java事件机制

说Java事件机制前首先让我们了解下什么是事件驱动机制：

• 事件驱动的常见形式便是发布-订阅模式。
• 在跨进程的通信间，我们通常采用引入MQ (消息队列) 来实现消息的发布和订阅。目前主流应用的架构中，均采用消息的发布-订阅模式来进行大型分布式系统的解耦。使得数据生产方和使用方分离，同时 MQ 还可起到削峰等作用。
• 同一进程内很多时候也需要这种事件驱动机制来进行逻辑解耦。
• 事件机制主要由三个部分组成：
  • 事件对象：事件实体。封装事件源对象和事件，在事件源和监听器之间传递信息。
  • 监听器：监听事件对象。事件发生时处理回调。
  • 事件源：事件发生的起源。注册监听，对事件进行响应。

———————————————————————————————————————————————————————

Java事件机制则是基于观察者模式，定义了如下接口：

• 事件对象：EventObject自定义事件对象需要继承该类。
• 监听器：EventListener事件监听器接口。
• 事件源：不需要实现任何接口，Java中也没给出相应的定义。

具体使用方式：与观察者模式大同小异。

1、事件对象：

public class JDKEventObject extends EventObject {

    private Object source;

    public JDKEventObject(JDKEventSource source) {
        super(source);
        this.source = source;
    }

    @Override
    public Object getSource() {
        return source;
    }
}

2、监听器：

public interface JDKEventListener extends EventListener {

    public void handleEvent(JDKEventObject event);
}

3、事件源：

public class JDKEventSource {

    private Set<EventListener> listeners = new HashSet();

    private String message;

    public void addListener(EventListener event) {
        listeners.add(event);
    }

    public void removeListener(EventListener event) {
        if (listeners.contains(event))
            listeners.remove(event);
    }

    public void fireEvent() {
        Iterator<EventListener> iter = listeners.iterator();
        while (iter.hasNext()) {
            JDKEventListener listener = (JDKEventListener) iter.next();
            listener.handleEvent(new JDKEventObject(this));
        }
    }
}

Spring事件驱动机制

Spring事件驱动是基于Java的事件驱动实现的，并且内置了一些时间：

• ContextRefreshedEvent：ApplicationContext初始化或刷新时触发该事件。
  • 通常在Spring加载或刷新应用上下文时，同时也想刷新预加载的资源，就可以通过监听ContextRefreshedEvent来做这样的事情。
  • 这里的“初始化”是指所有Bean均已加载，检测到并激活了BeanPostProcessors，已预先实例化单例并且可以使用ApplicationContext对象。
  • 只要上下文尚未关闭，选用的ApplicationContext支持这种“热”刷新（如：XmlWebApplicationContext支持热刷新，但GenericApplicationContext不支持），刷新可以被多次触发。
• ContextStartedEvent：ApplicationContext启动时触发该事件。
  • "Started" 意味着所有Lifecycle Bean会获得启动事件。
  • 通常，此事件用于在显式停止后重新启动Bean时，也可以用于启动尚未配置为自动启动的组件。
• ContextStoppedEvent：ApplicationContext被停止时触发该事件。
  • "Stopped"是指所有Lifecycle Bean都收到一个明确的停止事件。
  • 已停止的上下文可以通过start()调用重新启动。
• ContextClosedEvent：ApplicationContext被关闭时触发该事件。
  • "Closed" 意味着容器管理的所有单例Bean都被销毁。
  • 关闭的上下文表示容器生命周期结束，它不能刷新或重新启动。
• RequestHandledEvent：基于Web应用的事件，当一个HTTP请求完成后，触发该事件。该事件仅适用于使用DispatcherServlet的Web应用程序。

———————————————————————————————————————————————————————

Spring事件机制中除了事件对象和监听者者两个角色之外，“事件广播器”则负责把事件转发给监听者：

• ApplicationEvent：Spring提供的事件类，继承自EventObject类。
• ApplicationListener：事件监听者，该类接收一个泛型，供ApplicationEventPublisher在发布事件时选择EventListener。
• ApplicationEventPublisher：封装事件发布功能的接口，通知所有在Spring中注册的该事件的监听者进行处理。
• ApplicationEventPublisherAware：Spring提供的Aware接口之一，实现该接口的Bean可以获取ApplicationEventPublisher并进行发布事件。
• ApplicationEventMulticaster：管理多个ApplicationListener对象并向其发布事件的接口。

Spring 中，不需要我们手动进行监听器注册。ApplicationListener对象一旦在Spring容器中被注册，Spring会进行监听器的注册，实现事件的监听。

1、服务类：

// Spring容器检测到Service实现了ApplicationEventPublisherAware接口，会自动调用setApplicationEventPublisher
public class SpringService implements ApplicationEventPublisherAware {

    private List<String> nameList;
    private ApplicationEventPublisher publisher;

    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher publisher) {
        this.publisher = publisher;
    }

    public void setNameList(List<String> list) {
        this.nameList = list;
    }

    // 要发布自定义ApplicationEvent，需要在ApplicationEventPublisher上调用publishEvent方法
    public void sendMessage(String name) {
        if (nameList.contains(name)) {
            publisher.publishEvent(new SpringEvent(this, name));
            return;
        }
    }
}

2、监听器：

// 要接收自定义的ApplicationEvent，需要实现ApplicationListener监听器
public class SpringListener implements ApplicationListener<SpringEvent> {

    String notifier;

    public void setNotifier(String notifier) {
        this.notifier = notifier;
    }

    @Override
    public void onApplicationEvent(SpringEvent event) {
        System.out.println("onApplicationEvent: "+ notifier);
    }
}

3、事件类：

public class SpringEvent extends ApplicationEvent {

    String name;

    /**
     * Create a new ApplicationEvent.
     *
     * @param source the object on which the event initially occurred (never {@code null})
     */
    public SpringEvent(Object source, String name) {
        super(source);
        this.name = name;
    }
}

容器生命周期

之前我们所说的BeanPostProcessor及Bean的初始和销毁回调这些事件都是建立在容器已经成功启动的基础上，如果我们想在容器启动前后做一些处理就需要实现如下接口：

// 生命周期接口，任何Spring管理的对象都可以实现该接口
public interface Lifecycle {
    void start();
    void stop();
    boolean isRunning();
}

// 管理ApplicationContext生命周期
public interface LifecycleProcessor extends Lifecycle {
    void onRefresh();
    void onClose();
}

public interface SmartLifecycle extends Lifecycle, Phased {
    // Lifecycle Bean是否自动启动
    boolean isAutoStartup();

    // 停止的时候执行回调，默认超时时间30秒
    void stop(Runnable callback);
}

// Phased最小的对象首先启动，停止时，顺序和启动时相反
public interface Phased {
    // SmartLifecycle的实现类默认Phase为0
    int getPhase();
}

示例：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean class="com.jdr.spring.event.TestLifeCycle" name="testLifeCycle"/>

    <bean class="com.jdr.spring.event.TestSmartLifeCycle" name="testSmartLifeCycle"/>

    <bean class="com.jdr.spring.event.CustomContextEvent" name="customContextEvent"/>

</beans>

public class TestLifeCycle implements Lifecycle {

    private boolean running = false;

    public TestLifeCycle() {
        System.out.println("TestLifeCycle....");
    }

    @Override
    public void start() {
        System.out.println("TestLifeCycle start...");
    }

    @Override
    public void stop() {
        System.out.println("TestLifeCycle stop...");
    }

    @Override
    public boolean isRunning() {
        return running;
    }
}

public class TestSmartLifeCycle implements SmartLifecycle {

    private boolean running = false;

    public TestSmartLifeCycle() {
        System.out.println("TestSmartLifeCycle....");
    }

    @Override
    public boolean isAutoStartup() {
        // 若自动启动标识为false，则容器启动时不会调用start()
        return true;
    }

    @Override
    public void stop(Runnable callback) {
        System.out.println("TestSmartLifeCycle stop callback....");
        this.running = false;
    }

    @Override
    public void start() {
        System.out.println("TestSmartLifeCycle start....");
        this.running = true;
    }

    @Override
    public void stop() {
        System.out.println("TestSmartLifeCycle stop....");
        this.running = false;
    }

    @Override
    public boolean isRunning() {
        return running;
    }

    @Override
    public int getPhase() {
        return 100;
    }
}

public class CustomContextEvent implements ApplicationListener<ApplicationEvent> {

    @Override
    public void onApplicationEvent(ApplicationEvent event) {
        if (event instanceof ContextRefreshedEvent) {
            System.out.println("ContextRefreshedEvent...");
        }
        if (event instanceof ContextStartedEvent) {
            System.out.println("ContextStartedEvent...");
        }
        if (event instanceof ContextStoppedEvent) {
            System.out.println("ContextStoppedEvent...");
        }
        if (event instanceof ContextClosedEvent) {
            System.out.println("ContextClosedEvent...");
        }
    }
}

注意：

• 常规的Lifecycle接口只在容器上下文显式的调用start()/stop()方法时，才会去回调Lifecycle实现类的start/stop方法逻辑。
  • 如果需要在容器启动时调用start()就需要实现SmartLifecycle接口，并且将isAutoStartup设置为true。
• 另外，LifeCycle Bean在销毁之前不能保证会收到停止通知。
  • 正常关闭时，所有Lifecycle Bean在销毁回调之前首先会收到停止通知，但是在上下文的生命周期内进行热刷新或中止刷新尝试时，只会调用destroy方法。