Null vérifier la chaîne de vs attraper NullPointerException

Attraper NullPointerException est un vraiment problématique chose à faire car ils peuvent se produire presque n'importe où. Il est très facile d'en obtenir un à partir d'un bug, l'attraper par accident et continuer comme si tout est normal, donc se cachait un véritable problème. C'est tellement difficile de traiter avec de sorte qu'il est préférable de l'éviter complètement. (Par exemple, pensez à l'auto-unboxing d'une valeur null Integer.)

Je vous suggérons d'utiliser le Facultatif classe à la place. C'est souvent la meilleure approche pour travailler avec des valeurs qui sont soit présente, soit absente.

L'aide que vous pouvez écrire votre code comme ceci:

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

---

Pourquoi facultatif?

À l'aide de Optionals au lieu de null pour les valeurs qui peuvent être absents le rend très visible et claire pour les lecteurs, et le type de système assurez-vous que vous n'avez pas accidentellement oublier.

Vous obtenez également l'accès à des méthodes de travail avec ces valeurs de façon plus pratique, comme map et orElse.

---

Est l'absence valide ou une erreur?

Mais penser aussi que si c'est un résultat valide pour l'intermédiaire des méthodes pour renvoyer la valeur null ou si c'est un signe d'une erreur. Si c'est toujours une erreur, alors il est probablement mieux de se débarrasser de l'exception que de retourner une valeur particulière, ou par l'intermédiaire des méthodes d'eux-mêmes pour lever une exception.

---

Peut-être plus d'options?

Si en revanche absente de valeurs à partir de l'intermédiaire de méthodes sont valables, peut-être que vous pouvez passer à Optionals pour eux aussi?

Puis vous pouvez les utiliser comme ceci:

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

---

Pourquoi ne pas en option?

La seule raison pour laquelle je peux penser pour ne pas utiliser Optional est de savoir si cela est vraiment dans une critique pour les performances de la partie du code, et si la collecte des déchets généraux s'avère être un problème. C'est parce que quelques Optional objets sont alloués à chaque fois que le code est exécuté, et la VM pourrait ne pas être en mesure d'optimiser ceux qui sont loin. Dans ce cas, l'original de votre si-tests peut-être mieux.

En supposant que la structure de classe est en effet hors de notre contrôle, comme cela semble être le cas, je pense que la capture de la NPE, comme suggéré dans la question est en effet une solution raisonnable, à moins que la performance est une préoccupation majeure. Une petite amélioration pourrait être pour envelopper le lancer/attraper logique pour éviter l'encombrement:

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

Maintenant, vous pouvez tout simplement faire:

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

Ma réponse est presque dans la même ligne que @comités janki, mais je voudrais modifier le code extrait légèrement comme ci-dessous:

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;

Vous pouvez ajouter un null vérifier wsObject ainsi, si il n'y a aucune chance de l'objet est null.

Vous dire que certaines méthodes "peut renvoyer null" mais ne dis pas dans quelles circonstances ils reviennent null. Vous dites que vous attraper le NullPointerException mais vous ne dites pas pourquoi vous l'attraper. Ce manque d'information suggère que vous n'avez pas une compréhension claire de ce que les exceptions sont et pourquoi ils sont supérieurs à l'alternative.

Envisager une méthode de classe est destinée à effectuer une action, mais la méthode peut pas garantie il va effectuer une action, en raison de circonstances indépendantes de sa volonté (qui est en fait pour tous méthodes en Java). Nous appelons cette méthode et qu'elle renvoie. Le code qui appelle la méthode doit savoir si elle a réussi. Comment peut-il savoir? Comment peut-il être structuré de manière à faire face avec les deux possibilités de réussite ou d'échec?

À l'aide d'exceptions, on peut écrire des méthodes qui ont succès en tant que post-condition. Si la méthode retourne, il a réussi. Si elle lève une exception, il avait échoué. C'est une grande victoire pour plus de clarté. Nous pouvons écrire le code qui clairement les processus de la normale, en cas de réussite, et de déplacer tout le code de gestion d'erreur dans catch clauses. Il apparaît souvent que les détails de comment ou pourquoi une méthode a échoué ne sont pas importants pour l'appelant, de sorte que le même catch clause peut être utilisée pour le traitement de plusieurs types de défaillance. Et il arrive souvent qu'une méthode n'a pas besoin d'intercepter des exceptions à tous les, mais de leur permettre de se propager à son de l'appelant. Les Exceptions en raison du programme de bugs sont dans cette dernière catégorie; quelques méthodes peuvent réagir de façon appropriée lorsqu'il y a un bug.

