Une brève analyse des annotations de type en Java8

Annotation Comme nous le savons tous, cette fonctionnalité a été ajoutée depuis Java5, et elle a fleuri partout désormais. Elle est largement utilisée dans de nombreux frameworks pour simplifier la configuration des programmes. Alors, quelles sont exactement les annotations de type controversées ? Complexe ou pratique ?

1. Que sont les annotations de type ?

Avant Java 8, les annotations ne peuvent être utilisées que là où elles sont déclarées, comme les classes, les méthodes, les propriétés dans Java 8 ; n'importe quel endroit, tel que :

Créer une instance de classe

new @Interned MyObject();

Mappage de types

myString = (@NonNull String) str;

implémente une instruction

class UnmodifiableList<T> implements @Readonly List<@Readonly T> { ... }

lancer une instruction d'exception

void monitorTemperature() throws @Critical TemperatureException { ... }

Il convient de noter que les annotations de type ne sont que de la syntaxe, pas de la sémantique, et n'affecteront pas le temps de compilation, le temps de chargement et le temps d'exécution de Java. En d'autres termes, le type n'est pas inclus lorsqu'il est compilé dans un. fichier de classe.

2. Le rôle des annotations de type

Regardez d'abord le code suivant :

Collections.emptyList().add("One");
int i=Integer.parseInt("hello");
System.console().readLine();

Le code ci-dessus est compilé avec succès, mais lors de son exécution, UnsupportedOperationException sera signalé ; NumberFormatException ; NullPointerException, ce sont des erreurs d'exécution ;

les annotations de type sont utilisées pour prendre en charge une vérification de type forte dans les programmes Java. Grâce au framework de vérification des plug-ins, les erreurs d'exécution peuvent être détectées lors de la compilation pour améliorer la qualité du code. C'est le rôle des annotations de type.

3. check framework

check framework est un outil tiers qui fonctionne avec les annotations de type Java. L'effet est 1 1>2. Il peut être intégré au compilateur javac, utilisé avec ant et maven, ou en tant que plug-in Eclipse. L'adresse est http://types.cs.washington.edu/checker-framework/.
Le framework de vérification peut trouver où les annotations de type apparaissent et les vérifier. Un exemple simple :

import checkers.nullness.quals.*;
public class GetStarted {
    void sample() {
        @NonNull Object ref = new Object();
    }
}

Utilisez javac pour compiler la classe ci-dessus

javac -processor checkers.nullness.NullnessChecker GetStarted.java

La compilation réussit, mais. Si modifié en :

@NonNull Object ref = null;

Si vous ne souhaitez pas utiliser d'annotations de type pour détecter les erreurs, vous n'avez pas besoin d'un processeur. Javac direct GetStarted.java peut être compilé et transmis. java 8 avec la version Type Annotation Support Oui, mais pas les versions Java 5, 6 ou 7, car le compilateur javac ne sait pas ce qu'est @NonNull, mais check framework a une solution rétrocompatible, qui consiste à annoter le type. annotation nonnull avec /**/
, par exemple, l'exemple ci-dessus est modifié en :

import checkers.nullness.quals.*;
public class GetStarted {
    void sample() {
        /*@NonNull*/ Object ref = null;
    }
}

De cette façon, le compilateur javac ignorera le bloc de commentaire, mais le compilateur javac dans la vérification Le framework peut également détecter des erreurs non nulles.
Grâce au framework de vérification des annotations de type, nous pouvons voir que des erreurs d'exécution peuvent désormais être trouvées lors de la compilation.

4. À propos de JSR 308

JSR 308 veut résoudre deux problèmes qui se posent dans les annotations Java 1.5 :

1. Restrictions syntaxiques sur les annotations : uniquement Possibilité d'écrire des annotations là où. déclaré
2. Limitations sémantiques du système de types : Le système de types ne peut pas empêcher tous les bugs
JSR 308 résout les deux problèmes ci-dessus grâce aux méthodes suivantes :

1. pour permettre aux annotations d'apparaître dans plus de positions. Comprend : les récepteurs de méthodes (Annotation : public int size() @Readonly { ... }), les paramètres génériques, les tableaux, les conversions de type, les tests de type, la création d'objets, la liaison des paramètres de type, l'héritage de classe et la clause throws. En fait, il s'agit de l'annotation de type, qui est désormais une fonctionnalité de Java 8

2. En introduisant des systèmes de types enfichables, un processeur d'annotation plus puissant peut être créé. Le vérificateur de type analyse le code source avec des annotations de qualification de type et génère des messages d'avertissement si des erreurs telles que des incompatibilités sont détectées. En fait, il s'agit d'un framework de vérification
Pour JSR308, certaines personnes s'y opposent, pensant que c'est plus compliqué et statique. Par exemple,

@NotEmpty List<@NonNull String> strings = new ArrayList<@NonNull String>()>

est remplacé par un langage dynamique comme

<🎜. >

var strings = ["one", "two"];

Certaines personnes conviennent qu'en dernière analyse, le Code est le document « le plus fondamental ». Les annotations incluses dans le code indiquent clairement l'intention de la personne qui a écrit le code. Lorsqu'elles ne sont pas mises à jour à temps ou qu'il y a des omissions, ce sont précisément les informations prévues contenues dans les annotations qui risquent le plus d'être perdues dans d'autres documents. De plus, transférer les erreurs d'exécution à l'étape de compilation peut non seulement accélérer le processus de développement, mais également gagner du temps dans la vérification des bogues lors des tests.

5. Résumé

Tout le monde n'aime pas cette fonctionnalité, surtout aujourd'hui où les langages dynamiques sont plus populaires. Heureusement, Java 8 n'oblige pas tout le monde à utiliser cette fonctionnalité. Ce n'est pas nécessaire. Grâce à cette fonctionnalité, les personnes ou les entreprises qui ont des exigences plus élevées en matière de qualité du code peuvent utiliser JSR 308. Après tout, le code est le document "le plus basique". Je suis d'accord avec cette phrase. Même si le code augmentera, cela peut rendre votre code plus expressif. Chacun a sa propre opinion sur ce qu’il pense de cette fonctionnalité. .

Pour plus d'articles liés à la brève analyse des annotations de type en Java8, veuillez faire attention au site Web PHP chinois !