Prefacio
El componente de validador del marco de Spring es un componente auxiliar, que es muy útil para la integridad y validez de los datos. Al definir un cierto validador, se puede usar en otros lugares donde se necesita, y es muy común.
Antes de ejecutar la lógica comercial, es necesario asegurarse de que los datos de entrada recibidos sean legales y correctos a través de la verificación. Sin embargo, muchas veces la misma verificación ocurre muchas veces, lo que conduce a la redundancia del código, desperdició el tiempo y viola el principio seco.
Puede considerar encapsular el código de verificación para resolver estos problemas.
JSR-303
JSR-303 es un marco estándar proporcionado por Java para la verificación de legalidad de datos de frijoles. Define un conjunto de anotaciones de verificación que se pueden anotar en variables de miembros y métodos de atributos.
La validación de Hibernate proporciona este conjunto de implementaciones estándar. Cuando presentamos la validación de arranque web de Spring Boot o Spring Boot Boot, la validación de Hibernate se introducirá de forma predeterminada.
Ejemplo de uso
Después de decir tantas tonterías, agregue el código.
1. Introducir el proyecto SpringBoot
<Spendency> <MoupRoMID> org.springframework.boot </groupid> <artifactID> spring-boot-starter-web </artifactid> </pendency> <spendency> <grupeD> org.hibernate.validator </groupId> <artifactid> hibernate-validator </artifactid> <//dependence> <! <Spendency> <MoupRoMID> org.projectlombok </groupid> <artifactid> lombok </artifactid> </dependencia>
2. Escribir objetos de verificación
@Datapublic de usuarios de clase {// El nombre no puede estar vacío, y la longitud del nombre es entre 2 y 30 bits // Si la longitud del nombre no pasa, entonces el mensaje de error se solicita @notnull @size (min = 2, max = 30, mensaje = "Compruebe si hay algún problema con la longitud del nombre") Nombre de cadena privada; // El nombre no puede estar vacío, y la edad mínima es 18 @notnull @min (18) edad de entero privado;}3. Crea un controlador
@SpringBootApplication@RestControllerPublic UserApplication {public static void main (string [] args) {springapplication.run (userApplication.class, args); } // 1. Agregue la anotación de @Valid antes del parámetro que se verifique // 2. Siga de inmediato, siga un BindingResult para almacenar la información de verificación @RequestMapping ("/test1") Public Object Test1 (@Valid User User, el usuario de Error BindeinSult) {// Si existe un problema con la verificación, un mensaje de error volverá a devolver // De hecho, la información personalizada se puede devolver de acuerdo con el método BindingResult según sea necesario. // La solución habitual es: JSR-303 + Global ExceptionHandler if (bindingResult.haserrors ()) {return bindingResult.getAllerrors (); } return "ok"; }} 4. Ejecute la aplicación
Después de una breve demostración de los resultados de la operación, se puede ver que el marco de verificación ha entrado en vigencia.
Verificar la edad
Verificar el nombre
Verificación aprobada
Anotaciones de verificación comunes
@Null El elemento anotado debe ser nulo
@Notnull El elemento anotado no debe ser nulo
@AssertTrue El elemento anotado debe ser verdad
@Assertfalse El elemento anotado debe ser falso
@Min (valor) El elemento anotado debe ser un número, y su valor debe ser mayor o igual al valor mínimo especificado.
@Max (valor) El elemento anotado debe ser un número, y su valor debe ser menor o igual al valor máximo especificado.
@Decimalmin (valor) El elemento anotado debe ser un número, y su valor debe ser mayor o igual al valor mínimo especificado
@DecimalMax (valor) El elemento anotado debe ser un número, y su valor debe ser menor o igual al valor máximo especificado
@Size (max =, min =) El tamaño del elemento anotado debe estar dentro del rango especificado.
@Digits (entero, fracción) El elemento anotado debe ser un número y su valor debe estar dentro de un rango aceptable.
@Past El elemento anotado debe ser una fecha pasada
@Future El elemento anotado debe ser una fecha futura
@Pattern (regex =, flag =) El elemento anotado debe cumplir con la expresión regular especificada
Verifique las anotaciones proporcionadas por Hibernate Validator:
@Notblank (mensaje =) Verifique que la cadena no sea nula y debe ser mayor que 0
@Email El elemento anotado debe ser una dirección de correo electrónico
@Length (min =, max =) El tamaño de la cadena anotada debe estar dentro del rango especificado.
@Notempty La cadena comentada no debe ser vacía
@Range (min =, max =, mensaje =) El elemento anotado debe estar dentro del rango apropiado
Anotaciones de verificación personalizadas
A veces, el tipo de verificación que queremos no está en la biblioteca de terceros. Afortunadamente, el sistema proporciona buenas capacidades de expansión, y podemos personalizar la verificación.
Por ejemplo, queremos verificar el formato del teléfono móvil del usuario y escribir el dispositivo de verificación del número de teléfono móvil.
1. Escribir anotaciones de verificación
// Podemos copiar directamente la anotación en el sistema como @min, copiarla en nuestra nueva anotación y luego modificarla según sea necesario. @Target ({método, campo, annotation_type, constructor, parámetro})@retención (tiempo de ejecución)@documented // la clase de implementación del anotado. @Constraint (validatedBy = {isMobileValidator.class}) public @Interface IsMobile {// Información predeterminada para la verificación de errores Mensaje de cadena () predeterminado "Hay un problema con el formato de número de teléfono móvil"; // si forzar verificación boolean es requirido () predeterminado falso; Clase <?> [] Grupos () predeterminado {}; Clase <? extiende la carga útil> [] Payload () predeterminado {};} 2. Escriba clases de implementación específicas
Sabemos que las anotaciones son solo una marca, y la lógica real debe implementarse en una clase específica. La anotación en el paso anterior especifica que la clase que implementa la función de verificación es ismobilevalidator.
// Las anotaciones personalizadas deben implementar la interfaz de restricción Validator, dos parámetros en ella // El primero es la anotación específica a verificar // El segundo es el tipo de parámetro de la clase pública de verificación ISMobilEvalidator implementa restricción Validator <isMobile, String> {Private Boolean requerido = falso; Patrón final estático privado mobile_pattern = patrón.compile ("1 // d {10}"); // Método de la herramienta, determine si se trata de un número de teléfono móvil public static boolean isMobile (String src) {if (stringUtils.isEmpty (src)) {return false; } Matcher m = mobile_pattern.matcher (src); return m.matches (); } @Override public void Initialize (isMobile RestrictAnnotation) {requirir = restrictInTannotation.isRequired (); } @Override public boolean isValid (teléfono de cadena, restrictValidatorContext restrictValidatorContext) {// es una implementación de un número de teléfono móvil if (requerido) {return isMobile (teléfono); } else {if (stringUtils.isEmpty (teléfono)) {return true; } else {return isMobile (teléfono); }}}} 3. Pruebe la función de las anotaciones personalizadas
@Datapublic de usuarios de clase {@notnull @size (min = 2, max = 30, mensaje = "Compruebe si hay algún problema con la longitud del nombre") Nombre de cadena privada; @Notnull @min (18) Private entero Age; // Esta es la anotación recién agregada @ismobile privado de cadena de cadena;}4. Prueba
aprobar
Hay un problema con el número de móvil
Se puede ver que la anotación personalizada ha entrado en vigencia.
También podemos continuar optimizando el lugar y creando una nueva excepción global. Si la verificación falla, arroje excepciones comerciales globales, capte las excepciones comerciales y luego devuelva la información de inmediato fácil de usar.
adicional
También puede pasar la verificación del método.
1. Agregar anotación @Validated al controlador
2. Agregue anotaciones de verificación, @min, @max, etc. al método del controlador.
@Validado@RestController@SpringBootApplicationPublic Class UserApplication {public static void main (string [] args) {springApplication.run (userApplication.class, args); } @RequestMapping ("/test2") public String test2 (@IsMobile String Phone) {return Phone + "OK"; } @ExceptionHandler (restrictiveViolationException.class) @ResponseBody Public Object HandLecUnstraintViolationException (restrictiveViolationException CVE) {Hashset <String> Messageset = new Hashset (); para (restrictSViolation restrictHViolation: cve.getConstraintViolations ()) {Messageset.Add (restrictiveViolation.getMessage ()); } return Messageset; }} Reglas de verificación de clase
por fin
Al usar el dispositivo de verificación, ya no necesitamos verificar todos los controladores. Si el código es muy refrescante, lo será. Escribimos código muy brevemente, pero debemos pensar en cómo escribir código más simple, más claro y más propicio para el mantenimiento. Escribir código duplicado es una pérdida de tiempo.
Cuando te encuentras con la verificación de parámetros en el futuro, lo primero que piensas es no verificarla directamente. Puede averiguar si ha escrito un cierto tipo de verificador y puede usarlo directamente.
Resumir
Lo anterior es todo el contenido de este artículo. Espero que el contenido de este artículo tenga cierto valor de referencia para el estudio o el trabajo de todos. Si tiene alguna pregunta, puede dejar un mensaje para comunicarse. Gracias por su apoyo a Wulin.com.