Null-check chain vs Fang NullPointerException

Fangen NullPointerException ist ein wirklich problematisch, was zu tun da können Sie passieren fast überall. Es ist sehr leicht zu bekommen, die man von einem bug, fängt es an durch Unfall und weitermachen, als wenn alles normal ist, wodurch ein echtes problem. Es ist so schwierig zu behandeln, so ist es am besten zu vermeiden. (Denken Sie zum Beispiel über auto-unboxing eines null -Integer.)

Ich empfehlen, dass Sie die Optional Klasse statt. Dies ist oft der beste Ansatz, wenn Sie wollen, um die Arbeit mit Werten, die entweder vorhanden oder nicht vorhanden.

Verwenden, die Sie schreiben, könnte dein code wie folgt:

public Optional<Integer> m(Ws wsObject) {
    return Optional.ofNullable(wsObject.getFoo()) //Here you get Optional.empty() if the Foo is null
        .map(f -> f.getBar()) //Here you transform the optional or get empty if the Bar is null
        .map(b -> b.getBaz())
        .map(b -> b.getInt());
        //Add this if you want to return an -1 int instead of an empty optional if any is null
        //.orElse(-1);
        //Or this if you want to throw an exception instead
        //.orElseThrow(SomeApplicationException::new);
}

Warum optional?

Mit Optionals statt null für Werte, die möglicherweise fehlen, macht diese Tatsache sehr klar und sichtbar für die Leser, und das Typ-system wird sicherstellen, dass Sie nicht versehentlich vergessen.

Erhalten Sie auch Zugang zu Methoden für die Arbeit mit diesen Werten mehr bequem, wie map und orElse.

Ist die Abwesenheit gültig ist oder Fehler?

Aber auch darüber nachdenken, ob es ein gültiges Ergebnis für den fortgeschrittene Methoden null zurück, oder wenn, dass ist ein Zeichen für einen Fehler. Wenn es ist immer ein Fehler, dann ist es wohl besser eine exception zu werfen, als die Rückgabe eines speziellen Wertes, oder für die fortgeschrittene Methoden selbst eine exception werfen.

Vielleicht mehr Optionen?

Wenn auf der anderen Seite fehlen die Werte aus dem temporären Methoden gültig sind, vielleicht können Sie wechseln, um Optionals für Sie auch?

Dann können Sie Sie wie folgt:

public Optional<Integer> mo(Ws wsObject) {
    return wsObject.getFoo()
        .flatMap(f -> f.getBar())
        .flatMap(b -> b.getBaz())
        .flatMap(b -> b.getInt());        
}

Warum nicht optional?

Der einzige Grund, warum ich denken kann, für nicht mit Optional ist, wenn dies in einer wirklich performance-kritischen code-Abschnitt, und wenn die garbage collection overhead stellt sich heraus, ein problem zu sein. Dies ist, weil ein paar Optional Objekte zugewiesen werden jedes mal, wenn der code ausgeführt wird, und die VM könnte nicht in der Lage sein, zu optimieren, entfernt. In diesem Fall Ihre original-wenn-tests besser sein könnte.

Vorausgesetzt, die Klasse Struktur ist in der Tat außerhalb unserer Kontrolle, wie der Fall zu sein scheint, denke ich, fangen die NPE vorgeschlagen, in der Frage ist in der Tat eine vernünftige Lösung, es sei denn, die Leistung ist ein wichtiges Anliegen. Eine kleine Verbesserung könnte es sein, wickeln Sie das throw/catch-Logik, um Unordnung zu vermeiden:

static <T> T get(Supplier<T> supplier, T defaultValue) {
    try {
        return supplier.get();
    } catch (NullPointerException e) {
        return defaultValue;
    }
}

Nun können Sie einfach tun:

return get(() -> wsObject.getFoo().getBar().getBaz().getInt(), -1);

Meine Antwort geht fast in die gleiche Zeile wie @janki, aber ich möchte zum ändern der code-snippet, das leicht wie folgt:

if (wsObject.getFoo() != null && wsObject.getFoo().getBar() != null && wsObject.getFoo().getBar().getBaz() != null) 
   return wsObject.getFoo().getBar().getBaz().getInt();
else
   return something or throw exception;

