Ich habe mich gefragt, ob es möglich ist, jedes Mal in Java nach Null zu suchen, aber mir wurde klar, dass Eclipse eine Funktion namens Null Analysis hat. (Es scheint, dass IntelliJ es zuerst implementiert hat)
Ich habe viel recherchiert, daher hier eine Zusammenfassung der Verwendung von Null Analysys (Stand Oktober 2018). Die von mir verwendete Eclipse-Version ist übrigens 2018-09 (4.9.0). Grundsätzlich kann die Nullanalyse nach Juno (4.2) durchgeführt werden, aber die neueste Version ist besser, da es verschiedene Fehler gibt.
Eine Möglichkeit, "Ich möchte nicht jedes Mal null prüfen" statisch zu lösen, indem Sie es wie Java mit Anmerkungen versehen. Weitere Informationen finden Sie unter Nullanalyse mit Eclipse Juno durchführen.
Java 8 oder höher ist erforderlich, um von der Nullanalyse ordnungsgemäß zu profitieren. Ohne die in Java 8 implementierten Anmerkungen vom Typ JSR 308 würden Sie keinen großen Nutzen daraus ziehen.
Es gibt verschiedene ähnliche und unterschiedliche Anmerkungen, wie die von Eclipse und die von IntelliJ IDEA, die schwer auszuwählen sind.
In meinem Fall möchte ich die Farbe einer bestimmten IDE nicht so sehr als Option festlegen.
--JSR 305 `@ javax.annotation.Nonnull``` System --Checker Framework `@ org.checkerframework.checker.nullness.qual.NonNull``` Serie
Wird entweder sein. Für verschiedene Anmerkungen Was ist Nonnull? wird detailliert beschrieben.
In Anbetracht des Modulsystems von Java 9 oder höher kann `@ javax.annotation.Nonnull``` von JSR 305 nicht verwendet werden. Einfach ausgedrückt, wenn Sie versuchen, das externe Modul javax.annotation.Nonnull``` zu verwenden, wobei javax.annotation. * `` Als Java-Standardmodul enthalten ist, kollidiert der Paket-Namespace. Es zu tun. Weitere Informationen finden Sie unter Funktionieren von JSR 305 unter Java 9.
Daher ist die verwendete Annotation eine Alternative zur Annotation des Checker Framework.
Es gibt jedoch ein Problem bei der Verwendung unter Eclipse. In Eclipse wird das Zielpaket für die Nullanalyse anhand der Annotation "@ NonNullByDefault" beurteilt. Das Checker Framework behandelt jedoch alle Standardeinstellungen zunächst als "NonNull", sodass es keine solche Annotation enthält ("@ DefaultQualifier"). `` Etwas ist anders .. Argumente sind erforderlich).
Lassen Sie uns hier ein wenig Kompromisse eingehen und Eclipse-Annotationen für `` `@ NonNullByDefault``` verwenden. Wenn Sie später wechseln, sollten Sie keine großen Probleme haben.
Wenn Sie Anmerkungen verwenden, beziehen Sie diese von Maven Central. `` `build.gradle``` Ein Beispiel ist wie folgt.
// 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'
Die Nullanalyse ist in Eclipse standardmäßig deaktiviert, daher müssen Sie auch den Compiler konfigurieren. Die Methode ist Was ist Nonnull? Es steht unten.
Grundsätzlich sind alle selbst erstellten Pakete standardmäßig auf NonNull eingestellt. Kommentieren Sie einfach die `` `package-info.java``` Ihres eigenen Pakets.
@org.eclipse.jdt.annotation.NonNullByDefault
package common.validator;
Dann erhalten Sie den folgenden Code
public class Foo {
String a;
public String bar(String b) {
String bb = b + b;
return bb;
}
}
Wie unten gezeigt, sieht es so aus, als hätte es `` `@ NonNull``` als Ganzes.
public class Foo {
@NonNull String a; //Das Feld ist@NonNull
@NonNull //Rückgabewert@NonNull
public String bar(@NonNull String b) { //Formale Argumente@NonNull
@NonNull String bb = bb + bb; //Auch lokale Variablen@NonNull
return bb;
}
}
`@ NonNull``` und` @ Nullable```@nonnullBei der Kompilierung (in Echtzeit beim Schreiben von Code in Eclipse) wird garantiert, dass an der mit gekennzeichneten Stelle nicht null eingegeben wird.
Fügen Sie übrigens `` `@ Nullable``` hinzu, wo Sie null setzen möchten.
@nonnullWenn Sie versuchen, null in eine Variable mit zu setzen, erhalten Sie einen Kompilierungsfehler und
@NonNull String a = null; //Kompilierungsfehler
Wenn Sie versuchen, einer @ NonNull-Variablen eine `` `@ Nullable```-Variable zuzuweisen, wird ein Kompilierungsfehler angezeigt, auch wenn sie nicht null ist.
@Nullable String a = "a";
@NonNull String s = a; //Kompilierungsfehler
Gleiches gilt für Methodenaufrufe. Der Versuch, eine Variable `` `@ Nullable``` in die Methode der obigen Beispielklasse einzufügen, führt zu einem Kompilierungsfehler.
Foo foo = new Foo();
@Nullable String nullableStr = "a";
String s = foo.bar(nullableStr); //Kompilierungsfehler hier
Natürlich ist es möglich, eine Variable mit dem Namen "@ NonNull" einer Variablen mit dem Namen "@ Nullable" zuzuweisen.
@NonNull String nonNullStr = "a";
@Nullable String nullableStr = nonNullStr; //OK
`@ Nullable``` in @ NonNull``` zu ändernWenn Sie das DTO-Muster in der Kommunikation mit der Außenwelt verwenden, wird unweigerlich der Wert "@ Nullable" eingegeben, sodass Sie es auf irgendeine Weise in "@ NonNull" konvertieren müssen.
Externe Bibliotheken fügen kein `@ NonNull``` hinzu, daher wird der Rückgabewert als` @ Nullable` `` behandelt.
Die Konvertierung erfolgt durch Zuweisen zu einer Variablen, die "@ NonNull" ist. Wenn Sie sie jedoch normal zuweisen, tritt ein Kompilierungsfehler auf. Teilen Sie dem Compiler daher mit, dass es "@ Nullable" ist, aber nicht null. Es gibt Bedarf.
objects#requirenonnull()Wenn Sie es bestehen, beurteilt der Compiler, dass es überprüft wurde. Dies ist leicht zu erkennen, wenn es offensichtlich ist, dass null nicht kommen wird. Wenn null kommtnullpointerexceptionwerden.
@Nullable String nullableStr = 〜〜;
Objects.requireNonNull(nullableStr); //NullPointerException bei Null
@NonNull String nonNullStr = nullableStr; //OK
Wenn Sie die Nullanalyse verwenden, verwenden Sie diesen Code häufig, sodass Sie ihn bequem in die Java Editor-Vorlage einfügen können.
In meinem Fall habe ich die folgende Definition gesetzt. Schreiben Sie `reqn und drücken Sie `` Strg + Leertaste```, um den Code gut zu erhalten.
Name : ReqNotNull
Context : Java Statement
Automatically insert : true
Pattern:
${:import (java.util.Objects)}Objects.requireNonNull(${localVar})
Auf diese Weise, wenn Sie keine NullPointerException erhalten möchten, wenn diese null ist.
@Nullable String nullableStr = 〜〜;
if (nullableStr != null) { //Sagen Sie mit if-Anweisung
@NonNull String nonNullStr = nullableStr; //OK
}
Wenn es einen anderen Weg gibt, lassen Sie es mich bitte wissen.
Für Arrays ist eine kleine Überlegung erforderlich. Wenn Sie ein Feld normal deklarieren (unter dem Paket @ NonNullByDefault```), wird die Array-Variable selbst zu @ NonNull, aber die Objekte, die in das Array aufgenommen werden, sind `` @ Nullable. werden.
public class Foo {
String[] args; //args ist NonNull, aber args[0]Ist nullbar
}
Wenn der Inhalt `` `@ NonNull``` sein soll, fügen Sie eine Anmerkung hinzu.
public class Foo {
@NonNull String[] args; //args auch args[0]Auch NonNull
}
Gleiches gilt für die Definition von Argumenten mit variabler Länge.
public class Foo {
//Keine Anmerkung
public void bar(String...args) {
//args ist NonNull, aber args[0]Ist nullbar
}
//Mit Anmerkung
public void baz(@NonNull String...args) {
//args auch args[0]Auch NonNull
}
}
Im Fall von List sind im Gegensatz zu einem Array sowohl der Container als auch der Inhalt "@ NonNull".
public class Foo {
List<String> args; //args auch args.get(0)Auch NonNull
}
Eine Notiz von dem, was ich nicht verstehe
Bei Verwendung der JSR 305-Annotation waren Standardmethoden wie "Object # toString ()" mit Nullable problematisch, aber mit der Annotation "Checker Framework + Eclipse" wurde sie als "NonNull" behandelt. Wieso ist es so?
Bei Verwendung der JSR 305-Annotation war das Standard-NonNull nur das formale Argument der Methode. Bei der Annotation Checker Framework + Eclipse waren sowohl das Feld als auch der Rückgabewert NonNull. Ändert Eclipse sein Verhalten, indem es sich den Annotationsnamen ansieht?
Ich werde es hinzufügen, wenn ich mehr Wissen habe.
Recommended Posts