Prenez en main Spring Boot

Inès a relu votre refactoring et l’a intégré à la branche principale. Elle n’a laissé qu’un commentaire, sur le constructeur du contrôleur : 

Avant qu’on ajoute les stages, je ne veux plus voir un seulnewici. 

Le même jour, Samuel vous écrit deux messages. Le premier annonce que le nouvel accord d’entreprise modifiera le taux d’acquisition des CDD au 1er janvier, et que la valeur exacte ne sera connue qu’en décembre. Le second transfère une plainte de Karim Benali : depuis que l’équipe a importé l’historique des congés des cinq dernières années, approuver une demande prend plusieurs secondes.

Ces trois remarques semblent sans rapport. Elles ont pourtant la même origine : Hamac utilise Spring Boot sans profiter de ce qu’il propose. Spring sait créer et assembler les objets de l’application, mais Hamac les crée à la main. Spring Boot sait lire des paramètres dans un fichier de configuration, mais le taux des CDD est écrit dans le code. Et Spring Data JPA sait filtrer les données dans la base, mais Hamac les filtre en mémoire.

Découvrez ce que fait Spring Boot au démarrage

Jusqu’ici, vous avez travaillé dans le contrôleur et dans le service. Mais avant qu’une requête n’atteigneLeaveController, quelque chose a démarré l’application, ouvert le port 8080 et créé le contrôleur. Tout part desrc/main/java/com/hamac/HamacApplication.java:

@SpringBootApplication
public class HamacApplication {

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

Une méthodemainet une annotation : c’est tout. L’annotation@SpringBootApplicationdéclenche deux mécanismes qui font l’essentiel du travail.

Le premier est l’auto-configuration. Spring Boot regarde les dépendances présentes dans lepom.xmlet configure ce qu’elles permettent :

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-webmvc</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>

Parce que le starter web est présent, Spring Boot démarre un serveur Tomcat intégré sur le port 8080 et route les requêtes vers vos contrôleurs. Parce que Thymeleaf est présent, il sait trouver les templates. Parce que Spring Data JPA et H2 sont présents, il crée une base en mémoire, s’y connecte et prépare l’accès aux données. Vous n’avez écrit aucune de ces configurations : vous pouvez seulement les ajuster, danssrc/main/resources/application.properties. Voici celle du starter :

spring.jpa.open-in-view=false
spring.jpa.defer-datasource-initialization=true

La seconde ligne demande d’exécuterdata.sqlaprès la création des tables. La première désactive un comportement historique de Spring Boot, qui garde la connexion à la base ouverte jusqu’à l’affichage de la réponse : vous verrez plus loin pourquoi il vaut mieux s’en passer.

Le second mécanisme est le scan des composants. Au démarrage, Spring parcourt le package deHamacApplication,com.hamac, et tous ses sous-packages. Chaque classe qui porte une annotation comme@Controllerou@RestControllerest créée par Spring, puis conservée dans un registre qu’on appelle le contexte d’application, ou plus simplement le conteneur. Les objets que le conteneur crée et gère s’appellent des beans.

Vous comprenez maintenant une phrase restée en suspens au chapitre 2 : vous n’écrivez nulle partnew LeaveController(…). C’est Spring qui crée le contrôleur. Pour cela, il lit son constructeur, cherche dans le conteneur un bean pour chacun de ses paramètres, puis l’appelle avec ces beans. Les deux repositories en font partie : Spring Data JPA en a généré l’implémentation au démarrage et l’a enregistrée comme bean.

Confiez la création des objets au conteneur Spring

Pour que Spring crée une classe, annotez-la avec un stéréotype. Tous ont le même effet technique, enregistrer la classe comme bean, mais ils indiquent son rôle à qui lit le code :

Annotation

Rôle

Dans Hamac

@Controller,@RestController

Recevoir des requêtes HTTP

PageController,LeaveController

@Service

Porter des règles métier

LeaveService

@Component

Tout autre composant de l’application

Les politiques, le résolveur,NotificationService

@Repository

Accéder aux données, dans une classe écrite à la main

Aucune classe : Spring Data génère les repositories

Ce dernier point surprend souvent. Vous verrez@Repositorysur des interfaces Spring Data dans beaucoup de projets, mais elle y est inutile : Spring Data détecte déjà les interfaces qui étendentRepository. Cette annotation n’a de sens que sur une implémentation que vous écrivez vous-même.

Une fois vos classes annotées, voici qui crée quoi :

Objet

Créé par, dans la version intermédiaire

Créé par, à la fin de ce chapitre

Les repositories

Spring Data

Spring Data

Les politiques et le résolveur

Le constructeur du contrôleur

Le conteneur

NotificationService

Le constructeur du contrôleur

Le conteneur

LeaveService

Le constructeur du contrôleur

Le conteneur

LeaveController

Le conteneur

Le conteneur, qui lui fournit son service

Une fois les services déclarés, le contrôleur n’a plus qu’à demander ce dont il a besoin :

private final LeaveService leaveService;

public LeaveController(LeaveService leaveService) {
    this.leaveService = leaveService;
}

À chaque démarrage, Spring crée le contrôleur. Pour satisfaire son constructeur, il crée unLeaveService. Pour satisfaire celui du service, il fournit les deux repositories, le résolveur et leNotificationService, en tant queLeaveNotifier. Vous n’avez écrit aucune de ces étapes : le conteneur a lu les constructeurs et reconstitué l’arbre des dépendances.

Retenez trois règles, que vous appliquerez à toutes vos classes :