Können Sie ein null-check für wsObject wie gut, wenn es irgendeine chance, dass das Objekt null.

Ihnen sagen, dass einige Methoden, die "möglicherweise zurück null" aber nicht sagen, in welchen Umständen Sie zurück null. Sie sagen, Sie fangen die NullPointerException aber Sie müssen nicht sagen, warum Sie es fangen. Dieser Mangel an Informationen schlägt vor, Sie nicht haben ein klares Verständnis von dem, was Ausnahmen sind und warum Sie besser sind als die alternative.

Betrachten Sie eine Klasse Methode, die gemeint ist, um eine Aktion durchzuführen, aber die Methode kann nicht Garantie wird die Aktion durchzuführen, aufgrund von Umständen, die außerhalb seiner Kontrolle liegen (das ist in der Tat der Fall für alle - Methoden in Java). Wir nennen diese Methode und es gibt. Der code zum aufrufen dieser Methode muss wissen, ob es erfolgreich war. Wie kann es wissen? Wie kann es sein, strukturiert zu bewältigen mit den zwei Möglichkeiten, Erfolg oder Misserfolg?

Mit Ausnahmen kann man Methoden schreiben, die Erfolg als post-Zustand. Wenn die Methode zurückkehrt, war es erfolgreich. Wenn es eine Ausnahme wirft, es hatte versagt. Dies ist ein großer Gewinn für die übersichtlichkeit. Wir können code schreiben, der eindeutig auf Prozesse der normalen, Erfolg, Fall, und verschieben Sie alle die code für die Fehlerbehandlung in catch Klauseln. Oft stellt sich heraus, dass die details, wie oder warum eine Methode nicht erfolgreich war, sind nicht wichtig, der Anrufer, also das gleiche catch - Klausel kann verwendet werden, für die Bearbeitung von verschiedenen Arten des Scheiterns. Und es passiert oft, dass ein Verfahren nicht zum abfangen von Ausnahmen an alle, sondern Sie können es Ihnen ermöglichen, zu verbreiten, zu seine Anrufer. Ausnahmen aufgrund von Programm-bugs werden in der letzten Klasse; einige Methoden angemessen reagieren können, wenn es ein bug ist.

So, die Methoden, die Rückkehr null.

• Hat eine null - Wert deuten auf einen Fehler in deinem code? Wenn Sie es tut, Sie sollten nicht zu fangen, die Ausnahme überhaupt. Und dein code sollte nicht versuchen, auf den zweiten erraten Sie sich. Schreiben Sie einfach, was klar und prägnant auf der Annahme, dass es funktionieren wird. Eine Kette von Methodenaufrufen klar und prägnant? Dann benutzen Sie einfach die.
• Hat eine null Wert anzugeben ungültige Eingabe an Ihr Programm? Wenn es funktioniert, eine NullPointerException ist nicht eine entsprechende Ausnahme zu werfen, weil es konventionell ist reserviert für Anzeige-bugs. Sie wollen wahrscheinlich werfen Sie eine eigene exception abgeleitet von IllegalArgumentException (wenn Sie möchten, eine ungeprüfte Ausnahme) oder IOException (wenn Sie möchten, eine checked exception). Ist Ihr Programm erforderlich, um eine detaillierte syntax-Fehlermeldungen, wenn es ungültige Eingabe? Wenn dem so ist, überprüfen Sie nach jeder Methode für eine null Rückgabewert dann werfen Sie einen geeigneten Diagnose-Ausnahme ist die einzige Sache, die Sie tun können. Wenn Ihr Programm nicht verpflichtet ist, detaillierte Diagnostik, die Verkettung der Methodenaufrufe zusammen, fangen alle NullPointerException und dann werfen Sie Ihre benutzerdefinierte Ausnahme ist die klarste und prägnanteste.

Eine der Antworten, die behauptet, dass die verkettete Methodenaufrufe gegen die Gesetz von Demeter und somit schlecht sind. Diese Behauptung ist falsch.

