Si vous ne comprenez pas le principe du démarrage de Spring Boot, vous devez le vérifier !

Lorsque nous développons un projet Spring Boot, nous utiliserons les classes de démarrage suivantes

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

Comme on peut le voir dans le code ci-dessus, la définition d'annotation ( @SpringBootApplication) et la définition de classe ( SpringApplication.run) sont les plus éblouissantes, donc pour découvrir le mystère de SpringBoot, nous devons commencer par ces deux.

---

1. Le secret derrière SpringBootApplication

L'annotation @SpringBootApplication est l'annotation principale de Spring Boot, qui est en fait une annotation combinée :

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {
        @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
        @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
...
}

Bien que la définition utilise plusieurs annotations pour annoter les informations d'origine, en fait, seules trois annotations sont importantes :

• @Configuration( @SpringBootConfigurationCliquez pour voir et constater qu'il est toujours appliqué @Configuration)

• @EnableAutoConfiguration

• @ComponentScan

C'est @SpringBootApplication= (attribut par défaut) @Configuration+ @EnableAutoConfiguration+ @ComponentScan.

Par conséquent, si nous utilisons la classe de démarrage SpringBoot suivante, l'intégralité de l'application SpringBoot peut toujours être fonctionnellement équivalente à la classe de démarrage précédente :

@Configuration
@EnableAutoConfiguration
@ComponentScan
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

C'est fatiguant d'écrire ces 3 à chaque fois, donc @SpringBootApplicationc'est pratique d'en écrire un. Ensuite, les trois annotations sont introduites séparément.

1、@Configuration

Cela @Configurationne nous est pas inconnu. C'est celui utilisé par la classe de configuration du conteneur Spring Ioc sous la forme de JavaConfig. La @Configurationcommunauté SpringBoot recommande d'utiliser le formulaire de configuration basé sur JavaConfig. Par conséquent, une fois la classe de démarrage ici marquée, @Configurationelle est en fait une classe de configuration de conteneur IoC.

Pour donner quelques exemples simples, passez en revue la différence entre les méthodes de configuration XML et config :

(1) Niveau d'expression

La configuration basée sur XML est la suivante :

<?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-3.0.xsd"
       default-lazy-init="true">
    <!--bean定义-->
</beans>

La méthode de configuration basée sur JavaConfig est la suivante :

@Configuration
public class MockConfiguration{
    //bean定义
}

Toute @Configurationdéfinition de classe Java annotée est une classe de configuration JavaConfig.

(2) Niveau de définition du bean d'enregistrement

La configuration basée sur XML ressemble à ceci :

<bean id="mockService" class="..MockServiceImpl">
    ...
</bean>

Le formulaire de configuration basé sur JavaConfig est le suivant :

@Configuration
public class MockConfiguration{
    @Bean
    public MockService mockService(){
        return new MockServiceImpl();
    }
}

Pour toute @Beanméthode marquée, sa valeur de retour sera enregistrée en tant que définition de bean dans le conteneur IoC de Spring, et le nom de la méthode sera par défaut l'id de la définition de bean.

(3) Niveau de relation d'injection de dépendance express

Afin d'exprimer la relation de dépendance entre les beans et les beans, c'est généralement comme ça sous forme XML :

<bean id="mockService" class="..MockServiceImpl">
   <propery name ="dependencyService" ref="dependencyService" />
</bean>
<bean id="dependencyService" class="DependencyServiceImpl"></bean>

Le formulaire de configuration basé sur JavaConfig est le suivant :

@Configuration
public class MockConfiguration{
    @Bean
    public MockService mockService(){
        return new MockServiceImpl(dependencyService());
    }

    @Bean
    public DependencyService dependencyService(){
        return new DependencyServiceImpl();
    }
}

Si la définition d'un bean dépend d'autres beans, vous pouvez appeler directement la méthode de création du bean dépendant dans la classe JavaConfig correspondante.

@Configuration: Quand vous le mentionnez, @Configurationvous devez mentionner son partenaire @Bean. À l'aide de ces deux annotations, vous pouvez créer une classe de configuration Spring simple pouvant être utilisée pour remplacer le fichier de configuration xml correspondant.

<beans> 
    <bean id = "car" class="com.test.Car"> 
        <property name="wheel" ref = "wheel"></property> 
    </bean> 
    <bean id = "wheel" class="com.test.Wheel"></bean> 
</beans>

Équivalent à:

@Configuration 
public class Conf { 
    @Bean 
    public Car car() { 
        Car car = new Car(); 
        car.setWheel(wheel()); 
        return car; 
    }

    @Bean 
    public Wheel wheel() { 
        return new Wheel(); 
    } 
}

@ConfigurationLa classe annotée identifie que cette classe peut utiliser le conteneur Spring IoC comme source de définitions de bean.

@BeanL'annotation indique à Spring qu'une méthode annotée avec @Bean renverra un objet qui doit être enregistré en tant que bean dans le contexte de l'application Spring.

2、@ComponentScan

@ComponentScanCette annotation est très importante dans Spring. Elle correspond aux éléments de la configuration XML. @ComponentScanSa fonction est d'analyser et de charger automatiquement des composants qualifiés (tels que @Componentet @Repositoryetc.) ou des définitions de bean, et enfin de charger ces définitions de bean dans le conteneur IoC.

Nous pouvons personnaliser finement la portée de l'analyse automatique via des attributs tels que basePackages @ComponentScanSi non spécifié, l'implémentation par défaut du framework Spring analysera @ComponentScanà partir du package où la classe est déclarée.

Remarque : Par conséquent, la classe de démarrage de SpringBoot est mieux placée sous le package racine, car basePackages n'est pas spécifié par défaut.

3、@EnableAutoConfiguration

Je pense personnellement que @EnableAutoConfigurationcette annotation est la plus importante, donc je l'interpréterai à la fin. Vous souvenez-vous encore de la @Enabledéfinition d'annotation avec différents noms fournie par le framework Spring ? Par @EnableScheduling、@EnableCaching、@EnableMBeanExportexemple, @EnableAutoConfigurationle concept et la façon de faire sont en fait dans la même ligne.Un bref résumé est que, avec l'aide @Importdu support, collectez et enregistrez les définitions de bean liées à des scénarios spécifiques.

@EnableSchedulingIl s'agit de charger toutes les définitions de bean liées au framework de planification Spring dans le conteneur IoC via @Import.
@EnableMBeanExportIl s'agit de charger les définitions de bean liées à JMX dans le conteneur IoC via @Import.
Mais @EnableAutoConfigurationavec l'aide de @Import, toutes les définitions de bean qui répondent aux conditions de configuration automatique sont chargées dans le conteneur IoC, c'est tout !

@EnableAutoConfigurationLe projet sera automatiquement configuré en fonction des dépendances jar dans le chemin de classe. Par exemple, si des dépendances sont ajoutées spring-boot-starter-web, les dépendances de Tomcat et Spring MVC seront automatiquement ajoutées, et Spring Boot configurera automatiquement Tomcat et Spring MVC.

En tant qu'annotation composite, @EnableAutoConfiguration définit les informations clés comme suit :

@SuppressWarnings("deprecation")
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(EnableAutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
    ...
}

Parmi eux, le plus important est d'utiliser le conteneur IoC @Import(EnableAutoConfigurationImportSelector.class)qui EnableAutoConfigurationImportSelector，@EnableAutoConfigurationpeut aider l'application SpringBoot à charger toutes @Configurationles configurations éligibles dans la création et l'utilisation actuelles de SpringBoot. SpringFactoriesLoaderTout comme une "pieuvre", avec le support d' une classe d'outils originale du framework Spring : la @EnableAutoConfigurationfonction de configuration automatique intelligente peut être accomplie !

Configurez automatiquement les héros des coulisses : SpringFactoriesLoader en détail

SpringFactoriesLoader est un schéma d'extension privé du framework Spring, et sa fonction principale est de charger la configuration à partir du fichier de configuration spécifié META-INF/spring.factories.

public abstract class SpringFactoriesLoader {
    //...
    public static <T> List<T> loadFactories(Class<T> factoryClass, ClassLoader classLoader) {
        ...
    }


    public static List<String> loadFactoryNames(Class<?> factoryClass, ClassLoader classLoader) {
        ....
    }
}

S'il est utilisé ensemble @EnableAutoConfiguration, il fournit un support plus fonctionnel pour la recherche de configuration, c'est-à-dire qu'en fonction du @EnableAutoConfigurationnom de classe complet de la classe org.springframework.boot.autoconfigure.EnableAutoConfigurationcomme clé de recherche, un ensemble de @Configurationclasses correspondant peut être obtenu.

L'image ci-dessus est META-INF/spring.factoriesun extrait du fichier de configuration du package de dépendances de configuration automatique de SpringBoot, qui peut bien illustrer le problème.

Par conséquent, @EnableAutoConfigurationle chevalier magique de la configuration automatique devient : rechercher tous META-INF/spring.factoriesles fichiers de configuration à partir du chemin de classe et org.springframework.boot.autoconfigure.EnableutoConfigurationinstancier les éléments de configuration correspondants dans @Configurationles classes de configuration de conteneur IoC correspondantes sous la forme de JavaConfig marqué par réflexion (Java Refletion). Il est ensuite agrégé en un seul. et chargé dans le conteneur IoC.

---

2. Exploration approfondie du processus d'exécution de SpringApplication

La mise en œuvre de la méthode run de SpringApplication est l'itinéraire principal de notre voyage. Le processus principal de cette méthode peut être grossièrement résumé comme suit :

1) Si nous utilisons la méthode d'exécution statique de SpringApplication, alors, dans cette méthode, nous devons d'abord créer une instance d'objet SpringApplication, puis appeler la méthode d'instance du SpringApplication créé. Lorsque l'instance SpringApplication est initialisée, elle fera plusieurs choses à l'avance :

