SpringBoot2 | SpringBoot監聽器源碼分析 | 自定義ApplicationListener（六）

時間  2019-12-09
標籤 springboot2 springboot 監聽器 源碼 分析 自定義 applicationlistener 欄目 Spring 简体版
原文   原文鏈接

微信公衆號：吉姆餐廳ak 學習更多源碼知識，歡迎關注。 spring

在這裏插入圖片描述

SpringBoot2 | SpringBoot啓動流程源碼分析（一）bash

SpringBoot2 | SpringBoot啓動流程源碼分析（二）微信

SpringBoot2 | @SpringBootApplication註解 自動化配置流程源碼分析（三）app

SpringBoot2 | SpringBoot Environment源碼分析（四）框架

SpringBoot2 | SpringBoot自定義AutoConfiguration | SpringBoot自定義starter（五）less

SpringBoot2 | SpringBoot監聽器源碼分析 | 自定義ApplicationListener（六）ide

SpringBoot2 | 條件註解@ConditionalOnBean原理源碼深度解析（七）工具

SpringBoot2 | Spring AOP 原理源碼深度剖析（八）源碼分析

SpringBoot2 | SpingBoot FilterRegistrationBean 註冊組件 | FilterChain 責任鏈源碼分析（九）學習

SpringBoot2 | BeanDefinition 註冊核心類 ImportBeanDefinitionRegistrar （十）

SpringBoot2 | Spring 核心擴展接口 | 核心擴展方法總結（十一）

概述

咱們都知道Spring源碼博大精深，閱讀起來相對困難。緣由之一就是內部用了大量的監聽器，spring相關的框架，皆是如此，spring security，springBoot等。今天來看下springBoot監聽器的應用。

由於springBoot是對spring的封裝，因此springBoot的監聽器的應用主要是在啓動模塊。

源碼

springBoot監聽器的主要分爲兩類：

1）運行時監聽器

# Run Listeners
org.springframework.boot.SpringApplicationRunListener=\
org.springframework.boot.context.event.EventPublishingRunListener
複製代碼

2）上下文監聽器

# Application Listeners
org.springframework.context.ApplicationListener=\
org.springframework.boot.builder.ParentContextCloserApplicationListener,\
org.springframework.boot.context.FileEncodingApplicationListener,\
org.springframework.boot.context.config.AnsiOutputApplicationListener,\
org.springframework.boot.context.config.ConfigFileApplicationListener,\
org.springframework.boot.context.config.DelegatingApplicationListener,\
org.springframework.boot.liquibase.LiquibaseServiceLocatorApplicationListener,\
org.springframework.boot.logging.ClasspathLoggingApplicationListener,\
org.springframework.boot.logging.LoggingApplicationListener
複製代碼

注意：springBoot運行時監聽器做用是用來觸發springBoot上下文監聽器，再根據各監聽器監聽的事件進行區分。 上面默認監聽器的做用以下：

在這裏插入圖片描述

運行時監聽器和上下文監聽器都是定義在spring.factories文件中。

監聽器觸發

啓動流程前面兩篇已經有詳細分析，因此本篇咱們只看監聽器相關邏輯。

public ConfigurableApplicationContext run(String... args) {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        ConfigurableApplicationContext context = null;
        configureHeadlessProperty();
        //獲取啓動監聽器的監聽器
        SpringApplicationRunListeners listeners = getRunListeners(args);
        //用該監聽器來啓動全部監聽器
        listeners.started();
        try {
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(
                    args);
            context = createAndRefreshContext(listeners, applicationArguments);
            afterRefresh(context, applicationArguments);
            listeners.finished(context, null);
            stopWatch.stop();
            if (this.logStartupInfo) {
                new StartupInfoLogger(this.mainApplicationClass)
                        .logStarted(getApplicationLog(), stopWatch);
            }
            return context;
        }
        catch (Throwable ex) {
            handleRunFailure(context, listeners, ex);
            throw new IllegalStateException(ex);
        }
    }
複製代碼

SpringApplicationRunListeners listeners = getRunListeners(args); 這裏建立了一個關鍵類：SpringApplicationRunListeners。

SpringApplicationRunListeners