Donc, ces méthodes qui retournent des null.

• Un null valeur indiquer un bug dans votre code? Si elle le fait, vous ne devriez pas être la capture de l'exception à tous. Et votre code ne doit pas être en essayant de deuxième deviner lui-même. Il suffit d'écrire ce qui est clair et concis sur l'hypothèse que cela va fonctionner. Est une chaîne d'appels de méthode claire et concise? Puis il suffit de les utiliser.
• Un null indiquent l'entrée non valide votre programme? Si c'est le cas, une NullPointerException n'est pas une exception appropriée à jeter, parce que traditionnellement il est réservé pour indiquer les bugs. Vous voulez probablement pour lever une exception personnalisée dérivé de IllegalArgumentException (si vous voulez un décochée exception) ou IOException (si vous voulez un checked exception). Est-ce votre programme requis pour fournir des informations détaillées de la syntaxe des messages d'erreur lorsque il y a une entrée non valide? Si oui, la vérification de chaque méthode pour un null valeur de retour puis jetant un diagnostic approprié exception est la seule chose que vous pouvez faire. Si votre programme n'a pas besoin de fournir des diagnostics détaillés, enchaînant les appels de méthode ensemble, attraper des NullPointerException, puis de le jeter vos exception personnalisée est la plus claire et la plus concise.

---

L'une des réponses les revendications que l'enchaînement des appels de méthode de violer les Loi de Déméter et sont donc mauvais. Cette affirmation est erronée.

• Quand il s'agit de la conception du programme, il n'y a pas vraiment de règles absolues sur ce qui est bon et ce qui est mauvais. Il y a seulement heuristique: les règles qui sont à droite de beaucoup (presque tous) de l'époque. Une partie des compétences de programmation est de savoir quand il est OK pour rompre ces sortes de règles. Donc un laconique affirmation que "c'est contre la règle X" n'est pas vraiment une réponse à tout. Est-ce une des situations où la règle devrait être cassé?
• La Loi de Déméter est vraiment une règle sur l'API ou interface de classe de conception. Lors de la conception des classes, il est utile de disposer d'un hiérarchie des abstractions. Vous avez les classes de bas niveau qui utilise la langue des primitives pour effectuer directement des opérations et de représenter les objets dans l'abstraction de plus haut niveau que les langues primitives. Vous avez un niveau moyen des classes de ce délégué pour les classes de bas niveau, et de mettre en œuvre des opérations et représentations, à un niveau plus élevé que les classes de bas niveau. Vous avez les classes que délégué à la moyenne des cours de niveau, et de mettre en œuvre encore plus haut le niveau des opérations et des abstractions. (J'ai parlé de trois niveaux d'abstraction ici, mais plusieurs sont possibles). Cela permet à votre code s'exprimer dans des termes appropriés abstractions à chaque niveau, afin de cacher la complexité. La justification de la Loi de Déméter est que si vous avez une chaîne d'appels de méthode, qui suggère que vous avez un niveau élevé de la classe d'atteindre à travers un niveau moyen de la classe de traiter directement avec les détails de bas niveau, et donc que votre niveau moyen de la classe n'a pas fourni un moyen niveau abstrait de l'opération que le haut niveau des besoins de la classe. Mais il semble qu'elle soit pas la situation que vous avez ici: vous n'avez pas à concevoir les classes de la chaîne d'appels de méthode, ils sont le résultat d'une auto-généré la sérialisation XML code (à droite?), et de la chaîne d'appels n'est pas de descendre dans une abstraction de la hiérarchie car la des-XML sérialisé est tous au même niveau de la hiérarchie d'abstraction (à droite?)?

Si vous ne voulez pas de refactoriser le code et vous pouvez utiliser Java 8, il est possible d'utiliser la Méthode de référence.

Une simple première démo (excusez la statique inner classes)

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

Sortie

