SpringBoot入门到精通-SpringBoot启动流程(七)-阿里云开发者社区

定义自己的starter

1.认识SpringApplication

SpringApplication 类提供了一种可通过运行 main() 方法来启动 Spring 应用的简单方式。多数情况下，您只需要委托给静态的 SpringApplication.run 方法：

public static void main(String[] args) {
   
   
    SpringApplication.run(MySpringConfiguration.class, args);
}

如果 SpringApplication 的默认设置不符合您的想法，您可以创建本地实例进行定制化。例如，要关闭 banner，您可以这样：

public static void main(String[] args) {
   
   
    SpringApplication app = new SpringApplication(MySpringConfiguration.class);
    app.setBannerMode(Banner.Mode.OFF);
    app.run(args);
}

2.SpringApplication.run执行流程

SpringApplication可用于从 Java 主方法引导和启动 Spring 应用程序的类。默认情况下，类将执行以下步骤来启动应用：

创建一个适当的[ApplicationContext]实例（取决于您的类路径）
注册 [CommandLinePropertySource]以将命令行参数公开为 Spring 属性
刷新应用程序上下文，加载所有单例 bean
触发任何[CommandLineRunner]bean

下面我们就来详细分析一下它的执行流程，见：org.springframework.boot.SpringApplication#run(java.lang.String...)

public ConfigurableApplicationContext run(String... args) {
   
   
        //创建秒表，用来计算启动事件
        StopWatch stopWatch = new StopWatch();
        //启动秒表
        stopWatch.start();
         //Spring IOC 容器对象
        ConfigurableApplicationContext context = null;
         //收集Spring Boot 异常报告器的list
        Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
        //配置无头属性，java.awt.headless
        configureHeadlessProperty();
        //SpringBoot的SpringApplication run方法的侦听器 监听器，
        //SpringApplicationRunListeners维护了一个 SpringApplicationRunListener 集合
        SpringApplicationRunListeners listeners = getRunListeners(args);
        //会触发所有 SpringApplicationRunListener#starting的执行
         //，会通过SimpleApplicationEventMulticaster广播一个ApplicationStartingEvent事件
        listeners.starting();
        try {
   
   
             //把应用参数封装到DefaultApplicationArguments，通过它可以访问应用参数
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
             //创建环境对象，Environment包括了property和profile
            ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
            //配置忽略 Bean 信息 ,spring.beaninfo.ignore
            configureIgnoreBeanInfo(environment);
            //打印横幅
            Banner printedBanner = printBanner(environment);
            //创建IOC容器对象 AnnotationConfigApplicationContext
            context = createApplicationContext();
             //创建Spring Boot 异常报告器实例。会扫描spring.factories下的 FailureAnalyzers实例，
            //FailureAnalyzer是用于分析故障并提供可显示给用户的诊断信息
            //比如：NoSuchBeanDefinitionFailureAnalyzer ； DataSourceBeanCreationFailureAnalyzer
            exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
                    new Class[] {
   
    ConfigurableApplicationContext.class }, context);
            //刷新容器准备工作
            //1.把environment绑定到context容器对象
            //2.context后置处理，比如绑定resourceLoader
            //3.触发 ApplicationContextInitializer#initialize初始化(用于在刷新之前初始化Context回调接口。)
            //4.触发 listener.contextPrepared ，抛出 ApplicationContextInitializedEvent 事件
            //5.把ApplicationArguments注册到容器中成为一个Bean
            //6.把 Banner注册到容器中成为一个Bean
            prepareContext(context, environment, listeners, applicationArguments, printedBanner);
            //刷新容器，底层走spring的刷新容器流程
            refreshContext(context);
            //空方法，留给我们扩展
            afterRefresh(context, applicationArguments);
            //暂定秒表
            stopWatch.stop();
            if (this.logStartupInfo) {
   
   
                //打印秒表记录的时间
                new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
            }
            //触发 SpringApplicationRunListener#started方法抛出 ApplicationStartedEvent 事件
            listeners.started(context);
            //调用 ApplicationRunner 和 CommandLineRunner
            callRunners(context, applicationArguments);
        }
        catch (Throwable ex) {
   
   
            //处理异常，会从exceptionReporters拿出异常进行打印
            //以及会触发 SpringApplicationRunListeners#failed，广播 ApplicationFailedEvent事件
            handleRunFailure(context, ex, exceptionReporters, listeners);
            throw new IllegalStateException(ex);
        }

        try {
   
   
                //执行listeners.running ， 抛出 ApplicationReadyEvent 事件
            listeners.running(context);
        }
        catch (Throwable ex) {
   
   
               //处理异常，会从exceptionReporters拿出异常进行打印
            handleRunFailure(context, ex, exceptionReporters, null);
            throw new IllegalStateException(ex);
        }
        //返回容器
        return context;
    }

画一个流程图总结一下

在这里插入图片描述

3.StopWatch秒表

Spring体用的秒表，允许对多个任务进行计时，显示每个命名任务的总运行时间和运行时间。隐藏System.nanoTime()的使用，提高应用程序代码的可读性并减少计算错误的可能性。注意，此对象并非设计为线程安全的，也不使用同步。

public class StopWatch {
   
   
        /**
     * Identifier of this {@code StopWatch}.
     * <p>Handy when we have output from multiple stop watches and need to
     * distinguish between them in log or console output.
     */
    //任务的ID
    private final String id;

    private boolean keepTaskList = true;
    //任务列表
    private final List<TaskInfo> taskList = new LinkedList<>();

    /** Start time of the current task. */
    //开始时间
    private long startTimeNanos;

    /** Name of the current task. */
    //当前任务名
    @Nullable
    private String currentTaskName;

    @Nullable
    private TaskInfo lastTaskInfo;
    //任务数量
    private int taskCount;

    /** Total running time. */
    //总时间
    private long totalTimeNanos;

    //开始任务，穿了一个“”作为taskName
    public void start() throws IllegalStateException {
   
   
        start("");
    }

    /**
     * Start a named task.
     * <p>The results are undefined if {@link #stop()} or timing methods are
     * called without invoking this method first.
     * @param taskName the name of the task to start
     * @see #start()
     * @see #stop()
     */
    //开始任务
    public void start(String taskName) throws IllegalStateException {
   
   
        if (this.currentTaskName != null) {
   
   
            throw new IllegalStateException("Can't start StopWatch: it's already running");
        }
        //任务名
        this.currentTaskName = taskName;
        //记录开始时间
        this.startTimeNanos = System.nanoTime();
    }

    //停止秒表
    public void stop() throws IllegalStateException {
   
   
        if (this.currentTaskName == null) {
   
   
            throw new IllegalStateException("Can't stop StopWatch: it's not running");
        }
        //时间差
        long lastTime = System.nanoTime() - this.startTimeNanos;
        //累计时间
        this.totalTimeNanos += lastTime;
        //创建一个TaskInfo任务信息
        this.lastTaskInfo = new TaskInfo(this.currentTaskName, lastTime);
        if (this.keepTaskList) {
   
   
            //加入任务列表
            this.taskList.add(this.lastTaskInfo);
        }
        //增加任务数量
        ++this.taskCount;
        //清空任务名
        this.currentTaskName = null;
    }
    //以优雅的格式打印秒表记录的时间日志
    public String prettyPrint() {
   
   
        StringBuilder sb = new StringBuilder(shortSummary());
        sb.append('\n');
        if (!this.keepTaskList) {
   
   
            sb.append("No task info kept");
        }
        else {
   
   
            sb.append("---------------------------------------------\n");
            sb.append("ns         %     Task name\n");
            sb.append("---------------------------------------------\n");
            NumberFormat nf = NumberFormat.getNumberInstance();
            nf.setMinimumIntegerDigits(9);
            nf.setGroupingUsed(false);
            NumberFormat pf = NumberFormat.getPercentInstance();
            pf.setMinimumIntegerDigits(3);
            pf.setGroupingUsed(false);
            for (TaskInfo task : getTaskInfo()) {
   
   
                sb.append(nf.format(task.getTimeNanos())).append("  ");
                sb.append(pf.format((double) task.getTimeNanos() / getTotalTimeNanos())).append("  ");
                sb.append(task.getTaskName()).append("\n");
            }
        }
        return sb.toString();
    }
}

