De hecho, es un método que se puede utilizar para definir anotaciones personalizadas a través de @Constraint.
@Constraint (validatedBy = xxxx.class)
A continuación se muestra un ejemplo de código de la anotación personalizada de Java que hice para implementar la verificación de parámetros delantero y backend
Si está interesado en esto, léelo cuidadosamente y aprenda con cuidado:
paquete sonn.sonnannotation; import java.lang.annotation.documented; import java.lang.annotation.ElementType; import java.lang.annotation.retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.target; import javax.validation.calentation; javax.Validation.ConstraNDValidator; import javax.validation.ConstraintValidatorContext; import javax.validation.payload; import sonn.util.stringutill;/*** @classname: isvalidString* @description: anotaciones personalizadas implementando la verificación de parámetros de back y back 2016-7-25 8:22:58 PM * @version 1.0 */@target ({elementType.field, elementType.method})@retention (retentionPolicy.runtime) @Constraint (validadado = isvalidString.validStringChecker.Classs) @DocumentedPublic @interface es ISValidString {String Message (). inválido."; Clase <?> [] Grupos () predeterminado {}; Clase <? extiende la carga útil> [] Payload () predeterminado {}; La clase ValidStringChecker implementa restrictValidator <isValidString, String> {@Override public void Initialize (isValidString arg0) {} @Override public boolean isValid (String strValue, restrictValidatorContext context) {if (stringutill.isstringempty (strvalue)) {return n. } if (strValue.contains ("<")) {return false; } return verdadero; }}}El código anterior define la lógica del método de la anotación a través de @Constraint (validatedBy = isValidString.ValidStringChecker.class)-La clase interna de la clase de anotación llamada ValidStringChecker.
Esta clase interna implementa la interfaz de restricción Validator <isValidString, String>
La documentación oficial lo describe así:
Javax.validación
Interface RestrictHValidator <A extiende la anotación, t>
•
----------------------------------------------------------------------------------------------------------------------------
Interfaz pública La restricción Validator <A extiende la anotación, t> Define la lógica para validar una restricción dada A para un tipo de objeto dado T.
Las implementaciones deben cumplir con las siguientes restricciones:
• T debe resolverse a un tipo no parametrizado
• o los parámetros genéricos de t deben ser tipos de comodín ilimitados
La anotación compatible con ValidationTarget se puede colocar en una implementación de Validator de restricciones para marcarlo como restricciones de parámetro cruzado. Consulte SupportDValidationTarget y restricción para obtener más información.
El método ISVALID implementado es el método de verificación de esta interfaz.
Pruebe el efecto y agregue anotaciones al campo de la clase de entidad que se verificará:
Escriba la página del artículo, agregue '<' en el título del artículo y envíe:
El envío falló, con un error de 500, lo que indica que la anotación entra en vigencia:
Pero todavía hay problemas con esto. El sitio web de mi blog no puede imprimir el mensaje de error directamente. Todavía tiene que crear una página de error.
Esto es simple, agregue la ruta de la página de error en Web.xml y luego haga una página:
<MOM-PAGE>
<código de error> 500 </error-código>
<Ococional> /error.jsp </bocation>
</error-PAGE>
Primero, presentemos algunos conceptos básicos:
1.Java define una anotación con @Interface XX {}.
La anotación en realidad no es misteriosa, es solo una marca. Cuando el programa se ejecuta en la marca, ejecuta la lógica correspondiente. Las anotaciones en sí mismas son una clase.
2. Al definir anotaciones, etiquetar algunas anotaciones puede representar significados específicos:
@Retention (retenciónPolicy.source) // La anotación solo existe en el código fuente y no la contiene en el archivo de bytecode de clase.
@Retention (retenciónPolicy.Class) // La política de retención predeterminada, la anotación existirá en el archivo de Bytecode de clase, pero no se puede obtener durante el tiempo de ejecución.
@Retention (retenciónPolicy.Runtime) // La anotación existirá en el archivo de Bytecode de clase y se puede obtener a través de la reflexión en tiempo de ejecución.
(Vale la pena señalar el tiempo de ejecución porque significa que se puede recuperar mediante la reflexión)
@Target (elementType.type) // interfaz, clase, enumeración, anotación
@Target (elementtype.field) // constante para campos y enums
@Target (elementtype.method) // método
@Target (elementtype.parameter) // parámetros de método
@Target (elementType.Constructor) // Constructor
@Target (elementtype.local_variable) // variables locales
@Target (elementtype.annotation_type) // anotación
@Target (elementType.package) // paquete
Hay una manera de agregar @taget (xx) y @Retention (retenciónPolicy.Runtime) al definir anotaciones, pero no escriba métodos en las anotaciones. Simplemente usan el mecanismo de reflexión para obtener las anotaciones en el tiempo de ejecución, y luego escriben la lógica correspondiente usted mismo (el llamado analizador de anotaciones)
Probablemente una forma similar de escribir:
import java.lang.annotation.documented; import java.lang.annotation.elementType; import java.lang.annotation.inherited; import java.lang.annotation.retention; import java.lang.annotation.retentionPolicy; import java.lang.annotation.target;@documented@inherited ({{{{{{{{{{{{{{@@inherited ({{{{{{{{{{{{{{{{{{{{{» Elementtype.field, elementtype.method}) @retención (retenciónPolicy.runtime) public @Interface Validate {public int min () predeterminado 1; public int max () predeterminado 10; Public boolean isnotnull () predeterminado verdadero;}Cuando ejecute más tarde, use la reflexión para obtener anotaciones, y no discutiré los detalles.
Encontré este tipo de artículos técnicos sobre esto antes de buscar artículos técnicos en Internet, lo que me trajo una gran confusión en ese momento. No creo que quiera.
El ejemplo anterior de la anotación personalizada de Java para implementar la verificación de parámetros frontales y de fondo es todo el contenido que comparto con usted. Espero que pueda darle una referencia y espero que pueda apoyar más a Wulin.com.