Création d'un démarreur personnalisé avec Spring Boot

1. Vue d'ensemble

Les principaux développeurs de Spring Boot fournissent des démarreurs pour la plupart des projets open source populaires, mais nous ne sommes pas limités à ceux-ci.

Nous pouvons également écrire nos propres démarreurs personnalisés . Si nous avons une bibliothèque interne à utiliser au sein de notre organisation, ce serait une bonne pratique d'écrire également un démarreur pour elle si elle doit être utilisée dans le contexte de Spring Boot.

Ces démarreurs permettent aux développeurs d'éviter une configuration longue et de démarrer rapidement leur développement. Cependant, avec beaucoup de choses qui se passent en arrière-plan, il devient parfois difficile de comprendre comment une annotation ou simplement inclure une dépendance dans le pom.xml active autant de fonctionnalités.

Dans cet article, nous démystifierons la magie de Spring Boot pour voir ce qui se passe dans les coulisses. Ensuite, nous utiliserons ces concepts pour créer un démarreur pour notre propre bibliothèque personnalisée.

2. Démystification de la configuration automatique de Spring Boot

2.1. Classes de configuration automatique

Lorsque Spring Boot démarre, il recherche un fichier nommé spring.factories dans le chemin des classes . Ce fichier se trouve dans le répertoire META-INF . Regardons un extrait de ce fichier du projet spring-boot-autoconfigure:

# 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

Ce fichier mappe un nom à différentes classes de configuration que Spring Boot essaiera d'exécuter. Ainsi, selon cet extrait, Spring Boot essaiera d'exécuter toutes les classes de configuration pour RabbitMQ, Cassandra, MongoDB et Hibernate.

L'exécution effective ou non de ces classes dépendra de la présence de classes dépendantes sur le chemin des classes. Par exemple, si les classes de MongoDB se trouvent sur le chemin de classe , MongoAutoConfiguration s'exécutera et tous les beans associés à mongo seront initialisés.

Cette initialisation conditionnelle est activée par l' annotation @ConditionalOnClass . Regardons l'extrait de code de la classe MongoAutoConfiguration pour voir son utilisation:

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

Maintenant, comment - si MongoClient est disponible dans le classpath - cette classe de configuration exécutera le remplissage de la fabrique de bean Spring avec un MongoClient initialisé avec les paramètres de configuration par défaut.

2.2. Propriétés personnalisées du fichier application.properties

Spring Boot initialise les beans à l'aide de certains paramètres par défaut préconfigurés. Pour remplacer ces valeurs par défaut, nous les déclarons généralement dans le fichier application.properties avec un nom spécifique. Ces propriétés sont automatiquement récupérées par le conteneur Spring Boot.

Voyons comment cela fonctionne.

Dans l'extrait de code de MongoAutoConfiguration , l' annotation @EnableConfigurationProperties est déclarée avec la classe MongoProperties qui sert de conteneur pour les propriétés personnalisées:

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

Le préfixe et le nom du champ forment les noms des propriétés dans le fichier application.properties . Ainsi, pour définir l' hôte de MongoDB, il suffit d'écrire ce qui suit dans le fichier de propriétés:

spring.data.mongodb.host = localhost

De même, les valeurs des autres champs de la classe peuvent être définies à l'aide du fichier de propriétés.

3. Création d'un démarreur personnalisé

Sur la base des concepts de la section 2, pour créer un démarreur personnalisé, nous devons écrire les composants suivants:

  1. Une classe de configuration automatique pour notre bibliothèque avec une classe de propriétés pour une configuration personnalisée.
  2. Un pom de démarrage pour intégrer les dépendances de la bibliothèque et du projet de configuration automatique.

Pour la démonstration, nous avons créé une bibliothèque de messages d'accueil simple qui prendra un message d'accueil pour différentes heures de la journée comme paramètres de configuration et affichera le message d'accueil. Nous allons également créer un exemple d'application Spring Boot pour démontrer l'utilisation de nos modules de configuration automatique et de démarrage.

3.1. Le module de configuration automatique

Nous appellerons notre module de configuration automatique greeter-spring-boot-autoconfigure . Ce module aura deux classes principales à savoir GreeterProperties qui permettra de définir des propriétés personnalisées via le fichier application.properties et GreeterAutoConfiguartion qui créera les beans pour la bibliothèque greeter .

Regardons le code pour les deux classes:

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

Nous devons également ajouter un fichier spring.factories dans le répertoire src / main / resources / META-INF avec le contenu suivant:

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

On application startup, the GreeterAutoConfiguration class will run if the class Greeter is present in the classpath. If run successfully, it will populate the Spring application context with GreeterConfig and Greeter beans by reading the properties via GreeterProperties class.

The @ConditionalOnMissingBean annotation will ensure that these beans will only be created if they don't already exist. This enables developers to completely override the auto-configured beans by defining their own in one of the @Configuration classes.

3.2. Creating pom.xml

Now let's create the starter pom which will bring in the dependencies for the auto-configure module and the greeter library.

As per the naming convention, all the starters which are not managed by the core Spring Boot team should start with the library name followed by the suffix -spring-boot-starter. So we will call our starter as greeter-spring-boot-starter:

 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. Using the Starter

Let's create greeter-spring-boot-sample-app which will use the starter. In the pom.xml we need to add it as a dependency:

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

Spring Boot will automatically configure everything and we will have a Greeter bean ready to be injected and used.

Modifions également certaines des valeurs par défaut des GreeterProperties en les définissant dans le fichier application.properties avec le préfixe baeldung.greeter :

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

Enfin, utilisons le bean Greeter dans notre application:

@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. Conclusion

Dans ce tutoriel rapide, nous nous sommes concentrés sur le déploiement d'un démarreur Spring Boot personnalisé et sur la façon dont ces démarreurs, ainsi que le mécanisme de configuration automatique - fonctionnent en arrière-plan pour éliminer une grande partie de la configuration manuelle.

Le code source complet de tous les modules que nous avons créés dans cet article est disponible sur GitHub.