StopWatch秒表可以用来对多个任务计时，，start的时候会使用System.nanoTime()来获时间记录到startTimeNanos ，stop结束方计算时间差，然后会把每次的时间和任务名封装成TaskInfo，加入taskList。最后会累计每次任务的时间总额。提供了prettyPrint方法以优雅的格式组织秒表记录的时间日志。

但是要注意：虽然它可以允许多个任务记时，但是它并不是线程安全的。

4.SpringBootExceptionReporter异常报告

4.1.核心类认识

SpringBootExceptionReporter是用于支持自定义上报SpringApplication启动错误的回调接口，它可以把启动的错误日志汇报给用户

@FunctionalInterface
public interface SpringBootExceptionReporter {
   
   

    /**
     * Report a startup failure to the user.
     * @param failure the source failure
     * @return {@code true} if the failure was reported or {@code false} if default
     * reporting should occur.
     */
    boolean reportException(Throwable failure);

}

reportException方法的作用就是为用户报告错误。它的唯一实现类是 FailureAnalyzers ，它提供了


final class FailureAnalyzers implements SpringBootExceptionReporter {
   
   

    private static final Log logger = LogFactory.getLog(FailureAnalyzers.class);

    private final ClassLoader classLoader;
    //故障分析仪
    private final List<FailureAnalyzer> analyzers;

    //报告指定的异常
    @Override
    public boolean reportException(Throwable failure) {
   
   
        //把异常封装到FailureAnalysis
        //FailureAnalysis中维护了很多的FailureAnalyzer，它的作用是分析故障并提供可显示给用户的诊断信息
        FailureAnalysis analysis = analyze(failure, this.analyzers);
        return report(analysis, this.classLoader);
    }

    //分析异常
    private FailureAnalysis analyze(Throwable failure, List<FailureAnalyzer> analyzers) {
   
   
        for (FailureAnalyzer analyzer : analyzers) {
   
   
            try {
   
   
                //把Throwable异常信息封装成FailureAnalysis
                FailureAnalysis analysis = analyzer.analyze(failure);
                if (analysis != null) {
   
   
                    return analysis;
                }
            }
            catch (Throwable ex) {
   
   
                logger.debug(LogMessage.format("FailureAnalyzer %s failed", analyzer), ex);
            }
        }
        return null;
    }

    private boolean report(FailureAnalysis analysis, ClassLoader classLoader) {
   
   
        //加载FailureAnalysisReporter，  FailureAnalysisReporter用来 向用户报告FailureAnalysis分析。
        List<FailureAnalysisReporter> reporters = SpringFactoriesLoader.loadFactories(FailureAnalysisReporter.class,
                classLoader);
        if (analysis == null || reporters.isEmpty()) {
   
   
            return false;
        }
        for (FailureAnalysisReporter reporter : reporters) {
   
   
            //报告异常
            reporter.report(analysis);
        }
        return true;
    }

reportException方法接收一个Throwable ，然后Throwable 会被封装到FailureAnalysis。然后通过SpringFactoriesLoader去加载FailureAnalysisReporter(向用户报告FailureAnalysis分析)，通过FailureAnalysisReporter去报告异常。FailureAnalysis结构如下

public class FailureAnalysis {
   
   
    //异常描述
    private final String description;

    private final String action;
    //异常对象
    private final Throwable cause;

LoggingFailureAnalysisReporter结构如下见：org.springframework.boot.diagnostics.LoggingFailureAnalysisReporter#report

public final class LoggingFailureAnalysisReporter implements FailureAnalysisReporter {
   
   

    private static final Log logger = LogFactory.getLog(LoggingFailureAnalysisReporter.class);

@Override
    public void report(FailureAnalysis failureAnalysis) {
   
   

        if (logger.isDebugEnabled()) {
   
   
            logger.debug("Application failed to start due to an exception", failureAnalysis.getCause());
        }
        //把错误日志打印到控制台
        if (logger.isErrorEnabled()) {
   
   
            logger.error(buildMessage(failureAnalysis));
        }
    }
    //构建错误日志内容
    private String buildMessage(FailureAnalysis failureAnalysis) {
   
   
        StringBuilder builder = new StringBuilder();
        builder.append(String.format("%n%n"));
        builder.append(String.format("***************************%n"));
        builder.append(String.format("APPLICATION FAILED TO START%n"));
        builder.append(String.format("***************************%n%n"));
        builder.append(String.format("Description:%n%n"));
        builder.append(String.format("%s%n", failureAnalysis.getDescription()));
        if (StringUtils.hasText(failureAnalysis.getAction())) {
   
   
            builder.append(String.format("%nAction:%n%n"));
            builder.append(String.format("%s%n", failureAnalysis.getAction()));
        }
        return builder.toString();
    }

4.2.报告异常

在SpringApplication#run方法中有try-catch操作，如果启动出现异常，会执行org.springframework.boot.SpringApplication#handleRunFailure来处理异常

private void handleRunFailure(ConfigurableApplicationContext context, Throwable exception,
            Collection<SpringBootExceptionReporter> exceptionReporters, SpringApplicationRunListeners listeners) {
   
   
        try {
   
   
            try {
   
   
                //处理退出码，发布一个ExitCodeEvent事件
                handleExitCode(context, exception);
                if (listeners != null) {
   
   
                    //发布ApplicationFailedEvent事件
                    listeners.failed(context, exception);
                }
            }
            finally {
   
   
                //报告异常，通过LoggingFailureAnalysisReporter 把异常打印到控制台
                reportFailure(exceptionReporters, exception);
                if (context != null) {
   
   
                    context.close();
                }
            }
        }
        catch (Exception ex) {
   
   
            logger.warn("Unable to close ApplicationContext", ex);
        }
        ReflectionUtils.rethrowRuntimeException(exception);
    }

上面重要是发布ApplicationFailedEvent事件, 然后通过SpringBootExceptionReporter#reportException去把异常打印到控制台，

5.监听器机制

上面代码中有很多地方都出现了事件发布，比如： SpringApplicationRunListeners listeners = getRunListeners(args) 它的作用是广播ApplicationStartingEvent事件，这用到了Spring的监听器机制。我们可以认为以 Listenner 结尾的类都是监听器，监听器使用到了观察者设计模式，其作用是监听一些事件的发生从而进行一些操作。监听器的好处是可以实现代码解耦,对此你可能不是很能理解，我这里用一个js例子来代理理解事件机制

function dothing(){
   
   
    //回调函数
}
//监听button的click事件
$("#button").click(dothing);

上面代码相信你是写过的，就是一个JS监听按钮点击事件，这里需要明确三个角色

button : 事件源，这个事件发生在谁身上
click : 事件类型，按钮发生了什么事件
dothing : 回调函数，当button被点击，触发 dothing函数。

那么Java中的事件机制和上面案例很相似，我这里有个案例：当用户注册成功，给用户推送一条短信，使用事件机制来实现

在这里插入图片描述

这么理解这幅图

首先需要定义一个事件类型RegisterApplicationEvent 继承于ApplicationEvent , 代表的注册这个事件，好比是"click"
然后需要在注册逻辑中，使用事件发布器ApplicationEventPublisher 发布该事件 ,好比 button 被 click了
事件被发布，需要触发某段逻辑，所以要写一个监听器类实现ApplicationListernner，该监听器监听的是“注册事件”。
然后就调用短信发送逻辑发送短信即可。好比是上面的dothing回调函数。

相信大致的流程你是看懂了，但是有些陌生类让我们比较迷惑，下面我们就来系统的认识一下这些类。

5.1. 核心类认识

EventListener

EventListener是java提供的最顶层的监听器接口，不管是Servlet的监听器还是Spring的监听器都是该接口的子类(所有事件侦听器接口都必须实现于接口)。

/**
 * A tagging interface that all event listener interfaces must extend.
 * @since JDK1.1
 */
public interface EventListener {
   
   
}

ApplicationListener

Spring提供的基于 Observer 设计模式(观察者)设计的监听器接口，实现了EventListener。

@FunctionalInterface
public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {
   
   

    /**
     * Handle an application event.
     * @param event the event to respond to
     */
    void onApplicationEvent(E event);

}

编写Spring的监听器都需要实现 ApplicationListener这个接口 , 比如这个类

public class ScheduledAnnotationBeanPostProcessor  implements ApplicationListener<ContextRefreshedEvent>...省略{
   
   
    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
   
   
        if (event.getApplicationContext() == this.applicationContext) {
   
   
            // Running in an ApplicationContext -> register tasks this late...
            // giving other ContextRefreshedEvent listeners a chance to perform
            // their work at the same time (e.g. Spring Batch's job registration).
            finishRegistration();
        }
    }
}

ScheduledAnnotationBeanPostProcessor就Schedule定时任务的处理器，它是实现ApplicationListener监听器接口，监听了ContextRefreshedEvent容器刷新完成事件，也就是说当Spring容器刷新完成，就会触发 onApplicationEvent方法，那么该监听器就可以对 Scheduled做一些处理了。

ApplicationEvent

Spring提供的事件对象，实现于EventObject，它代表了事件的类型。下面是EventObject的结构

public class EventObject implements java.io.Serializable {
   
   

