Créez une application Java avec Spring Boot

Notre structure minimale étant prête, il nous faut désormais :

1. Structurer avec des packages.

2. Configurer notre application.

À vous de jouer !

Pour la structure de packages, je vous encourage à reprendre ce que je vous ai montré dans la partie 2. Comme indiqué, c’est une organisation standard qui s’applique très bien aux projets web.

Pour la configuration, vous pouvez également reprendre ce qu’on avait vu ensemble précédemment concernant le fichier application.properties. On reste sur une configuration standard.

Je vous laisse la main, essayez de votre côté, on se retrouve dans quelques minutes pour débriefer ces étapes.

Correction

Créez les packages

Certainement le plus facile de cet exercice, voici tout simplement la capture d’écran du résultat :

Définissez les propriétés

Regardons maintenant le résultat de la configuration du fichier application.properties.

Et voici mon résultat en image :

#Global configuration
spring.application.name=webapp

 #Tomcat configuration
 server.port=9001
 
 #Log level configuration
 logging.level.root=ERROR
 logging.level.com.openclassrooms=INFO
 logging.level.org.springframework.boot.web.embedded.tomcat=INFO

• spring.application.name=webapp : pour définir un nom à l’application ;

• server.port=9001 : pour ne pas être sur le port par défaut 8080, ni sur le port 9000 qui est utilisé par l’API (Cf. partie 3 chapitre 2) ;

• logging.level :

  • root=ERROR : par défaut, seules les traces en ERROR s’affichent. L’idée est simple : réduire les affichages dans la console de toutes les "3rd party",

  • com.openclassrooms=INFO : pour ce qui est de notre code, on est en INFO pour avoir du détail,

  • org.springframework.boot.web.embedded.tomcat : permet de voir dans la console le port utilisé par Tomcat au démarrage.

Allez plus loin dans la gestion des propriétés

Je souhaite saisir l’opportunité de ce chapitre pour vous apprendre à créer de la configuration custom. Jusqu’à présent, je vous ai montré comment configurer votre application en fonction de propriétés existantes.

Rassurez-vous, Spring Boot s’occupe de tout ! (Comme d’hab )

Dans la partie 2 du cours, chapitre 2, j’ai eu l’occasion de vous apprendre que Spring Boot lit nos sources de propriétés, et rend disponible les propriétés via des beans.

Le fichier application.properties correspond à l’une de ces sources de propriétés.

Jusqu’à présent, nous avons saisi des valeurs pour des propriétés existantes. Propriétés utiles à des classes de Spring qu’on ne manipule pas. Cependant, si je souhaite ajouter une nouvelle propriété, comment y accéder dans mon code ?

Un screencast, ça vous tente ? 

Récapitulons !

Etape 1 : Créez la nouvelle propriété.

J’ai commencé par ajouter ma nouvelle propriété dans mon fichier application.properties (pour rappel, ce fichier est ma source de propriétés).

Étape 2 : Créez le bean associé.

J’ai ensuite créé une nouvelle classe nommée CustomProperties. Je l’ai annotée avec :

• @Configuration : permet de déclarer la classe en tant que bean de configuration.

• @ConfigurationProperties(prefix = “com.openclassrooms.webapp”) : demande à Spring de charger les properties qui commencent par “com.openclassrooms.webapp” au sein des attributs de la classe.

• @Data : génère automatiquement getter/setter pour les attributs de classe.

J’ai conclu cette classe en ajoutant l’attribut apiUrl.

package com.openclassrooms.webapp.repository;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

import lombok.Data;


@Configuration
@ConfigurationProperties(prefix = "com.openclassrooms.webapp")
@Data
public class CustomProperties {

    private String apiUrl;

}

Étape 3 : Utilisez les propriétés dans le code.

Pour la démonstration, j’ai modifié la classe WebappApplication, afin qu’elle implémente un CommandLineRunner. Ainsi, dans la méthode run, j’ai voulu vérifier que j’accédais bien à la propriété, en affichant cette dernière dans la console.

Le point clé à retenir est l’injection du bean CustomProperties, comme vous pouvez le voir aux lignes 16/17 ci-dessous.

Il est ensuite facile d’accéder à la propriété, comme le montre la ligne 25.

package com.openclassrooms.webapp;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import com.openclassrooms.webapp.repository.CustomProperties;

import lombok.Data;

@Data
@SpringBootApplication
public class WebappApplication implements CommandLineRunner {

    @Autowired
    private CustomProperties properties;

    public static void main(String[] args) {
        SpringApplication.run(WebappApplication.class, args);
    }

    @Override
    public void run(String... args) throws Exception {
        System.out.println(properties.getApiUrl());
    }

}

En résumé

• La structure des packages reste le standard : controller/service/repository/model.

• Le fichier application.properties est ma source de propriétés.

• Je peux créer des propriétés et les manipuler dans mon code, notamment grâce à l’annotation @ConfigurationProperties.

Votre configuration est terminée ! Vous êtes prêt pour la phase 3 de chaque projet Spring : écrire le code !