• En fonction de la présence ou non d'une classe caractéristique dans le classpath, org.springframework.web.context.ConfigurableWebApplicationContextil est déterminé si un type ApplicationContext pour les applications Web doit être créé.

• Utilisez SpringFactoriesLoadertrouve et charge tous ceux disponibles dans le classpath de l'application ApplicationContextInitializer.

• Utilisez SpringFactoriesLoadertrouve et charge tous ceux disponibles dans le classpath de l'application ApplicationListener.

• Déduire et définir la classe de définition de la méthode principale.

2) Une fois l'initialisation de l'instance SpringApplication terminée et les paramètres terminés, la logique de la méthode d'exécution commence à être exécutée. Au début de l'exécution de la méthode, elle parcourt et exécute d'abord toutes les méthodes qui peuvent être trouvées et SpringFactoriesLoaderchargées SpringApplicationRunListener. Appelez leurs started()méthodes pour leur dire SpringApplicationRunListener"Hé, l'application SpringBoot est sur le point de commencer à s'exécuter !".

3) Créez et configurez l'environnement à utiliser par l'application Spring Boot actuelle (y compris la configuration du PropertySource et du profil à utiliser).

4) Parcourez et appelez toutes SpringApplicationRunListenerles environmentPrepared()méthodes et dites-leur : "L'environnement utilisé par l'application SpringBoot actuelle est prêt !".

