Eccezioni Concatenate in Java

Eccezioni concatenate

Di recente, una funzionalità è stata incorporata nel sottosistema delle eccezioni di Java: le Eccezioni concatenate.

La funzionalità delle eccezioni concatenate consente di associare un'altra eccezione a un'eccezione. Questa seconda eccezione descrive la causa della prima eccezione.

Per esempio, si immagini una situazione in cui un metodo lancia un'ArithmeticException a causa di un tentativo di divisione per zero. Tuttavia, la causa reale del problema era che si era verificato un errore di I/O, che ha causato l'impostazione errata del divisore. Sebbene il metodo debba sicuramente lanciare un'ArithmeticException, poiché questo è l'errore verificatosi, potrebbe essere utile informare anche il codice chiamante che la causa sottostante era un errore di I/O. Le eccezioni concatenate permettono di gestire questo e ogni altra situazione in cui esistono livelli di eccezioni.

Per consentire le eccezioni concatenate, sono stati aggiunti due costruttori e due metodi alla classe Throwable. I costruttori sono mostrati qui:

Throwable(Throwable causaEccezione)
Throwable(String messaggio, Throwable causaEccezione)

Nel primo formato, causaEccezione è l'eccezione che causa l'eccezione corrente. Cioè, causaEccezione è la ragione sottostante per cui si è verificata un'eccezione.

Il secondo formato consente di specificare una descrizione nello stesso momento in cui si specifica un'eccezione di causa. Questi due costruttori sono stati aggiunti anche alle classi Error, Exception e RuntimeException.

I metodi supportati da Throwable per le eccezioni concatenate sono getCause() e initCause():

Throwable getCause()
Throwable initCause(Throwable causaEccezione)

Il metodo getCause() restituisce l'eccezione che sottende l'eccezione corrente. Se non esiste un'eccezione sottostante, viene restituito null. Il metodo initCause() associa causaEccezione all'eccezione invocante e restituisce un riferimento all'eccezione. Così, si può associare una causa con un'eccezione dopo che l'eccezione è stata creata. Tuttavia, la causa dell'eccezione può essere impostata una sola volta. Questo significa che si può chiamare initCause() solo una volta per ogni oggetto eccezione. Inoltre, se la causa dell'eccezione è stata impostata tramite un costruttore, non può essere impostata nuovamente usando initCause(). In generale, initCause() è usato per impostare una causa per le classi di eccezione che non supportano i due costruttori aggiuntivi descritti prima.

Ecco un esempio che illustra la meccanica della gestione delle eccezioni concatenate:

// Dimostrare la concatenazione delle eccezioni.
class DimostrazioneEccezioniConcatenate {
    static void demoProcedura() {

        // creare un'eccezione
        NullPointerException e =
            new NullPointerException("livello superiore");

        // aggiungere una causa
        e.initCause(new ArithmeticException("causa"));

        throw e;
    }

    public static void main(String[] args) {
        try {
            demoProcedura();
        } catch(NullPointerException e) {
            // visualizzare l'eccezione di livello superiore
            System.out.println("Catturata: " + e);

            // visualizzare l'eccezione causa
            System.out.println("Causa originale: " +
                               e.getCause());
        }
    }
}

L'output del programma è mostrato qui:

Catturata: java.lang.NullPointerException: livello superiore
Causa originale: java.lang.ArithmeticException: causa

In questo esempio, l'eccezione di livello superiore è NullPointerException. A essa è aggiunta un'eccezione causa, ArithmeticException. Quando l'eccezione è lanciata da demoProcedura(), essa è catturata da main(). Qui, viene visualizzata l'eccezione di livello superiore, seguita dall'eccezione sottostante, ottenuta chiamando getCause().

Le eccezioni concatenate possono essere estese a qualunque profondità necessaria. Così, anche l'eccezione causa può, a sua volta, avere una causa. Occorre fare attenzione perché lunghe catene di eccezioni possono indicare una progettazione povera.