Pausa caffè #158. 10 suggerimenti per la gestione delle eccezioni in Java

Fonte: Medium Questo post ti aiuterà a capire meglio come gestire le eccezioni in modo efficace in Java. La gestione delle eccezioni Java può essere complessa. Può essere difficile determinare quali eccezioni Java gestire, quali eccezioni rilanciare e quali semplicemente ignorare. Tuttavia, esistono numerose linee guida utili che possono aiutarti efficacemente a gestire le eccezioni e creare nuove applicazioni. Facciamo la loro conoscenza.

1. Fai attenzione a ciò che registri.
2. Non ignorare le eccezioni generate.
3. Utilizzare un gestore di eccezioni globale.
4. Non chiudere le risorse manualmente.
5. Lancialo presto e gestisci le eccezioni più tardi.
6. Le eccezioni Java non devono essere registrate e riproposte.
7. Esaminare le eccezioni soppresse.
8. Nell'istruzione Throw dichiarare con precisione le eccezioni.
9. Gestire prima l'eccezione più ovvia.
10. Utilizzare la semantica moderna per la gestione delle eccezioni.

1. Fai attenzione a ciò che registri

Gli sviluppatori di software dovrebbero essere sempre consapevoli dei diritti dei loro clienti alla sicurezza e alla privacy.

• Un programma Java può spostare dati su altri sistemi e un numero enorme di sviluppatori e amministratori può lavorarci (inclusa la correzione dei bug).
• Se nei file di registro vengono registrati dati sensibili, la tua azienda non sarà conforme ai requisiti di sicurezza e potresti perdere il lavoro.

2. Non ignorare le eccezioni generate

Non rilevare un'eccezione e poi ignorarla. Nascondere le eccezioni non è un buon modo per gestirle in Java. Come minimo, annotare il nome dell'eccezione e il messaggio associato. In questo modo è possibile trovare informazioni sul problema nella voce inserita. Il debug delle applicazioni Java a causa di eccezioni nascoste è incredibilmente difficile.

3. Utilizzare un gestore di eccezioni globale

Durante l'esecuzione del programma ci saranno sempre alcune eccezioni che non erano state precedentemente catturate nel codice. Pertanto, aggiungi sempre un gestore di eccezioni globale per gestire le eccezioni non rilevate. Ciò non solo consentirà la registrazione e la gestione dell'eccezione, ma impedirà anche l'arresto anomalo dell'applicazione se viene generata un'eccezione in fase di runtime.

4. Non chiudere le risorse manualmente

Un'altra raccomandazione importante quando si gestiscono le eccezioni Java è consentire alla JVM di chiamare il metodo close() sulle risorse da chiudere. Non provare a chiuderli da solo. Ciò può essere facilmente ottenuto inizializzando le risorse all'interno del modulo try-resources . Semantica:

public class TryWithResourcesExample {

public static void main(String[] args) throws Exception {

try (Door door = new Door()) {

door.swing();

} catch (Exception e) { ..... }

} finally { .....}

}

}

Come puoi vedere, una volta completato il blocco try...catch, la JVM chiude la risorsa, eliminando la possibilità di perdite di risorse complesse e difficili da risolvere.

5. Lancia in anticipo e gestisci le eccezioni in seguito

Genera un'eccezione ogni volta che si verifica una condizione di eccezione nel tuo codice. Non attendere l'esecuzione di alcuna riga di codice prima di uscire dal metodo in cui ti trovi. Quando si rilevano le eccezioni, la funzione deve essere posizionata alla fine del metodo. Ciò riduce il numero di blocchi catch nei metodi, rendendo il codice più semplice da leggere e gestire.

6. Le eccezioni Java non devono essere registrate e riproposte

Se si verifica un'eccezione, effettuare una delle seguenti operazioni:

• Continua a lavorare con il tuo programma mentre registri l'eccezione.
• Genera nuovamente l'eccezione e consente un modo diverso di registrare i dati.

Non combinare entrambe le fasi. Non registrare mai e quindi rilanciare la stessa eccezione, come mostrato nell'esempio seguente:

try {

Class.forName("com.min.Example");

} catch (ClassNotFoundException ex) {

log.warning("Class was not found.");

throw ex;

}

Ciò provoca la duplicazione del codice e i file di registro si intasano con voci duplicate, rendendo molto più difficile la diagnosi del codice.

7. Esaminare le eccezioni soppresse

L'eccezione soppressa è una nuova funzionalità del linguaggio di cui non tutti gli sviluppatori sono a conoscenza. Implementando un metodo collaudato con risorse, è possibile generare due eccezioni contemporaneamente. Questa condizione può essere facilmente verificata interrogando la presenza di un'eccezione soppressa. L'unico modo per determinare se questa condizione si è verificata è verificare se l'eccezione di destinazione contiene anche un'eccezione soppressa.

8. Quando si utilizza l'istruzione Throw, specificare le eccezioni esatte

Utilizzando un'istruzione Throw all'interno del corpo di un metodo, uno sviluppatore disattento utilizzerebbe una classe di eccezione generica. Ma questo non è il modo migliore per gestire le eccezioni in Java. Specificare invece sempre le eccezioni esatte che il metodo potrebbe generare. iAiuta altri sviluppatori a conoscere le diverse tecniche di gestione degli errori che possono essere utilizzate quando un determinato metodo non funziona come previsto.

9. Gestire prima l'eccezione più ovvia

Questo è più un requisito del compilatore che un suggerimento per le pratiche di gestione delle eccezioni Java, ma uno sviluppatore dovrebbe sempre gestire prima l'eccezione più ovvia e per ultima quella meno certa. Se questa regola non viene seguita, la JVM restituirà un errore in fase di compilazione con un messaggio di errore molto criptico e difficile da comprendere. Rendi più semplice la tua vita di sviluppatore di software gestendo sempre alcune eccezioni nel tuo codice.

10. Utilizzare la moderna semantica di gestione delle eccezioni

Java fornisce molte funzionalità di gestione degli errori e delle eccezioni che semplificano lo sviluppo e riducono significativamente la quantità di codice Java. Utilizza la possibilità di gestire più eccezioni in un singolo blocco catch e di chiudere automaticamente le risorse utilizzando un blocco try . Utilizza le eccezioni di runtime in modo che altri sviluppatori non debbano gestire le eccezioni generate.