    private static final long serialVersionUID = 5516075349620653480L;

    /**
     * The object on which the Event initially occurred.
     */
    protected transient Object  source;

    /**
     * Constructs a prototypical Event.
     *
     * @param    source    The object on which the Event initially occurred.
     * @exception  IllegalArgumentException  if source is null.
     */
    public EventObject(Object source) {
   
   
        if (source == null)
            throw new IllegalArgumentException("null source");

        this.source = source;
    }

    /**
     * The object on which the Event initially occurred.
     *
     * @return   The object on which the Event initially occurred.
     */
    public Object getSource() {
   
   
        return source;
    }

    /**
     * Returns a String representation of this EventObject.
     *
     * @return  A a String representation of this EventObject.
     */
    public String toString() {
   
   
        return getClass().getName() + "[source=" + source + "]";
    }
}

Object source; 可以用来传送数据，当我们要发布一个事件的时候，就需要创建一个事件对象，同时事件对象指定一个shource。在Spring中内置了很多事件对象，他们都是ApplicationEvent的子类比如：

ContextStartedEvent ： ApplicationContext Spring容器启动时引发的事件。
ContextRefreshedEvent ：初始化或刷新ApplicationContext时引发的事件。
ContextStoppedEvent：当ApplicationContext停止时引发的事件。
ContextClosedEvent：ApplicationContext关闭时引发的事件。

下面这几个是ＳpringBoot提供的事件对象，也是ApplicationEvent的子类，在上面的SpringBoot执行流程中也有看到

ApplicationPreparedEvent ：当SpringApplication启动并且ApplicationContext已完全准备好但未刷新时发布的事件。将加载 bean 定义，并且在此阶段Environment已准备好使用
ApplicationStartingEvent ：在SpringApplication启动后尽可能早地发布事件 - 在Environment或ApplicationContext可用之前，但在ApplicationListener已注册之后
ApplicationStartedEvent ：刷新应用程序上下文但在调用任何application和command line运行程序之前发布的事件。
ApplicationReadyEvent ：发布该事件表明应用程序已准备好为请求提供服务
ApplicationFailedEvent ： SpringApplication启动失败时发布的事件

ApplicationEventPublisher

事件发布器，提供了发布事件的基础功能

@FunctionalInterface
public interface ApplicationEventPublisher {
   
   

    default void publishEvent(ApplicationEvent event) {
   
   
        publishEvent((Object) event);
    }

    void publishEvent(Object event);
}

大名鼎鼎的 ApplicationContext 容器对象就是实现该接口ApplicationEventPublisher ，拥有了事件发布的能力。

他们的继承体系如下

在这里插入图片描述

5.2.发布自定义事件

我们来把上面的案例实现以下，即：当注册成功，给用户发送一条短信，确定好三个角色

事件是什么？“注册成功事件” -> 需要定义一个事件对象
事件源是什么？“注册逻辑” -> 在注册成功后，发布"注册事件"
做出的反映是什么？“推送短信” -> 监听“注册事件”，推送短信

第一步，创建一个事件对象，继承ApplicationEvent

//注册成功事件对象
public class RegisterSuccessEvent extends ApplicationEvent {
   
   

    //Object source ：待会要传递的参数
    public RegisterSuccessEvent(Object source) {
   
   
        super(source);
    }
}

第二步，创建事件监听器，监听RegisterSuccessEvent事件

//注册成功的监听器，监听 RegisterSuccessEvent事件
@Slf4j
@Service
public class RegisterSuccessListenner implements ApplicationListener<RegisterSuccessEvent> {
   
   

    @Override
    public void onApplicationEvent(RegisterSuccessEvent event) {
   
   
        Map<String,String> source = (Map<String, String>) event.getSource();
        if(source == null){
   
   
            log.error("短信内容不能为空");
        }else{
   
   
            String phone = source.get("phone");
            String message = source.get("message");
            log.info("注册成功，给： {} 发送短信，内容： {}" , phone , message);
        }
    }
}

第三步，注册逻辑，抛出RegisterSuccessEvent事件，我这里就简单模拟一下


//注入事件发布器
@Autowired
private ApplicationEventPublisher applicationEventPublisher;

@RequestMapping("/register")
public JSONResult register(){
   
   
    Map<String,String> map = new HashMap<>();
    map.put("phone","18233333333");
    map.put("message","注册成功");
    applicationEventPublisher.publishEvent(new RegisterSuccessEvent(map));
    return JSONResult.builder().build();
}

第四步，启动测试，效果如下

2022-01-14 10:10:31.941 INFO 20448 --- [nio-8081-exec-5] cn.whale.event.RegisterSuccessListenner : 注册成功，给： 18233333333 发送短信，内容：注册成功

这里我再给一个小案例：项目启动完成，往数据库初始化一个管理员账号，这个应该怎么做呢？

我们可以编写一个类，实现 ApplicationListener<ContextRefreshedEvent> ，监听事件是Spring容器刷新完成，然后复写onApplicationEvent方法，在该方法中往数据库保存管理员账号即可。你可以自己试着写一下。

5.3.web三大监听器

这里给大家介绍web环境中，三个比较有用的监听器

HttpSessionListener ：它是针对于Session的监听器，提供了两个方法来监听session的创建和销毁，代码如下

public interface HttpSessionListener extends EventListener {
   
   
    //session创建
    public default void sessionCreated(HttpSessionEvent se) {
   
   
    }
    //session销毁
    public default void sessionDestroyed(HttpSessionEvent se) {
   
   
    }
}

如果我们实现该接口，就可以监听到session的什么周期方法了，你可能会问，这有什么用，那我给一个需求你思考一下怎么做：“记录用户在网站的登录到退出的时间”

ServletContextListener : 它是用来监听ServletContext上下文对象的生命周期，结构如下


public interface ServletContextListener extends EventListener {
   
   

