Explorer les principes de fonctionnement

Nous avons écritHelloSpringBoot,Comment ça marche?,MavenProjets,Nous commençons généralement parpom.xmlDébut de la recherche documentaire;

1、Le père dépend

pom.xml

• Configuration automatique

• spring-boot-dependencies：Les dépendances du noyau sont dans le projet parent！
• Nous écrivons ou introduisonsSpringbootQuand on est dépendant,La version spécifiée n'est pas nécessaire,Juste parce qu'il y a ces versions de l'entrepôt

1、Où il dépend principalement d'un projet parent,Principalement pour gérer le filtrage des ressources et les plug - ins du projet！

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.4</version>
        <relativePath/> 
    <!-- lookup parent from repository -->
</parent>

2、À l'intérieur.,J'ai trouvé une autre dépendance parentale.

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-dependencies</artifactId>
    <version>2.4.4</version>
</parent>

3、 C'est la vraie gestion. SpringBootToutes les versions dépendantes de l'application,SpringBootCentre de contrôle de version pour;

4、Par défaut, nous n'avons pas besoin d'écrire la version pour importer des dépendances à l'avenir.; Mais si le paquet importé n'est pas géré dans une dépendance, vous devez configurer manuellement la version ;

2、Démarreur spring-boot-starter

• Dépendance

  <dependency>        								 		       		<groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter</artifactId>
  </dependency>
  

• springboot-boot-starter-xxx,C'est tout.Springboot Scénario de démarrage pour

• Par exemple,spring-boot-starter-web, Il nous aidera à importer automatiquement webToutes les dépendances de

• springboot Tous les scénarios fonctionnels , Sont devenus des initiateurs individuels

• Quelles fonctions allons - nous utiliser? , Il suffit de trouver l'initiateur correspondant. start

3、Procédure principale

3.1、Classe de démarrage primaire par défaut

package com.sxau;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication Pour marquer une classe de programme principale
//Ça veut dire que c'est unSpring BootApplication
public class Springboot01HelloworldApplication {
    
    // J'ai cru qu'il y avait un moyen. , Je ne m'attendais pas à démarrer un service. 
    public static void main(String[] args) {
    
        SpringApplication.run(Springboot01HelloworldApplication.class, args);
    }

}

Mais** Une simple classe de démarrage n'est pas facile ！** Analysons ce que ces notes ont fait.

3.2、Notes（@SpringBootApplication）

• Action：L'annotation d'une classe indique que cette classe estSpringBoot Configuration principale pour

• SpringBootC'est la classe qui devrait fonctionner.mainMéthode de démarrageSpringBootApplication;

• Entrez cette note：Comme vous pouvez le voir, il y a beaucoup d'autres annotations！

  @SpringBootConfiguration springbootConfiguration de
      @Configuration	 springConfigurer la classe
      @Component  La description est une springComposants de
  @EnableAutoConfiguration	Importer automatiquement des paquets
  @ComponentScan(		 Numériser les paquets de la classe de démarrage principale actuelle 
      excludeFilters = {
        @Filter(
      type = FilterType.CUSTOM,
      classes = {
        TypeExcludeFilter.class}
  ), @Filter(
      type = FilterType.CUSTOM,
      classes = {
        AutoConfigurationExcludeFilter.class}
  )}
  )
  // @interface Interface personnalisée
  public @interface SpringBootApplication {
        
      // ......
  }
  

@ComponentScan

• Cette note est disponible enSpringC'est important. ,Ça correspond.XMLÉléments de configuration.

• Action：Numériser et charger automatiquement les composants admissibles oubean , Prends ça.beanDéfinition chargée dansIOCDans le récipient

@SpringBootConfiguration

• Action：SpringBootClasse de configuration pour ,Dimension sur une classe , Ça veut dire que c'est unSpringBootClasse de configuration pour;

• Passons à l'annotation.

  //  Allumez - le et obtenez - le en bas.  @Component
  @Configuration
  public @interface SpringBootConfiguration {
        
      @AliasFor(		//@AliasForDéfinir un alias
          annotation = Configuration.class
      )
      boolean proxyBeanMethods() default true;
  }
  
  @Component
  public @interface Configuration {
        }
  

• Ici. @Configuration,Ça veut dire que c'est unspringClasse de configuration pour ,La classe de configuration correspondSpringDexml Profil;

• @Component Ça veut dire,La classe de démarrage elle - mêmeSpringUn des composantsC'est juste,Responsable du démarrage de l'application！

• On revient. SpringBootApplication Continuer à lire dans les notes .

@EnableAutoConfiguration

