En fait, c'est une méthode qui peut être utilisée pour définir des annotations personnalisées via @Constraint.
@Constraint (ValidatedBy = xxxx.class)
Vous trouverez ci-dessous un exemple de code de l'annotation personnalisée Java que j'ai faite pour implémenter la vérification des paramètres avant et backend
Si cela vous intéresse, veuillez le lire attentivement et l'apprendre attentivement:
Package SONN.SONNAnnotation; Import Java.lang.annotation.Documented; Import Java.lang.annotation.ElementType; Import Java.lang.annotation.Retention; Importer Java.lang.annotation.retentionPolicy; Importer Java.Lang.annotation.target; Import Javax.Valid javax.validation.constraintValidator; import javax.validation.constraintValidatorContext; import javax.validation.payload; importer sonn.util.stringutill; / *** @classname: isvalidString * @description: les annotations personnalisées implémentent le paramètre avant et le paramètre de backend pour déterminer si 2016-7-25 8:22:58 PM * @version 1.0 * / @ Target ({elementType.field, elementType.Method}) @ Rétention (RetentionPolicy.Runtime) @Constraint (validedBy invalide."; Classe <?> [] Groupes () default {}; Classe <? étend la charge utile> [] Payload () par défaut {}; class ValidStringChecker implémente CONSTRAINTVALIDATOR <ISVALIDSTRING, String> {@Override public void initialize (IsvalidString arg0) {} @Override public boolean isvalid (String strvalue, constraintValidatorContext context) {if (stringutiLL.isStRingEMPTy (strvalue) {return true; } if (strValue.Contains ("<")) {return false; } return true; }}}Le code ci-dessus définit la logique de la méthode de l'annotation via @Constraint (validedBy = isvalidString.validStringChecker.class) - la classe intérieure de la classe d'annotation nommée validstringchecker.
Cette classe interne met en œuvre l'interface de contrainte Validator <IsvalidString, String>
La documentation officielle le décrit comme ceci:
Javax.validation
Interface ConstraintValidator <A étend l'annotation, t>
•
--------------------------------------------------------------------------------------------------------------------------------
Interface publique ContraintValidator <A étend l'annotation, T> définit la logique pour valider une contrainte donnée A pour un type d'objet donné T.
Les implémentations doivent se conformer aux restrictions suivantes:
• t doit se résoudre à un type non paramétré
• ou les paramètres génériques de t doivent être des types de caractères génériques illimités
L'annotation soutenue à l'appui peut être placée sur une implémentation de contrainte-valeur pour le marquer en tant que contraintes de paramètre croisé. Consultez Poubli enValidationTarget et contrainte pour plus d'informations.
La méthode ISVALID implémentée est la méthode de vérification de cette interface.
Testez l'effet et ajoutez des annotations au champ de classe d'entité à vérifier:
Écrivez la page de l'article, ajoutez '<' dans le titre de l'article et soumettez:
La soumission a échoué, avec une erreur de 500, indiquant que l'annotation prend effet:
Mais il y a encore des problèmes avec cela. Le site Web de mon blog ne peut pas imprimer directement le message d'erreur. Vous devez toujours créer une page d'erreur.
Ceci est simple, ajoutez le chemin d'erreur de la page d'erreur sous web.xml, puis créez une page:
<Reur d'erreur>
<CODE-CODE> 500 </ror Error-Code>
<l location> /error.jsp </lancier>
</ error-page>
Tout d'abord, présentons quelques concepts de base:
1.Java définit une annotation avec @Interface xx {}.
L'annotation n'est en fait pas mystérieuse, c'est juste une marque. Lorsque le programme s'exécute à la marque, il exécute la logique correspondante. Les annotations elles-mêmes sont une classe.
2. Lors de la définition d'annotations, l'étiquetage de certaines annotations peut représenter des significations spécifiques:
@Retention (RetentionPolicy.Source) // L'annotation existe uniquement dans le code source et ne le contienne pas dans le fichier de bytecode de classe.
@Retention (RetentionPolicy.class) // La politique de rétention par défaut, l'annotation existera dans le fichier bytecode de classe, mais il ne peut pas être obtenu pendant l'exécution.
@Retention (RetentionPolicy.Runtime) // L'annotation existera dans le fichier de bytecode de classe et peut être obtenue par réflexion lors de l'exécution.
(Runtime mérite d'être noté car cela signifie qu'il peut être récupéré par réflexion)
@Target (elementType.Type) // Interface, classe, énumération, annotation
@Target (elementType.field) // constante pour les champs et les énumériques
@Target (elementType.Method) // Méthode
@Target (elementType.Parameter) // Paramètres de méthode
@Target (elementType.Constructor) // Constructeur
@Target (elementType.local_variable) // Variables locales
@Target (elementType.annotation_type) // Annotation
@Target (elementType.package) // package
Il existe un moyen d'ajouter @taget (xx) et @retention (retenderPolicy.runtime) lors de la définition d'annotations, mais n'écrivez pas de méthodes dans les annotations. Ils utilisent simplement le mécanisme de réflexion pour obtenir les annotations lors de l'exécution, puis écrivez vous-même la logique correspondante (l'annuaire soi-disant)
Probablement une façon similaire d'écrire:
Importer java.lang.annotation.documented; import java.lang.annotation.elementType; import java.lang.annotation.inherited; import java.lang.annotation.retention; import java.lang.annotation.retentiondpolicy; import java.lang.annotation.target; @ documenté @ inherite ElementType.field, elementType.Method}) @ rétention (retenderPolicy.runtime) public @Interface valider {public int min () par défaut 1; public int max () par défaut 10; public boolean isnotnull () par défaut true;}Lorsque vous exécutez plus tard, utilisez la réflexion pour obtenir des annotations et je ne discuterai pas des détails.
J'ai trouvé ce type d'articles techniques à ce sujet avant de chercher des articles techniques sur Internet, ce qui m'a fait une grande confusion à ce moment-là. Je ne pense pas que je veux.
L'exemple ci-dessus de l'annotation personnalisée Java pour implémenter la vérification des paramètres avant et backend est tout le contenu que je partage avec vous. J'espère que vous pourrez vous faire référence et j'espère que vous pourrez soutenir Wulin.com plus.