Was ist das Implementierungsprinzip der automatischen Konfiguration von SpringBoot?

1. Was ist die automatische Konfiguration von Springboot? Wenn die Klasse die in der Annotation @Condition angegebenen Bedingungen erfüllt, wird sie mit Unterstützung von Abhängigkeiten instanziiert und im Spring-Container registriert.

Als wir das SSM-Projekt zuvor geschrieben haben, haben wir im Allgemeinen viele Koordinaten und Konfigurationsinhalte konfiguriert. Der Prozess der Einrichtung der Umgebung hat bei der Projektentwicklung viel Zeit in Anspruch genommen Der Vorteil von SpringBoot besteht darin, dass es verschiedene XML-Konfigurationsinhalte vereinfacht. Daher verwendet die automatische Konfiguration von Springboot Anmerkungen, um Standardkonfigurationen für einige herkömmliche Konfigurationen zu erstellen, wodurch die XML-Konfigurationsinhalte vereinfacht werden, sodass Ihr Projekt schnell ausgeführt werden kann.

Springboot-Kernkonfigurationsprinzip:

Autokonfigurationsklassen werden in org.springframework unter spring-boot-autoconfigure-version number.jar gespeichert Starten Sie in .boot.autoconfigure
den Container, wenn wir debug=true in application.properties konfigurieren. Sie können die anfängliche Konfiguration der Serverinitialisierung sehen # ?? 🎜 ##🎜 🎜#

• Wenn Sie Abhängigkeiten von anderen Funktionen hinzufügen, implementiert SpringBoot auch die automatische Konfiguration dieser Funktionen

# 🎜🎜#2. Starter-Komponente

• Starter-Komponente ist eine Maven-Abhängigkeit, die in die Anwendung geladen werden kann. Nur durch Hinzufügen der entsprechenden Abhängigkeitskonfiguration in der Maven-Konfiguration können Sie die entsprechende Starter-Komponente verwenden. Beispielsweise kann das Hinzufügen der Spring-Boot-Starter-Web-Abhängigkeit zum Erstellen eines REST-API-Dienstes verwendet werden, der eingebettete Spring MVC- und Tomcat-Container enthält.

Eine vollständige Starter-Komponente umfasst die folgenden zwei Punkte:
Ein automatisches Konfigurationsmodul, das eine automatische Konfigurationsfunktion bereitstellt
• #🎜🎜 #
  Ein Komponentenmodul, das Abhängigkeitsverwaltungsfunktionen bereitstellt, alle Funktionen der Komponente kapselt und sofort verwendet werden kann.

• Spring-Boot-Starter-Web-Abhängigkeitsquellcode

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 {
    ......
}
@

Drei, drei wichtige Anmerkungen

@SpringBootConfiguration : Von Configuration geerbt und unterstützt die Konfiguration mit JavaConfig.

@EnableAutoConfiguration: Dieser Artikel konzentriert sich auf die Erläuterung und wird hauptsächlich zum Aktivieren der automatischen Konfiguration verwendet.

@ComponentScan: Komponenten automatisch scannen. Standardmäßig werden alle Klassen mit angegebenen Annotationen unter dem Paket und Unterpaketen der Klasse gescannt und automatisch in den Bean-Container zusammengestellt Zu den automatisch zusammengestellten Elementen gehören @Controller, @Service, @Component, @Repository usw. Es können auch Scanpfade angegeben werden.

4. @EnableAutoConfiguration

Diese Annotation hilft uns, die Standardkonfiguration automatisch zu laden. Sie verfügt über zwei wichtige Annotationen: @AutoConfigurationPackage und @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) Annotation, importieren Sie die AutoConfigurationImportSelector-Klasse hier. In dieser Klasse gibt es eine sehr wichtige Methode - selectImports (), die fast die gesamte Verarbeitungslogik der automatischen Komponentenassemblierung abdeckt, einschließlich des Abrufens von Kandidatenkonfigurationsklassen, der Deduplizierung von Konfigurationsklassen, des Ausschlusses unnötiger Konfigurationsklassen, der Filterung usw. Zum Schluss noch ein vollständiges Array Es werden qualifizierte Namen qualifizierter Autokonfigurationsklassen zurückgegeben.

5. SpringFactoriesLoader

• Die SpringFactoriesLoader-Klasse ist im Spring-Core-Paket definiert. Diese Klasse implementiert das Abrufen der META-INF/spring.factories-Datei und das Abrufen der Konfiguration angegebene Schnittstelle. In dieser Klasse sind zwei externe Methoden definiert:

loadFactories ruft die Instanz seiner Implementierungsklasse basierend auf der Schnittstellenklasse ab. Diese Methode gibt eine Liste von Objekten zurück.

loadFactoryNames ruft den Namen seiner Schnittstellenklasse basierend auf der Schnittstelle ab. Diese Methode gibt eine Liste von Klassennamen zurück.

Der Schlüssel zu den beiden oben genannten Methoden besteht darin, die spring.factories-Datei vom angegebenen ClassLoader abzurufen und sie zu analysieren, um die Klassennamenliste zu erhalten. Der spezifische Code lautet wie folgt folgt: #🎜🎜 #

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);
    }
}

Wie aus dem Code ersichtlich ist, werden bei dieser Methode die spring.factories-Dateien unter allen JAR-Paketen im gesamten ClassLoader durchlaufen. Mit anderen Worten: Wir können die spring.factories-Datei in unserem eigenen JAR konfigurieren, ohne die Konfiguration an anderen Stellen zu beeinträchtigen oder durch die Konfiguration anderer Leute überschrieben zu werden.

spring.factories werden durch Eigenschaftenanalyse erhalten, sodass der Inhalt der von uns geschriebenen Datei auf folgende Weise installiert und konfiguriert wird:

com .xxx. interface=com.xxx.classname

Das obige ist der detaillierte Inhalt vonWas ist das Implementierungsprinzip der automatischen Konfiguration von SpringBoot?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!