  • les dépendances sont des champsfinal, affectés dans le constructeur : une fois l’objet créé, elles ne changent plus et ne peuvent pas valoirnull;

  • la classe n’a qu’un seul constructeur : Spring l’utilise automatiquement ;

  • vous n’écrivez pas@Autowired: avec un constructeur unique, cette annotation est inutile depuis longtemps.

Faut-il créer une interfaceLeaveServiceet une classeLeaveServiceImpl, comme dans beaucoup de projets Spring ? 

Ce n’est pas nécessaire ici. Il n’existe qu’une implémentation du service, et le contrôleur est testé à travers l’API, avec le vrai service. Une interface sans second usage ajoute un fichier sans réduire aucun risque. Vous la créerez le jour où un besoin concret apparaîtra.

Reste le résolveur. Au chapitre précédent, il recevait une liste construite à la main dans le contrôleur. Vous pourriez déplacer cette liste ailleurs, mais le conteneur propose mieux : quand un constructeur demande uneListd’une interface, Spring lui fournit tous les beans qui implémentent cette interface.

Le choix fait au chapitre 3 porte ici ses fruits. Annotez les trois politiques et le résolveur avec@Component: le résolveur reçoit automatiquement les trois politiques, sans qu’aucune ligne ne les énumère. Ajouter les stages se résumera à créer une classe annotée@Component. Le résolveur, le service et le contrôleur ne changeront pas : le principe ouvert/fermé est mieux respecté qu’au chapitre précédent.

Cette souplesse a un revers : une politique oubliée, ou deux politiques pour le même contrat après un copier-coller, ne provoquent plus d’erreur de compilation. Profitez du constructeur du résolveur pour vérifier la configuration :

public LeavePolicyResolver(List<LeaveEntitlementPolicy> policies) {
    for (var type : ContractType.values()) {
        var count = policies.stream().filter(policy -> policy.supports(type)).count();
        if (count != 1) {
            throw new IllegalStateException(count + " leave policies found for " + type + ", expected 1");
        }
    }
    this.policies = List.copyOf(policies);
}

Comme Spring crée le résolveur au démarrage, une erreur de configuration empêche l’application de démarrer, au lieu de produire un calcul faux le jour où un salarié concerné consulte son solde.

Par défaut, Spring crée une seule instance de chaque bean, partagée par toute l’application : on dit que le bean est un singleton. Le mêmeLeaveServicetraite donc toutes les requêtes, y compris celles de deux managers qui approuvent une demande au même moment.

Ce choix est sûr tant que vos beans ne gardent aucun état propre à une requête. Les politiques ne contiennent que des constantes, et le service ne conserve que des références vers d’autres beans : tout va bien. Les repositories sont eux aussi des singletons, car Spring les relie automatiquement à la transaction en cours. Mais imaginez un champprivate Employee currentEmployeedansLeaveService, affecté au début d’approve: deux requêtes simultanées écriraient dans le même champ, et l’une approuverait la demande avec le salarié de l’autre.

Sortez les paramètres des règles du code

Le message de Samuel pose un problème concret. Le taux des CDD est une constante,DAYS_PER_FULL_MONTH = 2.08, dansFixedTermContractPolicy. Pour appliquer le nouveau taux au 1er janvier, il faudrait modifier le code, le recompiler, relancer les tests et livrer une nouvelle version, pour une simple valeur décidée par les RH. Et tant que l’accord n’est pas signé, vous ne pouvez même pas préparer cette livraison.

Un taux de ce type n’est pas une règle, c’est un paramètre de la règle. La règle, « 2,08 jours par mois complet », reste dans le code ; la valeur 2,08 doit pouvoir changer sans lui.

Spring Boot sait associer des propriétés de configuration à un objet Java. Déclarez unrecordqui décrit les paramètres des congés :

@ConfigurationProperties("hamac.leave")
public record LeaveProperties(double fixedTermDaysPerFullMonth) {

