Java 7 e i Doni Tardivi – Seconda Parte

Every1 Loves Java7Continuiamo a vedere insieme cosa ci ha portato di nuovo la versione 7 di Java. Nel post precedente abbiamo visto gli string switch e le risorse autoclosable, che possono rendere il codice in caso di try-catch-finally molto più coinciso. Oggi parliamo ancora di innovazioni che girano intorno alla gestione dell’errore.

Horcrux numero 3: rilancia la precisione!

Spesso vorremmo gestire nel catch più di una eccezione di tipo diverso, eseguire delle operazioni e rilanciarle. Vediamo un esempio di codice:

 public static void main(String[] args) throws IOException, SQLException {
        try {
            caricaFileDB();
        } catch (SQLException ex) {
            // logga ex
            throw ex;
        } catch (IOException ex) {
            // logga ex
            throw ex;
        }
    }

Stiamo gestendo ogni tipo di eccezione lanciata dal blocco try per poi rilanciarla. Questo codice però presenta ridondanza: prima di Java 7 l’unico modo di evitarla era di gestire l’eccezione base:

 public static void main(String[] args) throws Exception {
        try {
            caricaFileDB();
        } catch (Exception ex) {
            // gestisci ex
            throw ex;
        } 
    }

Così però abbiamo dovuto rilanciare l’eccezione base java.lang.Exception dal metodo chiamante, perdendo in specificità. Con Java 7 invece:

 public static void main(String[] args) throws IOException, SQLException {
        try {
            caricaFileDB();
        } catch (final Exception ex) {
            // gestisci ex
            throw ex;
        }
    }

Con il final nella clausola catch istruiamo il compilatore a lanciare solo quelle eccezioni checked che non sono state gestisce in nessuno dei blocchi catch precedenti.

Horcrux numero 4: prendi tutto!

In Java 6 non esiste un modo di gestire più eccezioni in un punto solo: questo produce codice boilerplate difficile da leggere e manutenere:

try {
faQualcosa();
} catch(Ex1 ex1) {
gestisciEccezione1();
} catch(Ex2 ex2) {
gestisciEccezione2();
} catch(Ex3 ex3) {
gestisciEccezione3();
}

Java 7 consente invece di gestire eccezioni multiple nel blocco catch nel modo seguente:

 public static void main(String[] args) throws Ex1, Ex2, Ex3, Ex4 {
        try {
            faQualcosa();
        } catch (Ex1 | Ex2 ex) {
            gestisciEccezione12():
        } catch (Ex3 | Ex4 ex) {
            gestisciEccezione34():
        }
    }

Bello, no? Un altro passo verso codice Java più corto e leggibile!

Conclusioni

Altri Horcrux sono stati recuperati, altre piccole migliorie del linguaggio che, nella loro globalità, fanno di Java 7 un linguaggio più coinciso e potente, se pur non rivoluzionario rispetto alla versione precedente. Nel prossimo post andremo alla caccia degli ultimi Horcrux e alla fine avremo ragione dell’Oscuro Signore!

Alla prossima!

Manuele Piastra

Sono uno Scrum Master e Project Manager i cui skill tecnici sono focalizzati al momento sullo sviluppo di applicazioni Java EE su IBM Websphere 7.0 utilizzando JSF (RichFaces), JPA (EclipseLink) ed EJB3. Presso OmniaGroup ricopro il ruolo di Training Manager: seleziono il personale tecnico, mi occupo della sua crescita formativa organizzando Corsi e Workshop sia interni che esterni, molti dei quali hanno visto me come docente. LinkedIn Profile - Google+