Conversión y validación en JSF

2
117318

VALIDACIONES Y CONVERSIONES EN JSF

Introducción

En este tutorial veremos como JSF proporciona mecanismos
para el formateo, conversión y validación de los componentes; veremos como estos
mecanismos pueden ser extendidos de forma sencilla para adaptarlos a nuestras
necesidades.  La primera parte del
tutorial estará dedicada al formateo y conversión y la segunda a la Validación.

 

Para entender en qué momento de la vida de una página JSF se
producen las conversiones y validaciones de los componentes del formulario,
quizá nos sea de ayuda el siguiente diagrama:

JSF proporciona dos mecanismos separados que nos ayuda a
validar los valores introducidos por los usuarios a la hora de submitir los
formularios:

  • El
    primer mecanismo es el de conversión
    y está definido por el interfaz javax.faces.convert.Converter
    y sus múltiples implementaciones. Las
    conversiones aseguran que el tipo de un dato introducido en un formulario
    JSF sea el correcto
    , es decir, que el dato tipo cadena del formulario
    corresponde con el tipo JAVA esperado, y que está especificado en la
    propiedad correspondiente del bean. Los Conversores (implementaciones de la interfaz Converter) son los componentes que
    se encargan de hacer estas transformaciones (cadena>Tipo JAVA y viceversa).
    JSF invoca a los Conversores
    antes de efectuar las validaciones y por lo tanto antes de aplicar los
    valores introducidos a las propiedades del bean. En el caso de que un dato
    tipo cadena no se corresponda con el tipo JAVA apropiado, el Conversor correspondiente lanzará
    un ConversionException y el
    componente se marcará como invalidado.
  • El segundo
    mecanismo es el de validación y
    está definido por la interfaz javax.faces.validator.Validator
    y sus múltiples implementaciones. El proceso de validación se asegura que
    el dato introducido en el correspondiente componente es correcto según la
    lógica de la aplicación. El proceso de validación ocurre antes de que el
    FrameWork asigne los valores introducidos en el formulario a las
    propiedades del bean y justo después de que se hayan aplicado las
    conversiones, en el caso de que haya. Las
    validaciones aseguran que un dato introducido en un formulario JSF tenga
    un valor correcto
    .

 

Los mensajes que lanzan tanto los Conversores como lo
Validadores en el caso de excepción se pueden mostrar en el formulario
correspondiente a través de la etiqueta messages.

 

A continuación vamos a ver 4 casos prácticos:

  • Un
    ejemplo de conversión utilizando un conversor estándar de JSF.
  • Un
    ejemplo de conversión realizada por un conversor que creemos nosotros.
  • Un
    ejemplo de validación utilizando un validador estándar de JSF.
  • Un
    ejemplo de validación utilizando un validador creado por nosotros.

 

Herramientas utilizadas

  • Sistema
    operativo: Windows XP Professional.
  • Servidor
    Web: Apache Tomcat 5.5.9
  • Entorno
    de desarrollo: Eclipse 3.1.1 con ExadelStudio-3[1].0.5

Preparamos el entorno

Seguiremos los siguientes pasos:

1.     
Creamos un
nuevo proyecto JSF en Eclipse
, al que llamaremos PruebaValidaciones. Indicaremos durante la creación que el entorno JSF
es MyFaces 1.1.0. La estructura de directorios que nos queda es la siguiente:

 

2.     
Creamos la
página index.jsp en el directorio WebContent
: redireccionará a la página home.jsf

 

3.     
Creamos la
página home.jsp en el directorio WebContent
: esta página tendrá enlaces a los diferentes ejemplos
que vamos a hacer:

 

Y si probamos lo poco que hemos hecho:

Los ejemplos que vamos a hacer a partir de este momento partirán de esta
página.

Primer ejemplo:
usando un conversor estándar

Antes
de nada debemos tener en cuenta que los conversores estándar que proporciona
JSF se dividen en conversores a tipos numéricos (NumberConverter) y conversores a tipos Fecha (DateTimeConverter)

 

Existen
dos formas de indicar que el valor de un determinado componente de nuestra
página va a ser “convertido”:

·       
Añadiendo el
atributo converter=”#{identificador_conversor}” 
al componente. Sólo los componentes del tipo UIInput (inputText, inputSecret, inputHidden) y outputText aceptan esta propiedad. Un  ejemplo sería el siguiente:

JSF deja a nuestra
disposición los siguientes conversores estándar:

 

TIPO DE CONVERSOR

IDENTIFICADOR DEL CONVERSOR

BigDecimalConverter

BigDecimal

BigIntegerConverter

BigInteger

NumberConverter

Number

IntegerConverter

Integer

ShortConverter

Short

ByteConverter

Byte

CharacterConverter

Character

FloatConverter

Float

DoubleConverter

Double

BooleanConverter

Boolean

DateTimeConverter

DateTime

 

 