• Wenn es um die Programm-design, es gibt wirklich keine absoluten Regeln über das, was gut und was schlecht ist. Es gibt nur Heuristiken: die Regeln sind Recht viel (sogar fast alle) der Zeit. Teil der Fertigkeit des Programmierens zu wissen, Wann es OK ist zu brechen diese Art von Regeln. So eine lapidare Behauptung, dass "das ist gegen die Regel X" ist nicht wirklich eine Antwort auf alle. Dies ist eine der Situationen, in denen die Regel sollte gebrochen werden?
• Die Gesetz von Demeter ist wirklich in der Regel über API-Klasse oder-interface-design. Beim entwerfen von Klassen, ist es nützlich, eine Hierarchie von Abstraktionen. Sie haben low-level-Klassen, die anhand der Sprache primitive direkt zu Operationen und Objekte in eine Abstraktion, die höher ist als die Sprache der "primitiven". Sie haben medium-level-Klassen, Delegat des low-level-Klassen und implementieren die Operationen und Repräsentationen auf einer höheren Ebene als die low-level-Klassen. Sie haben high-level-Klassen, Delegat für die medium-level-Klassen und implementieren von noch höheren level-Operationen und Abstraktionen. (Ich habe darüber gesprochen, nur drei Abstraktionsebenen hier, aber mehr sind möglich). Dies erlaubt Ihrem code selbst zu äußern in Bezug auf entsprechende Abstraktionen auf jeder Ebene, damit versteckt die Komplexität. Die Begründung für die Gesetz von Demeter ist, dass, wenn man eine Kette von Methodenaufrufen, die vermuten lässt, dass Sie eine hohe Klasse erreichen, in der durch ein medium-level-Klasse, um sich direkt mit low-level-details, und daher, dass Ihr medium-level-Klasse nicht vorgesehen sind, eine mittlere Ebene abstrakter Vorgang, der die high-level-Klasse muss. Aber es scheint, dass nicht der situation, die Sie hier haben: Sie haben nicht das design der Klassen in der Kette der Methodenaufrufe, Sie sind das Ergebnis einer automatisch generierten XML-Serialisierung-code (rechts -?), und die Kette der Aufrufe wird nicht absteigend durch eine Abstraktion, Hierarchie, weil die des serialisierten XML ist alles auf der gleichen Ebene der Abstraktion Hierarchie (rechts?)?

Wenn Sie nicht wollen, zu überarbeiten Sie den code, und Sie können die Verwendung von Java 8 ist es möglich, verwenden Sie die Methode Referenzen.

Eine einfache demo erste (entschuldigen Sie die statische innere Klassen)

public class JavaApplication14 
{
    static class Baz
    {
        private final int _int;
        public Baz(int value){ _int = value; }
        public int getInt(){ return _int; }
    }
    static class Bar
    {
        private final Baz _baz;
        public Bar(Baz baz){ _baz = baz; }
        public Baz getBar(){ return _baz; }   
    }
    static class Foo
    {
        private final Bar _bar;
        public Foo(Bar bar){ _bar = bar; }
        public Bar getBar(){ return _bar; }   
    }
    static class WSObject
    {
        private final Foo _foo;
        public WSObject(Foo foo){ _foo = foo; }
        public Foo getFoo(){ return _foo; }
    }
    interface Getter<T, R>
    {
        R get(T value);
    }

    static class GetterResult<R>
    {
        public R result;
        public int lastIndex;
    }

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) 
    {
        WSObject wsObject = new WSObject(new Foo(new Bar(new Baz(241))));
        WSObject wsObjectNull = new WSObject(new Foo(null));

        GetterResult<Integer> intResult
                = getterChain(wsObject, WSObject::getFoo, Foo::getBar, Bar::getBar, Baz::getInt);

        GetterResult<Integer> intResult2
                = getterChain(wsObjectNull, WSObject::getFoo, Foo::getBar, Bar::getBar, Baz::getInt);


        System.out.println(intResult.result);
        System.out.println(intResult.lastIndex);

        System.out.println();
        System.out.println(intResult2.result);
        System.out.println(intResult2.lastIndex);

        //TODO code application logic here
    }

    public static <R, V1, V2, V3, V4> GetterResult<R>
            getterChain(V1 value, Getter<V1, V2> g1, Getter<V2, V3> g2, Getter<V3, V4> g3, Getter<V4, R> g4)
            {
                GetterResult result = new GetterResult<>();

                Object tmp = value;


                if (tmp == null)
                    return result;
                tmp = g1.get((V1)tmp);
                result.lastIndex++;


                if (tmp == null)
                    return result;
                tmp = g2.get((V2)tmp);
                result.lastIndex++;

                if (tmp == null)
                    return result;
                tmp = g3.get((V3)tmp);
                result.lastIndex++;

                if (tmp == null)
                    return result;
                tmp = g4.get((V4)tmp);
                result.lastIndex++;


                result.result = (R)tmp;

                return result;
            }
}

