Manière pragmatique de gérer les vérifications nuls imbriquées dans une base de code Java xmlbeans existante?

Question

Ceci est une question assez courante, mais je dois dire que la question que vous suggérez est une copie de ne contient pas de solutions qui sont appropriées à notre situation. Au travail, nous utilisons xmlbeans sur une base de code de 8 ans et pour le dire délicatement, il n'est pas bien géré. Bien sûr, la vraie solution est que nous ne devrions pas utiliser null comme information (et probablement pas utiliser du tout xmlbeans), mais je cherche la manière la moins terrible de gérer le problème suivant:

Si nous avons un entité de Person, qui peut éventuellement avoir une subentité de Wallet, qui peut éventuellement avoir des subentities de WalletItems, qui peuvent éventuellement avoir une subentity de Card qui peut avoir un CardNumber, quelle est la manière la plus pratique de vérifier si une Person a au moins un CardNumber?

Nous avons trois solutions de travail, ainsi que d'un argument sur lequel l'équipe doit en tenir à:

isCardHolder(Person person){ 
    if (person != null && person.getWallet != null && 
     person.getWallet.getWalletItems != null && 
     person.getWallet.getWalletItems.get(0) != null && // Just a dirty example, don't worry here 
     person.getWallet.getWalletItems.get(0).getCard != null && 
     person.getWallet.getWalletItems.get(0).getCard.getCardNumber != null){ 
     return true; 
    } else { 
     return false; 
} 

Ou:

isCardHolder(Person person){ 
    Wallet wallet = (Person != null ? person.getWallet : null); 
    WalletItems[] walletItems = (wallet != null ? wallet.getWalletItems : null); 
    // etc etc 
    if (card.getCardNumber != null) { 
     return true; 
    } else { 
     return false; 
    } 
} 

Ou encore:

isCardHolder(Person person){ 
    try { 
     if (person.getWallet.getWalletItems.get(0).getCard.getCardNumber != null){ 
      return true; 
     } 
    } finally { 
     return false; 
    } 
} 

Ma préférence personnelle est de le graver et de recommencer, ou au moins d'abandonner xmlbeans afin que nous puissions utiliser Null O modèles de bject ou quoi que ce soit d'autre dans la question standard on this topic mais nous sommes coincés avec cela pour le moment, trop de choses en dépendent.

Answer 1

Quelques citations de Robert C. Martin "Clean Code" sur les fonctions.

La première règle des fonctions est qu'elles doivent être petites. Les fonctions devraient faire quelque chose ou répondre à quelque chose, mais pas aux deux.

à mon humble avis la meilleure façon de faire cela pourrait être quelque chose comme:

package com.example.sampl; 

    public class MainSampl { 



     public static void main(String[] args) { 
      Person p = new Person(); 
      boolean correct = isCorrect(p); 
      System.out.println(correct); 
     } 

     private static boolean isCorrect(Person person){ 
      return isNotNull(person) && 
        isNotNull(person.getWallet()) && 
        isNotNull(person.getWallet().getWalletItems()) && 
         isNotNull(person.getWallet().getWalletItems().getItems().get(0)); 
//etc 
     } 

     private static boolean isNotNull(Object data) { 
      return data != null; 
     } 

    } 

Je pense donc que ma fonction isNotNull répond que si le paramètre est très bien, puis la fonction isCorrect répond que tout préférable de vérifier les objets sont ok ou pas. Vos fonctions:

1. Vérifier si les objets sont null et répondre si cela est correct ou non. Donc faire les deux choses
2. Deuxième fait la même chose que le premier et à mon avis, il est très illisible pour moi. Donc pas lisible et faire les deux choses.
3. Troisième la même chose. Il fait deux choses en répondant et fait quelque chose et c'est trop long.

Et de moi à propos de l'utilisation des opérateurs logiques.Je pense que si vous avez des opérateurs moins logiques dans votre code, il est meilleur pour l'avenir refactoring et mieux pour la lecture en général parce que

si vous voulez aller vite, si vous voulez vous faire rapidement, si vous voulez votre code pour être facile à écrire, le rendre facile à lire