·       
Incluyendo <f:convertNumber  [lista_atributos]/> o <f:convertDateTime  [lista_atributos]/> dentro de la
invocación al componente, como por ejemplo:

Los
atributos disponibles para tipos number
son:

 

NOMBRE DEL ATRIBUTO

TIPO

currencyCode

String

currencySymbol

String

groupingUsed

boolean

integerOnly

boolean

locale

java.util.Locale

maxFractionDigits

int

maxIntegerDigits

Int

minFractionDigits

Int

minIntegerDigits

int

pattern

String

type

String

 

Y los
disponibles para tipos DateTime:

NOMBRE DEL ATRIBUTO

TIPO

dateStyle

String

parseLocale

String o Locale

pattern

String

timeStyle

String

timeZone

String o TimeZone

type

String

 

1.     
Vamos a crear por fin el bean

La clase se llama com.autentia.tutorialValidacion.GestionUsuariosBean.java, cuelga del
directorio JavaSource  y de momento tiene la siguiente pinta:

 

 

Y
lo registramos en el fichero descriptor de JSF (WEB-INF/validaciones-config.xml)

 

2.     
Creamos la página

La
llamamos conversion_estandar.jsp y
cuelga de WebContent:

 

 

Como
vemos, es muy sencillo utilizar los conversores estándar y cualquier
explicación sobra. Para que el botón de Validar
funcione, debemos añadir la correspondiente regla de navegación en el fichero WEB-INF/validaciones-config.xml:

 

 

Y
para que el ejemplo nos quede chulo, creamos la página que dice que dice que
todo ha ido bien y muestra los valores introducidos por el usuario:

 

 

Por
ultimo, para completar el ejemplo, añadimos la navegabilidad para el botón de volver, que retornará a la página home.jsp:

 

 

3.     
Probamos

Vamos
a introducir todos los valores incorrectos y vemos cual es el resultado:

 

 

Y
ahora con valores correctos (bueno, menos la edad y el sueldo, pero eso no hay
forma que lo conozcan los conversores de JSF ;-) ):

 

Segundo ejemplo:
creando nuestro propio conversor

Para
crear nuestro propio conversor, debemos seguir los siguientes pasos:

o       Crear una clase que implemente la interfaz javax.faces.convert.Converter.

o       Implementar el método getAsObject, que convierte el valor del componente que tengamos en
la página (tipo cadena) a un objeto (tipo JAVA que requiera la aplicación).

o       Implementar el método getAsString, que convierte el objeto (tipo JAVA de nuestra
aplicación) a tipo cadena (requerido por la página).

o       Registrar el nuevo conversor en el contexto de JSF.

o       Utilizarlo en la página insertando dentro del
componente cuyo valor queramos convertir el tag <f:converter>.

 

1.     
Qué va hacer nuestro conversor

Va a desglosar un número de teléfono de tipo:

   91-888 33 66

En dos partes:

   Prefijo = 91

   Número de teléfono= 888 33 66

El conversor lanzará excepciones si:

·       
No se introduce el guión para separar el prefijo del número

·       
Si el prefijo no consta de 2 números

·       
Si el número no consta de 7 números. Los espacios entre los números se
ignorarán

 

2.     
Creamos el conversor

Como hemos indicado antes, debe implementar la interfaz Converter y los métodos getAsObject
y getAsString.
Vamos a llamarlo TelefonoConverter. Para este ejemplo he
utilizado la librería commons-lang de
Yakarta que nos la podemos descargar desde la página
http://jakarta.apache.org/site/downloads/downloads_commons-lang.cgi.
La he incorporado al paquete lib y he actualizado el classpath de la aplicación.

 

El método getAsObject va a devolver la instancia
de una nueva clase Telefono.java que
tiene la siguiente pinta:

 

 

Y por fin la clase TelefonoConverter:

 

 

 

3.     
Adaptamos el bean GestionUsuariosBean para probar
nuestro conversor

Añadimos un nuevo atributo de tipo Telefono
al bean:

 

 

4.     
Registramos el nuevo conversor en el contexto de JSF

Para ello editamos el fichero WEB-INF/validaciones-config.xml
y ponemos lo siguiente:

 

 

5.     
Creamos la página conversión_nuestra.jsp
que cuelga de WebContent:

 

 

Y también añadimos la navegabilidad necesaria para que, una vez
convertido el valor, la aplicación vaya a la página de resultados (resultado_conversion_nuestra) y para que
desde esta página de resultados podamos volver a la página home (home)

 

6.     
Y probamos:

Tercer ejemplo:
utilizando validaciones estándar de JSF

En la primera parte
de este tutorial hemos visto como los Conversores
pueden cubrir gran parte de la funcionalidad necesaria para validar que los
valores introducidos por los usuarios en un formulario JSF sean correctos.

 

