Erstellen eines benutzerdefinierten Starters mit Spring Boot

1. Übersicht

Die wichtigsten Spring Boot-Entwickler bieten Starter für die meisten beliebten Open Source-Projekte, aber wir sind nicht auf diese beschränkt.

Wir können auch unsere eigenen Starter schreiben . Wenn wir eine interne Bibliothek zur Verwendung in unserer Organisation haben, empfiehlt es sich, auch einen Starter dafür zu schreiben, wenn diese im Spring Boot-Kontext verwendet werden soll.

Mit diesen Startern können Entwickler langwierige Konfigurationen vermeiden und ihre Entwicklung schnell starten. Da jedoch viele Dinge im Hintergrund geschehen, ist es manchmal schwierig zu verstehen, wie eine Annotation oder nur das Einfügen einer Abhängigkeit in die pom.xml so viele Funktionen ermöglicht.

In diesem Artikel werden wir die Spring Boot-Magie entmystifizieren, um zu sehen, was sich hinter den Kulissen abspielt. Anschließend verwenden wir diese Konzepte, um einen Starter für unsere eigene benutzerdefinierte Bibliothek zu erstellen.

2. Entmystifizierung der Autokonfiguration von Spring Boot

2.1. Automatische Konfigurationsklassen

Beim Start von Spring Boot wird im Klassenpfad nach einer Datei mit dem Namen spring.factories gesucht . Diese Datei befindet sich im META-INF- Verzeichnis. Schauen wir uns einen Ausschnitt dieser Datei aus dem Spring-Boot-Autoconfigure-Projekt an:

# Auto Configure org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\ org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration,\ org.springframework.boot.autoconfigure.mongo.MongoAutoConfiguration,\ org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration

Diese Datei ordnet einen Namen verschiedenen Konfigurationsklassen zu, die Spring Boot ausführen soll. Gemäß diesem Snippet versucht Spring Boot also, alle Konfigurationsklassen für RabbitMQ, Cassandra, MongoDB und Hibernate auszuführen.

Ob diese Klassen tatsächlich ausgeführt werden oder nicht, hängt vom Vorhandensein abhängiger Klassen im Klassenpfad ab. Wenn beispielsweise die Klassen für MongoDB im Klassenpfad gefunden werden, wird MongoAutoConfiguration ausgeführt und alle mongo-bezogenen Beans werden initialisiert.

Diese bedingte Initialisierung wird durch die Annotation @ConditionalOnClass aktiviert . Schauen wir uns das Code-Snippet aus der MongoAutoConfiguration- Klasse an, um zu sehen, wie es verwendet wird:

@Configuration @ConditionalOnClass(MongoClient.class) @EnableConfigurationProperties(MongoProperties.class) @ConditionalOnMissingBean(type = "org.springframework.data.mongodb.MongoDbFactory") public class MongoAutoConfiguration { // configuration code }

Wie nun - wenn der MongoClient im Klassenpfad verfügbar ist - diese Konfigurationsklasse ausgeführt wird, um die Spring Bean-Factory mit einem MongoClient zu füllen, der mit den Standardkonfigurationseinstellungen initialisiert wurde.

2.2. Benutzerdefinierte Eigenschaften aus der Datei application.properties

Spring Boot initialisiert die Beans mit einigen vorkonfigurierten Standardeinstellungen. Um diese Standardeinstellungen zu überschreiben, deklarieren wir sie im Allgemeinen in der Datei application.properties mit einem bestimmten Namen. Diese Eigenschaften werden automatisch vom Spring Boot-Container übernommen.

Mal sehen, wie das funktioniert.

Im Code-Snippet für MongoAutoConfiguration wird die Annotation @EnableConfigurationProperties mit der MongoProperties- Klasse deklariert , die als Container für benutzerdefinierte Eigenschaften fungiert:

@ConfigurationProperties(prefix = "spring.data.mongodb") public class MongoProperties { private String host; // other fields with standard getters and setters }

Das Präfix und der Feldname geben die Namen der Eigenschaften in der Datei application.properties an . Um den Host für MongoDB festzulegen, müssen wir nur Folgendes in die Eigenschaftendatei schreiben:

spring.data.mongodb.host = localhost

Ebenso können Werte für andere Felder in der Klasse mithilfe der Eigenschaftendatei festgelegt werden.

3. Erstellen eines benutzerdefinierten Starters

Basierend auf den Konzepten in Abschnitt 2 müssen wir zum Erstellen eines benutzerdefinierten Starters die folgenden Komponenten schreiben:

  1. Eine automatisch konfigurierte Klasse für unsere Bibliothek sowie eine Eigenschaftenklasse für die benutzerdefinierte Konfiguration.
  2. Ein Starter- POM , um die Abhängigkeiten der Bibliothek und des Autokonfigurationsprojekts einzubeziehen.

Zur Demonstration haben wir eine einfache Begrüßungsbibliothek erstellt, die eine Begrüßungsnachricht für verschiedene Tageszeiten als Konfigurationsparameter aufnimmt und die Begrüßungsnachricht ausgibt. Wir werden auch eine Beispielanwendung für Spring Boot erstellen, um die Verwendung unserer Autokonfigurations- und Startermodule zu demonstrieren.

3.1. Das Autokonfigurationsmodul

Wir werden unser Auto-Konfigurationsmodul greeter-spring-boot-autoconfigure nennen . Dieses Modul verfügt über zwei Hauptklassen, z. B. GreeterProperties, mit denen benutzerdefinierte Eigenschaften über die Datei application.properties festgelegt werden können, und GreeterAutoConfiguartion, mit dem die Beans für die Greeter- Bibliothek erstellt werden.

Schauen wir uns den Code für beide Klassen an:

@ConfigurationProperties(prefix = "baeldung.greeter") public class GreeterProperties { private String userName; private String morningMessage; private String afternoonMessage; private String eveningMessage; private String nightMessage; // standard getters and setters }
@Configuration @ConditionalOnClass(Greeter.class) @EnableConfigurationProperties(GreeterProperties.class) public class GreeterAutoConfiguration { @Autowired private GreeterProperties greeterProperties; @Bean @ConditionalOnMissingBean public GreetingConfig greeterConfig() { String userName = greeterProperties.getUserName() == null ? System.getProperty("user.name") : greeterProperties.getUserName(); // .. GreetingConfig greetingConfig = new GreetingConfig(); greetingConfig.put(USER_NAME, userName); // ... return greetingConfig; } @Bean @ConditionalOnMissingBean public Greeter greeter(GreetingConfig greetingConfig) { return new Greeter(greetingConfig); } }

Wir müssen auch eine spring.factories- Datei im Verzeichnis src / main / resources / META-INF mit folgendem Inhalt hinzufügen :

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ com.baeldung.greeter.autoconfigure.GreeterAutoConfiguration

Beim Start der Anwendung wird die GreeterAutoConfiguration- Klasse ausgeführt, wenn die Klasse Greeter im Klassenpfad vorhanden ist. Bei erfolgreicher Ausführung wird der Spring-Anwendungskontext mit GreeterConfig- und Greeter- Beans gefüllt, indem die Eigenschaften über die GreeterProperties- Klasse gelesen werden .

Die Annotation @ConditionalOnMissingBean stellt sicher, dass diese Beans nur erstellt werden, wenn sie noch nicht vorhanden sind. Auf diese Weise können Entwickler die automatisch konfigurierten Beans vollständig überschreiben, indem sie ihre eigenen in einer der @ Configuration- Klassen definieren.

3.2. Pom.xml erstellen

Jetzt erstellen wir den Starter- POM, der die Abhängigkeiten für das Auto-Configure-Modul und die Greeter-Bibliothek einbringt.

Gemäß der Namenskonvention sollten alle Starter, die nicht vom Spring Boot-Kernteam verwaltet werden, mit dem Bibliotheksnamen beginnen, gefolgt vom Suffix -spring-boot-Starter . Also werden wir unseren Starter als Greeter-Spring-Boot-Starter bezeichnen:

 4.0.0 com.baeldung greeter-spring-boot-starter 0.0.1-SNAPSHOT  UTF-8 0.0.1-SNAPSHOT 2.2.6.RELEASE    org.springframework.boot spring-boot-starter ${spring-boot.version}   com.baeldung greeter-spring-boot-autoconfigure ${project.version}   com.baeldung greeter ${greeter.version}   

3.3. Den Starter benutzen

Lassen Sie uns eine Greeter-Spring-Boot-Sample-App erstellen, die den Starter verwendet. In der pom.xml müssen wir es als Abhängigkeit hinzufügen:

 com.baeldung greeter-spring-boot-starter ${greeter-starter.version} 

Spring Boot konfiguriert automatisch alles und wir haben eine Greeter- Bean bereit, die injiziert und verwendet werden kann.

Lassen Sie sich auch einige der Standardwerte der ändern GreeterProperties von ihnen bei der Definition von application.properties Datei mit dem baeldung.greeter Präfix:

baeldung.greeter.userName=Baeldung baeldung.greeter.afternoonMessage=Woha\ Afternoon

Verwenden wir zum Schluss die Greeter- Bohne in unserer Anwendung:

@SpringBootApplication public class GreeterSampleApplication implements CommandLineRunner { @Autowired private Greeter greeter; public static void main(String[] args) { SpringApplication.run(GreeterSampleApplication.class, args); } @Override public void run(String... args) throws Exception { String message = greeter.greet(); System.out.println(message); } }

4. Fazit

In diesem kurzen Tutorial haben wir uns darauf konzentriert, einen benutzerdefinierten Spring Boot-Starter einzuführen und wie diese Starter zusammen mit dem Autokonfigurationsmechanismus im Hintergrund arbeiten, um viele manuelle Konfigurationen zu vermeiden.

Den vollständigen Quellcode für alle Module, die wir in diesem Artikel erstellt haben, finden Sie auf GitHub.