    //上下文初始化，代表应用启动
    public default void contextInitialized(ServletContextEvent sce) {
   
   
    }

    //上下文销毁，代表应用结束
    public default void contextDestroyed(ServletContextEvent sce) {
   
   
    }
}

我这么说把，Spirng整合web,就是通过实现ServletContextListenner监听器，复写 contextInitialized方法，然后在该方法中创建WebApplicationContext容器。所以该监听器可以监听整个程序的启动和销毁。

ServletRequestListener : 它是监听request对象的生命周期方法

public interface ServletRequestListener extends EventListener {
   
   

   //销毁
    public default void requestDestroyed (ServletRequestEvent sre) {
   
   
    }

    //request初始化
    public default void requestInitialized (ServletRequestEvent sre) {
   
   
    }
}

该监听器是监听request对象的初始化和销毁，我不知道你有没有通过 RequestContextHolder.getRequestAttributes() 来获取Request对象，它的实现原理就是通过一个 RequestContextListener类去实现 ServletRequestListener 接口，然后在requestInitialized方法中拿到request对象，封装到RequestContextHolder中的一个 ThreadLocal<RequestAttributes> requestAttributesHolder 中存储起来，所以我们在业务代码中可以通过RequestContextHolder直接获取Request对象。

6.SpringBoot的事件

讲完Spirng事件我们来讲SpringBoot中的事件，在SpringBoot启动流程中出现 SpringApplicationRunListeners#starting 等代码，其实就是在发布SpringBoot的事件。我们来看

4.1.SpringApplicationRunListeners

SpringApplicationRunListeners ：下面是 SpringApplicationRunListeners的代码结构

class SpringApplicationRunListeners {
   
   

    private final Log log;
    //保存了很多的SpringApplicationRunListener
    private final List<SpringApplicationRunListener> listeners;

    SpringApplicationRunListeners(Log log, Collection<? extends SpringApplicationRunListener> listeners) {
   
   
        this.log = log;
        this.listeners = new ArrayList<>(listeners);
    }
    //调用starting，本质是调用SpringApplicationRunListener的starting
    void starting() {
   
   
        for (SpringApplicationRunListener listener : this.listeners) {
   
   
            listener.starting();
        }
    }
    //调用environmentPrepared环境准备完成，本质是调用SpringApplicationRunListener的environmentPrepared
    void environmentPrepared(ConfigurableEnvironment environment) {
   
   
        for (SpringApplicationRunListener listener : this.listeners) {
   
   
            listener.environmentPrepared(environment);
        }
    }
     //调用contextPrepared 容器刷新完成，本质是调用SpringApplicationRunListener的contextPrepared
    void contextPrepared(ConfigurableApplicationContext context) {
   
   
        for (SpringApplicationRunListener listener : this.listeners) {
   
   
            listener.contextPrepared(context);
        }
    }
    //容器加载完成
    void contextLoaded(ConfigurableApplicationContext context) {
   
   
        for (SpringApplicationRunListener listener : this.listeners) {
   
   
            listener.contextLoaded(context);
        }
    }
    //启动
    void started(ConfigurableApplicationContext context) {
   
   
        for (SpringApplicationRunListener listener : this.listeners) {
   
   
            listener.started(context);
        }
    }
   //运行中
    void running(ConfigurableApplicationContext context) {
   
   
        for (SpringApplicationRunListener listener : this.listeners) {
   
   
            listener.running(context);
        }
    }
    //出现错误
    void failed(ConfigurableApplicationContext context, Throwable exception) {
   
   
        for (SpringApplicationRunListener listener : this.listeners) {
   
   
            callFailedListener(listener, context, exception);
        }
    }
    //出现错误
    private void callFailedListener(SpringApplicationRunListener listener, ConfigurableApplicationContext context,
            Throwable exception) {
   
   
        try {
   
   
            listener.failed(context, exception);
        }
        catch (Throwable ex) {
   
   
            if (exception == null) {
   
   
                ReflectionUtils.rethrowRuntimeException(ex);
            }
            if (this.log.isDebugEnabled()) {
   
   
                this.log.error("Error handling failed", ex);
            }
            else {
   
   
                String message = ex.getMessage();
                message = (message != null) ? message : "no error message";
                this.log.warn("Error handling failed (" + message + ")");
            }
        }
    }

}

在 SpringApplicationRunListeners这类中维护了一个 List<SpringApplicationRunListener> listeners;集合，SpringApplicationRunListeners#starting方法本质是调用的SpringApplicationRunListener#starting方法

4.2.SpringApplicationRunListener

SpringApplicationRunListener是一个接口，其中维护了很多的事件方法

public interface SpringApplicationRunListener {
   
   

    //开始
    default void starting() {
   
   
    }
    //环境准备完成
    default void environmentPrepared(ConfigurableEnvironment environment) {
   
   
    }
     //容器准备完成
    default void contextPrepared(ConfigurableApplicationContext context) {
   
   
    }
    //容器加载完成
    default void contextLoaded(ConfigurableApplicationContext context) {
   
   
    }
    //启动成功
    default void started(ConfigurableApplicationContext context) {
   
   
    }
    //运行中
    default void running(ConfigurableApplicationContext context) {
   
   
    }
    //启动失败
    default void failed(ConfigurableApplicationContext context, Throwable exception) {
   
   
    }

}

这里我找到了它的唯一一个默认实现类EventPublishingRunListener , 看名字是一个时间发布器

public class EventPublishingRunListener implements SpringApplicationRunListener, Ordered {
   
   
    ...省略...

    //简单应用事件广播器
    private final SimpleApplicationEventMulticaster initialMulticaster;

    @Override
    public void starting() {
   
   
        //通过 SimpleApplicationEventMulticaster 发布ApplicationStartingEvent 应用开始启动事件
        this.initialMulticaster.multicastEvent(new ApplicationStartingEvent(this.application, this.args));
    }

    @Override
    public void environmentPrepared(ConfigurableEnvironment environment) {
   
   
        //通过 SimpleApplicationEventMulticaster 发布ApplicationEnvironmentPreparedEvent 应用环境准备完成事件
        this.initialMulticaster
                .multicastEvent(new ApplicationEnvironmentPreparedEvent(this.application, this.args, environment));
    }

    @Override
    public void contextPrepared(ConfigurableApplicationContext context) {
   
   
        //通过 SimpleApplicationEventMulticaster 发布ApplicationContextInitializedEvent 应用初始化完成事件
        this.initialMulticaster
                .multicastEvent(new ApplicationContextInitializedEvent(this.application, this.args, context));
    }

    @Override
    public void contextLoaded(ConfigurableApplicationContext context) {
   
   
        for (ApplicationListener<?> listener : this.application.getListeners()) {
   
   
            if (listener instanceof ApplicationContextAware) {
   
   
                ((ApplicationContextAware) listener).setApplicationContext(context);
            }
            context.addApplicationListener(listener);
        }
        //通过 SimpleApplicationEventMulticaster 发布ApplicationPreparedEvent 应用准备成功事件
        this.initialMulticaster.multicastEvent(new ApplicationPreparedEvent(this.application, this.args, context));
    }

    @Override
    public void started(ConfigurableApplicationContext context) {
   
   
        //通过 ConfigurableApplicationContext 发布ApplicationStartedEvent 应用启动成功事件
        context.publishEvent(new ApplicationStartedEvent(this.application, this.args, context));
    }

    @Override
    public void running(ConfigurableApplicationContext context) {
   
   
        //通过 ConfigurableApplicationContext 发布ApplicationReadyEvent 应用启动完毕，可以接受请求了
        context.publishEvent(new ApplicationReadyEvent(this.application, this.args, context));
    }