5) Si la propriété showBanner de SpringApplication est définie sur true, imprimez la bannière.

6) Selon que l'utilisateur a explicitement défini applicationContextClassle type et le résultat d'inférence de la phase d'initialisation, décidez quel type créer pour l'application SpringBoot actuelle ApplicationContextet terminez la création, puis décidez d'ajouter ShutdownHook en fonction des conditions, décidez si pour en utiliser un personnalisé BeanNameGeneratoret décider d'en utiliser un personnalisé Bien sûr ResourceLoader, le plus important est de définir l'environnement précédemment préparé sur celui créé ApplicationContext.

7) Une fois l'ApplicationContext créé, SpringApplication l'utilisera à nouveau Spring-FactoriesLoaderpour rechercher et charger tous ceux disponibles dans le chemin de classe ApplicationContext-Initializer, puis traverser et appeler ces méthodes ApplicationContextInitializer( applicationContext) pour traiter davantage initializecelles créées .ApplicationContext

8) Parcourez et appelez toutes SpringApplicationRunListenerles méthodes contextPrepared().

9) L'étape principale consiste à @EnableAutoConfigurationcharger toutes les configurations obtenues auparavant et d'autres formes de configurations de conteneurs IoC dans celle préparée ApplicationContext.

10) Parcourez et appelez toutes SpringApplicationRunListenerles méthodes contextLoaded().

