Recupero di un valore senza dover annullare il controllo in Java

Molte volte mi ritrovo a controllare nulla durante il recupero di un valore da una gerarchia di dati per evitare NullPointerExceptions, che trovo essere soggetto a errori e necessita di molta piastra di caldaia.

Ho scritto una routine molto semplice che mi consente di saltare il controllo null durante il recupero di un oggetto ...

public final class NoNPE {

    public static <T> T get(NoNPEInterface<T> in) {
        try {
            return in.get();
        } catch (NullPointerException e) {
            return null;
        }
    }

    public interface NoNPEInterface<T> {
        T get();
    }
}

Lo uso un po 'come questo ...

Room room = NoNPE.get(() -> country.getTown().getHouses().get(0).getLivingRoom());

Quanto sopra mi dà come risultato ottenere un oggetto Room o null, senza dover controllare tutti i livelli padre.

Cosa ne pensi di quanto sopra? Sto creando un modello problematico? C'è un modo migliore per farlo secondo te?

La tua soluzione è molto intelligente. Il problema che vedo è il fatto che non sai perché hai un null? Era perché la casa non aveva stanze? Era perché la città non aveva case? Era perché il paese non aveva città? È stato perché c'era un nullnella posizione 0 della collezione a causa di un errore anche quando ci sono case nelle posizioni 1 e successive?

Se usi estensibe la NonPEclasse, avrai seri problemi di debug. Penso che sia meglio sapere dove si rompe esattamente la catena piuttosto che ottenere silenziosamente un nullche potrebbe nascondere un errore più profondo.

Anche questo viola la Legge di Demetra : country.getTown().getHouses().get(0).getLivingRoom(). Più spesso, la violazione di alcuni buoni principi ti rende necessario implementare soluzioni non ortodosse per risolvere il problema causato dalla violazione di tale principio.

La mia raccomandazione è di usarlo con cautela e provare a risolvere il difetto di progettazione che ti costringe a incorrere nell'antipasto del disastro ferroviario (quindi non devi usarlo NonPEovunque). Altrimenti potresti avere dei bug che saranno difficili da rilevare.

L'idea va bene, davvero molto bene. Dal momento che Optionalesistono i tipi Java 8 , è possibile trovare una spiegazione dettagliata nel tipo Opzionale Java . Un esempio di ciò che hai pubblicato è

Optional.ofNullable(country)
    .map(Country::getTown)
    .map(Town::Houses);

E più avanti.

Il tuo metodo funziona abbastanza bene per lo scopo previsto, sebbene restituisca nulls quando ottieni un NullPointerExceptionsuono come un cattivo design.

Cerca di evitare nulls quando puoi e passali solo quando rappresentano qualcosa o hanno un significato speciale e restituiscili solo quando rappresentano / significano qualcosa - altrimenti dovresti lanciare a NullPointerException. Questo evita bug e confusione. Se Objectnon dovrebbe essere null, NullPointerdovrebbe essere lanciato. Se un oggetto può essere, nullallora nulla andrà storto quando viene passato. Altrimenti il ​​metodo sopra funziona.

Sento il tuo dolore, ma la soluzione proposta è una cattiva idea.

• Se uno dei getter lancia un NPE per qualche altro motivo, lo ignorerai.
• C'è il rischio che quella lambda interiore si trasformi in un codice orribile. Ad esempio, se c'è un nuovo requisito per restituire una costante speciale quando non ci sono case in città, un programmatore pigro può estendere il lamda, lasciando tutto avvolto NoNPE.get.
• Come già accennato, Optional.mapè quello che stai cercando.
• La penalità per la creazione di una nuova istanza di NullPointerException è spesso significativa. Sono molti microsecondi, soprattutto perché lo stack delle chiamate sta diventando più grande. È difficile prevedere dove verrà utilizzata la tua utility.

Come nota a margine, NoNPEInterfaceè un duplicato di java.util.function.Supplier.

In alcuni casi potresti prendere in considerazione l'utilizzo di utils di valutazione di espressioni presenti in molti framework (ad esempio: EL, SpEL):

evaluateProperty(country, "town.houses[0].livingRoom")