    @Override
    public void failed(ConfigurableApplicationContext context, Throwable exception) {
   
   
        //应用启动失败的事件
        ApplicationFailedEvent event = new ApplicationFailedEvent(this.application, this.args, context, exception);
        if (context != null && context.isActive()) {
   
   
            // Listeners have been registered to the application context so we should
            // use it at this point if we can
            context.publishEvent(event);
        }
        else {
   
   
            // An inactive context may not have a multicaster so we use our multicaster to
            // call all of the context's listeners instead
            if (context instanceof AbstractApplicationContext) {
   
   
                for (ApplicationListener<?> listener : ((AbstractApplicationContext) context)
                        .getApplicationListeners()) {
   
   
                    this.initialMulticaster.addApplicationListener(listener);
                }
            }
            //处理错误
            this.initialMulticaster.setErrorHandler(new LoggingErrorHandler());
            //通过 initialMulticaster 发布ApplicationFailedEvent 应用启动失败
            this.initialMulticaster.multicastEvent(event);
        }
    }

    private static class LoggingErrorHandler implements ErrorHandler {
   
   

        private static final Log logger = LogFactory.getLog(EventPublishingRunListener.class);

        //打印错误
        @Override
        public void handleError(Throwable throwable) {
   
   
            logger.warn("Error calling ApplicationEventListener", throwable);
        }

    }
}

在EventPublishingRunListener中维护了一个 SimpleApplicationEventMulticaster 事件广播器，其中 starting ；environmentPrepared ；contextPrepared；contextLoaded ；failed 使用的是SpringBoot提供的SimpleApplicationEventMulticaster去发布事件。而对于；started ；failed； running ；会用到 ConfigurableApplicationContext容器对象去发布事件，ConfigurableApplicationContext是ApplicationEventPublisher Spring的事件发布器的实现类。

下面这几个是ＳpringBoot提供的事件对象，也是ApplicationEvent的子类，在上面的SpringBoot执行流程中也有看到

ApplicationPreparedEvent ：当SpringApplication启动并且ApplicationContext已完全准备好但未刷新时发布的事件。将加载 bean 定义，并且在此阶段Environment已准备好使用
ApplicationStartingEvent ：在SpringApplication启动后尽可能早地发布事件 - 在Environment或ApplicationContext可用之前，但在ApplicationListener已注册之后
ApplicationStartedEvent ：刷新应用程序上下文但在调用任何application和command line运行程序之前发布的事件。
ApplicationReadyEvent ：发布该事件表明应用程序已准备好为请求提供服务
ApplicationFailedEvent ： SpringApplication启动失败时发布的事件
ApplicationEnvironmentPreparedEvent：当SpringApplication启动并且Environment首次可供检查和修改时发布的事件。
ApplicationContextInitializedEvent ：当SpringApplication启动并准备ApplicationContext并且 ApplicationContextInitializers 已被调用但在加载任何 bean 定义之前发布的事件

我们来看一下 initialMulticaster 是怎么广播事件的，如： this.initialMulticaster.multicastEvent(new ApplicationStartingEvent(this.application, this.args)); ，见：org.springframework.context.event.SimpleApplicationEventMulticaster#multicastEvent

public class SimpleApplicationEventMulticaster extends AbstractApplicationEventMulticaster {
   
   
   ...省略...
    @Override
    public void multicastEvent(ApplicationEvent event) {
   
   
        multicastEvent(event, resolveDefaultEventType(event));
    }

    @Override
    public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
   
   
        ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
        Executor executor = getTaskExecutor();
        //这里是拿到监听了该event事件的Listenner，循环去调用监听器
        for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {
   
   
            if (executor != null) {
   
   
                executor.execute(() -> invokeListener(listener, event));
            }
            else {
   
   
                //调用监听器
                invokeListener(listener, event);
            }
        }
    }

    protected void invokeListener(ApplicationListener<?> listener, ApplicationEvent event) {
   
   
        //错误处理器
        ErrorHandler errorHandler = getErrorHandler();
        if (errorHandler != null) {
   
   
            try {
   
   
                //调用监听器
                doInvokeListener(listener, event);
            }
            catch (Throwable err) {
   
   
                //错误处理
                errorHandler.handleError(err);
            }
        }
        else {
   
   
            doInvokeListener(listener, event);
        }
    }


    private void doInvokeListener(ApplicationListener listener, ApplicationEvent event) {
   
   
        try {
   
   
            //触发了 ApplicationListener#onApplicationEvent
            listener.onApplicationEvent(event);
        }
        catch (ClassCastException ex) {
   
   
            ...省略...
        }
    }


}

你应该看明白了，SimpleApplicationEventMulticaster 中先是根据某个事件类型比如 ApplicationStartingEvent ，获取到监听了该事件的ApplicationListener 监听类，循环去调用监听类即：调用ApplicationListener#onApplicationEvent方法去触发事件。

那么如果你的Listenner监听了ApplicationStartingEvent 该事件，你的onApplicationEvent方法就会被触发执行。

那我们再看一下ConfigurableApplicationContext#publishEvent是怎么发布事件的，如：context.publishEvent(new ApplicationStartedEvent(this.application, this.args, context));，见：org.springframework.context.support.AbstractApplicationContext#publishEvent

protected void publishEvent(Object event, @Nullable ResolvableType eventType) {
   
   
        Assert.notNull(event, "Event must not be null");

        // Decorate event as an ApplicationEvent if necessary
        ApplicationEvent applicationEvent;
        if (event instanceof ApplicationEvent) {
   
   
            applicationEvent = (ApplicationEvent) event;
        }
        else {
   
   
            applicationEvent = new PayloadApplicationEvent<>(this, event);
            if (eventType == null) {
   
   
                eventType = ((PayloadApplicationEvent<?>) applicationEvent).getResolvableType();
            }
        }

        // Multicast right now if possible - or lazily once the multicaster is initialized
        if (this.earlyApplicationEvents != null) {
   
   
            this.earlyApplicationEvents.add(applicationEvent);
        }
        else {
   
   
            //这里还是通过 Multicaster 去广播事件
            getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
        }

        // Publish event via parent context as well...
        if (this.parent != null) {
   
   
            if (this.parent instanceof AbstractApplicationContext) {
   
   
                ((AbstractApplicationContext) this.parent).publishEvent(event, eventType);
            }
            else {
   
   
                this.parent.publishEvent(event);
            }
        }
    }

我们看到 ConfigurableApplicationContext 其实掉用了AbstractApplicationContext#publishEvent方法去广播事件，底层还是使用了 org.springframework.context.event.SimpleApplicationEventMulticaster#multicastEvent去广播事件

@Override
public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
   
   
    ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
    Executor executor = getTaskExecutor();
    for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {
   
   
        if (executor != null) {
   
   
            executor.execute(() -> invokeListener(listener, event));
        }
        else {
   
   
            invokeListener(listener, event);
        }
    }
}

SpringBoot的事件就讲到这，那么我们学会了什么呢？至少你应该知道如果我要在SpirngBoot启动，或者启动失败做一些自己的业务，那你应该怎么做了。

7.printBanner打印横幅

横幅是SpringBoot启动时候在控制台打印的SpringBoot图案

在这里插入图片描述

我们可以在resources中创建banner.txt来自定义横幅内容，也可以通过 spring.main.banner-mode=off来关闭打印。

7.1.相关类介绍

在SpringBoot中提供了一个Banner接口专门用于以编程方式编写横幅的接口类。

@FunctionalInterface
public interface Banner {
   
   

    //打印横幅
    void printBanner(Environment environment, Class<?> sourceClass, PrintStream out);

    //模式
    enum Mode {
   
   
        OFF,
        CONSOLE,
        LOG

    }

}

