Quel est le processus de démarrage de SpringBoot ?

Introduction au processus de démarrage SpringBoot

Le processus de démarrage de l'application SpringBoot peut être divisé en les étapes suivantes :

• Charger le contexte de l'application

• Scanner tous les composants de l'application

• Configurer automatiquement l'environnement de l'application

  #🎜 🎜 #
• Démarrer le serveur Web intégré

Charger le contexte de l'application

Celui qui contient tous les composants d'une application SpringBoot. le conteneur est son contexte. Pendant le processus de démarrage, SpringBoot chargera et initialisera ce conteneur.

Le code source de cette étape est dans la classe SpringApplication. Plus précisément, la méthode run de la classe SpringApplication est le point d'entrée de ce processus. Dans cette méthode, Spring Boot créera le contexte d'application en appelant la méthode createApplicationContext.

SpringApplication类中。具体来说，SpringApplication类的run方法是这个过程的入口点。在这个方法中，Spring Boot会通过调用createApplicationContext方法来创建应用程序上下文。

下面是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:
                    contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);
            }
        }
        catch (ClassNotFoundException ex) {
            throw new IllegalStateException(
                    "Unable to create a default ApplicationContext, " +
                    "please specify an ApplicationContextClass", ex);
        }
    }
    return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
}

在这个方法中，SpringBoot 会根据应用程序类型（Servlet或Reactive）选择合适的上下文类。接着，使用 Java 反射机制来实例化该类并返回一个可配置的应用程序上下文对象。

扫描应用程序中的所有组件

在上一步中，SpringBoot创建了应用程序上下文。在此阶段，SpringBoot会扫描应用程序中的所有组件并将它们注册到应用程序上下文中。

这个步骤的源代码在SpringApplication类中的scan方法中。具体来说，在这个方法中，SpringBoot 会创建一个SpringBootBeanDefinitionScanner对象，并使用它来扫描应用程序中的所有组件。

下面是scan方法的源代码：

private void scan(String... basePackages) {
    if (ObjectUtils.isEmpty(basePackages)) {
        return;
    }
    ClassPathScanningCandidateComponentProvider scanner = new ClassPathScanningCandidateComponentProvider(
            this.includeFilters, this.excludeFilters, this.resourceLoader);
    scanner.setResourceLoader(this.resourceLoader);
    scanner.setEnvironment(this.environment);
    scanner.setIncludeAnnotationConfig(this.useAnnotatedConfig);
    scanner.addExcludeFilter(new AbstractTypeHierarchyTraversingFilter(false, false) {
        @Override
        protected boolean matchClassName(String className) {
            return getExcludeClassNames().contains(className);
        }
    });
    for (String basePackage : basePackages) {
        scanner.findCandidateComponents(basePackage).forEach(this.componentDefinitions::add);
    }
}

在这个方法中，SpringBoot 会创建一个ClassPathScanningCandidateComponentProvider对象，并使用它来扫描应用程序中的所有组件。这个对象会扫描指定包路径下的所有类，并将它们转换为 Spring 的 Bean 定义。这些 Bean 定义将被注册到应用程序上下文中。

自动配置应用程序环境

SpringBoot在前一步将应用程序中的所有组件注册到应用程序上下文中。SpringBoot会自动配置应用程序环境，其中包括数据源、事务管理器和JPA配置。

这个步骤的源代码在SpringApplication类中的configureEnvironment方法中。在这个方法中，Spring Boot会创建一个SpringApplicationRunListeners对象，并使用它来配置应用程序环境。

下面是configureEnvironment方法的源代码：

private void configureEnvironment(ConfigurableEnvironment environment, String[] args) {
    if (this.addCommandLineProperties) {
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
        environment.getPropertySources().addLast(new CommandLinePropertySource(applicationArguments));
    }
    this.listeners.environmentPrepared(environment);
    if (this.logStartupInfo) {
        this.logStartupInfo(environment);
    }
    ConfigurationPropertySources.attach(environment);
    Binder.get(environment).bind(ConfigurationPropertyName.EMPTY, Bindable.ofInstance(this.sources));
    if (!this.isCustomEnvironment) {
        EnvironmentConverter.configureEnvironment(environment, this.deduceEnvironmentClass());
    }
    this.listeners.environmentPrepared(environment);
}

在这个方法中，SpringBoot 会创建一个ApplicationArguments对象，并将其转换为一个命令行属性源。然后，它会调用listeners中的environmentPrepared方法来通知应用程序环境已经准备好了。随后，SpringBoot 会绑定属性源到应用程序环境中，并调用listeners中的environmentPrepared方法来通知应用程序环境已经准备好了。

启动嵌入式Web服务器

在前一步骤中，SpringBoot已自动完成了应用程序环境的配置。在这一步，SpringBoot将启动嵌入式Web服务器，以便应用程序提供Web服务。

这个步骤的源代码在SpringApplication类中的run方法中。具体来说，在这个方法中，SpringBoot 会根据应用程序类型（Servlet或Reactive）选择合适的嵌入式Web服务器，并使用它来启动应用程序。

下面是run方法的源代码：