這是一個封裝工具類，封裝了全部的啓動類監聽器。默認只有一個實例，這裏封裝成List<SpringApplicationRunListener> listeners，主要是方便咱們擴展，咱們能夠定義本身的啓動類監聽器。

//啓動類監聽器
    private final List<SpringApplicationRunListener> listeners;

    SpringApplicationRunListeners(Log log,
            Collection<? extends SpringApplicationRunListener> listeners) {
        this.log = log;
        this.listeners = new ArrayList<SpringApplicationRunListener>(listeners);
    }

	//啓動上下文事件監聽
    public void started() {
        for (SpringApplicationRunListener listener : this.listeners) {
            listener.started();
        }
    }

	//environment準備完畢事件監聽
    public void environmentPrepared(ConfigurableEnvironment environment) {
        for (SpringApplicationRunListener listener : this.listeners) {
            listener.environmentPrepared(environment);
        }
    }

    //spring上下文準備完畢事件監聽
    public void contextPrepared(ConfigurableApplicationContext context) {
        for (SpringApplicationRunListener listener : this.listeners) {
            listener.contextPrepared(context);
        }
    }

	//上下文配置類加載事件監聽
    public void contextLoaded(ConfigurableApplicationContext context) {
        for (SpringApplicationRunListener listener : this.listeners) {
            listener.contextLoaded(context);
        }
    }

	//上下文構造完成事件監聽
    public void finished(ConfigurableApplicationContext context, Throwable exception) {
        for (SpringApplicationRunListener listener : this.listeners) {
            callFinishedListener(listener, context, exception);
        }
    }
複製代碼

在前面的啓動流程源碼分析中介紹過，這些方法會在合適的時間點觸發執行，而後廣播出不一樣的事件。

跟進去EventPublishingRunListener:

public EventPublishingRunListener(SpringApplication application, String[] args) {
        this.application = application;
        this.args = args;
        //spring事件機制通用的事件發佈類
        this.multicaster = new SimpleApplicationEventMulticaster();
        for (ApplicationListener<?> listener : application.getListeners()) {
            this.multicaster.addApplicationListener(listener);
        }
    }
複製代碼

上面會默認建立全局的事件發佈工具類SimpleApplicationEventMulticaster。

@Override
    public void started() {
        publishEvent(new ApplicationStartedEvent(this.application, this.args));
    }

    @Override
    public void environmentPrepared(ConfigurableEnvironment environment) {
        publishEvent(new ApplicationEnvironmentPreparedEvent(this.application, this.args,
                environment));
    }

    @Override
    public void contextPrepared(ConfigurableApplicationContext context) {
        registerApplicationEventMulticaster(context);
    }

    @Override
    public void contextLoaded(ConfigurableApplicationContext context) {
        for (ApplicationListener<?> listener : this.application.getListeners()) {
            if (listener instanceof ApplicationContextAware) {
                ((ApplicationContextAware) listener).setApplicationContext(context);
            }
            context.addApplicationListener(listener);
        }
        publishEvent(new ApplicationPreparedEvent(this.application, this.args, context));
    }

    @Override
    public void finished(ConfigurableApplicationContext context, Throwable exception) {
        publishEvent(getFinishedEvent(context, exception));
    }
複製代碼

能夠看出每一個方法都會發布不一樣的事件，全部的事件統一繼承SpringApplicationEvent：

事件廣播

繼續跟進事件廣播方法：

@Override
    public void multicastEvent(ApplicationEvent event) {
        multicastEvent(event, resolveDefaultEventType(event));
    }

    @Override
    public void multicastEvent(final ApplicationEvent event, ResolvableType eventType) {
        ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
        //根據事件類型選取須要通知的監聽器
        for (final ApplicationListener<?> listener : getApplicationListeners(event, type)) {
            //獲取線程池，若是爲null，則同步執行
            Executor executor = getTaskExecutor();
            if (executor != null) {
                executor.execute(new Runnable() {
                    @Override
                    public void run() {
                        invokeListener(listener, event);
                    }
                });
            }
            else {
                invokeListener(listener, event);
            }
        }
    }
複製代碼

重點來看一下根據類型獲取監聽器：getApplicationListeners(event, type) 跟進該方法：