    public LeaveProperties {
        if (fixedTermDaysPerFullMonth <= 0) {
            throw new IllegalArgumentException("hamac.leave.fixed-term-days-per-full-month must be positive");
        }
    }
}

Ajoutez la valeur dansapplication.properties:

hamac.leave.fixed-term-days-per-full-month=2.08

Le préfixehamac.leavede l’annotation, suivi du nom du composant écrit en minuscules avec des tirets, donne le nom de la propriété. Pour que Spring Boot crée ce record au démarrage, ajoutez@ConfigurationPropertiesScansurHamacApplication. Le record devient alors un bean comme les autres, que la politique des CDD reçoit par son constructeur :

private final double daysPerFullMonth;

public FixedTermContractPolicy(LeaveProperties properties) {
    this.daysPerFullMonth = properties.fixedTermDaysPerFullMonth();
}

Le constructeur compact du record vérifie la valeur dès sa création. Une faute de frappe dans le fichier, comme un taux négatif, empêche l’application de démarrer au lieu de priver les salariés de leurs droits.

Le jour où l’accord sera signé, il suffira de changer une ligne de configuration. En production, on ne modifie d’ailleurs même pas le fichier : une variable d’environnement, iciHAMAC_LEAVE_FIXEDTERMDAYSPERFULLMONTH, remplace la valeur du fichier sans toucher au code livré.

J’ai vu des exemples qui utilisent@Value("${hamac.leave.fixed-term-days-per-full-month}")directement sur un paramètre du constructeur. Pourquoi un record ? 

@Valuefonctionne pour une valeur isolée. Mais les paramètres des règles RH vont se multiplier : le plafond des stages, peut-être un jour le nombre de jours de l’alternance. Avec@Value, leurs noms seraient éparpillés dans des chaînes de caractères, sans vérification par le compilateur. Le record les regroupe en un seul endroit, typé et immuable, qui documente à lui seul tout ce qu’on peut configurer.

Accédez aux données avec Spring Data JPA

Vous utilisezEmployeeetLeaveRequestdepuis le début du cours sans vous être arrêté sur leur fonctionnement. C’est le moment, car le problème signalé par Karim en dépend.

JPA (Jakarta Persistence API) est la norme Java qui associe des classes à des tables. Hibernate en est l’implémentation utilisée par Spring Boot. Voici l’entitéLeaveRequestdu starter :

@Entity
public class LeaveRequest {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private Long employeeId;
    private LocalDate startDate;
    private LocalDate endDate;
    private int workingDays;
    private String status;

    // getters et setters
}

@Entityassocie la classe à la tableleave_request.@Iddésigne la clé primaire, et@GeneratedValuelaisse la base en générer la valeur à l’insertion. Deux contraintes de JPA piègent régulièrement les développeurs :

  • une entité doit avoir un constructeur sans argument, que Hibernate utilise pour créer les objets à partir des lignes de la table.LeaveRequestn’en déclare aucun : Java lui fournit ce constructeur implicitement. Si vous ajoutez un jour un constructeur avec paramètres, gardez aussi un constructeur sans argument ;