public ConfigurableApplicationContext run(String... args) {
    StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    ConfigurableApplicationContext context = null;
    Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
    configureHeadlessProperty();
    SpringApplicationRunListeners listeners = getRunListeners(args);
    listeners.starting();
    try {
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
        ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
        configureIgnoreBeanInfo(environment);
        Banner printedBanner = printBanner(environment);
        context = createApplicationContext();
        exceptionReporters = getSpringFactoriesInstances(
                SpringBootExceptionReporter.class,
                new Class[] { ConfigurableApplicationContext.class }, context);
        prepareContext(context, environment, listeners, applicationArguments, printedBanner);
        refreshContext(context);
        afterRefresh(context, applicationArguments);
        stopWatch.stop();
        if (this.logStartupInfo) {
            new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
        }
        listeners.started(context);
        callRunners(context, applicationArguments);
    }
    catch (Throwable ex) {
        handleRunFailure(context, ex, exceptionReporters, listeners);
        throw new IllegalStateException(ex);
    }
    try {
        listeners.running(context);
    }
    catch (Throwable ex) {
        handleRunFailure(context, ex, exceptionReporters, null);
        throw new IllegalStateException(ex);
    }
    return context;
}

在这个方法中，SpringBoot 会使用一个StopWatch对象来计算应用程序启动时间。然后，它会调用listeners中的starting方法来通知应用程序即将启动。接着，SpringBoot 会准备应用程序环境，并使用它来创建应用程序上下文。随后，SpringBoot 会调用listeners中的started方法来通知应用程序已经启动。最后，SpringBoot 会调用callRunners方法来运行所有的CommandLineRunner和ApplicationRunnerCe qui suit est le code source de la méthode createApplicationContext :

rrreee#🎜🎜#Dans cette méthode, SpringBoot choisira celle appropriée en fonction du type d'application Classe de contexte (Servlet ou Reactive). Ensuite, utilisez le mécanisme de réflexion Java pour instancier la classe et renvoyer un objet de contexte d'application configurable. #🎜🎜##🎜🎜#Analysez tous les composants de l'application #🎜🎜##🎜🎜#À l'étape précédente, SpringBoot a créé le contexte de l'application. À ce stade, SpringBoot analyse tous les composants de l'application et les enregistre dans le contexte de l'application. #🎜🎜##🎜🎜#Le code source de cette étape se trouve dans la méthode scan de la classe SpringApplication. Plus précisément, dans cette méthode, SpringBoot crée un objet SpringBootBeanDefinitionScanner et l'utilise pour analyser tous les composants de l'application. #🎜🎜##🎜🎜#Ce qui suit est le code source de la méthode scan : #🎜🎜#rrreee#🎜🎜#Dans cette méthode, SpringBoot créera un ClassPathScanningCandidateComponentProvider object et utilisez-le pour analyser tous les composants de l'application. Cet objet analyse toutes les classes sous le chemin de package spécifié et les convertit en définitions de bean Spring. Ces définitions de bean seront enregistrées avec le contexte d'application. #🎜🎜##🎜🎜#Configurer automatiquement l'environnement de l'application #🎜🎜##🎜🎜#SpringBoot enregistre tous les composants de l'application dans le contexte de l'application à l'étape précédente. SpringBoot configure automatiquement l'environnement de l'application, y compris les sources de données, les gestionnaires de transactions et la configuration JPA. #🎜🎜##🎜🎜#Le code source de cette étape se trouve dans la méthode configureEnvironment de la classe SpringApplication. Dans cette méthode, Spring Boot crée un objet SpringApplicationRunListeners et l'utilise pour configurer l'environnement de l'application. #🎜🎜##🎜🎜#Ce qui suit est le code source de la méthode configureEnvironment : #🎜🎜#rrreee#🎜🎜#Dans cette méthode, SpringBoot créera un ApplicationArguments object et convertissez-le en source de propriétés de ligne de commande. Ensuite, il appelle la méthode environmentPrepared dans listeners pour informer l'application que l'environnement est prêt. Par la suite, SpringBoot liera la source de propriété à l'environnement d'application et appellera la méthode environmentPrepared dans listeners pour informer l'application que l'environnement est prêt. #🎜🎜##🎜🎜#Démarrer le serveur web embarqué#🎜🎜##🎜🎜#À l'étape précédente, SpringBoot a automatiquement terminé la configuration de l'environnement de l'application. Au cours de cette étape, SpringBoot démarrera le serveur Web intégré afin que l'application puisse fournir des services Web. #🎜🎜##🎜🎜#Le code source de cette étape se trouve dans la méthode run de la classe SpringApplication. Plus précisément, dans cette méthode, SpringBoot sélectionne un serveur Web intégré approprié en fonction du type d'application (Servlet ou Reactive) et l'utilise pour démarrer l'application. #🎜🎜##🎜🎜#Ce qui suit est le code source de la méthode run : #🎜🎜#rrreee#🎜🎜#Dans cette méthode, SpringBoot utilisera un StopWatch objet pour calculer le temps de démarrage de l'application. Ensuite, il appelle la méthode starting dans listeners pour avertir l'application qu'elle est sur le point de démarrer. Ensuite, SpringBoot prépare l'environnement d'application et l'utilise pour créer le contexte d'application. Par la suite, SpringBoot appellera la méthode started dans listeners pour informer l'application qu'elle a été démarrée. Enfin, SpringBoot appellera la méthode callRunners pour exécuter tous les composants CommandLineRunner et ApplicationRunner. #🎜🎜#

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!