private Collection<ApplicationListener<?>> retrieveApplicationListeners(
            ResolvableType eventType, Class<?> sourceType, ListenerRetriever retriever) {

        //......
        //根據類型匹配監聽器
        for (ApplicationListener<?> listener : listeners) {
            if (supportsEvent(listener, eventType, sourceType)) {
                if (retriever != null) {
                    retriever.applicationListeners.add(listener);
                }
                allListeners.add(listener);
            }
        }
        //......
        AnnotationAwareOrderComparator.sort(allListeners);
        return allListeners;
    }
複製代碼

上面省去了一些不相關代碼，繼續跟進：supportsEvent(listener, eventType, sourceType)：

protected boolean supportsEvent(ApplicationListener<?> listener, ResolvableType eventType, Class<?> sourceType) {
        //判斷監聽器是不是 GenericApplicationListener 的子類，若是不是就返回一個GenericApplicationListenerAdapter
        GenericApplicationListener smartListener = (listener instanceof GenericApplicationListener ?
                (GenericApplicationListener) listener : new GenericApplicationListenerAdapter(listener));
        return (smartListener.supportsEventType(eventType) && smartListener.supportsSourceType(sourceType));
    }
複製代碼
public interface GenericApplicationListener extends ApplicationListener<ApplicationEvent>, Ordered {

    boolean supportsEventType(ResolvableType eventType);
    boolean supportsSourceType(Class<?> sourceType);
}
複製代碼

這裏又出現一個關鍵類：GenericApplicationListener,該類是 spring 提供的用於重寫匹配監聽器事件的接口。 就是說若是須要判斷的監聽器是GenericApplicationListener的子類，說明類型匹配方法已被重現，就調用子類的匹配方法。若是不是，則爲咱們提供一個默認的適配器用來匹配：GenericApplicationListenerAdapter：

在這裏插入圖片描述

繼續跟進該類的supportsEventType(ResolvableType eventType)方法：

public boolean supportsEventType(ResolvableType eventType) {
        if (this.delegate instanceof SmartApplicationListener) {
            Class<? extends ApplicationEvent> eventClass = (Class<? extends ApplicationEvent>) eventType.getRawClass();
            return ((SmartApplicationListener) this.delegate).supportsEventType(eventClass);
        }
        else {
            return (this.declaredEventType == null || this.declaredEventType.isAssignableFrom(eventType));
        }
    }
複製代碼

能夠看到該類最終調用的是declaredEventType.isAssignableFrom(eventType)方法，也就是說，若是咱們沒有重寫監聽器匹配方法，那麼發佈的事件 event 會被監聽 event以及監聽event的父類的監聽器監聽到。

自定義監聽器

/**
 * Created by zhangshukang on 2018/9/22.
 */
public class SimpleApplicationListener implements GenericApplicationListener,ApplicationListener<ApplicationEvent> {
    @Override
    public void onApplicationEvent(ApplicationEvent event) {
        System.out.println("myApplistener execute...");
    }

    @Override
    public boolean supportsEventType(ResolvableType eventType) {
        return true;
    }

    @Override
    public boolean supportsSourceType(Class<?> sourceType) {
        return true;
    }

    @Override
    public int getOrder() {
        return 0;
    }
複製代碼

上面supportsEventType和supportsSourceType是預留的擴展方法，這裏所有爲true，也就意味着監聽全部的ApplicationEvent事件，方法會執行屢次：

在這裏插入圖片描述

總結

springBoot總體框架就是經過該監聽器org.springframework.boot.SpringApplicationRunListeners，來觸發上下文監聽器。經過上下文監聽器來完成總體邏輯，好比加載配置文件，加載配置類，初始化日誌環境等。

SpringBoot2 | SpringBoot啓動流程源碼分析（一）

SpringBoot2 | SpringBoot啓動流程源碼分析（二）

SpringBoot2 | @SpringBootApplication註解 自動化配置流程源碼分析（三）

SpringBoot2 | SpringBoot Environment源碼分析（四）

SpringBoot2 | SpringBoot自定義AutoConfiguration | SpringBoot自定義starter（五）

SpringBoot2 | SpringBoot監聽器源碼分析 | 自定義ApplicationListener（六）

SpringBoot2 | 條件註解@ConditionalOnBean原理源碼深度解析（七）

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程