Ausgabe

241

4

null

2

Die Schnittstelle Getter ist nur eine funktionale Schnittstelle, können Sie alle gleichwertig.

GetterResult Klasse, Zugriffsmethoden beraubt, für Klarheit, halten Sie das Ergebnis der get-Kette, falls vorhanden, oder der index des letzten getter aufgerufen.

Die Methode getterChain ist eine einfache, boilerplate-code, generiert werden können automatisch (oder manuell wenn erforderlich).

Ich strukturierte Sie den code so, dass das wiederholte blockieren, ist selbstverständlich.

Dies ist keine perfekte Lösung, da Sie noch brauchen, um eine überlastung der getterChain pro Anzahl der Getter.

Ich würde Umgestaltung des Codes statt, aber wenn nicht und Sie finden Sie Ihr selbst mit langen getter-Ketten Häufig können Sie darüber nachdenken, eine Klasse mit den überladungen, die aus 2 bis, sagen wir, 10, get.

Möchte ich hinzufügen, eine Antwort, die den Fokus auf die Bedeutung der Fehler -. Null exception in sich selbst nicht bieten jeglichen Sinn voller Fehler. Also ich würde raten, um zu vermeiden Umgang mit Ihnen direkt.

Es gibt Tausende Fälle, in denen der code schief gehen kann: kann keine Verbindung zur Datenbank, E /a-Ausnahme, Netzwerk-Fehler... Wenn man sich mit Ihnen eins nach dem anderen (wie der null-check hier), es wäre zu viel Aufwand.

In den code:

wsObject.getFoo().getBar().getBaz().getInt();

Selbst wenn man weiß, welches Feld null ist, haben Sie keine Idee über das, was schief geht. Vielleicht Bar ist null, aber ist zu erwarten? Oder ist es ein Daten-Fehler??? Denken Sie über Menschen, die Lesen Ihren code

Wie in xenteros die Antwort, ich würde vorschlagen mit benutzerdefinierte unchecked exception. Zum Beispiel in dieser situation: Foo null sein kann (gültige Daten), aber die Bar und Baz sollte nie null (ungültige Daten)

Den code neu geschrieben werden kann:

void myFunction()
{
    try 
    {
        if (wsObject.getFoo() == null)
        {
          throw new FooNotExistException();
        }

        return wsObject.getFoo().getBar().getBaz().getInt();
    }
    catch (Exception ex)
    {
        log.error(ex.Message, ex); //Write log to track whatever exception happening
        throw new OperationFailedException("The requested operation failed")
    }
}


void Main()
{
    try
    {
        myFunction();
    }
    catch(FooNotExistException)
    {
        //Show error: "Your foo does not exist, please check"
    }
    catch(OperationFailedException)
    {
        //Show error: "Operation failed, please contact our support"
    }
}

Verfolge diesen Beitrag seit gestern.

Ich habe Kommentierung/Abstimmung die Kommentare, die sagt, fangen NPE ist schlecht. Hier ist der Grund, warum ich getan haben, dass.

package com.todelete;

public class Test {
    public static void main(String[] args) {
        Address address = new Address();
        address.setSomeCrap(null);
        Person person = new Person();
        person.setAddress(address);
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000; i++) {
            try {
                System.out.println(person.getAddress().getSomeCrap().getCrap());
            } catch (NullPointerException npe) {

            }
        }
        long endTime = System.currentTimeMillis();
        System.out.println((endTime - startTime) / 1000F);
        long startTime1 = System.currentTimeMillis();
        for (int i = 0; i < 1000000; i++) {
            if (person != null) {
                Address address1 = person.getAddress();
                if (address1 != null) {
                    SomeCrap someCrap2 = address1.getSomeCrap();
                    if (someCrap2 != null) {
                        System.out.println(someCrap2.getCrap());
                    }
                }
            }
        }
        long endTime1 = System.currentTimeMillis();
        System.out.println((endTime1 - startTime1) / 1000F);
    }
}

  public class Person {
    private Address address;

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }
}

