TOC

Création d’un démarreur personnalisé avec démarrage à ressort

Création d'un démarreur personnalisé avec démarrage à ressort

1. Vue d'ensemble

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

We can also write our own custom starters. Si nous avons une bibliothèque interne à utiliser au sein de notre organisation, il serait judicieux d’écrire également un point de départ pour celle-ci si elle doit être utilisée dans le contexte de Spring Boot.

Ces démarreurs permettent aux développeurs d’éviter une configuration trop longue et de relancer 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 lepom.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. Nous utiliserons ensuite ces concepts pour créer un démarreur pour notre propre bibliothèque personnalisée.

2. Démystifier 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 de classe. Ce fichier se trouve dans le répertoireMETA-INF. Examinons un extrait de ce projetfile from the 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 sur différentes classes de configuration que Spring Boot essaiera d'exécuter. Donc, selon cet extrait, Spring Boot essaiera d’exécuter toutes les classes de configuration pour RabbitMQ, Cassandra, MongoDB et Hibernate.

Que ces classes soient réellement exécutées ou non dépendra de la présence de classes dépendantes dans le classpath. 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. Examinons l'extrait de code de la classeMongoAutoConfiguration 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 leMongoClient est disponible dans le chemin de classe - cette classe de configuration s'exécutera en remplissant la fabrique de bean Spring avec unMongoClient initialisé avec les paramètres de configuration par défaut.

2.2. Propriétés personnalisées du fichierapplication.properties

Spring Boot initialise les beans en utilisant certaines valeurs par défaut préconfigurées. Pour remplacer ces valeurs par défaut, nous les déclarons généralement dans le fichierapplication.properties avec un nom spécifique. Ces propriétés sont automatiquement sélectionnées par le conteneur Spring Boot.

Voyons comment cela fonctionne.

Dans l'extrait de code pourMongoAutoConfiguration, l'annotation@EnableConfigurationProperties est déclarée avec la classeMongoProperties 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 fichierapplication.properties. Donc, pour définir leshost pour 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éer 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 ainsi qu'une classe de propriétés pour une configuration personnalisée.

  2. Un starterpom pour introduire les dépendances de la bibliothèque et du projet d'autoconfiguration.

Pour la démonstration, nous avons créé unsimple greeting library 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 illustrer 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 automatiquegreeter-spring-boot-autoconfigure. Ce module aura deux classes principales: i.e. GreeterProperties qui permettra de définir des propriétés personnalisées via le fichierapplication.properties etGreeterAutoConfiguartion qui créera les beans pour la bibliothèquegreeter.

Examinons le code des deux classes: 

@ConfigurationProperties(prefix = "example.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 fichierspring.factories dans le répertoiresrc/main/resources/META-INF avec le contenu suivant: 

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

Au démarrage de l'application, la classeGreeterAutoConfiguration s'exécutera si la classeGreeter est présente dans le chemin de classe. S'il est exécuté avec succès, il remplira le contexte de l'application Spring avec les beansGreeterConfig etGreeter en lisant les propriétés via la classeGreeterProperties.

L'annotation@ConditionalOnMissingBean garantira que ces beans ne seront créés que s'ils n'existent pas déjà. Cela permet aux développeurs de remplacer complètement les beans auto-configurés en définissant les leurs dans l'une des classes@Configuration.

3.2. Création depom.xml

Créons maintenant le starterpom qui apportera les dépendances pour le module de configuration automatique et la bibliothèque d'accueil.

Conformément à la convention de dénomination, tous les démarreurs qui ne sont pas gérés par l'équipe principale de Spring Boot doivent commencer par le nom de la bibliothèque suivi du suffixe-spring-boot-starter. Nous appellerons donc notre démarreurgreeter-spring-boot-starter: 


    4.0.0

    com.example
    greeter-spring-boot-starter
    0.0.1-SNAPSHOT

    
        UTF-8
        0.0.1-SNAPSHOT
        1.5.2.RELEASE
    

    

        
            org.springframework.boot
            spring-boot-starter
            ${spring-boot.version}
        

        
            com.example
            greeter-spring-boot-autoconfigure
            ${project.version}
        

        
            com.example
            greeter
            ${greeter.version}

3.3. Utilisation du démarreur

Créonsgreeter-spring-boot-sample-app qui utilisera le démarreur. Dans lespom.xml, nous devons l'ajouter en tant que dépendance: 


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

Spring Boot va tout configurer automatiquement et nous aurons un beanGreeter prêt à être injecté et utilisé.

Modifions également certaines des valeurs par défaut desGreeterProperties en les définissant dans le fichierapplication.properties avec le préfixeexample.greeter: 

example.greeter.userName=example
example.greeter.afternoonMessage=Woha\ Afternoon

Enfin, utilisons le beanGreeter 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 rapide tutoriel, 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 beaucoup de configuration manuelle.

Le code source complet de tous les modules que nous avons créés dans cet article se trouve àover on GitHub.

Related