Java Gestisci Diverse Eccezioni, Rilancia l’Eccezione

In Java 7, il blocco catch è stato migliorato per gestire più eccezioni in un unico blocco catch. Se stai gestendo più eccezioni e hanno codice simile, utilizzare questa funzionalità ridurrà la duplicazione del codice. Capiamo la funzionalità di cattura delle eccezioni multiple di Java con un esempio.

Java cattura eccezioni multiple

Prima di Java 7, catturavamo più eccezioni una per volta come mostrato di seguito.

catch (IOException ex) {
     logger.error(ex);
     throw new MyException(ex.getMessage());
catch (SQLException ex) {
     logger.error(ex);
     throw new MyException(ex.getMessage());
}

In Java 7, possiamo catturare entrambe queste eccezioni in un unico blocco catch come segue:

catch(IOException | SQLException ex){
     logger.error(ex);
     throw new MyException(ex.getMessage());
}

Se un blocco catch gestisce più eccezioni, puoi separarle usando una barra verticale (|) e in questo caso, il parametro di eccezione (ex) è finale, quindi non è possibile modificarlo. Il bytecode generato da questa funzionalità è più piccolo e riduce la ridondanza del codice.

Java rilancia eccezione

Un altro miglioramento è stato fatto nell’analisi del compilatore delle eccezioni rilanciate. Java rilancia eccezione ti consente di specificare tipi di eccezioni più specifici nella clausola throws della dichiarazione di un metodo. Vediamo questo con un piccolo esempio:

package com.journaldev.util;

public class Java7MultipleExceptions {

	public static void main(String[] args) {
		try{
			rethrow("abc");
		}catch(FirstException | SecondException | ThirdException e){
			//l'assegnazione sottostante genererà un'eccezione in fase di compilazione poiché e è finale
			//e = new Exception();
			System.out.println(e.getMessage());
		}
	}

	static void rethrow(String s) throws FirstException, SecondException,
			ThirdException {
		try {
			if (s.equals("First"))
				throw new FirstException("First");
			else if (s.equals("Second"))
				throw new SecondException("Second");
			else
				throw new ThirdException("Third");
		} catch (Exception e) {
			//l'assegnazione sottostante disabilita la funzionalità migliorata di controllo dei tipi di eccezione di rethrow di Java 7
			// e=new ThirdException();
			throw e;
		}
	}

	static class FirstException extends Exception {

		public FirstException(String msg) {
			super(msg);
		}
	}

	static class SecondException extends Exception {

		public SecondException(String msg) {
			super(msg);
		}
	}

	static class ThirdException extends Exception {

		public ThirdException(String msg) {
			super(msg);
		}
	}

}

Come puoi vedere nel metodo rethrow, il blocco catch sta catturando Exception ma non fa parte della clausola throws. Il compilatore Java 7 analizza l’intero blocco try per verificare quali tipi di eccezioni vengono lanciati e poi rilanciati dal blocco catch. Nota che questa analisi viene disabilitata se si modifica l’argomento del blocco catch. Ulteriori letture: Gestione delle eccezioni in Java.