package com.todelete;

public class Address {
    private SomeCrap someCrap;

    public SomeCrap getSomeCrap() {
        return someCrap;
    }

    public void setSomeCrap(SomeCrap someCrap) {
        this.someCrap = someCrap;
    }
}

package com.todelete;

public class SomeCrap {
    private String crap;

    public String getCrap() {
        return crap;
    }

    public void setCrap(String crap) {
        this.crap = crap;
    }
}

Ausgabe

3.216

0.002

Sehe ich einen klaren Sieger hier. Wenn Prüfungen ist übrigens auch weniger teuer als abfangen einer Ausnahme. Ich habe gesehen, dass Java-8 Weg, das zu tun. Wenn man bedenkt, dass 70% der aktuellen Anwendungen laufen immer noch auf Java 7 ich bin das hinzufügen dieser Antwort.

Bottom Line Für jede geschäftskritische Anwendungen, Umgang mit NPE ist teuer.

Ist es eine überlegung Wert, um erstellen Sie Ihre eigene Ausnahme. Nennen wir es MyOperationFailedException. Sie können werfen Sie stattdessen zurückgeben eines Wertes. Das Ergebnis wird das gleiche sein - Sie werden beenden Sie die Funktion, aber Sie nicht zurückkehren, hart-codierten Wert -1, was den Java-anti-pattern. In Java verwenden wir Ausnahmen.

try {
    return wsObject.getFoo().getBar().getBaz().getInt();
} catch (NullPointerException ignored) {
    throw new MyOperationFailedException();
}

EDIT:

Gemäß der Diskussion in den Kommentaren lassen Sie mich etwas hinzufügen zu meinen vorherigen Gedanken. In diesem code gibt es zwei Möglichkeiten. Einer ist, dass Sie akzeptieren null-und das andere ist, dass es ein Fehler ist.

Wenn es ein Fehler ist und es Auftritt, können Sie das Debuggen des Codes mit anderen Strukturen, die für debugging-Zwecke, wenn die Haltepunkte sind nicht genug.

Wenn es akzeptabel ist, Sie kümmern sich nicht darum, wo diese null erschien. Wenn Sie dies tun, Sie sollten nicht definitiv Kette diese Anforderungen.

return wsObject.getFooBarBazInt();

durch die Anwendung des Gesetz von Demeter,

class WsObject
{
    FooObject foo;
    ..
    Integer getFooBarBazInt()
    {
        if(foo != null) return foo.getBarBazInt();
        else return null;
    }
}

class FooObject
{
    BarObject bar;
    ..
    Integer getBarBazInt()
    {
        if(bar != null) return bar.getBazInt();
        else return null;
    }
}

class BarObject
{
    BazObject baz;
    ..
    Integer getBazInt()
    {
        if(baz != null) return baz.getInt();
        else return null;
    }
}

class BazObject
{
    Integer myInt;
    ..
    Integer getInt()
    {
        return myInt;
    }
}

Schrieb ich eine Klasse namens Snag können Sie definieren einen Pfad zu navigieren durch einen Baum von Objekten. Hier ist ein Beispiel zu Ihrer Verwendung:

Snag<Car, String> ENGINE_NAME = Snag.createForAndReturn(Car.class, String.class).toGet("engine.name").andReturnNullIfMissing();

Bedeutung, dass die Instanz ENGINE_NAME würde effektiv nennen Car?.getEngine()?.getName() auf die Instanz übergeben, und zurück null wenn keine Referenz zurückgegeben null:

final String name =  ENGINE_NAME.get(firstCar);

Es ist nicht veröffentlicht, Maven, aber wenn jemand findet das nützlich ist es hier (ohne Garantie natürlich!)

Es ist ein bisschen einfach, aber es scheint, um den job zu erledigen. Natürlich, es ist mehr veraltet, die mit neueren Versionen von Java und anderen JVM-Sprachen, die Unterstützung einer sicheren navigation oder Optional.