在这里插入图片描述

我们来介绍一下这几个实现类

SpringBootBanner ： SpringBoot默认的横幅打印实现类

class SpringBootBanner implements Banner {
   
   
    //默认要打印的横幅
    private static final String[] BANNER = {
   
    "", "  .   ____          _            __ _ _",
            " /\\\\ / ___'_ __ _ _(_)_ __  __ _ \\ \\ \\ \\", "( ( )\\___ | '_ | '_| | '_ \\/ _` | \\ \\ \\ \\",
            " \\\\/  ___)| |_)| | | | | || (_| |  ) ) ) )", "  '  |____| .__|_| |_|_| |_\\__, | / / / /",
            " =========|_|==============|___/=/_/_/_/" };

    private static final String SPRING_BOOT = " :: Spring Boot :: ";

    private static final int STRAP_LINE_SIZE = 42;

    @Override
    public void printBanner(Environment environment, Class<?> sourceClass, PrintStream printStream) {
   
   
        //打印横幅
        for (String line : BANNER) {
   
   
            printStream.println(line);
        }
        //拿到SpringBoot的版本号
        String version = SpringBootVersion.getVersion();
        version = (version != null) ? " (v" + version + ")" : "";
        StringBuilder padding = new StringBuilder();
        while (padding.length() < STRAP_LINE_SIZE - (version.length() + SPRING_BOOT.length())) {
   
   
            padding.append(" ");
        }
        //打印版本号
        printStream.println(AnsiOutput.toString(AnsiColor.GREEN, SPRING_BOOT, AnsiColor.DEFAULT, padding.toString(),
                AnsiStyle.FAINT, version));

        printStream.println();
    }

}

ImageBanner ：用来打印图片横幅，我们只需要在resources下创建一个 banner.gif ，就可以被打印，也可以使用spring.banner.image.location 来指定横幅的位置。

spring:
  main:
    banner-mode: console #横幅模式，在控制台打印 off是关闭
  banner:
    image:
      location: classpath:banner.gif #图片横幅，默认也是banner.gif
      #height: 
      #width:

ImageBanner结构如下

public class ImageBanner implements Banner {
   
   
        private static final String PROPERTY_PREFIX = "spring.banner.image.";

    private static final Log logger = LogFactory.getLog(ImageBanner.class);

    private static final double[] RGB_WEIGHT = {
   
    0.2126d, 0.7152d, 0.0722d };

    private final Resource image;

    //打印横幅
    private void printBanner(Environment environment, PrintStream out) throws IOException {
   
   
        //处理图片属性
        int width = getProperty(environment, "width", Integer.class, 76);
        int height = getProperty(environment, "height", Integer.class, 0);
        int margin = getProperty(environment, "margin", Integer.class, 2);
        boolean invert = getProperty(environment, "invert", Boolean.class, false);
        BitDepth bitDepth = getBitDepthProperty(environment);
        PixelMode pixelMode = getPixelModeProperty(environment);
        Frame[] frames = readFrames(width, height);
        for (int i = 0; i < frames.length; i++) {
   
   
            if (i > 0) {
   
   
                resetCursor(frames[i - 1].getImage(), out);
            }
            //打印
            printBanner(frames[i].getImage(), margin, invert, bitDepth, pixelMode, out);
            sleep(frames[i].getDelayTime());
        }
    }
}

7.2.横幅打印流程

横幅的打印是在SpringBoot启动流程中，调用 org.springframework.boot.SpringApplication#printBanner方法实现


private Banner printBanner(ConfigurableEnvironment environment) {
   
   
    //判断横幅功能是否被关闭，对应yaml中的 spring.main.banner-mode=off
    if (this.bannerMode == Banner.Mode.OFF) {
   
   
        return null;
    }
    //资源加载器，比如：用来加载banner.txt
    ResourceLoader resourceLoader = (this.resourceLoader != null) ? this.resourceLoader
        : new DefaultResourceLoader(getClassLoader());
    //创建 Banner打印器
    SpringApplicationBannerPrinter bannerPrinter = new SpringApplicationBannerPrinter(resourceLoader, this.banner);
    if (this.bannerMode == Mode.LOG) {
   
   
        //如果是log模式走这，对应：spring.main.banner-mode=log
        return bannerPrinter.print(environment, this.mainApplicationClass, logger);
    }
    //默认是console模式，走这
    return bannerPrinter.print(environment, this.mainApplicationClass, System.out);
}

代码中会判断 this.bannerMode == Banner.Mode.OFF 时候开启日志打印(对应yaml中的配置)，默认是Console，然后会创建一个ResourceLoader，主要是用来加载banner.txt或banner.gif 资源文件的。然后会判断如果this.bannerMode == Mode.LOG就使用logger打印，否则使用System.out打印，默认是System.out。打印横幅调用的是SpringApplicationBannerPrinter#print方法完成的。代码来到org.springframework.boot.SpringApplicationBannerPrinter#print

class SpringApplicationBannerPrinter {
   
   
    //banner.txt的地址
    static final String BANNER_LOCATION_PROPERTY = "spring.banner.location";
    //banner.gif的地址
    static final String BANNER_IMAGE_LOCATION_PROPERTY = "spring.banner.image.location";
    //banner文件的名字
    static final String DEFAULT_BANNER_LOCATION = "banner.txt";
    //图片bannre的支持的后缀
    static final String[] IMAGE_EXTENSION = {
   
    "gif", "jpg", "png" };
    //默认的banner,使用SpringBootBanner
    private static final Banner DEFAULT_BANNER = new SpringBootBanner();

    private final ResourceLoader resourceLoader;


    Banner print(Environment environment, Class<?> sourceClass, PrintStream out) {
   
   
        //获取Banner
        Banner banner = getBanner(environment);
        //打印Banner
        banner.printBanner(environment, sourceClass, out);
        return new PrintedBanner(banner, sourceClass);
    }

    private Banner getBanner(Environment environment) {
   
   
        Banners banners = new Banners();
        //尝试获取image Banner，默认banner.gif，加入Banners
        banners.addIfNotNull(getImageBanner(environment));
        //尝试获取banner.txt ，加入Banners
        banners.addIfNotNull(getTextBanner(environment));
        if (banners.hasAtLeastOneBanner()) {
   
   
            //返回多个banners
            return banners;
        }
        if (this.fallbackBanner != null) {
   
   
            return this.fallbackBanner;
        }
        //如果没有指定banner.txt或者banner.gif,就会使用默认的SpringBootBanner
        return DEFAULT_BANNER;
    }

    private Banner getTextBanner(Environment environment) {
   
   
        //以：获取banner的location：spring.banner.location 
        String location = environment.getProperty(BANNER_LOCATION_PROPERTY, DEFAULT_BANNER_LOCATION);
        //加载 banner.txt
        Resource resource = this.resourceLoader.getResource(location);
        if (resource.exists()) {
   
   
            //返回banner
            return new ResourceBanner(resource);
        }
        //如果不存在banner.txt，那么就会使用默认的SpringBootBanner去打印
        return null;
    }