11) La méthode appelée ApplicationContextpour refresh()terminer le dernier processus disponible pour le conteneur IoC.

12) Découvrez ApplicationContexts'il existe des enregistrements dans le système actuel CommandLineRunner, et si oui, parcourez-les et exécutez-les.

13) Dans des circonstances normales, traversez la SpringApplicationRunListenerméthode d'exécution finished()(si une exception se produit dans l'ensemble du processus, toutes les méthodes seront toujours appelées SpringApplicationRunListener, finished()mais dans ce cas, les informations d'exception seront transmises pour le traitement)

Après avoir supprimé le point de notification d'événement, l'ensemble du processus est le suivant :

---

Cet article prend comme exemple le débogage d'un programme de démarrage SpringBoot réel et analyse sa logique de démarrage et ses principes de configuration automatique en référence au diagramme de classes principal du processus.

Aperçu:

L'image ci-dessus montre le schéma de la structure de démarrage de SpringBoot. Nous avons constaté que le processus de démarrage est principalement divisé en trois parties :

• La première partie consiste à initialiser le module de SpringApplication et à configurer certaines variables d'environnement de base, ressources, constructeurs et écouteurs ;

• La deuxième partie implémente le schéma de démarrage spécifique de l'application, y compris le module de surveillance du processus de démarrage, le module d'environnement de configuration de chargement et le module de contexte de création de base ;

• La troisième partie est le module de configuration automatique, qui est au cœur de la configuration automatique de springboot et sera discuté en détail dans l'analyse suivante. Dans la routine de démarrage ci-dessous, nous câblerons les principales fonctions de la structure.

Commencez:

Chaque programme SpringBoot a une entrée principale, qui est la méthode principale, qui appelle et démarre SpringApplication.run()l'ensemble du programme spring-boot.La classe où se trouve la méthode doit utiliser @SpringBootApplicationdes annotations et @ImportResourcedes annotations (si nécessaire), @SpringBootApplicationy compris trois annotations.Les fonctions sont comme suit:

• @EnableAutoConfiguration: SpringBoot configure automatiquement le framework Spring en fonction des dépendances déclarées par l'application.

• @SpringBootConfiguration(Interne @Configuration) : la classe marquée est égale à ( applicationContext.xml) dans le fichier de configuration XML du printemps, assemblant toutes les transactions de bean et fournissant un contexte de printemps.

• @ComponentScan: analyse des composants, qui peut automatiquement découvrir et assembler des beans. Par défaut, les fichiers sous le chemin du package dans la méthode run de SpringApplication sont analysés Booter.class, il est donc préférable de placer la classe de démarrage sous le chemin du package racine.

Classe de démarrage SpringBoot

Entrez d'abord la méthode d'exécution

Dans la méthode run, une instance de SpringApplication est créée. Dans cette méthode de construction, nous pouvons constater qu'elle appelle une méthode initialize initialisée.

Il s'agit principalement d'attribuer certaines valeurs initiales à l'objet SpringApplication. Une fois le constructeur exécuté, nous revenons à la méthode run

Les étapes clés suivantes sont mises en œuvre dans cette méthode :

1. Créez un écouteur d'application SpringApplicationRunListenerset commencez à écouter

2. Chargez l'environnement de configuration SpringBoot ( ConfigurableEnvironment), s'il est publié via le conteneur Web, il sera chargé StandardEnvironmentet il sera éventuellement hérité ConfigurableEnvironment. Le diagramme de classes est le suivant

On peut voir que *Environment implémente enfin l'interface PropertyResolver. Lorsque nous obtenons généralement la méthode de valeur correspondant à la clé spécifiée dans le fichier de configuration via l'objet d'environnement, nous appelons la méthode getProperty de l'interface propertyResolver.

3. L'environnement de configuration ( Environment) est ajouté à l'objet écouteur ( SpringApplicationRunListeners)

4. Créez l'objet de retour de la méthode run : ConfigurableApplicationContext(contexte de configuration de l'application), nous pouvons regarder la méthode de création :

