Wie kann man die Annotationen @Nullable und @Nonnull effektiver nutzen?

Ich kann das sehen @Nullableund @NonnullAnmerkungen könnten hilfreich sein, um NullPointerExceptions zu verhindern, aber sie verbreiten sich nicht sehr weit.

• Die Effektivität dieser Anmerkungen nimmt nach einer Indirektionsebene vollständig ab. Wenn Sie also nur einige hinzufügen, breiten sie sich nicht sehr weit aus.
• Da diese Anmerkungen nicht gut durchgesetzt werden, besteht die Gefahr, dass ein mit gekennzeichneter Wert @Nonnullnicht null ist und folglich keine Nullprüfungen durchgeführt werden.

Der folgende Code verursacht einen Parameter mit markiert @Nonnullwerden , nullohne irgendwelche Beschwerden zu erhöhen. Es wirft ein, NullPointerExceptionwenn es ausgeführt wird.

public class Clazz {
    public static void main(String[] args){
        Clazz clazz = new Clazz();

        // this line raises a complaint with the IDE (IntelliJ 11)
        clazz.directPathToA(null);

        // this line does not
        clazz.indirectPathToA(null); 
    }

    public void indirectPathToA(Integer y){
        directPathToA(y);
    }

    public void directPathToA(@Nonnull Integer x){
        x.toString(); // do stuff to x        
    }
}

Gibt es eine Möglichkeit, diese Anmerkungen strenger durchzusetzen und / oder weiter zu verbreiten?

Kurze Antwort: Ich denke, diese Anmerkungen sind nur für Ihre IDE nützlich, um Sie vor potenziell Nullzeigerfehlern zu warnen.

Wie im Buch "Code bereinigen" erwähnt, sollten Sie die Parameter Ihrer öffentlichen Methode überprüfen und auch die Überprüfung von Invarianten vermeiden.

Ein weiterer guter Tipp ist, niemals Nullwerte zurückzugeben, sondern stattdessen das Null-Objektmuster zu verwenden.

Abgesehen von Ihrer IDE, die Ihnen Hinweise gibt, wenn Sie nullan Methoden übergeben, bei denen erwartet wird, dass das Argument nicht null ist, gibt es weitere Vorteile:

• Tools zur Analyse statischer Codes können dieselben Tests wie Ihre IDE durchführen (z. B. FindBugs).
• Sie können AOP verwenden, um diese Aussagen zu überprüfen

Dies kann dazu beitragen, dass Ihr Code besser gewartet werden kann (da Sie ihn nicht benötigen null Überprüfungen ) und weniger fehleranfällig ist.

Ich denke, diese ursprüngliche Frage weist indirekt auf eine allgemeine Empfehlung hin, dass eine Laufzeit-Nullzeigerprüfung weiterhin erforderlich ist, obwohl @NonNull verwendet wird. Siehe folgenden Link:

Die neuen Typanmerkungen von Java 8

Im obigen Blog wird empfohlen, dass:

Optionale Typanmerkungen sind kein Ersatz für die Laufzeitvalidierung. Vor Typanmerkungen befand sich der primäre Speicherort für die Beschreibung von Dingen wie Nullbarkeit oder Bereichen im Javadoc. Bei Typanmerkungen wird diese Kommunikation auf eine Weise zur Überprüfung der Kompilierungszeit in den Bytecode eingegeben. Ihr Code sollte weiterhin eine Laufzeitüberprüfung durchführen.

Beim Kompilieren des Originalbeispiels in Eclipse mit Konformität 1.8 und aktivierter annotationsbasierter Nullanalyse wird folgende Warnung angezeigt:

    directPathToA(y);
                  ^
Null type safety (type annotations): The expression of type 'Integer' needs unchecked conversion to conform to '@NonNull Integer'

Diese Warnung ist analog zu den Warnungen formuliert, die Sie erhalten, wenn Sie generierten Code mit Legacy-Code unter Verwendung von Rohtypen mischen ("ungeprüfte Konvertierung"). Wir haben hier genau die gleiche Situation: MethodeindirectPathToA() hat eine "Legacy" -Signatur, da sie keinen Nullvertrag angibt. Tools können dies leicht melden, sodass sie Sie durch alle Gassen jagen, in denen Nullanmerkungen weitergegeben werden müssen, aber noch nicht.

Und wenn man einen cleveren benutzt @NonNullByDefault wir wir das nicht jedes Mal sagen.

Mit anderen Worten: Ob sich Nullanmerkungen "sehr weit ausbreiten" oder nicht, hängt möglicherweise von dem von Ihnen verwendeten Tool ab und davon, wie streng Sie alle vom Tool ausgegebenen Warnungen beachten. Mit TYPE_USE-Nullanmerkungen haben Sie endlich die Möglichkeit, sich vom Tool vor jeder möglichen NPE in Ihrem Programm warnen zu lassen , da die Nullheit zu einer intrisischen Eigenschaft des Typsystems geworden ist.