    private Banner getImageBanner(Environment environment) {
   
   
        //获取图片banner的地址：spring.banner.image.location
        String location = environment.getProperty(BANNER_IMAGE_LOCATION_PROPERTY);
        if (StringUtils.hasLength(location)) {
   
   
            //加载图片，banner.gif
            Resource resource = this.resourceLoader.getResource(location);
            return resource.exists() ? new ImageBanner(resource) : null;
        }
        for (String ext : IMAGE_EXTENSION) {
   
   
            Resource resource = this.resourceLoader.getResource("banner." + ext);
            if (resource.exists()) {
   
   
                return new ImageBanner(resource);
            }
        }
        return null;
    }

SpringApplicationBannerPrinter会尝试获取spring.banner.image.location , 默认指向的resources/banner.gif 以及 spring.banner.location 指向的resources/banner.txt ，然后送resourceLoader加载资源文件，封装成 ImageBanner 或者 ResourceBanner。并交给Banners，Banners维护了Banner的列表。也就是说可以同时打印多个横幅，我们可以通过修改这2个路径来指定banner资源的位置。

如果没有banner.txt 和 banner.gif ，就会使用SpringBootBanner打印默认的banner.

紧接着就会调用Banners#printBanner方法循环执行每个Banner#printBanner方法。具体的Banner是如何打印出来的上面ImageBanner和SpringBootBanner已有介绍。

8.容器创建

8.1.容器介绍

SpringBoot底层是Spring,启动的过程中肯定要创建Spring容器，下面简单介绍一下IOC的容器工厂类

BeanFactory： Spring的容器顶层工厂，提供了获取Bean的基础方法，所有的IOC容器都是其子类
XmlWebApplicationContext : 整合web的容器对象，默认从'/WEB-INF/applicationContext.xml'加载配置
ClassPathXmlApplicationContext : 使用ResourcePatternResolver，默认从classpath加载xml配置的容器对象
AnnotationConfigApplicationContext ：针对于注解的容器对象，SpringBoot使用它

8.2.容器的创建

创建容器是在SpringBoot启动流程中的 org.springframework.boot.SpringApplication#createApplicationContext方法

protected ConfigurableApplicationContext createApplicationContext() {
   
   
    Class<?> contextClass = this.applicationContextClass;
    if (contextClass == null) {
   
   
        try {
   
   
            switch (this.webApplicationType) {
   
   
                case SERVLET:
                    contextClass = Class.forName(DEFAULT_SERVLET_WEB_CONTEXT_CLASS);
                    break;
                case REACTIVE:
                    contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);
                    break;
                default:
                    //默认走这，使用的是AnnotationConfigApplicationContext
                    contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);
            }
        }
        catch (ClassNotFoundException ex) {
   
   
            throw new IllegalStateException(
                "Unable create a default ApplicationContext, please specify an ApplicationContextClass", ex);
        }
    }
    //反射创建AnnotationConfigApplicationContext的实例
    return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
}

9.容器刷新

9.1.容器刷新

在SpringBoot启动流程中有一句代码 SpringApplication#prepareContext, 这句代码在准备Spring容器,代码如下org.springframework.boot.SpringApplication#prepareContext

private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment,
            SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {
   
   
    //把environment绑定到容器
    context.setEnvironment(environment);
    //容器的后置处理，里面也没干啥
    postProcessApplicationContext(context);
    //触发ApplicationContextInitializer#initialize的调用
    applyInitializers(context);
    //触发监听器，发布ApplicationContextInitializedEvent事件
    listeners.contextPrepared(context);
    if (this.logStartupInfo) {
   
   
        logStartupInfo(context.getParent() == null);
        logStartupProfileInfo(context);
    }
    // Add boot specific singleton beans
    ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
    //把applicationArguments注册Bean我们可以通过注入 ApplicationArguments 来获取程序启动参数
    beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
    if (printedBanner != null) {
   
   
        //把Bnaner注册为Bean
        beanFactory.registerSingleton("springBootBanner", printedBanner);
    }
    if (beanFactory instanceof DefaultListableBeanFactory) {
   
   
        ((DefaultListableBeanFactory) beanFactory)
        //如果出现相同的Bean,是否允许覆盖，默认为false,
        //可用在yaml通过spring.main.allow-bean-definition-overriding: true来指定
        .setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
    }
    if (this.lazyInitialization) {
   
   
        //延迟初始化
        context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
    }
    // Load the sources
    //配置类资源
    Set<Object> sources = getAllSources();
    Assert.notEmpty(sources, "Sources must not be empty");
    //load启动类，把启动类注册为Bean
    load(context, sources.toArray(new Object[0]));
    //抛出ApplicationPreparedEvent事件
    listeners.contextLoaded(context);
}

9.2.容器刷新

容器刷新在 org.springframework.boot.SpringApplication#refreshContext 方法中

private void refreshContext(ConfigurableApplicationContext context) {
   
   
    //刷新容器
    refresh(context);
    if (this.registerShutdownHook) {
   
   
        try {
   
   
            //注册一个钩子，当容器被关闭，
            context.registerShutdownHook();
        }
        catch (AccessControlException ex) {
   
   
            // Not allowed in some environments.
        }
    }
}

上面代码做了两个事情，一个是调用refresh方法刷新容器，二个是向 JVM 的Runtime 注册一个名为SpringContextShutdownHook的关闭钩子，在 JVM 关闭时关闭此上下文，委托容器的 doClose()执行实际的关闭过程。下面是context.registerShutdownHook();的内部代码,见：org.springframework.context.support.AbstractApplicationContext#registerShutdownHook

    @Override
    public void registerShutdownHook() {
   
   
        if (this.shutdownHook == null) {
   
   
            // No shutdown hook registered yet.
            this.shutdownHook = new Thread(SHUTDOWN_HOOK_THREAD_NAME) {
   
   
                @Override
                public void run() {
   
   
                    synchronized (startupShutdownMonitor) {
   
   
                        doClose();
                    }
                }
            };
            //Runtime: 每个 Java 应用程序都有一个Runtime类的实例，它允许应用程序与运行应用程序的环境进行交互 
            //给Runtime 注册SpringContextShutdownHook 钩子
            Runtime.getRuntime().addShutdownHook(this.shutdownHook);
        }
    }



    protected void doClose() {
   
   
        // Check whether an actual close attempt is necessary...
        if (this.active.get() && this.closed.compareAndSet(false, true)) {
   
   
            if (logger.isDebugEnabled()) {
   
   
                logger.debug("Closing " + this);
            }

            LiveBeansView.unregisterApplicationContext(this);

            try {
   
   
                //发布 ContextClosedEvent 容器关闭事件
                // Publish shutdown event.
                publishEvent(new ContextClosedEvent(this));
            }
            catch (Throwable ex) {
   
   
                logger.warn("Exception thrown from ApplicationListener handling ContextClosedEvent", ex);
            }

            // Stop all Lifecycle beans, to avoid delays during individual destruction.
            if (this.lifecycleProcessor != null) {
   
   
                try {
   
   
                    //生命周期处理器,close触发
                    this.lifecycleProcessor.onClose();
                }
                catch (Throwable ex) {
   
   
                    logger.warn("Exception thrown from LifecycleProcessor on context close", ex);
                }
            }

            // Destroy all cached singletons in the context's BeanFactory.
            //销毁所有的单利Bean
            destroyBeans();
            //close工厂
            // Close the state of this context itself.
            closeBeanFactory();
            //空实现，让子类做一些最后的清理...
            // Let subclasses do some final clean-up if they wish...
            onClose();

            // Reset local application listeners to pre-refresh state.
            if (this.earlyApplicationListeners != null) {
   
   
                //监听器清理
                this.applicationListeners.clear();
                this.applicationListeners.addAll(this.earlyApplicationListeners);
            }

            // Switch to inactive.
             //下文当前是否处于活动状态的标志修改为false
            this.active.set(false);
        }
    }

总结一下上面代码：就是给JVM的Runtime注册一个SpringContextShutdownHook钩子，当程序关闭，会触发AbstractApplicationContext#doClose方法，该方法中最了一些销毁和扫尾工作。

接下来就是刷新容器方法 refresh 分析了，代码最终来到 AbstractApplicationContext#refresh 方法中。