• Activer la fonction de configuration automatique

  • Ce que nous avions besoin de configurer nous - mêmes,Et maintenantSpringBootPeut être configuré automatiquement pour nous ;
  • @EnableAutoConfigurationDis - le.SpringBootActiver la fonction de configuration automatique,Pour que la configuration automatique prenne effet;

  Voir la suite des notes de pointage ：

• @AutoConfigurationPackage ：Paquet de configuration automatique

  @Import({
        Registrar.class})
  public @interface AutoConfigurationPackage {
        
  }
  

  • @import ：SpringNotes de bas [email protected] , Importer un composant dans un conteneur

  • Registrar.class Action： Configurer automatiquement l'enregistrement des paquets ,Numériser le paquet dans lequel se trouve la classe de démarrage principale et tous les composants de tous les sous - paquets sous le paquet àSpringConteneur ;

  • Cette analyse est terminée. , Retour à l'étape précédente ,Continue de regarder.

• @Import({AutoConfigurationImportSelector.class}) ：Importer des composants pour le conteneur ;

  • AutoConfigurationImportSelector ：Configurer automatiquement le sélecteur d'importation, Quel sélecteur de composants importe - t - il? ？ Nous cliquons sur cette classe pour voir le code source ：

    //  Obtenir toutes les configurations 
    List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);
    

  • Obtenir une configuration candidate

    protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
            
        //  Correspond à la méthode suivante 
        //Ici.getSpringFactoriesLoaderFactoryClass（）Méthodes
        //Le retour est la classe d'annotation que nous avons d'abord vue pour démarrer le Profil d'importation automatique;EnableAutoConfiguration
      List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());
        
      
        Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you are using a custom packaging, make sure that file is correct.");
        return configurations;
    }
    
    // Et les méthodes de la classe ci - dessus loadFactoryNames Le premier paramètre correspond 
    //Ici.getSpringFactoriesLoaderFactoryClass（）Méthodes
    //Le retour est la classe d'annotation que nous avons d'abord vue pour démarrer le Profil d'importation automatique;EnableAutoConfiguration
     protected Class<?> getSpringFactoriesLoaderFactoryClass() {
            
         return EnableAutoConfiguration.class;
     }
    

  • Cette méthodegetCandidateConfigurations()Encore appelé SpringFactoriesLoader Méthode statique de la classe！Nous entrons dansSpringFactoriesLoaderCatégorieloadFactoryNames() Méthodes, Obtenir toutes les configurations de chargement

    public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
            
        String factoryClassName = factoryClass.getName();
        //Ici, il appelle à nouveau loadSpringFactories Méthodes
        return (List)loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
    }
    

  • Nous continuons à cliquer pour voir loadSpringFactories Méthodes

    • Ressources du projet:META-INF/spring.factories
    • Ressources du système:META-INF/spring.factories
    • 
    • Toutes configurées à partir de ces ressources nextElement（Configuration automatique）, Sous - Assemblée properties

    // Charger toutes les ressources dans la classe de configuration （ Extraire les éléments suivants de l'analyse ,No13D'accord）
    Properties properties = PropertiesLoaderUtils.loadProperties(resource);
    

    private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
            
        //ObtenirclassLoader , Et ce que nous pouvons voir en revenant ici, c'est queEnableAutoConfigurationClasse annotée elle - même
        MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
            if (result != null) {
            
                return result;
            } else {
            
                try {
            
                //Pour obtenir une ressource "META-INF/spring.factories"
                Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
                LinkedMultiValueMap result = new LinkedMultiValueMap();
                // Déterminer s'il y a d'autres éléments , Boucler les ressources lues ,Encapsulé dans unProperties
                while(urls.hasMoreElements()) {
            
                  URL url = (URL)urls.nextElement();
                    UrlResource resource = new UrlResource(url);
                    Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                    Iterator var6 = properties.entrySet().iterator();
                    while(var6.hasNext()) {
            
                        Entry<?, ?> entry = (Entry)var6.next();
                        String factoryClassName = ((String)entry.getKey()).trim();
                        String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                        int var10 = var9.length;
                        for(int var11 = 0; var11 < var10; ++var11) {
            
                            String factoryName = var9[var11];
                            result.add(factoryClassName, factoryName.trim());
                        }
                    }
                }
                cache.put(classLoader, result);
                return result;
            } catch (IOException var13) {
            
                throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13);
            }
        }
    }
    

  • Un fichier récurrent a été trouvé ：spring.factories, Recherche globale

3.3、spring.factories

On l'ouvre à la source.spring.factories , J'ai vu beaucoup de fichiers configurés automatiquement;C'est la racine de la configuration automatique！