La méthode obtiendra d'abord le contexte d'application explicitement défini ( applicationContextClass), s'il n'existe pas, puis chargera la configuration d'environnement par défaut (en jugeant s'il s'agit de web environment), sélectionnera le contexte d'annotation par défaut AnnotationConfigApplicationContext(charger les beans en analysant toutes les classes d'annotation), et enfin, instanciez via BeanUtils l'objet de contexte et renvoyez-le.

Le diagramme de classes ConfigurableApplicationContext est le suivant :

Elle dépend principalement des deux sens de son héritage :

• LifeCycle : classe de cycle de vie, qui définit start start, stop end, isRunning s'il faut exécuter la méthode de valeur nulle du cycle de vie moyen

• ApplicationContext : classe de contexte d'application, qui hérite principalement de beanFactory (classe de fabrique de haricots)

5. De retour dans la méthode run, la méthode prepareContext listeners、environment、applicationArguments、bannerassocie d'autres composants importants à l'objet de contexte

6. La refreshContext(context)méthode suivante (la méthode d'initialisation est la suivante) sera spring-boot-starter-*la clé pour réaliser la configuration automatique (mybatis, redis, etc.), y compris spring.factoriesle travail de base du chargement, l'instanciation du bean, etc.

Après la configuration, Springboot a effectué quelques travaux de finition de base et a renvoyé le contexte de l'environnement de l'application. En regardant le processus global, le démarrage de Springboot crée principalement l'environnement de configuration (environnement), les écouteurs d'événements (écouteurs) et le contexte d'application (applicationContext), et sur la base des conditions ci-dessus, nous commençons à instancier les beans dont nous avons besoin dans le conteneur Jusqu'à présent, grâce au démarrage de SpringBoot, le programme a été construit. Ensuite, discutons de la manière de réaliser la configuration automatique.

---

Paramétrage automatique :

Dans le diagramme de structure de démarrage précédent, nous avons remarqué que l'initialisation de l'application et le processus d'exécution spécifique invoquaient le module de configuration automatique SpringBoot.

Module de configuration automatique SpringBoot

L'utilisation principale de ce module de configuration SpringFactoriesLoaderest le chargeur d'usine Spring. Cet objet fournit loadFactoryNamesdes méthodes. Les paramètres d'entrée sont factoryClass et classLoader, c'est-à-dire que le nom de la classe d'usine dans la figure ci-dessus et le chargeur de classe correspondant doivent être transmis. La méthode sera basée sur le classLoader spécifié, chargez le fichier spécifié sous le chemin de recherche de l'additionneur de classe, c'est-à-dire spring.factoriesle fichier, la classe de fabrique entrante est l'interface et la classe correspondante dans le fichier est la classe d'implémentation du interface, ou enfin en tant que classe d'implémentation, donc le fichier est généralement comme suit Ce type de collection de noms de classe un-à-plusieurs, après avoir obtenu les noms de classe de ces classes d'implémentation, la méthode renvoie la collection de noms de classe et l'appelant de la loadFactoryNamesméthode obtient ces collections, puis obtient les objets de classe et les méthodes de construction de ces classes par réflexion, et enfin génère une instance.

Interface d'usine et plusieurs noms d'interface de classe d'implémentation

La figure ci-dessous nous aide à visualiser le processus de configuration automatique.

Schéma de relation des composants clés de configuration automatique de SpringBoot

mybatis-spring-boot-starter, spring-boot-starter-webet les fichiers META-INF d'autres composants contiennent spring.factoriesdes fichiers. Dans le module de configuration automatique, SpringFactoriesLoaderle nom complet de la classe dans le fichier est collecté et un tableau du nom complet de la classe est renvoyé. Le nom complet renvoyé de la classe est instancié par réflexion, formant une instance spécifique de l'usine, l'instance de l'usine pour générer les beans dont le composant a spécifiquement besoin.

Nous avons EnableAutoConfigurationdéjà mentionné les annotations, et son diagramme de classes est le suivant :

On peut constater qu'il implémente finalement ImportSelector(sélecteur) et BeanClassLoaderAware(intergiciel bean class loader), en se concentrant sur les AutoConfigurationImportSelectorméthodes suivantes selectImports.

[Le transfert d'image du lien externe a échoué, le site source peut avoir un mécanisme de lien antivol, il est recommandé de sauvegarder l'image et de la télécharger directement (img-Dm6tiUWw-1597051375071) (https://upload-images.jianshu.io/ upload_images/18688925-97932faefd1184cf?imageMogr2 /auto-orient/strip%7CimageView2/2/w/1240)]

Cette méthode est exécutée avant le processus de démarrage springboot - instanciation du bean, et renvoie une liste d'informations de classe à instancier. Nous savons que si les informations de classe sont obtenues, le printemps peut naturellement charger la classe dans la jvm via le chargeur de classe.Maintenant que nous nous sommes appuyés sur les composants dont nous avons besoin via la dépendance du démarreur spring-boot, les informations de classe de ces composants sont dans la méthode select. Elle peut également être obtenue, ne vous inquiétez pas, continuons à analyser vers le bas.

La méthode de cette méthode getCandidateConfigurations, apprise via l'annotation de méthode, renvoie une liste de noms de classe de la classe de configuration automatique, la méthode appelle la loadFactoryNamesméthode, affiche la méthode

Dans le code ci-dessus, vous pouvez voir que le configurateur automatique trouvera la clé correspondante dans factoryClass.getName()tous spring.factoriesles fichiers sous le chemin système du projet transmis, afin de charger les classes à l'intérieur. Nous allons sélectionner le fichier mybatis-spring-boot-autoconfiguresous cespring.factories

En entrant org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration, regardez principalement l'en-tête de classe :

J'ai trouvé que Spring @Configurationest comme un springBean marqué d'annotations, continuez à regarder vers le bas,

• @ConditionalOnClass({ SqlSessionFactory.class, SqlSessionFactoryBean.class}): Lorsque ces deux classes existent SqlSessionFactory.class, la classe de configuration sera analysée, sinon cette classe de configuration ne sera pas analysée, logique, nous avons besoin de mybatis pour nous renvoyer l'objet de session, et il doit y avoir des classes liées à l'usine de session.SqlSessionFactoryBean.classMybatisAutoConfiguration

• @CondtionalOnBean(DataSource.class): ne traite que les sources de données qui ont été déclarées en tant que beans.

• @ConditionalOnMissingBean(MapperFactoryBean.class)Cette annotation signifie que si le bean spécifié par name n'existe pas dans le conteneur, l'injection de bean sera créée, sinon elle ne sera pas exécutée (le code source de cette classe est long, et la limite d'espace n'est pas entièrement collée)

La configuration ci-dessus peut garantir sqlSessionFactory、sqlSessionTemplate、dataSourceque les composants requis par mybatis peuvent être configurés automatiquement. @ConfigurationL'annotation a fourni le contexte Spring, de sorte que la méthode de configuration des composants ci-dessus a le même effet que la configuration via le fichier mybatis.xml au démarrage de Spring.

Grâce à l'analyse, nous pouvons constater que tant qu'un chemin de classe basé sur le projet SpringBoot existe et que le dataSourceBean a été enregistré dans le conteneur, la configuration automatique peut être déclenchée, ce qui signifie que nous n'avons qu'à ajouter plusieurs dépendances requises par mybatis SqlSessionFactory.classpour SqlSessionFactoryBean.classLa configuration automatique peut être déclenchée, mais si la dépendance native de mybatis est introduite, la classe de configuration automatique doit être modifiée pour chaque fonction intégrée, de sorte que l'effet prêt à l'emploi ne sera pas obtenu.

Spring-boot nous fournit donc un démarreur unifié qui peut configurer directement les classes associées, et les dépendances (mybatis) nécessaires pour déclencher la configuration automatique sont les suivantes :

Voici mybatis-spring-boot-startertoutes les dépendances du fichier pom.xml dans le code source intercepté :

En raison de la nature transitive des dépendances maven, nous pouvons compter sur toutes les classes qui doivent être configurées automatiquement tant que nous comptons sur le démarreur pour réaliser des fonctions prêtes à l'emploi. Cela montre également que Springboot simplifie la grande quantité de configuration XML et la gestion complexe des dépendances apportées par le framework Spring, permettant aux développeurs d'accorder plus d'attention au développement de la logique métier.

enfin

Faites attention au compte officiel : Programmer Chasing the Wind. Réponse 003 Obtenez le dernier manuel de questions d'entretien Java 2020 (plus de 200 pages de documents PDF)