Vérifier les chaînes de “sortir” des appels pour les nuls

Dans le cas où vous ne peut pas éviter de briser la Loi de Déméter (LoD), comme indiqué dans la réponse choisie, et avec Java 8 l'introduction de En option, ce serait probablement la meilleure pratique pour gérer les valeurs null dans les chaînes de obtient comme la vôtre.

La Optional type vous permettra de tuyau de plusieurs carte des opérations (qui contiennent de recevoir des appels) dans une rangée. Null contrôles sont automatiquement gérées sous le capot.

Par exemple, lorsque les objets ne sont pas initialisés, pas de print() sera faite et aucune exception n'est levée. Il nous être manipulés délicatement sous le capot. Lorsque les objets sont initialisés, l'impression sera faite.

System.out.println("----- Not Initialized! -----");
Optional.ofNullable(new Outer())
.map(out -> out.getNested())
.map(nest -> nest.getInner())
.map(in -> in.getFoo())
.ifPresent(foo -> System.out.println("foo: " + foo)); //no print
System.out.println("----- Let's Initialize! -----");
Optional.ofNullable(new OuterInit())
.map(out -> out.getNestedInit())
.map(nest -> nest.getInnerInit())
.map(in -> in.getFoo())
.ifPresent(foo -> System.out.println("foo: " + foo)); //will print!
class Outer {
Nested nested;
Nested getNested() {
return nested;
}
}
class Nested {
Inner inner;
Inner getInner() {
return inner;
}
}
class Inner {
String foo = "yeah!";
String getFoo() {
return foo;
}
}
class OuterInit {
NestedInit nested = new NestedInit();
NestedInit getNestedInit() {
return nested;
}
}
class NestedInit {
InnerInit inner = new InnerInit();
InnerInit getInnerInit() {
return inner;
}
}
class InnerInit {
String foo = "yeah!";
String getFoo() {
return foo;
}
}

Donc, avec votre getters de la chaîne d', il ressemblera à ceci:

Optional.ofNullable(house)
.map(house -> house.getFloor(0))
.map(floorZero -> floorZero.getWall(WEST))
.map(wallWest -> wallWest.getDoor())
.map(door -> wallWest.getDoor())

Le retour de il sera quelque chose comme Optional<Door> qui vous permettra beaucoup plus sûr de travailler sans se soucier de la valeur null exceptions.

Vous pouvez bien sûr simplement envelopper l'ensemble de l'expression dans un bloc try-catch, mais c'est une mauvaise idée. Quelque chose de plus propre est le Objet Null modèle. Avec ça, si votre maison n'a pas de plancher de 0, elle retourne un Étage qui agit comme un Plancher, mais n'a pas de contenu réel, les Planchers, quand on lui a demandé Murs dont ils ne disposent pas rendre la pareille "Null" des Murs, etc, en bas de la ligne.

Il n'y a pas de checkForNull méthode que vous pouvez écrire qui faciliteront cela (ce n'est simplement pas comment la méthode invokation et de l'argument d'évaluation fonctionne en Java).

Vous pouvez briser l'enchaînement des instructions dans plusieurs états, en vérifiant à chaque étape. Cependant, peut-être une meilleure solution est de ne pas avoir ces méthodes retournent null en premier lieu. Il y a quelque chose qui s'appelle la Objet Null Modèle que vous pouvez utiliser à la place.

Questions connexes

• Comment éviter de != null états en Java?

Vous pourrait soutenir ce en java (juste pour ajouter un sucre syntaxique) à l'aide d'une techinque similaire à celui utilisé par Mockito:

org.mockito.Mockito.spy(house).getFloor(0).getWall(WEST).getDoor().getDoorknob()

ou CatchException

com.googlecode.catchexception.CatchException
.catchException(house).getFloor(0).getWall(WEST).getDoor().getDoorknob()

Mockito ne peut pas être utilisé directement depuis vérifie pas la valeur null maison et lève une exception, alors que CatchException est conçu pour un but différent.

Néanmoins peut-être quelqu'un peut suggérer où une telle fonctionnalité pourrait être trouvé.