Configuración avanzada

Introducción

En este capítulo abordaremos los elementos más complejos de Spring. Comenzaremos por los recursos, continuaremos con los conversores y formateadores y terminaremos con los binders y validadores.

Estos elementos se pueden utilizar en los contextos de aplicación standalone y aplicación web.

Archivos de recursos

Un recurso es un archivo de texto, por ejemplo. Primero veremos el uso normal de los archivos de recursos en Java. Seguidamente, veremos cómo cargar un archivo de recursos con Spring usando el contexto Spring. Para terminar, veremos cómo utilizar el ResourceLoaderAware, que es una interfaz que debe implementar cualquier objeto que desee ser notificado por el ResourceLoader (generalmente, ApplicationContext) en el que se ejecuta.

1. Archivos de recursos estándares

Los archivos y las URL que hacen referencia a un archivo se pueden leer de manera estándar, como en el siguiente ejemplo:

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

Conversores y formateadores

Spring a menudo manipula los valores usando cadenas de caracteres. Este es el caso cuando tenemos una configuración en un archivo de texto; por ejemplo, un archivo XML. Este principio también se utiliza cuando Spring intercambia datos entre las diferentes partes de una aplicación, como en el caso de Spring MVC, para el que los datos hacia y desde las vistas, ya sean páginas JSP o páginas JSF, circulan en formato de texto.

Un conversor puede transformar un objeto en String, pero también un objeto de una clase a otra.

1. Built-in converters

Un built-in converter es un conversor integrado. Usamos la clase Spring GenericConversionService para tener los conversores estándar. Esta clase permite disponer de un servicio de conversión que se puede extender con conversores personalizados.

En el siguiente ejemplo, se muestra cómo utilizar un DefaultConversionService que implementa la clase de uso general GenericConversionService.

Declaración del conversor genérico

GenericConversionService cs = new DefaultConversionService();

a. Para los tipos estándares

Para los tipos estándares, utilizaremos los conversores disponibles.

En el siguiente ejemplo se presenta la conversión, seguida de la prueba unitaria asociada:

Boolean buleano = cs.convert("true", Boolean.class); 
assertTrue(buleano); 
 
buleano = cs.convert("no", Boolean.class); 
assertFalse(buleano); 
 
Caracter car = null; 
car = cs.convert("Z", Caracter.class); 
assertEquals(new Caracter('Z'), car); 
 
try { 
   car = cs.convert("Exception", Caracter.class); 
   fail("Debe generar una excepción porque la cadena no es un 
carácter"); 
} catch (ConversionFailedException aExp) { 
assert (aExp.getMessage() 
.contains("Failed to convert from type java.lang.String to type 
java.lang.Caracter")); 
} 
Integer entero = cs.convert("43210", Integer.class); 
assertEquals(new Integer(43210), entero); 
 
Float flotante = cs.convert("123.456f", Float.class); 
assertEquals(new Float(123.456f), flotante);

b. Para tablas y listas

Para las tablas y las listas, podemos utilizar directamente String[].class o List.class en el argumento Class<T>...

BeanWrappers, binding y validadores

Los wrappers, el binding y la validación se utilizan juntas y es muy habitual en las aplicaciones Spring MVC.

1. Clase LosBeanWrappers

En este ejemplo se muestran las posibilidades de la clase BeanWrapperImpl:

@Log 
public class LosBeanWrappers { 
   public static void main(String[] args) {  
      //Utilización del BeanWrapper 
      Usuario usuario = new Usuario(); 
        BeanWrapper bw = new BeanWrapperImpl(usuario); 
        bw.setPropertyValue("nombre", "John"); 
        bw.setPropertyValue("apellido", "DOE"); 
        bw.setPropertyValue("id", "200"); 
        final int id=200; 
        log.info("Verificación:"+(id==usuario.getId())+  
"Usuario="+usuario); 
        try { 
            bw.setPropertyValue("id", "no es numérico"); 
        } catch (TypeMismatchException...

Puntos clave

Los conversores, binders, BeanWrappers y validadores son fáciles de usar con Spring.
Es necesario pensar en términos globales para reutilizar estas herramientas de conversión tanto como sea posible.
Es necesario utilizar las posibilidades de externalizar valores en archivos .properties para personalizar la configuración de Spring en función de elementos externos.