241

4

null

2

L'interface Getter est juste une interface fonctionnelle, vous pouvez utiliser un équivalent.

GetterResult classe, les accesseurs sont supprimés pour des raisons de clarté, maintenez la suite de la lecture de la chaîne, le cas échéant, ou de l'indice de la dernière getter appelé.

La méthode getterChain est un simple passe-partout morceau de code, qui peuvent être générées automatiquement (ou manuellement en cas de besoin).

J'ai structuré le code de sorte que la répétition d'un bloc est évident.

---

Ce n'est pas une solution parfaite, comme vous avez encore besoin de définir une surcharge de getterChain par nombre d'accesseurs.

Je refactoriser le code à la place, mais si vous pouvez pas, et vous trouvez votre auto à l'aide de longues getter chaînes souvent, vous pouvez envisager la construction d'une classe avec les surcharges que prendre de 2 à 10, les accesseurs.

Je voudrais ajouter une réponse qui mettent l'accent sur la sens de l'erreur. Exception nulle en elle-même ne fournit pas de sens complet de l'erreur. Donc, je vous conseille d'éviter de traiter directement avec eux.

Il y a des milliers de cas où votre code peut aller mal: impossible de se connecter à la base de données IO Exception, erreur de Réseau... Si vous les traiter un par un (comme le nul voir ici), ce serait trop de tracas.

Dans le code:

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

Même lorsque vous savez que le champ est nul, vous n'avez aucune idée sur ce qui va mal. Peut-être que la Barre est nul, mais est-il prévu? Ou est-ce une erreur de données? Pensez aux gens qui lisent votre code

Comme dans xenteros réponse, j'aimerais proposer l'aide de personnalisé décoché exception. Par exemple, dans cette situation: Foo peut être null (données valides), mais la Barre et Baz ne doit jamais être nul (données non valides)

Le code peut être ré-écrit:

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

Ont suivi ce post depuis hier.

J'ai été de commentaire/vote les commentaires qui dit, la capture de NPE est mauvais. Ici, c'est pourquoi je l'ai fait.

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

Sortie

3.216

0.002

Je vois un gagnant clair ici. Avoir si la vérification est beaucoup trop moins cher que de prendre une exception. J'ai vu que Java 8 façon de faire. Considérant que 70% des applications actuelles continuent d'utiliser Java-7-je suis l'ajout de cette réponse.

Ligne de fond Pour toutes les applications à mission critique, la manipulation des NPE est coûteux.

Il est utile d'envisager de créer votre propre Exception. Appelons ça de la MyOperationFailedException. Vous pouvez le jeter au lieu de retourner une valeur. Le résultat sera le même - vous allez quitter la fonction, mais vous ne retourne pas de valeur codée en dur -1 ce qui est de Java anti-modèle. En Java, nous utilisons des Exceptions.

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

EDIT:

En fonction de la discussion dans les commentaires, permettez-moi d'ajouter quelque chose à mes pensées précédentes. Dans ce code il y a deux possibilités. L'une est que vous acceptez nulle et l'autre est, que c'est une erreur.

Si c'est une erreur et il se produit, Vous pouvez déboguer votre code à l'aide d'autres structures à des fins de débogage lorsque les points d'arrêt ne sont pas assez.

Si c'est acceptable, vous ne se soucient pas où cette valeur null est apparu. Si vous le faites, vous ne devriez pas la chaîne de ces demandes.

return wsObject.getFooBarBazInt();

par l'application de la Loi de Déméter,

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

J'ai écrit une classe appelée Snag qui permet de définir un chemin d'accès pour naviguer dans une arborescence d'objets. Voici un exemple de son utilisation:

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

Ce qui signifie que l'instance ENGINE_NAME serait effectivement appel Car?.getEngine()?.getName() sur l'instance est passé, et le retour null cas échéant la référence retournée null:

final String name =  ENGINE_NAME.get(firstCar);

Il n'est pas publié sur Maven, mais si quelqu'un trouve cela utile il ici (sans garantie bien sûr!)

C'est un peu basique mais il semble faire le travail. Bien évidemment, il est plus obsolète avec les plus récentes versions de Java et d'autres JVM langages qui prennent en charge la sécurité de la navigation ou Optional.