WebMvcAutoConfiguration

Nous allons ouvrir la classe de configuration automatique ci - dessus.,Par exemple, ：WebMvcAutoConfiguration

Vous pouvez voir que chacun d'eux estJavaConfigConfigurer la classe,Et en a injecté un peu.Bean,Vous pouvez trouver des classes que vous connaissez, Regarde et familiarise - toi. ！

Alors...,L'implémentation réelle de la configuration automatique est declasspathRechercher tousMETA-INF/spring.factoriesProfil ,Et mettre le org.springframework.boot.autoconfigure. Éléments de configuration sous paquet,Les dimensions correspondantes sont instantanées par réflexion@ConfigurationDeJavaConfigLa formeIOCClasse de configuration du conteneur , Ensuite, résumez - les en une seule instance et chargez - les dansIOCDans le récipient.

4、Conclusions：

1. SpringBootDepuis le chemin de classe au démarrageMETA-INF/spring.factoriesAccès moyenEnableAutoConfigurationValeur spécifiée
2. Importer ces valeurs dans le conteneur en tant que classe de configuration automatique , La classe de configuration automatique prend effet , Aidez - nous à automatiser la configuration;
3. Ce que nous avions besoin de configurer automatiquement ,MaintenantspringbootIl l'a fait pour nous.
4. IntégrationJavaEE, La solution globale et la configuration automatique springboot-autoconfigureDejarDans le sac;
5. Il prend tous les composants à importer , Renvoie comme nom de classe ,Ces composants sont ajoutés au conteneur
6. Il importe beaucoup de classes de configuration automatique dans le conteneur （xxxAutoConfiguration）, Est d'importer tous les composants nécessaires pour cette scène dans le conteneur , Et configurer automatiquement ,@Configuration（javaConfig） ;
7. Avec la classe de configuration automatique , Nous avons éliminé le travail d'écriture manuelle pour configurer les composants de la fonction d'injection, etc. ;

Maintenant, tout le monde devrait avoir un aperçu. ,SpringBootPrincipe de fonctionnement, Nous approfondirons encore une fois. ！

Démarrage

1、 Pas facile.

J'ai d'abord pensé que j'en avais un. mainMéthodes, J'ai ouvert un service. ;

package com.sxau;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication //Pour marquer une classe de programme principale
//Ça veut dire que c'est unSpring BootApplication
public class Springboot01HelloworldApplication {
    
    //Cette méthode renvoie unConfigurableApplicationContextObjet
    //Paramètre 1： Classe d'entrée de l'application ; Paramètre 2：Paramètres de la ligne de commande 
    public static void main(String[] args) {
    
        SpringApplication.run(Springboot01HelloworldApplication.class, args);
    }

}

SpringApplication.runAnalyse

• La méthode est divisée en deux parties.
• Un.SpringApplicationInstanciation de,
• Deux.runExécution de la méthode;

2、SpringApplication

Cette classe fait principalement les quatre choses suivantes:：

1. Déduire si le type d'application est normal ouWebProjets

2. Trouver et charger tous les initialisateurs disponibles , Set toinitializersDans les propriétés

3. Trouver tous les auditeurs d'application,Set tolistenersDans les propriétés

4. Extrapoler et définirmainClasse de définition de la méthode,Trouver la classe principale en cours d'exécution

Voir le constructeur ：

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
    
        this.sources = new LinkedHashSet();
        this.bannerMode = Mode.CONSOLE;
        this.logStartupInfo = true;
        this.addCommandLineProperties = true;
        this.addConversionService = true;
        this.headless = true;
        this.registerShutdownHook = true;
        this.additionalProfiles = Collections.emptySet();
        this.isCustomEnvironment = false;
        this.lazyInitialization = false;
        this.applicationContextFactory = ApplicationContextFactory.DEFAULT;
        this.applicationStartup = ApplicationStartup.DEFAULT;
        this.resourceLoader = resourceLoader;
        Assert.notNull(primarySources, "PrimarySources must not be null");
        this.primarySources = new LinkedHashSet(Arrays.asList(primarySources));
        this.webApplicationType = WebApplicationType.deduceFromClasspath();
        this.bootstrappers = new ArrayList(this.getSpringFactoriesInstances(Bootstrapper.class));
        this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class));
        this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
        this.mainApplicationClass = this.deduceMainApplicationClass();
}

3、runAnalyse du processus méthodologique

Suivez le code source et cette image et vous pouvez l'explorer. ！

4、À propos deSpringBoot, Parlez de votre compréhension ;

• Montage automatique
• run()
• Prise en charge complèteSpringMVCConfiguration de