Struts Validator En el presente capítulo veremos el Struts Validator, un componente con funcionalidad para validar automáticamente nuestros formularios. Manejaremos sus validaciones básicas y aprenderemos a crear nuevas.
▼
C#_Struts_Validator.indd 1
Validar los formularios.................2 Definir un validador ......................5 Validaciones estándar ...................7 Validación en el cliente ...............18 Un validador propio ....................23 Validaciones multipágina ............28
Mostrar errores con estilo...........33 El ejemplo completo ...................35 ▼
Resumen .....................................41
▼
Actividades .................................42
08/09/2014 10:43
2
APÉNDICE C. STRUTS VALIDATOR
Validar los formularios En el Capítulo 5 vimos cómo programar nuestros objetos ActionForm para que se validen los datos ingresados por el usuario. Este enfoque es útil para validaciones complejas; sin embargo, la mayoría de las veces las validaciones que necesitaremos realizar en los formularios son muy simples: que un campo no quede vacío, que un campo sea numérico, que un campo contenga una fecha válida, etcétera. En estos casos, implementar el método Validate para repetir las mismas validaciones básicas es un proceso que podría simplificarse. Además, se suma el hecho de que probablemente queramos usar forms como DynaActionForm o LazyValidatorForm para evitar crear una clase por cada formulario, y, en esos casos, no tendremos dónde implementar el método Validate. Para todos estos casos, Struts Validator es la mejor herramienta a utilizar. Struts Validator es un componente muy poderoso y simple de usar para casos sencillos. No obstante esto, provee funcionalidades como para poder definir cualquier tipo de validador propio. Lo que primero debemos hacer para empezar a usar el validador es declararlo en el archivo struts-config.xml. El validador es un plugin, esto es, un componente que Struts carga al iniciarse y destruye al finalizar su ejecución. Los elementos plugin son el último tipo de elemento que definimos en el archivo de configuración. Veamos cómo definir el validador:
COMMONS VALIDATOR El componente de validación de Struts no es más que una interfaz para el proyecto Commons Validator, un proyecto de Apache. Este proyecto provee todo tipo de validaciones y se lo puede usar tanto en aplicaciones web como en cualquier otro tipo de aplicación que necesite de validaciones. Su sitio web: http://jakarta.apache.org/commons/validator.
www.redusers.com
C#_Struts_Validator.indd 2
08/09/2014 10:43
3
DESARROLLO WEB CON JAVA DESDE CERO
El elemento plugin toma un atributo de nombre className que especifica la clase (que ha de implementar la interfaz org.apache.struts.action. PlugIn) a instanciar. Dentro del cuerpo del elemento, podemos definir un conjunto de elementos set-property, que establecen valores a propiedades de la clase al instanciarse. En el caso de la clase ValidatorPlugin, las propiedades a las que podemos establecer su valor son:
•
pathnames: una lista de nombres de archivo, separados por coma, que contienen las descripciones de las validaciones a realizar. Es muy importante no olvidar agregar los archivos XML que vayamos creando a esta lista; si no, por más que definamos correctamente el resto de las configuraciones, la validación no se realizará.
ACENTOS EN ARCHIVOS DE RECURSOS En los ejemplos del capítulo omitiremos, por claridad y legibilidad, el uso de acentos en el archivo de recursos. Recordemos que podemos escribir palabras acentuadas, pero estas serán enviadas al navegador y puede que no se vean correctamente. Para usar palabras acentuadas, en el archivo de recursos debemos hacerlo usando la entidad HTML correspondiente (por ejemplo, ó para ó).
www.redusers.com
C#_Struts_Validator.indd 3
08/09/2014 10:43
4
•
APÉNDICE C. STRUTS VALIDATOR
stopOnFirstError: si es true, se detendrá la validación de JavaScript al primer error encontrado y se mostrará dicho error. Caso contrario, se validarán todos los campos y se mostrarán todos los errores juntos. Como vemos, en principio estamos definiendo solamente un archivo
de configuración de validación. El archivo validator-rules.xml (ubicado en la carpeta raíz de la distribución Library de Struts) contiene las descripciones de las validaciones básicas que provee Struts en base al proyecto Commons Validator. Estas validaciones estándar usan ciertas claves del archivo de recursos para mostrar los errores. Por eso, para su correcto uso, es necesario que agreguemos al archivo de recursos las siguientes claves (los valores podemos cambiarlos a nuestro gusto o idioma):
errors.required={0} es requerido. errors.minlength={0} no puede ser menor de {1} caracteres. errors.maxlength={0} no puede ser mayor de {1} caracteres. errors.invalid={0} es invalido. errors.byte={0} debe ser un byte. errors.short={0} debe ser un short. errors.integer={0} debe ser un integer. errors.long={0} debe ser un long. errors.float={0} debe ser un float. errors.double={0} debe ser un double. errors.date={0} no es una fecha. errors.range={0} no está en el rango {1} - {2}.
www.redusers.com
C#_Struts_Validator.indd 4
08/09/2014 10:43
5
DESARROLLO WEB CON JAVA DESDE CERO
errors.creditcard={0} es una tarjeta de credito invalida. errors.email={0} no es una direccion de correo electronico valida. errors.url={0} no es una direccion web valida.
En cuanto conozcamos cada tipo de validación, veremos cómo se utilizan estos mensajes.
Definir un validador Para definir validaciones sobre un formulario, debemos proveerle al validador un archivo XML. Técnicamente, podríamos agregar al archivo validatorrules.xml los elementos XML para las validaciones, pero es una práctica no recomendada. Una buena práctica es crear un archivo XML para cada formulario que deseemos validar. Veamos en qué consiste este archivo:
www.redusers.com
C#_Struts_Validator.indd 5
08/09/2014 10:43
6
APÉNDICE C. STRUTS VALIDATOR
datePattern MM/dd/yy
El validador internamente tiene un conjunto de objetos llamado formset. Cada elemento form, dentro de este elemento, agrega un formulario al conjunto de formularios que tendrán validación. Veamos elemento por elemento el archivo:
Mediante este elemento, declaramos que estamos definiendo la validación para el formulario de nombre proyectoForm. Este form debe existir con este nombre en el struts-config.xml. www.redusers.com
C#_Struts_Validator.indd 6
08/09/2014 10:43
7
DESARROLLO WEB CON JAVA DESDE CERO
En un formulario, podemos validar uno o más campos. Cada elemento field define un campo y las validaciones que han de realizarse sobre él cuando el formulario sea enviado. El campo que validamos lo definimos con el atributo property. Las validaciones que se efectuarán sobre el campo las definimos mediante el atributo depends. Si queremos realizar más de una validación, las escribimos separadas por comas. Un campo debe pasar todas las validaciones para que sea válido. En el cuerpo del tag field insertaremos elementos y propiedades diversas, dependiendo del tipo de validación que estemos efectuando.
Validaciones estándar Veamos cuáles son las validaciones que Struts provee, su uso y cómo configurarlas. En todos los casos, los elementos arg dentro del elemento field definen la clave del archivo de recursos con la etiqueta del campo a ser usada por el mensaje de error. Por ejemplo, para el validador required, el mensaje de error es:
UBICACIÓN DE ARCHIVOS DE VALIDACIÓN Si bien los archivos de validación no tienen restricciones sobre su ubicación, es una buena práctica agruparlos en una carpeta (o más, si se desea) dentro de la carpeta WEB-INF. En una aplicación de tamaño mediano a grande, este tipo de archivos crece
considerablemente y es conveniente, entonces, tenerlos guardados en una subcarpeta.
www.redusers.com
C#_Struts_Validator.indd 7
08/09/2014 10:43
8
APÉNDICE C. STRUTS VALIDATOR
errors.required={0} es requerido.
Si nuestro arg de posición 0 es, como en el ejemplo, proyecto.nombre, y su valor en castellano es nombre, entonces, al producirse un error y mostrarlo en la página, veremos: nombre es requerido
required Valida que el campo contenga un valor. Ejemplo de uso:
minlength, maxlength Verifican que el campo tenga un número mínimo o máximo de caracteres, respectivamente. Estos elementos toman una variable especificando el valor del mínimo o máximo: minlength y maxlength. Ejemplo de uso:
minlength 5
www.redusers.com
C#_Struts_Validator.indd 8
08/09/2014 10:43
9
DESARROLLO WEB CON JAVA DESDE CERO
Este es un ejemplo para validar un campo con un número mínimo de caracteres. Para validar por el máximo, es igual: se reemplaza por maxlength, en vez de minlength. Viendo este ejemplo, notamos dos inconvenientes. El primero es que tenemos que repetir el valor mínimo (o máximo) tanto en
PARA DEFINIR VALIDACIONES PROVEEMOS UN ARCHIVO .XML PARA EL VALIDADOR
la variable como en el argumento del mensaje. El segundo, y más importante, es que el segundo atributo de arg es key, o sea, la clave de una entrada en el archivo de recursos. Esto quiere decir que... ¡tendríamos que generar una entrada en el archivo de recursos por cada número que usemos en los validadores! Afortunadamente, podemos resolver estos dos inconvenientes. Para el primer problema, simplemente podemos establecer una referencia al valor de la variable que definimos en el elemento var. Para el segundo problema, existe el atributo resource, dentro de los elementos arg, que especifica si el valor es una clave del archivo de recursos o si es un valor literal. Veamos entonces el mismo ejemplo anterior pero con estas salvedades:
minlength 5
El atributo key del segundo elemento arg hace referencia al valor de la variable minlength, y, a su vez, define que dicho valor no es una clave del archivo de recursos sino el valor en sí. www.redusers.com
C#_Struts_Validator.indd 9
08/09/2014 10:43
10
APÉNDICE C. STRUTS VALIDATOR
mask Valida el campo según una expresión regular. Si el valor del campo se ajusta a la expresión regular, entonces se lo considera válido. Este validador es muy útil para comparar y admitir formatos específicos en los campos. Veamos un ejemplo: supongamos que un campo del formulario pide al usuario el código postal de su residencia. Supongamos, también, que todo código postal válido consta de 3 letras y 4 dígitos. Entonces, definimos así el siguiente validador:
mask ^[a-zA-Z]{3}[0-9]{4}$
Este validará la propiedad cp del formulario. En la variable mask definimos la expresión regular. Esta debe empezar con el signo ^ y debe terminar con el signo $. El validador mask es un genérico y, por consiguiente, no tiene un mensaje de error por defecto. En el ejemplo, ve-
EXPRESIONES REGULARES EN STRUTS El validador mask no usa las expresiones regulares de Java sino las que provee el proyecto Jakarta ORO. Estas expresiones son ligeramente distintas de las de Java: son expresiones regulares del estilo Perl5. Para un detalle de cómo hacer expresiones regulares en ese estilo, podemos ingresar a http://jakarta.apache.org/oro.
www.redusers.com
C#_Struts_Validator.indd 10
08/09/2014 10:43
11
DESARROLLO WEB CON JAVA DESDE CERO
mos el elemento msg. Dicho atributo especifica la clave, para el validador mask, del mensaje de error. Si el mensaje de error tuviera variables, además podemos especificar un elemento arg. Las entradas para el archivo de recursos correspondientes son:
form.cp=Codigo postal form.cp.msg={0} debe ser de la forma ABC1234
byte, short, integer, long, float, double Estos validadores verifican que el valor del campo pueda ser convertido al tipo dado. En todos los casos, no se necesita otra variable más que el argumento para el mensaje de error. Veamos dos ejemplos:
date Este validador verifica que el valor del campo represente una fecha según el patrón de conversión que se haya otorgado. Las posibles variables son datePattern y datePatternStrict. La diferencia entre estos dos es que datePatternStrict, como su nombre lo indica, es estricto en cuanto a la cantidad de caracteres. Por ejemplo, con un patrón dd/MM/yyyy, la fecha 4/6/1979 fallará si el patrón es declarado como datePatternStrict. Para este caso, la fecha correcta sería 04/06/1979. www.redusers.com
C#_Struts_Validator.indd 11
08/09/2014 10:43
12
APÉNDICE C. STRUTS VALIDATOR
datePattern dd/MM/yyyy
intRange, floatRange, doubleRange Con estos validadores podemos verificar que el valor de un campo se encuentre dentro de cierto rango. Por lo general, se utilizan en conjunto con el validador de tipo acorde. Por ejemplo, intRange lo usaremos en conjunto con el validador integer. Las variables que usan son min y max, que especifican, como es de esperarse, la cota inferior y superior. Al igual que con minlength y maxlength, los argumentos para el mensaje de error los especificaremos como una referencia a la variable. Veamos el ejemplo:
min 4 max 24
www.redusers.com
C#_Struts_Validator.indd 12
08/09/2014 10:43
13
DESARROLLO WEB CON JAVA DESDE CERO
creditCard Corrobora que el campo sea un número de tarjeta de crédito válido.
email Valida que el campo sea una dirección de correo electrónico válida.
url Valida que el campo sea una dirección web válida. Este validador posee 4 variables, todas opcionales:
•
allowallschemes: si esta variable es true, cualquier esquema será válido;
•
allow2slashes: si el valor es true, se aceptarán dos barras / consecutivas.
caso contrario, solo los especificados por la variable schemes.
DIRECCIONES WEB Existen muchas opciones para determinar si una dirección web es válida o no. El documento RFC 2396, disponible en la dirección www.ietf.org/rfc/rfc2396.txt, especifica de manera precisa el estándar existente de las direcciones web.
www.redusers.com
C#_Struts_Validator.indd 13
08/09/2014 10:43
14
•
APÉNDICE C. STRUTS VALIDATOR
nofragments: si es true, no se aceptarán direcciones web que contengan fragmentos.
•
schemes: especifica los esquemas válidos a ser considerados: por defecto, HTTP, HTTPS y FTP. Notemos que si especificamos allowallschemes con valor true, entonces el
valor de schemes será omitido. Ejemplos:
nofragments true schemes http,https
Esta configuración aceptará http://onweb.tectimes.com y https:// java.sun.com, pero no http://www.jengibre.com.ar#anchor (tiene fragmento), ftp://sitio.ftp.com (esquema inválido) y http://www.jengibre. com.ar//index.html (dos barras consecutivas).
validwhen Cuando necesitamos validar un campo pero en función de otro campo, ninguna de las validaciones vistas hasta ahora nos sirve, ni siquiera la validación realizada por el método validate en un ActionForm. Este validador sirve exactamente para estos casos. El ejemplo típico es cuando pedimos a un usuario que ingrese su clave en un campo y la www.redusers.com
C#_Struts_Validator.indd 14
08/09/2014 10:43
15
DESARROLLO WEB CON JAVA DESDE CERO
reingrese en otro campo, como confirmación. Ninguno de estos campos es válido o inválido por sí solo, sino que su validez está dada por ambos valores. El validador toma solamente una variable de nombre test, que debe contener una expresión booleana. Si la evaluación de la expresión es verdadera, la validación es exitosa. La expresión booleana tiene reglas sintácticas que debemos respetar:
• •
Toda comparación debe estar encerrada entre paréntesis. Los conectores and y or solo conectan dos elementos. Los valores posibles son:
• • • •
Nombre de un campo del formulario. Cadenas de texto encerradas por comillas simples o dobles. El literal null. El literal *this*, que representa el valor del campo actual. Si los valores a ser comparados pueden ser convertidos a enteros, se
realiza una comparación numérica; en otro caso, una comparación textual. Supongamos que tenemos dos campos. Estos campos son válidos si los dos contienen un valor o si ninguno contiene un valor. Esto sería una extensión al validador required. Dados los campos campo1 y campo2, la expresión que realiza esta validación es:
(((campo1 == null) and (campo2 == null)) or ((campo1 != null) and (campo2 != null)))
Si logramos abstraer nuestra mente de la sopa de letras de paréntesis, vemos que la lógica es muy sencilla: ambos nulos o ambos no nulos. Veamos un ejemplo más complejo. Tenemos un checkbox que permite al usuario elegir realizar su pago en cuotas y un campo de texto donde el usuario ingresa el número de cuotas. Necesitamos que el usuario ingrese www.redusers.com
C#_Struts_Validator.indd 15
08/09/2014 10:43
16
APÉNDICE C. STRUTS VALIDATOR
el número de cuotas solamente si marcó la opción de pagar en cuotas. Veamos un ejemplo donde, además, de usar validwhen, lo mezclamos con otros validadores para hacer un validador completo. La porción de código de la página JSP:
:
Y el validador correspondiente:
test ((cuotas == null) or (*this* != null))
www.redusers.com
C#_Struts_Validator.indd 16
08/09/2014 10:43
17
DESARROLLO WEB CON JAVA DESDE CERO
min 2 max 12
Vamos a repasar con detenimiento este validador. En primer lugar, estamos asignando al campo tres validadores: validwhen, integer e intRange. Esto significa que las tres validaciones deben ser exitosas para que el campo sea válido. En primer lugar, se ejecutará validwhen:
((cuotas == null) or (*this* != null))
Esto implica que la validación será exitosa si cuotas es nulo (o sea, no está marcado) o si cantCuotas no es nulo.
ERRORES POR DOQUIER Es una buena práctica mostrar los errores por duplicado. Primero, al principio de la página, en un lugar bien visible, los mostramos todos juntos, y luego, en el lugar específico donde ocurrió cada error, los mostramos de a uno.
www.redusers.com
C#_Struts_Validator.indd 17
08/09/2014 10:43
18
APÉNDICE C. STRUTS VALIDATOR
Si esta validación fue exitosa, se procederá a validar que lo ingresado sea un número, y luego, que esté en el rango establecido.
Validación en el cliente Los validadores de Struts también traen consigo código JavaScript para agregar a las páginas JSP. De esta forma, en los casos en que se pueda, la validación se realizará del lado del cliente, mediante código JavaScript. Este enfoque tiene pros y contras. Su ventaja principal es que enviar la información al servidor, que esta sea validada y que vuelva, en caso de error, toma su tiempo. Si la conexión es lenta o si hay mucho tráfico, pueden pasar varios segundos hasta que el servidor nos conteste que nos olvidamos de marcar una opción que no logramos ver. Usando código JavaScript y realizando la validación en el cliente, esto es prácticamente instantáneo: ningún tipo de información viaja por la red. Como contras, tenemos varias, aunque menores. En primer lugar, no podemos depender de este tipo de validaciones, ya que el usuario puede haber elegido deshabilitar el código JavaScript en su navegador o simplemente puede tener un navegador que no soporte este lenguaje. Agregar código JavaScript incrementa el tamaño de la página. Este incremento suele ser despreciable, pero es algo a considerar. Además, muchas veces las validaciones necesitan intrínsecamente ser realizadas en el servidor. La corroboración de un nombre de usuario y contraseña claramente no podremos realizarla del lado del cliente. A fin de cuentas, la validación en el cliente es una importante herramienta que ayuda al cliente a ahorrar tiempos, y, al servidor, a aliviar su carga.
Activar el código JavaScript Aplicar la validación en el cliente es muy sencillo. Veamos un pequeño ejemplo al que aplicaremos validación JavaScript. Dos acciones: www.redusers.com
C#_Struts_Validator.indd 18
08/09/2014 10:43
19
DESARROLLO WEB CON JAVA DESDE CERO
El archivo XML que define las validaciones (¡recordemos agregar este archivo a la lista de pathnames del Validator PlugIn!):
www.redusers.com
C#_Struts_Validator.indd 19
08/09/2014 10:43
20
APÉNDICE C. STRUTS VALIDATOR
Hasta ahora, todo como siempre. Suena lógico, y la parte de validación del cliente la realizaremos, como es de esperarse, en el cliente. Veamos el código JSP de la página:
Nombre:
Edad:
El tag html:javascript inserta el código JavaScript necesario para las validaciones. Sus atributos son los siguientes:
•
cdata: si es true (por defecto lo es), encierra el código JavaScript generado en una sección CDATA, de forma de ser compatible con XML. www.redusers.com
C#_Struts_Validator.indd 20
08/09/2014 10:43
21
DESARROLLO WEB CON JAVA DESDE CERO
•
htmlComment: si es true (por defecto lo es), encierra el código JavaScript en comentarios.
• •
formName: nombre del formulario a validar. method: nombre del método JavaScript que realizará la validación. Si no especificamos este parámetro, el valor por defecto es validate[formName]. En el ejemplo, hubiera sido: validateClienteForm.
•
page: número de página que estamos validando, para validaciones multipágina.
•
scriptLanguage: si es true (por defecto), se agrega el atributo language
• •
src: el atributo src del elemento .
al elemento . staticJavascript: si es true (por defecto), el código JavaScript estático es agregado a la página.
•
dynamicJavascript: si es true (por defecto), el código JavaScript dinámico es agregado a la página. Los atributos staticJavascript y dynamicJavascript ameritan una explicación
extra. El código estático se refiere a las funciones JavaScript genéricas validadoras, funciones como validateRequired o validateInteger, que son las asociadas a los validadores. El código dinámico es el que llama a estas funciones en base a lo que el formulario requiera. En nuestro caso, el código dinámico será el encargado de llamar a las funciones que validen que los campos no estén vacíos y que el campo edad, además, sea numérico.
LOGIC:MESSAGESPRESENT El tag Logic:messagesPresent resulta muy útil si lo que queremos es mostrar cierto código, solo en los casos en que arroje mensajes de error. De esta forma, podemos crear tablas que los contengan y, si no existen errores, no nos encontraremos con una tabla vacía.
www.redusers.com
C#_Struts_Validator.indd 21
08/09/2014 10:43
22
APÉNDICE C. STRUTS VALIDATOR
Por defecto, ambos códigos son generados. Podríamos crear una página que se use para generar el código estático y guardarlo como un archivo o que las páginas con validaciones incluyan el contenido. Si generamos solo el código estático, no es necesario especificar un form:
En este ejemplo, generamos el código estático que podremos incluir o referenciar desde cualquier página. Además de incluir el código JavaScript, necesario para las validaciones en el cliente, debemos llamar al código cuando se envía el formulario para que la validación efectivamente se ejecute. En el ejemplo, hicimos:
El atributo onsubmit especifica código JavaScript a ejecutar cuando el formulario es enviado. La función validar (que toma ese nombre porque así lo definimos usando el atributo method en el tag html:javascript) devuelve un resultado booleano. Si el resultado es falso, el formulario no se envía al servidor. En la Figura 1 vemos el validador en acción.
DOBLE VALIDACIÓN Cuando un campo necesita una validación automática y otra que involucre lógica de negocios (por ejemplo, un nombre de usuario no vacío y que no exista en la base de datos), tenemos que considerar si queremos hacer ambas validaciones en la acción o separarlas, para mostrarle al usuario todos los errores juntos y que los pueda corregir, sin necesidad de enviar el formulario varias veces.
www.redusers.com
C#_Struts_Validator.indd 22
08/09/2014 10:43
23
DESARROLLO WEB CON JAVA DESDE CERO
Si incluimos en la página un botón de cancelación (como en nuestro ejemplo), no necesitamos agregar código extra, ya que el botón trae generado un código JavaScript para saltear la validación. Al cancelar el formulario lo estamos enviando, pero no queremos que sea validado.
Figura 1. Con las validaciones JavaScript fácilmente mejoramos la validación de datos para el usuario.
Un validador propio Mediante los validadores del proyecto Commons Validator –en conjunción con validwhen– podemos realizar una gran cantidad de validaciones de uso recurrente. Pero, en el caso de necesitar una validación que no esté al alcance de estas herramientas, podemos fácilmente programarla y usarla como cualquier otra validación.
ANTES DE CREAR UN VALIDADOR PROPIO Es más eficiente programar un validador propio una vez que sepamos, de antemano, que vamos a usarlo varias veces en nuestra aplicación. No tiene mucho sentido crear un validador para cada caso particular que necesitemos y que termine siendo usado solo una vez; en esos casos, es preferible sobrescribir el método validate del ActionForm.
www.redusers.com
C#_Struts_Validator.indd 23
08/09/2014 10:43
24
APÉNDICE C. STRUTS VALIDATOR
En los archivos de configuración de validaciones, donde veníamos definiendo los validadores para los campos de formularios, podemos agregar nuestros propios validadores. Dentro del elemento global (que debe definirse antes que el elemento formset), el elemento validator especifica un validador. Si miramos el archivo validator-rules.xml que trae Struts, veremos que consta básicamente de las declaraciones de los validadores que hemos estado viendo durante el capítulo. Los atributos a definir en el elemento son:
• • • • •
name: nombre del validador. classname: clase que implementa la validación. method: nombre del método que implementa la validación. methodParams: parámetros que recibe el método. depends: validadores de los que depende este validador, separados por coma. Estos validadores son llamados antes que el actual.
•
msg: clave del mensaje de error que se mostrará si la validación falla. Si bien un validador puede definir por defecto una clave de mensaje
a mostrar, siempre podemos redefinir el mensaje para cada validación particular mediante el elemento msg. Por ejemplo, el validador required define como clave errors.required, pero podemos definir un validador sobre un campo que use required y redefina el mensaje:
Volviendo al tema de los validadores propios, veamos cómo es la definición de nuestro propio validador, encargado de verificar que el valor de un campo sea un número primo. www.redusers.com
C#_Struts_Validator.indd 24
08/09/2014 10:43
25
DESARROLLO WEB CON JAVA DESDE CERO
Los parámetros que recibe el método que implementa la validación deben respetar esta aridad. Struts asume que todo método validador recibirá estos parámetros y de esta manera los invoca. El validador depende de integer, ya que, para verificar que el campo sea un número primo, primeramente debe ser número. Veamos la clase que implementa el método que realiza la validación:
package capitulo8.validador; import javax.servlet.http.HttpServletRequest; import org.apache.commons.validator.Field; import org.apache.commons.validator.GenericValidator; import org.apache.commons.validator.Validator; import org.apache.commons.validator.ValidatorAction; import org.apache.commons.validator.util.ValidatorUtils; import org.apache.struts.action.ActionMessages;
www.redusers.com
C#_Struts_Validator.indd 25
08/09/2014 10:43
26
APÉNDICE C. STRUTS VALIDATOR
import org.apache.struts.validator.Resources; public class Validador { /** * Verifica que el valor sea un número primo * * @param bean: El bean sobre el que efectuamos la validación * @param va: La acción de validación que se está efectuando * @param field: El campo perteneciente al bean que queremos validar * @param errors: Una lista de errores a la que agregaremos los nuestros de ser necesario * @param validator: El validador actual que está ejecutando la validación *@param request: El pedido */ public static Object validarPrimo(Object bean, ValidatorAction va, Field field, ActionMessages errors, Validator validator, HttpServletRequest request) { /* Podemos devolver un objeto de tipo Boolean indicando si la validación falló, o bien un objeto cualquiera no nulo para indicar validación exitosa, o nulo para indicar validación fallida */ Object result = null; // Obtenemos el valor del campo del bean String value = ValidatorUtils.getValueAsString(bean, field .getProperty()); /* No requerimos valor, pero, si existe, que sea un número primo */ if (!GenericValidator.isBlankOrNull(value)) { try {
www.redusers.com
C#_Struts_Validator.indd 26
08/09/2014 10:43
27
DESARROLLO WEB CON JAVA DESDE CERO
// Obtenemos el valor numérico int valor = Integer.parseInt(value); if (esPrimo(valor)) { /* Es primo, devolvemos un objeto no nulo, indicando validación exitosa */ result = new Integer(valor); } else { /* Es compuesto, agregamos el error a la lista */ errors.add(field.getKey(), Resources.getActionMessage( validator, request, va, field)); } } catch (Exception e) { /* No debería ocurrir nunca, ya que dependemos del validador integer, pero igualmente agregamos el error */ errors.add(field.getKey(), Resources.getActionMessage( validator, request, va, field)); } } return result; } /** * Devuelve si el entero es primo */ private static boolean esPrimo(int n) { if (n < 2) { return false; }
www.redusers.com
C#_Struts_Validator.indd 27
08/09/2014 10:43
28
APÉNDICE C. STRUTS VALIDATOR
if ((n & 1) == 0) { return true; } int raiz = (int) Math.sqrt(n); for (int i = 3; i
COMMONS VALIDATOR EN VALIDACIONES PROPIAS Una buena práctica es usar los métodos de validación del proyecto Commons Validator en nuestras validaciones propias, cuando sea posible, para asegurarnos de emplear código ya probado. La página web del proyecto es: http://jakarta.apache.org/commons/validator.
www.redusers.com
C#_Struts_Validator.indd 29
08/09/2014 10:43
30
APÉNDICE C. STRUTS VALIDATOR
El código de la primera página:
Nombre:
Apellido:
Y el de la segunda:
Correo electrónico:
www.redusers.com
C#_Struts_Validator.indd 30
08/09/2014 10:43
31
DESARROLLO WEB CON JAVA DESDE CERO
Dirección:
Notemos cómo se utiliza el atributo page, que es enviado al servidor como un atributo más y es usado por el validador para saber qué página es la que se necesita validar. Notemos también que, en la segunda página, guardamos los valores que el usuario ingresó en la primera. De no hacer esto, la segunda página solo enviaría los atributos email, dir y page, y el validador, al recibir estos datos, intentará validar todos los campos con código de página menor o igual a 1 (y esto incluye también nombre y apellido), y la validación, por lo tanto, fallaría.
FORMULARIOS MULTIPÁGINA Son formularios muy extensos, por lo que, idealmente, deberíamos brindar al usuario la posibilidad de guardar lo hecho hasta el momento para que pueda proseguir más tarde. Usando el enfoque visto en el ejemplo con el bean DatosForm, podríamos ir guardando en sesión o en alguna base de datos lo ingresado para, una vez obtenido todo, procesarlo.
www.redusers.com
C#_Struts_Validator.indd 31
08/09/2014 10:43
32
APÉNDICE C. STRUTS VALIDATOR
La acción que maneje este pedido recibirá los cuatro atributos. Una alternativa a ir guardando los valores anteriores en campos hidden sería, en las acciones intermedias, ir guardando los valores en sesión (dentro de un bean, por ejemplo). Veamos cómo sería la acción intermedia correspondiente al ejemplo:
package capitulo8.action; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import org.apache.struts.action.Action; import org.apache.struts.action.ActionForm; import org.apache.struts.action.ActionForward; import org.apache.struts.action.ActionMapping; import org.apache.struts.validator.LazyValidatorForm; public class Wizard1Action extends Action { public ActionForward execute(ActionMapping map, ActionForm form, HttpServletRequest req, HttpServletResponse res) throws Exception { LazyValidatorForm dyna = (LazyValidatorForm) form; String nombre = (String) dyna.get(“nombre”); String apellido = (String) dyna.get(“apellido”); // El bean donde guardamos los datos DatosWizard dw = new DatosWizard(); dw.setNombre(nombre); dw.setApellido(apellido); req.getSession().setAttribute(“DatosWizard”, dw); return map.findForward(“ok”); } }
www.redusers.com
C#_Struts_Validator.indd 32
08/09/2014 10:43
33
DESARROLLO WEB CON JAVA DESDE CERO
Mostrar errores con estilo Hemos visto en los ejemplos que, usando el tag html:errors, podemos mostrar los errores de validación ocurridos en la página o respecto a un campo en particular. Este tag posee muchas opciones en cuanto al estilo y la forma de mostrar los errores. Además del atributo property –que, al usarlo, devuelve solo los errores para la propiedad dada–, hay cuatro atributos extra asociados con el estilo del error:
• • • •
header: clave de lo que se imprimirá antes de todos los errores. footer: clave de lo que se imprimirá después de todos los errores. prefix: clave de lo que se imprimirá antes de cada error. suffix: clave de lo que se imprimirá después de cada error. Si no especificamos estos atributos, los valores por defecto son:
errors.header, errors.footer, errors.prefix y errors.suffix, respectivamente. Usando estos atributos, veamos un ejemplo no muy estético (pero funcional) de errores con estilos aplicados:
Ingrese sus datos Nombre:
www.redusers.com
C#_Struts_Validator.indd 33
08/09/2014 10:43
34
APÉNDICE C. STRUTS VALIDATOR
Edad:
Este código es prácticamente igual (excepto por la parte de validación JavaScript) que el anterior; solamente agregamos un tag para mostrar todos los errores juntos antes de los campos, y, además, los campos mostrarán su error específico, si hubiera. La porción correspondiente al archivo MessageResources.properties:
errors.table.header=
errors.table.prefix=
| errors.table.suffix= |
errors.header= errors.footer= errors.prefix= → errors.suffix= ←
El resultado de esta obra de arte posmoderno de diseño web, en la Figura 2. También podemos combinar esta técnica con los atributos errorStyle o errorStyleClass de los campos, resaltando aún más la ubicación del error. www.redusers.com
C#_Struts_Validator.indd 34
08/09/2014 10:43
35
DESARROLLO WEB CON JAVA DESDE CERO
Figura 2. Usando atributos del tag, podemos resaltar más los errores y hacerlos visibles para el usuario.
El ejemplo completo Veamos un ejemplo completo, usando todas las validaciones que vimos en este apéndice, tanto las de Struts como las propias. La página JSP:
:
:
:
www.redusers.com
C#_Struts_Validator.indd 35
08/09/2014 10:43
36
APÉNDICE C. STRUTS VALIDATOR
:
:
:
:
:
:
:
Campos amigos:
:
www.redusers.com
C#_Struts_Validator.indd 36
08/09/2014 10:43
37
DESARROLLO WEB CON JAVA DESDE CERO
El archivo validator-form.xml con las validaciones:
www.redusers.com
C#_Struts_Validator.indd 37
08/09/2014 10:43
38
APÉNDICE C. STRUTS VALIDATOR
minlength 5 mask ^[a-zA-Z]{3}[0-9]{4}$
www.redusers.com
C#_Struts_Validator.indd 38
08/09/2014 10:43
39
DESARROLLO WEB CON JAVA DESDE CERO
datePattern dd/MM/yyyy min 4 max 24
www.redusers.com
C#_Struts_Validator.indd 39
08/09/2014 10:43
40
APÉNDICE C. STRUTS VALIDATOR
nofragments true schemes http,https test ((cuotas = = null) or (*this* != null)) min 2 max 12
www.redusers.com
C#_Struts_Validator.indd 40
08/09/2014 10:43
41
DESARROLLO WEB CON JAVA DESDE CERO
test (((campo1 == null) and (campo2 = = null)) or ((campo1 != null) and (campo2 != null)))
Este ejemplo completo lo podemos realizar en el entorno de ECLIPSE.
RESUMEN En este capítulo comprendimos el poder de las validaciones de Struts. Añadimos validaciones predefinidas a nuestros campos, definimos validaciones complejas usando validwhen e implementamos nuestras propias validaciones. Agregamos, también, validación del lado del cliente y personalizamos los mensajes de error.
www.redusers.com
C#_Struts_Validator.indd 41
08/09/2014 10:43
42
APÉNDICE C. STRUTS VALIDATOR
Actividades PARTE TEÓRICA 1
¿Cuál es la utilidad de las validaciones en las páginas web?
2
¿Cuál es la diferencia entre datePattern y datePatternStrict en la validación por fecha? ¿En qué caso usaría cada validador?
PARTE PRÁCTICA 1
Agregue validación al proyecto del juego Ahorcado que utilizamos en capítulos anteriores.
2
Cree un validador para el juego del Ahorcado, que valide que se ingrese una y solo una letra en el campo, usando el validador mask.
3
Cree un validador para el Ahorcado, que valide que se ingrese una y solo una letra en el campo, implementando un validador propio.
4
¿Es válida la siguiente expresión booleana del validador validwhen?: ((*this* == null) or (campo1 != null) or (campo2 != null))
5
¿Qué validación realiza la siguiente expresión en un validador validwhen?: (((cant >= 60) and (cant