@Override
   public void refresh() throws BeansException, IllegalStateException {
   
   
       synchronized (this.startupShutdownMonitor) {
   
   
           // Prepare this context for refreshing.
           //1.准备刷新工作 ,记录开始时间，初始化属性，校验配置文件，准备事件的存储Set
           prepareRefresh();

           // Tell the subclass to refresh the internal bean factory.
           //告诉子类，刷新Bean工厂，销毁旧beanFactory，创建新beanFactory，默认DefaultListableBeanFactory
           //从子容器的refreshBeanFactory方法中载入Bean的资源文件
        //2.加载配置，加载Bean,注册Bean就在这儿
           ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

           // Prepare the bean factory for use in this context.
           //3.准备工厂，配置工厂的下文特性， 例如上下文的 ClassLoader 和后处理器。Bean表达式解析器，
           //BeanPostProcessor和 Aware类的自动装配等
           prepareBeanFactory(beanFactory);

           try {
   
   
               // Allows post-processing of the bean factory in context subclasses.
               //4.BeanFactory初始化完成的后置工作，
            //这是一个空方法，留给三方框架或者自己配置，作用是允许对beanFoctory进行扩展处理
               postProcessBeanFactory(beanFactory);

               // Invoke factory processors registered as beans in the context.
               //5.调用BeanFactory的后置处理器BeanFactoryPostProcessor,在 bean定义注册之后bean实例化之前调用
               invokeBeanFactoryPostProcessors(beanFactory);

               // Register bean processors that intercept bean creation.
               //6.注册Bean的后置处理器BeanPostProcessor，在Bean初始化前，后执行
               registerBeanPostProcessors(beanFactory);

               // Initialize message source for this context.
               //7.初始化信息源，国际化相关
               initMessageSource();

               // Initialize event multicaster for this context.
               //8.初始化容器事件传播器，比如：SimpleApplicationEventMulticaster
               initApplicationEventMulticaster();

               // Initialize other special beans in specific context subclasses.
               //9.空方法，该方法子类实现，在容器刷新的时候可以自定义逻辑；如创建Tomcat，Jetty等WEB服务器
               onRefresh();

               // Check for listener beans and register them.
               //10.注册事件监听器，注册实现了ApplicationListener接口的监听器bean，
               //这些监听器是注册到ApplicationEventMulticaster中的
               registerListeners();

               // Instantiate all remaining (non-lazy-init) singletons.
               //11.实例化所有剩余的（非延迟初始化）单例的Bean
             //也就是创建Bean的真正实例就在该方法中
               finishBeanFactoryInitialization(beanFactory);

               // Last step: publish corresponding event.
               //12.完成context的刷新。主要是调用LifecycleProcessor的onRefresh()方法，并且发布事件（ContextRefreshedEvent）
               finishRefresh();
           }

           catch (BeansException ex) {
   
   
               if (logger.isWarnEnabled()) {
   
   
                   logger.warn("Exception encountered during context initialization - " +
                           "cancelling refresh attempt: " + ex);
               }
               // Destroy already created singletons to avoid dangling resources.
               //销毁已经创建的单例Bean。
               destroyBeans();
               // Reset 'active' flag.
               //取消容器刷新
               cancelRefresh(ex);
               // Propagate exception to caller.
               throw ex;
           }
           finally {
   
   
               // Reset common introspection caches in Spring's core, since we
               // might not ever need metadata for singleton beans anymore...
               //重置缓存
               resetCommonCaches();
           }
       }
   }

这里其实已经在调用Spirng的容器刷新流程了，这里大概说明一下，具体的详细流程见

在obtainFreshBeanFactory方法中回去解析配置文件,然后把Bean封装成BeanDefinition,注册到IOC容器中(一个CurrentHashMap)
在invokeBeanFactoryPostProcessors方法中会触发BeanFactory的后置处理器的调用，这个很有用，可以在BeanFactory初始化过程中做扩展
registerBeanPostProcessors 方法中注册了BeanPostProcessors后置处理器，这个很有用，可以在Bean实例化前后，做一些扩展业务，比如：@Transactionl ,@Autowired的实现原理就是基于Bean的后置处理器
finishBeanFactoryInitialization ：这个方法中会对单利的Bean做正在的实例化，然后缓存到Spring的IOC容器中，以后获取Bean的时候会从缓存中取。这保证了Bean的单利。

10.callRunners

10.1.认识ApplicationRunner 和 CommandLineRunner

SpringBoot启动完成之后的最后一步就是org.springframework.boot.SpringApplication#callRunners，该方法中回去执行所有的ApplicationRunner ，和 CommandLineRunner 。

private void callRunners(ApplicationContext context, ApplicationArguments args) {
   
   
        List<Object> runners = new ArrayList<>();
        runners.addAll(context.getBeansOfType(ApplicationRunner.class).values());
        runners.addAll(context.getBeansOfType(CommandLineRunner.class).values());
        AnnotationAwareOrderComparator.sort(runners);
        for (Object runner : new LinkedHashSet<>(runners)) {
   
   
            if (runner instanceof ApplicationRunner) {
   
   
                callRunner((ApplicationRunner) runner, args);
            }
            if (runner instanceof CommandLineRunner) {
   
   
                callRunner((CommandLineRunner) runner, args);
            }
        }
    }

ApplicationRunner 和 CommandLineRunner 可以看做是SpringBoot的扩展，两个接口的功能是一样的，通过实现该接口可以在SpringBoot启动成功之后做一些初始化工作。

这两个Runner的不同之处在于CommandLineRunner#run方法接收的是main方法传递过来的直接参数args，而ApplicationRunner#run方法接收的是封装了args的ApplicationArguments对象。我们来演示其中一个

10.2.使用ApplicationRunner

第一步：定义一个Runner类

@Component
@Slf4j
public class ApplicationRunnerBean implements ApplicationRunner {
   
   

    @Override
    public void run(ApplicationArguments args) throws Exception {
   
   
        log.info("ApplicationRunnerBean.run SpringBoot启动完成，做一些初始化...");
    }
}

第二步：启动测试

在这里插入图片描述

文章结束啦，如果文章对你有所帮助，请一定给个好评哦，请一定给个好评哦，请一定给个好评哦

SpringBoot入门到精通-SpringBoot启动流程(七)

定义自己的starter

1.认识SpringApplication

2.SpringApplication.run执行流程

3.StopWatch秒表

4.SpringBootExceptionReporter异常报告

4.1.核心类认识

4.2.报告异常

5.监听器机制

5.1. 核心类认识

5.2.发布自定义事件

5.3.web三大监听器

6.SpringBoot的事件

4.1.SpringApplicationRunListeners

4.2.SpringApplicationRunListener

7.printBanner打印横幅

7.1.相关类介绍

7.2.横幅打印流程

8.容器创建

8.1.容器介绍

8.2.容器的创建

9.容器刷新

9.1.容器刷新

9.2.容器刷新

10.callRunners

10.1.认识ApplicationRunner 和 CommandLineRunner

10.2.使用ApplicationRunner

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

SpringBoot入门到精通-SpringBoot启动流程(七)

定义自己的starter

1.认识SpringApplication

2.SpringApplication.run执行流程

3.StopWatch秒表

4.SpringBootExceptionReporter异常报告

4.1.核心类认识

4.2.报告异常

5.监听器机制

5.1. 核心类认识

5.2.发布自定义事件

5.3.web三大监听器

6.SpringBoot的事件

4.1.SpringApplicationRunListeners

4.2.SpringApplicationRunListener

7.printBanner打印横幅

7.1.相关类介绍

7.2.横幅打印流程

8.容器创建

8.1.容器介绍

8.2.容器的创建

9.容器刷新

9.1.容器刷新

9.2.容器刷新

10.callRunners

10.1.认识ApplicationRunner 和 CommandLineRunner

10.2.使用ApplicationRunner

热门文章

最新文章

相关课程

相关电子书

相关实验场景