Blog ENI : Toute la veille numérique !
Offre estivale️ ☀️ : de -20% à -30% sur les livres en ligne et vidéos, avec le code PLAGE Cliquez ici !
Accès illimité 24h/24 à tous nos livres & vidéos ! 
Découvrez la Bibliothèque Numérique ENI. Cliquez ici
  1. Livres et vidéos
  2. Java Spring
  3. Configuration avancée Java Spring
Extrait - Java Spring Le socle technique des applications Jakarta EE (5e édition)
Extraits du livre
Java Spring Le socle technique des applications Jakarta EE (5e édition) Revenir à la page d'achat du livre

Configuration avancée Java Spring

Introduction

Ce chapitre se penche sur des aspects plus avancés de Spring Framework. Nous débuterons par une exploration des ressources, puis nous aborderons les convertisseurs et les formateurs. Le chapitre se conclura avec un examen approfondi des bindeurs et des validateurs. Il est important de noter que ces composants de Spring peuvent être appliqués aussi bien dans des applications autonomes (standalone) que dans des environnements d’application web. Cette polyvalence illustre la flexibilité et la puissance de Spring en tant que framework pour le développement d’applications Java.

Fichiers de ressources

Les fichiers de ressources, tels que les fichiers texte, jouent un rôle clé dans les applications Java. Leur utilisation et leur gestion seront expliquées dans trois parties principales.

Nous débuterons par examiner comment les fichiers de ressources sont habituellement gérés et utilisés en Java standard. Cela inclut le chargement de fichiers depuis le système de fichiers, les chemins de classe, ou d’autres sources. Nous explorerons ensuite comment Spring facilite le chargement de ces fichiers de ressources. Nous verrons comment utiliser le contexte Spring pour accéder et gérer efficacement ces ressources.

Cette partie mettra en lumière la manière dont Spring simplifie l’accès aux ressources, qu’elles soient internes ou externes à l’application. Enfin, nous aborderons l’utilisation de ResourceLoaderAware, une interface que les objets peuvent implémenter pour être notifiés du ResourceLoader qu’ils utilisent. En implémentant cette interface, un objet peut obtenir une référence au ResourceLoader (généralement le ApplicationContext) qui est actif dans son environnement d’exécution. Cela permet une interaction plus sophistiquée avec le mécanisme de chargement de ressources de Spring, offrant une plus grande flexibilité et un contrôle plus fin sur la gestion des ressources. 

1. Fichiers de ressources standards

Les fichiers et les URL désignant un fichier peuvent être lus de façon standard comme dans cet exemple :

@Slf4j 
public class Ressources1 { 
  public static void traiterRessource(Resource resource) { 
    try { 
      InputStream is = resource.getInputStream(); 
      BufferedReader br = new BufferedReader( 
        new InputStreamReader(is)); 
      String ligne; ...

Convertisseurs et formateurs

Spring utilise fréquemment des chaînes de caractères pour gérer les valeurs, particulièrement dans des contextes où la configuration est réalisée via des fichiers texte, tels que des fichiers XML. Cette approche est courante dans le cadre de la configuration et de la gestion des paramètres de l’application.

Le principe d’utilisation de chaînes de caractères s’étend également à l’échange de données entre différentes parties d’une application. Par exemple, dans Spring MVC, les données envoyées vers les vues et reçues des vues (comme des pages JSP ou JSF) sont souvent manipulées sous forme de texte.

Un convertisseur dans Spring a la capacité de transformer un objet en une chaîne de caractères (String). Mais sa fonction ne se limite pas à cela ; il peut également convertir un objet d’une classe en un objet d’une autre classe. Cette capacité est particulièrement utile pour assurer la compatibilité des données et leur bonne manipulation au sein de l’application.

En complément des convertisseurs, les formateurs (formatters) jouent un rôle similaire, mais sont souvent utilisés pour la conversion entre des types de données et des représentations textuelles formatées, par exemple, pour la gestion des dates et des nombres.

Les convertisseurs et formateurs de Spring fournissent une méthode flexible et puissante pour gérer la conversion de données au sein des applications. Ils facilitent l’intégration et l’échange de données entre différents composants de l’application, tout en assurant une gestion cohérente et efficace des formats de données.

1. Built-in converters

Un built-in converter est un convertisseur intégré. Nous utilisons la classe Spring GenericConversionService pour disposer des convertisseurs standards. Cette classe permet de disposer d’un service de conversion qu’il est possible d’augmenter par des convertisseurs personnalisés.

L’exemple suivant montre comment utiliser un DefaultConversionService qui implémente la classe généraliste GenericConversionService.

Déclaration du convertisseur...

BeanWrapper, binding et validateurs

Les wrappers, le binding et la validation sont utilisés conjointement. On rencontre beaucoup ces utilisations dans les applications Spring MVC.

1. Classe LesBeanWrappers

Cet exemple montre les possibilités de la classe BeanWrapperImpl :

@Log 
public class LesBeanWrappers { 
   public static void main(String[] args) { 
      //Utilisation du BeanWrapper 
      Utilisateur utilisateur = new Utilisateur(); 
        BeanWrapper bw = new BeanWrapperImpl(utilisateur); 
        bw.setPropertyValue("nom", "John"); 
        bw.setPropertyValue("prenom", "DOE"); 
        bw.setPropertyValue("id", "200"); 
        final int id=200; 
        log.info("Vérification :"+(id==utilisateur.getId())+ 
"Utilisateur="+utilisateur); 
        try { 
            bw.setPropertyValue("id", "pas numérique"); 
        }...

Points clés

Points à retenir :

  • Les convertisseurs, bindeurs, BeanWrappers et validateurs sont simples à utiliser avec Spring.

  • Il faut raisonner en terme global afin de réutiliser le plus possible ces outils de conversion.

  • Il faut utiliser les possibilités d’externaliser des valeurs dans des fichiers .properties pour personnaliser la configuration Spring en fonction d’éléments externes.