@Nullable ve @Nonnull ek açıklamalarını nasıl daha etkin kullanabilirim?

Bunu görebiliyorum @Nullableve @Nonnullek açıklamalar s'yi önlemede yardımcı olabilirNullPointerException ama çok ilerlemiyorlar.

• Bu ek açıklamaların etkinliği bir dolaylı aktarım düzeyinden sonra tamamen düşer, bu nedenle yalnızca birkaçını eklerseniz çok fazla yayılmazlar.
• Bu ek açıklamalar iyi uygulanmadığından, işaretli bir değerin @Nonnullnull olmadığını ve sonuç olarak null kontrol gerçekleştirmediğini varsayma tehlikesi vardır .

Aşağıdaki kod ile işaretlenmiş bir parametre neden @Nonnullolmak nullherhangi bir şikayet yükseltmeden. NullPointerExceptionÇalıştırıldığında bir atar .

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

Bu ek açıklamaları daha katı hale getirmenin ve / veya daha fazla yaymanın bir yolu var mı?

Kısa cevap: Bu ek açıklamaların yalnızca IDE'nizin sizi potansiyel olarak boş işaretçi hataları konusunda uyarması için yararlı olduğunu düşünüyorum.

"Kodu Temizle" kitabında belirtildiği gibi, genel yönteminizin parametrelerini kontrol etmeli ve değişmezleri kontrol etmekten kaçınmalısınız.

Başka bir iyi ipucu asla null değerler döndürmektir, bunun yerine Null Nesne Deseni kullanmaktır.

nullArgümanın boş olmamasını bekleyen yöntemlere geçtiğinizde size IDE veren ipuçları dışında başka avantajlar da vardır:

• Statik kod analiz araçları IDE'nizle aynı testi yapabilir (örn. FindBugs)
• Bu iddiaları kontrol etmek için AOP'yi kullanabilirsiniz

Bu, kodunuzun daha sürdürülebilir ( nullkontrollere ihtiyacınız olmadığından) ve daha az hataya açık olmasına yardımcı olabilir .

Bu orijinal sorunun dolaylı olarak @NonNull kullanılmasına rağmen, çalışma zamanı null-pointer kontrolünün hala gerekli olduğuna dair genel bir tavsiyeye işaret ettiğini düşünüyorum. Aşağıdaki bağlantıya bakın:

Java 8'in yeni Tip Ek Açıklamaları

Yukarıdaki blogda şunlar önerilir:

İsteğe Bağlı Tür Ek Açıklamaları, çalışma zamanı doğrulamasının yerini almaz Tür Ek Açıklamalarından önce, güvenlik açığı veya aralıklar gibi şeyleri açıklamanın birincil konumu javadoc'taydı. Tür ek açıklamaları ile bu iletişim, derleme zamanı doğrulaması için bayt koduna gelir. Kodunuz yine de çalışma zamanı doğrulaması yapmalıdır.

Eclipse'deki orijinal örneği uyumluluk 1.8'de derleyerek ve ek açıklama tabanlı boş analiz etkinleştirildiğinde şu uyarıyı alırız:

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

Bu uyarı, ham türleri ("denetlenmeyen dönüşüm") kullanarak oluşturulmuş kodu eski kodla karıştırırken aldığınız uyarılara benzer şekilde ifade edilir. Burada da tam olarak aynı durum var: yöntemindirectPathToA() herhangi bir boş sözleşme belirtmemesi nedeniyle "eski" imzası var. Araçlar bunu kolayca raporlayabilir, böylece boş ek açıklamaların yayılması gereken ancak henüz bulunmayan tüm sokaklarda sizi takip ederler.

Ve akıllıca kullanırken @NonNullByDefault bunu her seferinde söylemek zorunda bile değiliz.

Başka bir deyişle: "çok ileri yayılan" null ek açıklamaların kullanılıp kullanılmadığına ve aracın verdiği tüm uyarılara ne kadar titizlikle katıldığınıza bağlı olabilir. İle TYPE_USE boş ek açıklamalar nihayet aracı hakkında uyarmak izin seçeneğine sahip her nullness tipi sisteminin bir intrisic özelliği haline gelmiştir, çünkü programda olası NPE.

Ek açıklamaların "çok fazla yayılmadığını" kabul ediyorum. Ancak, programcı tarafında hatayı görüyorum.

NonnullEk açıklamayı dokümantasyon olarak anlıyorum . Aşağıdaki yöntem null olmayan bir bağımsız değişken gerektirdiğini (ön koşul olarak) ifade eder x.

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

Aşağıdaki kod snippet'i bir hata içeriyor. Yöntem null olmayan directPathToA()zorlama olmadan çağırır y(yani, çağrılan yöntemin önkoşulunu garanti etmez). Bir olasılık da bir ön Nonnullaçıklama eklemektir indirectPathToA()(ön koşulu yaymak). Olasılık iki geçersizliği için kontrol etmektir yiçinde indirectPathToA()ve çağrısını önlemek directPathToA()zaman yboş.

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

Projelerimde "Sabit koşullar ve istisnalar" kod denetiminde aşağıdaki seçeneği etkinleştirmektir:
@null değeri eklenebilir, null döndürülebilecek ve ek açıklama eklenmemiş parametrelere geçirilen boş değerleri bildirebilecek yöntemler için öner

Etkinleştirildiğinde, tüm açıklamalı olmayan parametreler boş olarak değerlendirilir ve böylece dolaylı aramanızda da bir uyarı görürsünüz:

clazz.indirectPathToA(null); 

Daha güçlü kontroller için Checker Çerçevesi iyi bir seçim olabilir (bu güzel eğiticiye bakın .
Not : Henüz kullanmadım ve Jack derleyicisiyle ilgili sorunlar olabilir: bu hata raporuna bakın

Java'da Guava'nın İsteğe bağlı türünü kullanırdım . Gerçek bir tür olarak derleyici kullanımı hakkında garanti alırsınız. Bunu atlamak ve bir elde etmek kolaydır NullPointerException, ancak en azından yöntemin imzası, bir argüman olarak ne beklediğini veya ne döndürebileceğini açıkça bildirir.

Kotlin'i kullanırsanız, derleyicisindeki bu nullabilite ek açıklamalarını destekler ve null olmayan bir argüman gerektiren bir java yöntemine null değerini geçirmenizi önler. Bu soru başlangıçta Java'yı hedeflemiş olsa da, bu Kotlin özelliğinden özellikle bu Java ek açıklamasını hedef aldığından ve " Bu ek açıklamaları daha sıkı bir şekilde uygulamanın ve / veya daha fazla yaymanın bir yolu var mı ?" ve bu özellik bu ek açıklamaları daha sıkı bir şekilde uygular .

@NotNullEk açıklama kullanan Java sınıfı

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

Java sınıfını çağıran ve @NotNull ile açıklanmış argüman için null ileten Kotlin sınıfı

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

@NotNullEk açıklamayı uygulayan Kotlin derleyici hatası .

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

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

Java 8'in yeni özelliği İsteğe bağlı olduğundan, artık kendi kodunuzda @Nullable veya @Notnull kullanmamalısınız . Aşağıdaki örneği alın:

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

Şununla yeniden yazılabilir:

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

İsteğe bağlı bir kullanım , null değeri kontrol etmeye zorlar . Yukarıdaki kodda, değere yalnızcaget yöntemi .

Diğer bir avantaj ise kodun daha okunabilir olmasıdır . Java 9 ifPresentOrElse eklenmesi ile işlev şu şekilde de yazılabilir:

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