Quel est le principe de mise en œuvre de la configuration automatique de SpringBoot ?

1. Qu'est-ce que la configuration automatique de Springboot ?

SpringBoot active la configuration automatique via l'annotation @EnableAutoConfiguration et analyse le fichier spring.factories sous le package jar. Ce fichier contient des classes qui peuvent être configurées automatiquement lorsque l'annotation @Condition est remplie. , Lorsque les conditions sont remplies, il est instancié avec le support des dépendances et enregistré dans le conteneur Spring.

En termes simples, lorsque nous avons écrit le projet ssm auparavant, nous avons configuré beaucoup de coordonnées et de contenu de configuration. Le processus de configuration de l'environnement a pris beaucoup de temps dans le développement du projet. simplifie divers contenus de configuration XML. Par conséquent, la configuration automatique de Springboot utilise des annotations pour créer des configurations par défaut pour certaines configurations courantes, simplifiant ainsi le contenu de la configuration XML afin que votre projet puisse s'exécuter rapidement.

Principe de configuration de base de Springboot :

• Les classes de configuration automatique sont stockées dans org.springframework.boot.autoconfigure sous le numéro de version spring-boot-autoconfigure.jar

• Lorsque nous configurons le débogage dans application.properties =true et démarrez le conteneur. Vous pouvez voir la configuration initiale de l'initialisation du serveur

• DispatcherServletAutoConfigratio enregistre le contrôleur frontal

• EmbeddedServletContainerAutoConfiguration enregistre le type de conteneur

• HttpMessageConvertersAutoConfiguration enregistre le processeur json ou xml

• J acksonAutoConfiguration enregistre l'analyseur d'objets json

• Si vous ajoutez des dépendances sur d'autres fonctions, springBoot implémentera également la configuration automatique de ces fonctions

2. Composant Starter

Le composant Starter est un élément de dépendance Maven qui peut être chargé dans l'application. Ce n'est qu'en ajoutant la configuration de dépendance correspondante dans la configuration Maven que vous pourrez utiliser le composant Starter correspondant. Par exemple, l'ajout de la dépendance spring-boot-starter-web peut être utilisé pour créer un service API REST, qui inclut les conteneurs intégrés Spring MVC et Tomcat.

Un composant Starter complet comprend les deux points suivants :

• Le module de configuration automatique qui assure la fonction de configuration automatique

• Le module composant qui fournit la fonction de gestion des dépendances, qui encapsule toutes les fonctions du composant et peut être utilisé hors de la boîte.

spring-boot-starter-web dépend du code source

package org.springframework.boot.autoconfigure.web.servlet;
@Configuration
@ConditionalOnClass({ServletRequest.class})
@ConditionalOnWebApplication(
    type = Type.SERVLET
)
@EnableConfigurationProperties({ServerProperties.class})
@Import({ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class})
public class ServletWebServerFactoryAutoConfiguration {
    ......
}
@

3. Trois annotations majeures

@SpringBootConfiguration : hérité de la configuration, prend en charge JavaConfig pour la configuration.

@EnableAutoConfiguration : Cet article se concentre sur l'explication, principalement utilisé pour activer la configuration automatique.

@ComponentScan : analyse automatiquement les composants. Par défaut, il analyse toutes les classes avec les annotations spécifiées sous le package et les sous-packages de la classe, et les assemble automatiquement dans le conteneur du bean. Les annotations qui seront automatiquement assemblées incluent @Controller, @Service, @Component, @Repository, etc. Les chemins d'analyse peuvent également être spécifiés.

4. @EnableAutoConfiguration

Cette annotation nous aide à charger automatiquement la configuration par défaut. Elle comporte deux annotations clés @AutoConfigurationPackage et @Import.

@Override
	public String[] selectImports(AnnotationMetadata annotationMetadata) {
		//检查自动配置功能是否开启，默认开启
		if (!isEnabled(annotationMetadata)) {
			return NO_IMPORTS;
		}
		//加载自动配置的元信息
		AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
				.loadMetadata(this.beanClassLoader);
		AnnotationAttributes attributes = getAttributes(annotationMetadata);
		//获取候选配置类
		List<String> configurations = getCandidateConfigurations(annotationMetadata,
				attributes);
		//去掉重复的配置类
		configurations = removeDuplicates(configurations);
		//获得注解中被exclude和excludeName排除的类的集合
		Set<String> exclusions = getExclusions(annotationMetadata, attributes);
		//检查被排除类是否可实例化、是否被自动注册配置所使用，不符合条件则抛出异常
		checkExcludedClasses(configurations, exclusions);
		//从候选配置类中去除掉被排除的类
		configurations.removeAll(exclusions);
		//过滤
		configurations = filter(configurations, autoConfigurationMetadata);
		//将配置类和排除类通过事件传入到监听器中
		fireAutoConfigurationImportEvents(configurations, exclusions);
		//最终返回符合条件的自动配置类的全限定名数组
		return StringUtils.toStringArray(configurations);

@Import(AutoConfigurationImportSelector.class), importez la classe AutoConfigurationImportSelector ici. Il existe une méthode très importante dans cette classe - selectImports(), qui couvre presque toute la logique de traitement de l'assemblage automatique des composants, y compris l'obtention des classes de configuration candidates, la déduplication des classes de configuration, l'exclusion des classes de configuration inutiles, le filtrage, etc. les noms qualifiés des classes de configuration automatique qualifiées sont renvoyés.

5. SpringFactoriesLoader

La classe SpringFactoriesLoader est définie dans le package spring-core. Cette classe implémente la fonction de récupération du fichier META-INF/spring.factories et d'obtention de la configuration de l'interface spécifiée. Deux méthodes externes sont définies dans cette classe :

• loadFactories obtient l'instance de sa classe d'implémentation basée sur la classe d'interface. Cette méthode renvoie une liste d'objets.

• loadFactoryNames obtient le nom de sa classe d'interface en fonction de l'interface. Cette méthode renvoie une liste de noms de classe.

La clé des deux méthodes ci-dessus est d'obtenir le fichier spring.factories à partir du ClassLoader spécifié et de l'analyser pour obtenir la liste des noms de classe. Le code spécifique est le suivant :

public static List<String> loadFactoryNames(Class<?> factoryClass, ClassLoader classLoader) {
    String factoryClassName = factoryClass.getName();
    try {
        Enumeration<URL> urls = (classLoader != null ? classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
                ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
        List<String> result = new ArrayList<String>();
        while (urls.hasMoreElements()) {
            URL url = urls.nextElement();
            Properties properties = PropertiesLoaderUtils.loadProperties(new UrlResource(url));
            String factoryClassNames = properties.getProperty(factoryClassName);
            result.addAll(Arrays.asList(StringUtils.commaDelimitedListToStringArray(factoryClassNames)));
        }
        return result;
    }
    catch (IOException ex) {
        throw new IllegalArgumentException("Unable to load [" + factoryClass.getName() +
                "] factories from location [" + FACTORIES_RESOURCE_LOCATION + "]", ex);
    }
}

Comme le montre le code. , l'intégralité du ClassLoader sera parcourue dans cette méthode dans les fichiers spring.factories sous tous les packages jar. En d'autres termes, nous pouvons configurer le fichier spring.factories dans notre propre fichier jar sans affecter la configuration ailleurs ni être écrasé par la configuration d'autres personnes.

spring.factories sont analysés via les propriétés, donc le contenu du fichier que nous écrivons est installé et configuré de la manière suivante :

com.xxx.interface=com.xxx.classname

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!