Je me demandais s'il serait possible de vérifier la valeur null en Java à chaque fois, mais j'ai réalisé qu'Eclipse avait une fonction appelée Null Analysis. (Il semble qu'IntelliJ l'ait implémenté en premier)
J'ai recherché diverses choses, je vais donc résumer comment utiliser Null Analysys (à partir d'octobre 2018). À propos, la version d'Eclipse que j'utilise est 2018-09 (4.9.0). Fondamentalement, l'analyse nulle peut être effectuée après Juno (4.2), mais la dernière version est meilleure car il y a divers bogues.
Un moyen de résoudre statiquement "Je ne veux pas vérifier null à chaque fois" en l'annotant comme Java. Pour plus d'informations, consultez Effectuer une analyse nulle avec Eclipse Juno.
Java 8 ou version ultérieure est nécessaire pour bénéficier correctement de Null Analysis. Sans les annotations de type JSR 308 implémentées dans Java 8, vous n'obtiendrez pas beaucoup d'avantages.
Il existe diverses annotations similaires et différentes, telles que celles d'Eclipse et celles d'IntelliJ IDEA, qui sont difficiles à sélectionner.
Dans mon cas, je ne veux pas tellement mettre la couleur d'un IDE spécifique, donc en option,
--JSR 305 @ javax.annotation.Nonnull``` série
--Checker Framework série @ org.checkerframework.checker.nullness.qual.NonNull ''
Sera non plus. Pour diverses annotations, Qu'est-ce que Nonnull? est détaillé.
De plus, compte tenu du système de modules de Java 9 ou version ultérieure, @ javax.annotation.Nonnull '' de JSR 305 ne peut pas être utilisé. En termes simples, si vous essayez d'utiliser le module externe javax.annotation.Nonnull``` where` `javax.annotation. *` `Est inclus en tant que module standard Java, l'espace de noms du package est en conflit. Pour le faire. Voir Faire fonctionner JSR 305 sur Java 9 pour plus de détails.
Par conséquent, l'annotation utilisée est une alternative à l'annotation Checker Framework.
Cependant, son utilisation sur Eclipse pose un problème.
Dans Eclipse, le package cible pour Null Analysis est jugé par l'annotation @ NonNullByDefault```, mais Checker Framework traite toutes les valeurs par défaut comme NonNull en premier lieu, donc il n'a pas une telle annotation ( @ DefaultQualifier` ". `` Quelque chose est différent ... Des arguments sont nécessaires).
Faisons un peu de compromis ici et utilisons les annotations Eclipse pour @ NonNullByDefault```. Même si vous changez plus tard, vous ne devriez pas avoir beaucoup de problèmes.
Lorsque vous utilisez des annotations, récupérez-les auprès de Maven Central. `` `build.gradle``` Un exemple est le suivant.
// https://mvnrepository.com/artifact/org.checkerframework/checker-qual
implementation group: 'org.checkerframework', name: 'checker-qual', version: '2.5.6'
// https://mvnrepository.com/artifact/org.eclipse.jdt/org.eclipse.jdt.annotation
implementation group: 'org.eclipse.jdt', name: 'org.eclipse.jdt.annotation', version: '2.2.100'
Null Analysis est désactivé par défaut dans Eclipse, vous devez donc également configurer le compilateur. La méthode est Qu'est-ce que Nonnull? Il est écrit en bas.
Fondamentalement, tous les packages créés par vous-même sont définis sur NonNull par défaut. Annotez simplement le `` package-info.java '' de votre propre paquet.
@org.eclipse.jdt.annotation.NonNullByDefault
package common.validator;
Ensuite, vous obtiendrez le code suivant
public class Foo {
String a;
public String bar(String b) {
String bb = b + b;
return bb;
}
}
Comme indiqué ci-dessous, il semble avoir @ NonNull``` dans son ensemble.
public class Foo {
@NonNull String a; //Le champ est@NonNull
@NonNull //Valeur de retour@NonNull
public String bar(@NonNull String b) { //Arguments formels@NonNull
@NonNull String bb = bb + bb; //Les variables locales aussi@NonNull
return bb;
}
}
@ NonNull et `` `` @ Nullable@nonnullIl est garanti lors de la compilation (en temps réel lors de l'écriture de code dans eclipse) que null n'est pas entré à l'endroit marqué par.
Au fait, ajoutez `` @ Nullable '' à l'endroit où vous voulez mettre null.
@nonnullSi vous essayez de mettre null dans une variable avec, vous obtiendrez une erreur de compilation et
@NonNull String a = null; //Erreur de compilation
Si vous essayez d'assigner une variable @ Nullable à une variable `` `` @ NonNull, même si elle n'est pas nulle, vous obtiendrez une erreur de compilation.
@Nullable String a = "a";
@NonNull String s = a; //Erreur de compilation
La même chose s'applique aux appels de méthode. Tenter de mettre une variable `` @ Nullable '' dans la méthode de l'exemple de classe ci-dessus entraînera une erreur de compilation.
Foo foo = new Foo();
@Nullable String nullableStr = "a";
String s = foo.bar(nullableStr); //Erreur de compilation ici
Bien entendu, il est possible d'assigner une variable qui est @ NonNull à une variable qui est` `` @ Nullable.
@NonNull String nonNullStr = "a";
@Nullable String nullableStr = nonNullStr; //OK
`@ Nullable``` en `@ NonNull```Si vous utilisez le modèle DTO pour la communication avec l'extérieur, vous obtiendrez inévitablement une valeur de @ Nullable, vous devez donc le convertir en `` `` @ NonNull d'une manière ou d'une autre.
Les bibliothèques externes n'ajoutent pas @ NonNull```, donc la valeur de retour sera traitée comme @ Nullable` ``.
La conversion se fait en affectant à une variable qui est @ NonNull, mais si vous l'affectez normalement, une erreur de compilation se produira, alors dites au compilateur que c'est` `` @ Nullable mais ce n'est pas nul. Il y a un besoin.
objects#requirenonnull()Si vous le réussissez, le compilateur jugera qu'il a été vérifié. C'est facile à dire s'il est évident que null ne viendra pas. Si nul vientnullpointerexceptiondevenir.
@Nullable String nullableStr = 〜〜;
Objects.requireNonNull(nullableStr); //NullPointerException lorsque Null
@NonNull String nonNullStr = nullableStr; //OK
Si vous utilisez Null Analysis, vous utiliserez ce code fréquemment, il est donc pratique de le mettre dans le modèle de l'éditeur Java.
Dans mon cas, je mets la définition suivante. Écrivez reqn` '' et appuyez sur `` Ctrl + Espace '' pour obtenir le code correctement.
Name : ReqNotNull
Context : Java Statement
Automatically insert : true
Pattern:
${:import (java.util.Objects)}Objects.requireNonNull(${localVar})
De cette façon, si vous ne voulez pas obtenir une exception `` NullPointerException '' lorsqu'elle est nulle.
@Nullable String nullableStr = 〜〜;
if (nullableStr != null) { //Dites avec une instruction if
@NonNull String nonNullStr = nullableStr; //OK
}
S'il existe une autre façon de le dire, faites-le moi savoir
Un peu de considération est nécessaire pour les tableaux. Si vous déclarez un champ normalement (sous le package @ NonNullByDefault ''), la variable tableau elle-même devient @ NonNull, mais les objets qui entrent dans le tableau sont `` @ Nullable. devenir.
public class Foo {
String[] args; //args est NonNull, mais args[0]Est nul
}
Si vous voulez que le contenu soit `` @ NonNull '', ajoutez une annotation.
public class Foo {
@NonNull String[] args; //args args également[0]Aussi NonNull
}
La même chose est vraie lors de la définition d'arguments de longueur variable.
public class Foo {
//Aucune annotation
public void bar(String...args) {
//args est NonNull, mais args[0]Est nul
}
//Avec annotation
public void baz(@NonNull String...args) {
//args args également[0]Aussi NonNull
}
}
Dans le cas de List, contrairement à un tableau, le conteneur et le contenu sont `` @ NonNull ''.
public class Foo {
List<String> args; //args args également.get(0)Aussi NonNull
}
Une note de ce que je ne comprends pas
Lors de l'utilisation de l'annotation JSR 305, les méthodes standard telles que ```Object # toString () étaient gênantes avec Nullable, mais avec l'annotation Checker Framework + Eclipse, elle était traitée comme NonNull. Pourquoi en est-il ainsi?
Lors de l'utilisation de l'annotation JSR 305, la valeur par défaut NonNull était uniquement l'argument formel de la méthode, mais avec l'annotation Checker Framework + Eclipse, le champ et la valeur de retour étaient NonNull. Eclipse change-t-il son comportement en regardant le nom de l'annotation?
Je l'ajouterai quand j'aurai plus de connaissances.
Recommended Posts