Ich bin damit einverstanden, dass sich die Anmerkungen "nicht sehr weit verbreiten". Ich sehe jedoch den Fehler auf der Seite des Programmierers.

Ich verstehe die NonnullAnmerkung als Dokumentation. Die folgende Methode drückt aus, dass (als Voraussetzung) ein Nicht-Null-Argument erforderlich ist x.

    public void directPathToA(@Nonnull Integer x){
        x.toString(); // do stuff to x        
    }

Das folgende Codefragment enthält dann einen Fehler. Die Methode ruft auf, directPathToA()ohne zu erzwingen, dass sie ynicht null ist (das heißt, sie garantiert nicht die Vorbedingung der aufgerufenen Methode). Eine Möglichkeit besteht darin, auch eine NonnullAnmerkung hinzuzufügen indirectPathToA()(Weitergabe der Vorbedingung). Möglichkeit zwei besteht darin, die Nichtigkeit von yin zu überprüfen indirectPathToA()und den Aufruf von directPathToA()when zu vermeiden, wenn ynull ist.

    public void indirectPathToA(Integer y){
        directPathToA(y);
    }

In meinen Projekten aktiviere ich die folgende Option in der Codeüberprüfung "Konstante Bedingungen und Ausnahmen":
Schlagen Sie eine Annullation @Nullable für Methoden vor, die möglicherweise null zurückgeben und nullfähige Werte melden, die an nicht annotierte Parameter übergeben werden

Wenn diese Option aktiviert ist, werden alle nicht mit Anmerkungen versehenen Parameter als nicht null behandelt. Daher wird bei Ihrem indirekten Aufruf auch eine Warnung angezeigt:

clazz.indirectPathToA(null); 

Für noch stärkere Überprüfungen ist das Checker Framework möglicherweise eine gute Wahl (siehe dieses nette Tutorial .
Hinweis : Ich habe das noch nicht verwendet und es kann Probleme mit dem Jack-Compiler geben: siehe diesen Fehlerbericht

In Java würde ich den optionalen Typ von Guava verwenden . Als tatsächlicher Typ erhalten Sie Compiler-Garantien für seine Verwendung. Es ist einfach, es zu umgehen und ein zu erhalten NullPointerException, aber zumindest die Signatur der Methode kommuniziert klar, was sie als Argument erwartet oder was sie zurückgeben könnte.

Wenn Sie Kotlin verwenden, werden diese Annotationen zur Nullfähigkeit in seinem Compiler unterstützt und Sie können keine Null an eine Java-Methode übergeben, für die ein Argument ungleich Null erforderlich ist. Obwohl diese Frage ursprünglich auf Java ausgerichtet war, erwähne ich diese Kotlin-Funktion, da sie speziell auf diese Java-Annotation ausgerichtet ist und die Frage lautete: "Gibt es eine Möglichkeit, diese Annotationen strenger durchzusetzen und / oder weiter zu verbreiten?" Durch diese Funktion werden diese Anmerkungen strenger erzwungen .

Java-Klasse mit @NotNullAnnotation

public class MyJavaClazz {
    public void foo(@NotNull String myString) {
        // will result in an NPE if myString is null
        myString.hashCode();
    }
}

Kotlin-Klasse, die die Java-Klasse aufruft und null für das mit @NotNull annotierte Argument übergibt

class MyKotlinClazz {
    fun foo() {
        MyJavaClazz().foo(null)
    }
}  

Kotlin-Compilerfehler beim Erzwingen der @NotNullAnmerkung.

Error:(5, 27) Kotlin: Null can not be a value of a non-null type String

Siehe: http://kotlinlang.org/docs/reference/java-interop.html#nullability-annotations

Seit der neuen Java 8-Funktion Optional sollten Sie @Nullable oder @Notnull nicht mehr in Ihrem eigenen Code verwenden . Nehmen Sie das folgende Beispiel:

public void printValue(@Nullable myValue) {
    if (myValue != null) {
        System.out.print(myValue);
    } else {
        System.out.print("I dont have a value");
}

Es könnte umgeschrieben werden mit:

public void printValue(Optional<String> myValue) {
    if (myValue.ifPresent) {
        System.out.print(myValue.get());
    } else {
        System.out.print("I dont have a value");
}

Wenn Sie eine Option verwenden, müssen Sie nach Nullwerten suchen . Im obigen Code können Sie nur durch Aufrufen von auf den Wert zugreifenget Methode .

Ein weiterer Vorteil ist, dass der Code besser lesbar wird . Mit Java 9 ifPresentOrElse könnte die Funktion sogar wie folgt geschrieben werden:

public void printValue(Optional<String> myValue) {
    myValue.ifPresentOrElse(
        v -> System.out.print(v),
        () -> System.out.print("I dont have a value"),
    )
}