  • une entité ne peut pas être unrecord. Hibernate doit pouvoir modifier ses champs après sa création, ce qu’un record interdit. Les records restent parfaits pour tout ce qui ne fait que transporter des données, commeLeaveProperties.

Au chapitre 3, vous avez réduitEmployeeRepositoryaux deux méthodes utilisées, et vous avez constaté que Spring Data générait toujours son implémentation. Le mécanisme est le suivant : au démarrage, Spring Data repère les interfaces qui étendentRepository, analyse le nom de chacune de leurs méthodes et en déduit la requête à exécuter.

findByIdetsavesont des méthodes connues. Mais vous pouvez aussi déclarer des méthodes dérivées, dont le nom décrit la requête :

List<LeaveRequest> findByStatus(String status);
List<LeaveRequest> findByEmployeeIdAndStatus(Long employeeId, String status);

Spring Data traduitfindByStatusenselect … from leave_request where status = ?. Vous n’écrivez aucune requête, et une faute de frappe dans un nom de propriété empêche l’application de démarrer. Vous utiliserez ce mécanisme au chapitre 5, pour lister les demandes en attente. Vous verrez alors qu’une méthode dérivée peut aussi renvoyer directement unrecordqui ne contient que les colonnes utiles, plutôt que l’entité entière : on parle de projection.

Observez les requêtes SQL

Pour comprendre la lenteur signalée par Karim, il faut voir ce que Hibernate envoie réellement à la base. Ajoutez cette ligne dansapplication.properties:

logging.level.org.hibernate.SQL=debug

Relancez l’application, puis approuvez une demande aveccurl. Dans la console, vous voyez apparaître la requête exécutée parleaveRequestRepository.findAll()(simplifiée ici) :

select lr.id, lr.employee_id, lr.end_date, lr.start_date, lr.status, lr.working_days
from leave_request lr

Aucune clausewhere: la base renvoie toutes les demandes de congés.findAll()charge chaque ligne dans une entité, et lefilterqui suit cherche ensuite la bonne demande en Java. Avec les quelques demandes dedata.sql, c’est imperceptible. Avec cinq années d’historique, chaque approbation transfère des dizaines de milliers de lignes pour n’en garder qu’une.

Corrigez le filtrage en mémoire

La règle à retenir est simple : ce que vous déclarez dans le repository est traduit en SQL ; ce que vous faites ensuite sur le résultat s’exécute en Java. Pour que la base fasse le tri, le critère doit donc faire partie de la méthode du repository.

RéduisezLeaveRequestRepositorycomme vous l’avez fait pourEmployeeRepository, en déclarantfindByIdetsave, puis utilisezfindByIddans le service :

var found = leaveRequestRepository.findById(requestId);

La requête générée contient désormais le filtre :

select lr.id, lr.employee_id, lr.end_date, lr.start_date, lr.status, lr.working_days
from leave_request lr
where lr.id = ?

findByIdrenvoie unOptional: une demande inexistante est unOptionalvide, jamaisnull. LeorElse(null)du starter, qui provoquait uneNullPointerException, n’a plus de raison d’être.

Confiez la transaction au service

Relisezapprove: la méthode enregistre la demande, puis le salarié. Si le second enregistrement échoue, le premier est déjà en base. La demande est approuvée, mais les jours n’ont pas été décomptés du solde.

Une transaction regroupe plusieurs opérations sur la base en un tout indivisible : soit elles réussissent toutes, soit aucune n’est conservée. Avec Spring, il suffit d’annoter la méthode :

@Transactional
public ApprovalResult approve(long requestId) {

Spring ouvre une transaction au début de la méthode et la valide à la fin, ou l’annule si une exception est levée. C’est au service de porter cette annotation : c’est lui qui sait quelles opérations forment un tout du point de vue métier. Un contrôleur qui ouvrirait la transaction mélangerait à nouveau HTTP et règles métier ; un repository ne connaît qu’une table à la fois.

Vous comprenez aussi la lignespring.jpa.open-in-view=falsedu starter. Sans elle, Spring Boot garderait une connexion ouverte pendant toute la requête HTTP, et des requêtes SQL pourraient partir depuis le contrôleur ou la vue, sans que personne ne les voie. En la désactivant, vous imposez que tout accès aux données se fasse dans le service, à l’intérieur d’une transaction.

Diagnostiquez une erreur de démarrage

Le conteneur vous libère de l’assemblage manuel, mais il déplace une partie des erreurs. Une dépendance oubliée ne provoque plus d’erreur de compilation : elle se révèle au démarrage. La bonne nouvelle, c’est que Spring Boot crée tous les singletons au démarrage : une erreur de configuration empêche l’application de démarrer, et vos tests, qui démarrent l’application, échouent aussitôt.

Les messages commencent tous parAPPLICATION FAILED TO START, suivi d’une description et d’une action suggérée. Lisez-les toujours de la même façon : repérez la classe que Spring essayait de créer, puis le type qu’il n’a pas su fournir.

Vous avez oublié@ComponentsurNotificationService. Ou votre IDE a créé la classe dans un packagenotificationà la racine desrc/main/java, hors decom.hamac: Spring ne l’a jamais scannée. Dans les deux cas, le message est le même :

Description:

Parameter 3 of constructor in com.hamac.service.LeaveService required a bean of type 'com.hamac.service.LeaveNotifier' that could not be found.

Action:

Consider defining a bean of type 'com.hamac.service.LeaveNotifier' in your configuration.

« Parameter 3 » désigne le quatrième paramètre du constructeur, car le compte commence à 0. Vérifiez d’abord l’annotation, puis le package de la classe : il doit commencer parcom.hamac.

Pour travailler sans envoyer de vraies notifications, un collègue a ajouté une classeLoggingNotifier, annotée@Component, qui implémente elle aussiLeaveNotifier. Spring trouve désormais deux candidats pour le même paramètre :

Description:

Parameter 3 of constructor in com.hamac.service.LeaveService required a single bean, but 2 were found:
	- loggingNotifier: defined in file [.../LoggingNotifier.class]
	- notificationService: defined in file [.../NotificationService.class]

Action:

Consider marking one of the beans as @Primary, updating the consumer to accept multiple beans, or using @Qualifier to identify the bean that should be consumed

Le message propose trois solutions.@Primary, placée sur l’une des deux classes, la désigne comme choix par défaut.@Qualifier("loggingNotifier"), placée sur le paramètre du constructeur, désigne précisément le bean attendu. Accepter plusieurs beans, c’est ce que fait déjà le résolveur avec saList: pour les politiques, la pluralité est voulue. Pour le notificateur, elle ne l’est pas. SiLoggingNotifierne sert qu’en développement, le plus simple est encore de ne pas la laisser dans le code de production.

Pour son récapitulatif hebdomadaire,NotificationServicea besoin des soldes. Un développeur lui injecte doncLeaveService, qui dépend lui-même deNotificationService:

Description:

The dependencies of some of the beans in the application context form a cycle:

┌─────┐
|  leaveService defined in file [.../LeaveService.class]
↑     ↓
|  notificationService defined in file [.../NotificationService.class]
└─────┘

Action:

Relying upon circular references is discouraged and they are prohibited by default. Update your application to remove the dependency cycle between beans. As a last resort, it may be possible to break the cycle automatically by setting spring.main.allow-circular-references to true.

Spring refuse les dépendances circulaires par défaut. Le message mentionne une propriété qui les autorise, mais la présente comme un dernier recours, et c’est un euphémisme. Un cycle est un signal de conception : deux classes ont besoin l’une de l’autre parce qu’une responsabilité est mal placée. Ici, le calcul du solde intéresse deux classes : il mérite d’être extrait dans un bean dont elles dépendront toutes les deux.

Rangez le code par fonctionnalité

Hamac range encore ses classes par couche technique : un packagecontroller, un packageservice. Ce découpage semble logique, mais il disperse chaque fonctionnalité dans tout le projet. Pour comprendre les congés, il faut ouvrir trois packages, et toutes les classes doivent êtrepublicpour se voir d’un package à l’autre.

On range plutôt aujourd’hui le code par fonctionnalité, avec les couches à l’intérieur de chaque package :

src/main/java/com/hamac/
├── HamacApplication.java
├── employee/
│   ├── ContractType.java
│   ├── Employee.java
│   └── EmployeeRepository.java
├── leave/
│   ├── ApprovalResult.java
│   ├── ApprenticeshipPolicy.java
│   ├── FixedTermContractPolicy.java
│   ├── LeaveController.java
│   ├── LeaveEntitlementPolicy.java
│   ├── LeaveNotifier.java
│   ├── LeavePolicyResolver.java
│   ├── LeaveProperties.java
│   ├── LeaveRequest.java
│   ├── LeaveRequestRepository.java
│   ├── LeaveService.java
│   └── PermanentContractPolicy.java
├── notification/
│   └── NotificationService.java
└── web/
    └── PageController.java

Les couches sont toujours là :LeaveControllerappelleLeaveService, qui appelleLeaveRequestRepository. Mais l’encapsulation de Java sert enfin à quelque chose. Une classe sans modificateur d’accès est package-private : seules les classes du même package la voient. Les politiques, le résolveur, le service et le repository des demandes n’ont rien à faire hors du packageleave: retirez leurpublic. Ne restent publics que les types dont une autre fonctionnalité a besoin, commeEmployee,EmployeeRepositoryouLeaveNotifier, queNotificationServiceimplémente depuis son propre package. Spring, lui, crée sans difficulté des beans package-private.

Remarquez le sens de cette dernière dépendance : c’estnotificationqui dépend deleave, et non l’inverse. Le package des congés définit le contrat dont il a besoin, et la notification s’y conforme. C’est l’inversion des dépendances du chapitre 3, à l’échelle des packages.

À vous de jouer

Inès souhaite livrer avant la fin de la semaine, et Samuel a prévenu Karim. Elle vous demande de traiter les trois sujets dans la même livraison, mais en commits distincts, un par sujet, puis un dernier pour la réorganisation des packages. Le comportement de l’API ne doit pas changer.

Commit 1, l’injection :

  1. AnnotezLeaveServiceavec@Service, et les trois politiques, le résolveur etNotificationServiceavec@Component.

  2. Ajoutez au constructeur du résolveur la vérification « une politique par type de contrat ».

  3. Remplacez le constructeur deLeaveControllerpar une injection du service. Lancez les tests.

  4. DansLeaveApprovalTests, remplacez le notificateur par une doublure avec@MockitoBean, et ajoutez un test qui vérifie qu’une approbation notifie le salarié.

Commit 2, les paramètres :

  1. Créez le recordLeaveProperties, ajoutez@ConfigurationPropertiesScanet la propriétéhamac.leave.fixed-term-days-per-full-month.

  2. Faites recevoirLeavePropertiesàFixedTermContractPolicy, puis adaptez son test unitaire.

Commit 3, l’accès aux données :

  1. Activez le journal SQL, approuvez une demande et repérez la requête qui charge toute la table.

  2. RéduisezLeaveRequestRepository, utilisezfindByIddans le service et vérifiez la nouvelle requête dans le journal.

  3. Annotezapproveavec@Transactional.

Commit 4, les packages :

  1. Réorganisez le code en packagesemployee,leave,notificationetweb, puis réduisez la visibilité de tout ce qui peut l’être.

Point de contrôle : le mot-clénewn’apparaît plus nulle part pour créer un service. Le taux des CDD se lit dansapplication.properties. Le journal SQL montre une clausewherelors de l’approbation../mvnw testse termine parBUILD SUCCESS, sans qu’aucune vraie notification ne soit envoyée. Enregistrez votre travail avec Git.

En résumé

  • @SpringBootApplicationdéclenche l’auto-configuration, qui configure ce que permettent les dépendances dupom.xml, et le scan des composants du packagecom.hamacet de ses sous-packages. Le rangement par fonctionnalité, avec des classes package-private, garde les couches tout en rendant l’encapsulation de Java utile.

  • Le conteneur crée les beans, singletons par défaut qui ne doivent garder aucun état propre à une requête, et les assemble en lisant leurs constructeurs : dépendances en champsfinal, constructeur unique, sans@Autowired. Quand un constructeur demande uneListd’une interface, Spring fournit toutes ses implémentations. 

  • Les paramètres des règles métier se regroupent dans unrecordannoté@ConfigurationProperties, et changent sans recompiler.

  • Avec Spring Data JPA, ce que vous déclarez dans le repository est traduit en SQL ; unfindAll()suivi d’unfilterfait trier en mémoire ce que la base aurait dû trier. La transaction se porte dans le service, avec@Transactional.

  • Une erreur de démarrage se lit toujours de la même façon : quelle classe Spring essayait-il de créer, et quel type n’a-t-il pas su fournir ?

Hamac s’appuie désormais sur son framework, et l’approbation ne charge plus toute la table des demandes. Il reste un défaut que vous avez repéré dès le chapitre 2 : une simple requête GET suffit à approuver une demande, et l’API répond 200 même en cas d’erreur. Dans le prochain chapitre, vous allez reprendre le contrat de l’API : routes, verbes, statuts, DTO et validation.

Ever considered an OpenClassrooms diploma?
  • Up to 100% of your training program funded
  • Flexible start date
  • Career-focused projects
  • Individual mentoring
Find the training program and funding option that suits you best