1: Introduction aux annotations Java
Les annotations sont souvent utilisées dans le développement et je vois parfois des annotations personnalisées dans les projets. Aujourd'hui, discutons de ce qu'est l'annotation, ainsi que les scénarios d'application de l'annotation et comment personnaliser l'annotation.
Le suivant répertorie les annotations communes en développement
@Override: utilisé pour identifier que la méthode hérite de la superclasse. Lorsque la méthode de la classe parent est supprimée ou modifiée, le compilateur invitera un message d'erreur (vous pouvez toujours le voir sur la méthode toString () que nous voyons le plus souvent)
@Deprecated: Cela signifie que cette classe ou méthode est obsolète et a expiré. Si l'utilisateur souhaite toujours l'utiliser, un avertissement de compilation sera généré.
@SuppressWarnings: Message d'avertissement du compilateur pour ignorer
Test Junit: @Test
Quelques annotations du printemps: @Controller, @RequestMapping, @RequestParam, @ResponseBody, @Service, @Component, @Repository, @Resource, @Autowire
Annotations pour la vérification Java: @notnull, @email
Jetons un coup d'œil au vrai visage du mont Lu dans l'annotation Override.java
@Target (elementType.Method) @retention (retenderPolicy.source) public @Interface Override {} 2: Connaissance de base de l'annotation Java
1. Type de données d'annotation Java
Les annotations sont écrites dans des fichiers .java et utilisent @Interface comme mot-clé, donc les annotations sont également un type de données de Java. À partir d'une définition large, de la classe, de l'interface, de l'énumération et de l'annotation sont tous des types de classe.
2. Java Meta Annotation
Lors de la création d'annotations, vous devez utiliser des annotations pour décrire les annotations que vous avez créées, c'est-à-dire les annotations écrites sur @Interface. Ces annotations sont appelées Meta Annotations, telles que @target, @retention, etc. vues dans la priorité. Voici quelques méta-annotations
@Documented: Utilisé pour marquer si l'annotation est incluse lors de la génération de Javadoc. Vous pouvez voir que cette annotation est la même que @Override, l'annotation est vide et il n'y a rien.
@ Documenté @ retenue (retentionPolicy.runtime) @target (elementType.annotation_type) public @Interface documenté {}@Target: utilisé pour définir où les annotations peuvent être utilisées. Par défaut, il peut être utilisé n'importe où, ou il peut spécifier la portée d'utilisation. En développement, il est plus courant d'utiliser des annotations sur les classes (telles que @Controller), les champs (tels que @Autowire), les méthodes (telles que @RequestMapping), les paramètres de méthodes (tels que @RequestParam), etc.
Type: classe, interface ou Déclaration d'énumération
Champ: Domaine (attribut) Déclaration
Méthode: Déclaration de méthode
Paramètre: Déclaration des paramètres
Constructeur: Déclaration de méthode du constructeur
Local_variable: Déclaration de variable locale
Annotation_type: Déclaration de type de commentaire
Package: instruction Package
Target.java
@ Documentée @ rétention (retenderPolicy.runtime) @target (elementType.annotation_type) public @Interface Target {/ ** * Renvoie un tableau des types d'éléments auquel un type d'annotation * peut être appliqué. * @return un tableau des types d'éléments Un type d'annotation * peut être appliqué à * / elementType [] value ();} Classe publique ENUM ElementType {/ **, interface (y compris le type d'annotation), ou Déclaration d'énumération * / Type, / ** Déclaration de champ (inclut les constantes enum) * / champ, / ** Déclaration de méthode * / Méthode, / ** Déclaration de paramètre formel * / Paramètre, / ** Déclaration de constructeur * / Constructeur, / * Déclaration variable locale * * / Annotation_type, / ** Déclaration de package * / package, / ** Type de déclaration de paramètre * / type_paramètre, / ** Utilisation d'un type * / type_use}@Inherited: permet aux sous-classes de hériter des annotations dans la classe parent et peut obtenir les annotations de la classe parent par la réflexion.
@ Documentée @ retenue (retentionPolicy.runtime) @target (elementType.annotation_type) public @Interface Hérité {}@Constraint: utilisé pour vérifier si la valeur d'attribut est légale
@ Documenté @ cible ({elementType.annotation_type}) @ rétention (retentionPolicy.runtime) public @Interface Contrainte {class <? étend CONSTRAINTVALIDATOR <?,? >> [] ValidatedBy ();}@Retention: Le cycle de déclaration de l'annotation est utilisé pour définir le stade de survie de l'annotation. Il peut survivre au niveau du code source, au niveau de compilation (niveau de code d'octets) et au niveau d'exécution.
Source: Niveau de code source, les annotations ne sont présentes que dans le code source et sont généralement utilisées pour interagir avec le compilateur et sont utilisées pour détecter le code. Comme @Override, @Suppresswarings.
Classe: Niveau bytecode, les annotations existent dans le code source et les fichiers bytecode. Ils sont principalement utilisés pour générer des fichiers supplémentaires pendant la compilation, tels que XML, les fichiers Java, etc., mais ne peuvent pas être obtenus pendant l'exécution. Par exemple, MyBatis génère des fichiers entités et mappage. À ce niveau, il est nécessaire d'ajouter un proxy (JavaAgent) lorsque JVM est chargé et d'utiliser un proxy pour modifier dynamiquement le fichier bytecode.
Exécution: niveau d'exécution, les annotations existent dans les machines virtuelles de code source, bytecode et java. Ils sont principalement utilisés pour l'exécution et la réflexion peut être utilisée pour obtenir des informations pertinentes.
@ Documentée @ retenue (retentionPolicy.runtime) @target (elementType.annotation_type) public @Interface Retention {/ ** * Renvoie la politique de rétention. * @return la politique de rétention * / RétentionPolicy Value ();} 3. Contenu des annotations Java
Dans le code source d'annotation ci-dessus, vous pouvez voir que certaines annotations n'ont pas de contenu, et certaines annotations ont du contenu, ce qui semble être une méthode.
Format de syntaxe du contenu annoté: Type de données Nom d'attribut () Valeur par défaut par défaut, le type de données est utilisé pour décrire le type de données de l'attribut. La valeur par défaut signifie que lorsqu'aucun attribut n'est attribué, la valeur par défaut est utilisée. Généralement, String utilise une chaîne vide "" comme valeur par défaut, et les tableaux utilisent généralement un array vide {} comme valeur par défaut.
Jetons un coup d'œil à l'énoncé de l'annotation de la mise en évidence dans Springmvc
@Target ({elementType.Method, elementType.type}) @ retention (retenderPolicy.runtime) @ documenté @ mappingPublic @interface requestmapping {String name () default ""; @Aliasfor ("path") string [] value () default {}; @Aliasfor ("valeur") string [] path () default {}; RequestMethod [] méthode () default {}; String [] params () Default {}; String [] Headers () Default {}; String [] Consumers () Default {}; String [] produit () par défaut {};}Utilisation de l'annotation de la mise en évidence dans Springmvc
@RequestMapping (value = "/ list", méthode = requestMethod.post, produit = {"application / json; charset = utf-8;"}) public String list () {} 4. Utiliser des scénarios d'annotations
Vous pouvez analyser les scénarios d'utilisation des annotations à travers la période de déclaration d'annotations:
Niveau de code source source: pour les compilateurs, tels que @Override, @DepreCated, etc., il n'y a pas beaucoup de scénarios que les développeurs devraient utiliser.
Classe: Niveau Bytecode, cette partie est rarement vue
Exécution: niveau d'exécution, c'est le plus courant, et presque toutes les annotations utilisées par les développeurs sont le niveau d'exécution. Les annotations d'exécution sont couramment utilisées dans les situations suivantes
Annotation sans aucun attribution dans l'annotation. Cette partie de l'annotation joue généralement un rôle d'annotation, comme @Test, @Before, @After. En obtenant ces annotations de balises, un traitement logique est effectué.
Vous pouvez utiliser l'annotation de contrainte @Constraint pour vérifier la valeur d'attribut, comme @email, @notnull, etc.
Vous pouvez configurer certains paramètres en utilisant des propriétés dans l'annotation, puis vous pouvez utiliser la réflexion pour obtenir ces paramètres. Ces annotations n'ont pas d'autres fonctions spéciales, elles configurent simplement certains paramètres au lieu de la configuration XML. En utilisant des annotations pour configurer les paramètres, cela est populaire dans Spring Boot, comme @configuration
En ce qui concerne la méthode de configuration XML vs annotation, utilisez généralement du XML pour configurer certaines configurations qui ne sont pas très proches de la relation commerciale et utilisent des annotations pour configurer certains paramètres étroitement liés à l'entreprise.
Trois: Java Annotation and Reflection Basic API
// Obtenir l'annotation d'un certain type public <a étend une annotation> une grenotation (classe <a> annotationclass); // obtient toutes les annotations (y compris les annotations modifiées par hérité dans la classe parent) Annotation publique [] getAnnotations (); // faire déclarer les annotations (mais n'inclut pas les annotations modifiées par héréditaires dans la classe parentale) Annotation publique [] getDeclarenAnnotations (); // Testez si un objet est annoté par une annotation publique boolean Isannotation Promense SecurityException; // Obtenez une certaine méthode Méthode publique GetMethod (nom de chaîne, classe <?> ... ParameterTypes);
Quatre: Annotations personnalisées
Utilisez des annotations personnalisées + intercepteurs ou AOPS pour contrôler les autorisations.
L'exemple suivant est utilisé pour définir une annotation pour restreindre les utilisateurs doivent se connecter lors de l'accès à une interface.
Étape 1: Définissez l'annotation
Requirenlogin.java
@ Documenté @ cible ({elementType.Method}) @ Rétention (retentionPolicy.runtime) public @Interface Deallogin {}Étape 2: Utilisez des annotations
@ Contrôleur @ requestmapping ("/ user") public class userController {@RequiresLogin @RequestMapping (value = "/ list", produit = {"application / json; charset = utf-8;"}) public string getUserList () {System.out.println ("------------------"); return "[{'id': 1, 'username': 'zhangsan'}]"; }}Étape 3: Utilisez AOP pour intercepter et analyser les annotations
classe publique LoginAdvices {public void avant (joinpoint joinpoint) lève l'exception {objet cible = joinpoint.getTarget (); String MethodName = joinpoint.getSignature (). GetName (); System.out.println (Target + "-------" + MethodName); Méthode méthode = cible.getClass (). GetMethod (méthodyName); Boolean AnnotationPresent = Method.IsannotationPresent (DealSLogin.class); if (annotationPresent) {// l'utilisateur doit se connecter booléen islogin = false; if (! Islogin) {lancer une nouvelle exception ("vous devez vous connecter pour accéder à cette interface"); } else {System.out.println ("Login ..."); }}}}Configurer AOP dans ApplicationContext.xml
<bean id = "LoginAdvices" /> <! - AOP Configuration -> <aop: config proxy-target-class = "true"> <! - section -> <aop: aspect ref = "LoginAdvices"> <! - Point -> <aop: Pointcut id = "Pointcut1" expression = "Expression (* comengdee.manager.Controller. <! - Méthode et point de notification de connexion -> <aop: avant méthode = "avant" Pointcut-ref = "Pointcut1" /> </aop: aspect> </ aop: config>
Exceptions personnalisées
Pourquoi personnaliser les exceptions
Bien que Java offre une riche variété de cours d'exception de traitement des exceptions, les exceptions personnalisées sont souvent utilisées dans les projets. La raison principale est que les classes d'exception fournies par Java ne peuvent toujours pas répondre aux besoins de diverses entreprises dans certains cas. Par exemple, certaines erreurs dans le système sont conformes à la syntaxe Java, mais ne respectent pas la logique métier. Si le compte n'existe pas lorsque l'utilisateur se connecte ou que le compte est verrouillé, vous pouvez personnaliser une exception de compte Accountexception.
Ou dans certains cas, la même exception en Java peut être causée par plusieurs raisons. Il n'est pas facile de localiser les erreurs lors du dépannage des problèmes. Pour le moment, vous pouvez utiliser une personnalisation d'une exception plus claire.
Avantages des exceptions personnalisées: les exceptions personnalisées peuvent rendre les exceptions plus claires et masquer les exceptions sous-jacentes, ce qui est plus sûr et plus intuitif.
Utilisation des exceptions personnalisées: les exceptions personnalisées sont généralement héritées de l'exception ou de RuntimeException. Selon les besoins de l'entreprise, certains attributs peuvent être considérés comme paramètres du constructeur. Les exceptions personnalisées nécessitent que les programmeurs lancent manuellement les exceptions et géraient les exceptions.
Vous trouverez ci-dessous un exemple d'exceptions personnalisées dans Apache Shiro
La classe publique ShiroException étend RuntimeException {public shiroException () {} public shiroException (String Message) {super (message); } public ShiroException (cause jetable) {super (cause); } public shiroException (message de chaîne, cause thrognable) {super (message, cause); }}Ce qui précède est une description détaillée de l'annotation Java et des annotations personnalisées