Configuration avancée

Introduction

Nous traitons dans ce chapitre des éléments plus complexes de Spring. Nous commencerons par les ressources, nous continuerons par les convertisseurs et les formateurs, et nous terminerons par les bindeurs et les validateurs.

Ces éléments sont utilisables dans un contexte d’application standalone et dans un contexte d’application web.

Les fichiers de ressources

Une ressource est, par exemple, un fichier texte. Nous verrons dans un premier temps l’utilisation normale des fichiers de ressources en Java. Nous verrons ensuite comment charger un fichier de ressources avec Spring via le contexte Spring. Nous verrons, enfin, comment utiliser le ResourceLoaderAwarequi est une interface à implémenter par tout objet souhaitant être averti du ResourceLoader (généralement le ApplicationContext) dans lequel il s’exécute.

1. Les fichiers de ressources standards

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

@Log 
public class Ressources1 { 
   public static void traiterRessource(Resource resource) { 
      try { 
         InputStream is = resource.getInputStream(); 
         BufferedReader br = new BufferedReader(new InputStreamReader(is)); 
         String ligne; 
         while ((ligne = br.readLine()) != null) { 
            log.info(ligne); 
         } 
         br.close(); 
      } catch (IOException e) { 
         e.printStackTrace(); 
      } 
   } 
   public...

Convertisseurs et formateurs

Spring manipule souvent les valeurs à travers l’utilisation des chaînes de caractères. C’est le cas quand nous avons une configuration dans un fichier texte, par exemple un fichier XML. Ce principe est également utilisé quand Spring échange des données entre les différentes parties d’une application comme dans le cas de Spring MVC pour lequel les données en provenance et à destination des vues, que ce soient des pages JSP ou des pages JSF, circulent au format texte.

Un convertisseur peut transformer un objet en String mais aussi un objet d’une classe en une autre classe.

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 générique

GenericConversionService cs = new DefaultConversionService();

a. Pour les types standards

Pour les types standards, nous utiliserons les convertisseurs disponibles.

L’exemple suivant présente la conversion suivie du test unitaire associé :

Boolean booleen = cs.convert("true", Boolean.class); 
assertTrue(booleen); 
 
booleen = cs.convert("no", Boolean.class); 
assertFalse(booleen); 
 
Character car = null; 
car = cs.convert("Z", Character.class); 
assertEquals(new Character('Z'), car); 
 
try { 
   car = cs.convert("Exception", Character.class); 
   fail("Devrait lever une exception car la chaine n'est pas un  
caractère !"); 
} catch (ConversionFailedException aExp) { 
assert (aExp.getMessage() 
.contains("Failed to convert from type java.lang.String to type  
java.lang.Character")); 
} 
Integer entier = cs.convert("43210", Integer.class); 
assertEquals(new Integer(43210), entier); 
 
Float flottant = cs.convert("123.456f", Float.class); ...

Les BeanWrappers, le binding et les 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

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.