En adición, los Validadores pueden realizar validaciones
más genéricas durantes la fase de Validación. Estos componentes implementan la
interfaz javax.faces.validator.Validator,
que contiene un único método validate(). JSF
provee un conjunto de Validadores
estándar que se describen en la tabla siguiente:

 

CLASE DE VALIDADOR

TAG JSF

ATRIBUTOS

DESCRIPCIÓN

DoubleRangeValidator

validateDoubleRange

minimum,maximum

Valida que el valor del componente sea mayor
que un mínimo y mayor que un máximo. Este valor debe ser tipo float

LengthValidator

validateLength

minimum,maximum

Valida que la longitud del valor del
componente esté entre un mínimo y un máximo

LongRangeValidator

validateLongRange

minimum,maximum

Valida que el valor del componente sea mayor
que un mínimo y mayor que un máximo. Este valor debe ser tipo entero

 

Además, myFaces
proporciona los siguientes Validadores
como adición a los anteriores:

 

CLASE DE VALIDADOR

TAG JSF

ATRIBUTOS

DESCRIPCIÓN

EmailValidator

validateEmail

 

Valida que el valor del componente tenga un
formato tipo email

CreditCardValidator

validateCreditCard

none(true|false), amex(true|false), visa(true|false), mastercard(true|false),
discover(true|false)

Valida que el valor del componente corresponde
con el número de los siguientes tipos de tarjetas de crédito: American
Express, Discover, Mastercard, Visa.

RegExprValidator

validateRegExpr

pattern

Valida que el valor del componente se
corresponde con el patrón especificado como atributo

EqualValidator

validateEqual

for

Valida que el valor del componente sea
exactamente igual al valor del componente cuyo id se corresponde con el atributo for.

 

1.     
Preparamos el bean GestionUsuariosBean para el ejemplo

Vamos a efectuar las siguientes validaciones:

·       
Que la edad del usuario esté comprendida entre 5 y 100 años

·       
Que el nombre no tenga más de 40 caracteres

·       
Que el nuevo atributo password
debe ser igual que el campo repetición de password

 

Por lo tanto, al bean sólo le falta un nuevo
atributo password:

 

/** Password del usuario */

private String password;

public String getPassword() {

            return
password;

}

public void setPassword(String password) {

            this.password
= password;

}

 

2.     
Creamos la página

La
llamaremos validación_estandar.jsp y
colgará de WebContent:

 

 

Añadimos
la navegación en el fichero WEB-INF/validaciones-config.xml
para que el botón Validar vaya al
sitio adecuado:

 

 

3.     
El resultado

 

 

Cuarto ejemplo:
creando nuestro propio Validador

Para
crear nuestro propio Validador,
debemos seguir los siguientes pasos:

·       
Crear una clase
que implemente la interfaz javax.faces.validator.Validator.

·       
Implementar el
método validate.

·       
Registrar el
nuevo validador en el contexto de JSF.

·       
Utilizarlo en la
página insertando dentro del componente cuyo valor queramos validar el tag <f:validator>.

 

1.     
Qué va a validar nuestro Validador

 

Que
el valor de un componente se corresponde un número de NIF válido.

 

El
algoritmo que voy a utilizar para validar el NIF es el siguiente

 

·       
Compruebo que el
valor a validar tiene una longitud igual a 9. Los primeros 8 caracteres deben
ser números (corresponden al DNI) y el último debe ser una letra (la del NIF)

·       
Almaceno la
siguiente lista de letras en una variable:

“TRWAGMYFPDXBNJZSQVHLCKE”

·       
Calculo el
módulo entero de 23.

·       
Recupero de la
lista de letras la que se encuentra en la posición resultado de efectuar el
módulo entero de 23

 

 

2.     
Creamos el Validador

Como
dijimos anteriormente, debe ser una implementación del interfaz Validator:

 

 

3.     
Registramos el nuevo Validador en el contexto de JSF.

 

Para
ello, editamos el fichero descriptor WEB-INF/validaciones-config.xml
e insertamos las siguientes líneas:

 

 

4.     
Creamos la página

 

La
llamaremos validacion_nuestra.jsp  y colgará de WebContent; su contenido es el siguiente:

 

 

Añadimos
en WEB-INF/validaciones-config.xml la
navegabilidad para el botón Validar:

 

 

Y
creamos la página de resultados WebContent/resultado_validacion_nuestra.jsp:

 

 

5.     
Probamos

 

Desplegamos
la aplicación en Tomcat y vemos cual es el resultado:

 

 

 

 

 

———————————————————–

Si
necesita ayuda al plantear sus soluciones tecnológicas no dude en contactar con
nosotros a través de nuestra web www.autentia.com.
Estaremos encantados de ayudarle en su problema poniendo a su disposición a
nuestros mejores expertos a precios asequibles.

 

 

 

 

 

 

 

 

 

 

2 Comentarios

Dejar respuesta

Please enter your comment!
Please enter your name here