Bagaimana cara menggunakan anotasi @Nullable dan @Nullull secara lebih efektif?

Saya dapat melihat itu @Nullabledan @Nonnullpenjelasan dapat membantu dalam mencegah NullPointerExceptiontetapi mereka tidak menyebar terlalu jauh.

• Keefektifan anotasi ini menurun sepenuhnya setelah satu tingkat tipuan, jadi jika Anda hanya menambahkan beberapa, mereka tidak menyebar terlalu jauh.
• Karena anotasi ini tidak ditegakkan dengan baik, ada bahaya menganggap nilai yang ditandai dengan @Nonnulltidak nol dan akibatnya tidak melakukan pemeriksaan nol.

Kode di bawah menyebabkan parameter yang ditandai dengan @Nonnullmenjadi nulltanpa menaikkan keluhan. Itu melempar NullPointerExceptionketika dijalankan.

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        
    }
}

Apakah ada cara untuk membuat anotasi ini lebih ketat ditegakkan dan / atau disebarkan lebih lanjut?

Jawaban singkat: Saya kira penjelasan ini hanya berguna bagi IDE Anda untuk memperingatkan Anda tentang kemungkinan kesalahan pointer nol.

Seperti yang dikatakan dalam buku "Kode Bersih", Anda harus memeriksa parameter metode publik Anda dan juga menghindari memeriksa invarian.

Tip lain yang baik adalah tidak pernah mengembalikan nilai null, tetapi menggunakan Pola Objek Null sebagai gantinya.

Selain IDE Anda memberi Anda petunjuk ketika Anda meneruskan nullke metode yang mengharapkan argumen tidak menjadi nol, ada keuntungan lebih lanjut:

• Alat analisis kode statis dapat menguji sama dengan IDE Anda (mis. FindBugs)
• Anda dapat menggunakan AOP untuk memeriksa pernyataan ini

Ini dapat membantu kode Anda lebih mudah dikelola (karena Anda tidak perlu nullmemeriksa) dan lebih sedikit kemungkinan kesalahan.

Saya pikir pertanyaan awal ini secara tidak langsung menunjuk ke rekomendasi umum bahwa pemeriksaan null-pointer run-time masih diperlukan, meskipun @NonNull digunakan. Lihat tautan berikut:

Anotasi Tipe Java 8 yang baru

Di blog di atas, disarankan agar:

Anotasi Jenis Opsional bukan pengganti untuk validasi runtime Sebelum Anotasi Tipe, lokasi utama untuk menjelaskan hal-hal seperti nullability atau rentang ada di javadoc. Dengan anotasi Jenis, komunikasi ini masuk ke dalam bytecode untuk verifikasi waktu kompilasi. Kode Anda masih harus melakukan validasi runtime.

Mengompilasi contoh asli di Eclipse at compliance 1.8 dan dengan analisis nol berbasis anotasi diaktifkan, kami mendapatkan peringatan ini:

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

Peringatan ini dianalogikan dengan peringatan yang Anda dapatkan ketika mencampur kode yang dibuat dengan kode lama menggunakan tipe mentah ("konversi tidak dicentang"). Kami memiliki situasi yang sama persis di sini: metode indirectPathToA()memiliki tanda tangan "lawas" karena tidak menentukan kontrak nol. Alat-alat dapat dengan mudah melaporkan ini, sehingga mereka akan memburu Anda semua gang di mana anotasi nol perlu diperbanyak tetapi belum.

Dan ketika menggunakan pintar @NonNullByDefaultkita bahkan tidak harus mengatakan ini setiap saat.

Dengan kata lain: apakah anotasi nol atau "menyebar sangat jauh" tergantung pada alat yang Anda gunakan, dan seberapa keras Anda memperhatikan semua peringatan yang dikeluarkan oleh alat tersebut. Dengan TYPE_USE null annotations Anda akhirnya memiliki opsi untuk membiarkan alat memperingatkan Anda tentang setiap NPE yang mungkin ada dalam program Anda, karena nullness telah menjadi properti intris dari sistem tipe.

Saya setuju bahwa anotasi "jangan menyebar terlalu jauh". Namun, saya melihat kesalahan di sisi programmer.

Saya mengerti Nonnullanotasi sebagai dokumentasi. Metode berikut ini menyatakan bahwa diperlukan (sebagai prasyarat) argumen non-nol x.

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

Cuplikan kode berikut ini kemudian berisi bug. Metode panggilan directPathToA()tanpa penegakan yang ynon-null (yaitu, itu tidak menjamin prasyarat dari metode yang disebut). Satu kemungkinan adalah menambahkan Nonnullanotasi juga ke indirectPathToA()(menyebarkan prakondisi). Kemungkinan kedua adalah untuk memeriksa nullity yin indirectPathToA()dan menghindari panggilan directPathToA()ketika ynull.

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

Apa yang saya lakukan dalam proyek saya adalah untuk mengaktifkan opsi berikut dalam inspeksi kode "Kondisi & pengecualian konstan":
Sarankan @ anotasi yang dapat dihapus untuk metode yang dapat mengembalikan nol dan melaporkan nilai yang dapat diupgrade yang dilewatkan ke parameter yang tidak dianotasi

Saat diaktifkan, semua parameter yang tidak dianotasi akan diperlakukan sebagai bukan nol dan karenanya Anda juga akan melihat peringatan pada panggilan tidak langsung Anda:

clazz.indirectPathToA(null); 

Untuk pemeriksaan yang lebih kuat, Kerangka Pemeriksa mungkin merupakan pilihan yang baik (lihat tutorial yang bagus ini .
Catatan : Saya belum menggunakannya dan mungkin ada masalah dengan kompiler Jack: lihat laporan bug ini

Di Jawa saya akan menggunakan jenis Opsional Guava . Menjadi tipe aktual Anda mendapatkan jaminan kompilator tentang penggunaannya. Sangat mudah untuk mem-bypassnya dan mendapatkan NullPointerException, tetapi setidaknya tanda tangan dari metode tersebut dengan jelas mengomunikasikan apa yang diharapkan sebagai argumen atau apa yang mungkin kembali.

Jika Anda menggunakan Kotlin, mendukung anotasi nullability ini di kompilernya dan akan mencegah Anda meneruskan null ke metode java yang memerlukan argumen non-nol. Meskipun pertanyaan ini awalnya ditargetkan di Jawa, saya menyebutkan fitur Kotlin ini karena secara khusus ditargetkan pada anotasi Java ini dan pertanyaannya adalah "Apakah ada cara untuk membuat anotasi ini lebih ketat ditegakkan dan / atau disebarkan lebih lanjut?" dan fitur ini membuat penjelasan ini lebih ketat .

Kelas Java menggunakan @NotNullanotasi

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

Kelas Kotlin memanggil kelas Java dan meneruskan null untuk argumen yang dijelaskan dengan @NotNull

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

Kesalahan kompilator Kotlin menegakkan @NotNullanotasi.

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

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

Karena Java 8 fitur baru Opsional Anda tidak boleh menggunakan @Nullable atau @Notnull dalam kode Anda sendiri lagi . Ambil contoh di bawah ini:

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

Itu dapat ditulis ulang dengan:

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

Menggunakan opsional memaksa Anda untuk memeriksa nilai nol . Dalam kode di atas, Anda hanya dapat mengakses nilai dengan memanggil getmetode.

Keuntungan lain adalah bahwa kode menjadi lebih mudah dibaca . Dengan tambahan Java 9 ifPresentOrElse , fungsi tersebut bahkan dapat ditulis sebagai:

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