Primavera – Validación de MVC

El marco Spring MVC nos proporciona validadores estándar predefinidos para validar los datos de entrada del usuario de una manera simple y directa. Bean Validation API es el enfoque popular para validaciones de datos en aplicaciones Spring. Aquí usaremos la implementación de hibernación de la API de validación de Bean conocida como Hibernate Validator. 

Anotaciones de validación

Estas son algunas de las anotaciones de validación más utilizadas.

1. @Min(value=) – Comprueba si el valor anotado es mayor o igual que el valor mínimo especificado.

2. @Max(value=) – Comprueba si el valor anotado es menor o igual que el valor máximo especificado. ‘

@Min(value = 18, message = "Age must be greater than 18")
@Max(value = 25, message = "Age must be smaller than 25")
private int age;

3. @NotNull : comprueba que el valor anotado no sea nulo.

4. @NotBlank : comprueba que la secuencia/string de caracteres anotados no sea nula y que la longitud recortada sea mayor que 0.

5. @NotEmpty : comprueba que el elemento anotado no sea nulo ni esté vacío.

// @NotNull: The CharSequence, Collection, Map or Array object is not null, but can be empty.
// @NotEmpty: The CharSequence, Collection, Map or Array object is not null and size > 0.
// @NotBlank: The string is not null and the trimmed length is greater than zero.

@NotEmpty(message = "First name cannot be null and must have size greater than 0")
private String firstName;

@NotNull(message = "Second name must not be null, empty value/space can be considered")
private String lastName;

@NotBlank(message = "Username must not be null and must contain 1 or more characters")
private String userName;

6. @Email : comprueba si la secuencia/string de caracteres especificada es una dirección de correo electrónico válida.

@Email(message = "Email should be valid")
private String email;

7. @Pattern(regex=, flags=) – Verifica que la string anotada coincida con la expresión regular considerando las coincidencias de la bandera dada.

// The regex specifies that the password can contain characters from a to z, A to Z and 0-9 only,
// also it must be in between 6 to 10 characters long.

@Pattern(regexp = "^[a-zA-Z0-9]{6,10}$")
private String password;

8. @AssertFalse : comprueba que el elemento anotado sea falso.

9. @AssertTrue: comprueba que el elemento anotado sea verdadero.

@AssertTrue 
private boolean isWorking;

@AssertFalse
private boolean isStudent;

10. @NegativeOrZero : comprueba si el elemento dado es menor o igual a 0.

11. @Null : comprueba que el valor anotado sea nulo.

12. @Negative : comprueba si el elemento es estrictamente menor que 0.

13. @Positive : comprueba si el elemento es estrictamente mayor que 0.

14. @PositiveOrZero – Comprueba si el elemento dado es mayor o igual a 0.

@Positive
private int operand1;

@Negative
private int operand2;

@PositiveOrZero
private int operand3

@NegativeOrZero
private int operand4;

@Null
private int nullVal;

15. @Size : comprueba si el tamaño del elemento anotado se encuentra entre el valor mínimo y el valor máximo proporcionado (incluido).

@Size(min = 10, max = 200, message = "About Me must be between 10 and 200 characters")
private String aboutMe;

Ejemplo 1: clase de usuario

// Java Program to Illustrate Calculator class
 
package com.example.springmvc;
 
// Importing required classes
import javax.validation.constraints.*;
import lombok.Data;
 
// Annotation
@Data
 
// Class
public class User {
 
    @NotEmpty(
        message
        = "First name cannot be null and must have size greater than 0")
    private String firstName;
 
    @NotNull(
        message
        = "Second name must not be null, empty value/space can be considered")
    private String lastName;
 
    @NotBlank(
        message
        = "Username must not be null and must contain 1 or more characters")
    private String userName;
    ;
 
    @AssertTrue private boolean working;
 
    @Min(value = 18,
         message = "Age must be greater than 18")
    @Max(value = 25,
         message = "Age must be smaller than 25")
    private int age;
 
    @Size(
        min = 10, max = 200,
        message
        = "About Me must be between 10 and 200 characters")
    private String aboutMe;
 
    @Email(message = "Email should be valid")
    private String email;
 
    @Pattern(regexp = "^[a-zA-Z0-9]{6,10}$")
    private String password;
 
    @AssertTrue private boolean isWorking;
 
    @AssertFalse private boolean isStudent;
}

Ejemplo 2: Clase de calculadora

// Java Program to Illustrate Calculator class
 
package com.example.springmvc;
 
// Importing required classes
import javax.validation.constraints.*;
import lombok.Data;
 
// Annotation
@Data
// Class
public class Calculator {
 
    // Operand4 can contain values > 0 only
    @Positive private int operand1;
 
    // Operand4 can contain values <  only
    @Negative private int operand2;
 
    // Operand4 can contain values >= 0 only
    @PositiveOrZero private int operand3;
 
    // Operand4 can contain values <= 0 only
    @NegativeOrZero private int operand4;
 
    // Value of operator must be assigned at runtime.
    @Null private char operator;
}

Nota: @Data utilizado en el código completo, es una anotación para usar lombok. Lombok ayuda a eliminar el código repetitivo como getters, setters, constructores, etc.

Dependencia

(A) Para Maven: agregue la siguiente dependencia al archivo pom.xml.

<!-- https://mvnrepository.com/artifact/org.hibernate.validator/hibernate-validator -->
<dependency>
    <groupId>org.hibernate.validator</groupId>
    <artifactId>hibernate-validator</artifactId>
    <version>6.2.0.Final</version>
</dependency>

(B) Para Gradle: agregue la siguiente dependencia al archivo build.gradle.

// https://mvnrepository.com/artifact/org.hibernate.validator/hibernate-validator
implementation group : 'org.hibernate.validator',name : 'hibernate-validator', version: '6.2.0.Final'
// Or
// implementation
// 'javax.validation:validation-api:2.0.1.Final'