Pausa para café #158. 10 dicas para lidar com exceções em Java

Fonte: Médio Esta postagem ajudará você a entender melhor como lidar com exceções de maneira eficaz em Java. Lidar com exceções Java pode ser um desafio. Pode ser difícil determinar quais exceções Java tratar, quais exceções relançar e quais simplesmente ignorar. No entanto, há uma série de diretrizes úteis que podem ajudá-lo efetivamente a lidar com exceções e a criar novos aplicativos. Vamos conhecê-los.

1. Tenha cuidado com o que você registra.
2. Não ignore exceções lançadas.
3. Use um manipulador de exceções global.
4. Não feche os recursos manualmente.
5. Lance antecipadamente e lide com exceções mais tarde.
6. As exceções Java não devem ser registradas e lançadas novamente.
7. Examine exceções suprimidas.
8. Na instrução throw, declare exceções com precisão.
9. Lide primeiro com a exceção mais óbvia.
10. Use a semântica moderna de tratamento de exceções.

1. Tenha cuidado com o que você registra

Os desenvolvedores de software devem estar sempre cientes dos direitos de seus clientes à segurança e à privacidade.

• Um programa Java pode mover dados para outros sistemas, e um grande número de desenvolvedores e administradores podem trabalhar com ele (incluindo a correção de bugs).
• Se quaisquer dados confidenciais forem registrados nos arquivos de log, sua empresa não estará em conformidade com os requisitos de segurança e você poderá perder seu emprego.

2. Não ignore exceções lançadas

Não capture uma exceção e depois ignore-a. Ocultar exceções não é uma boa maneira de lidar com elas em Java. No mínimo, anote o nome da exceção e a mensagem associada. Dessa forma, informações sobre o problema podem ser encontradas em sua entrada. A depuração de aplicativos Java devido a exceções ocultas é incrivelmente difícil.

3. Use um manipulador de exceções global

Durante a execução do programa sempre existirão algumas exceções que não foram capturadas anteriormente no seu código. Portanto, sempre adicione um manipulador de exceções global para tratar exceções não detectadas. Isso não apenas permitirá que a exceção seja registrada e tratada, mas também evitará que o aplicativo trave se uma exceção for lançada em tempo de execução.

4. Não feche recursos manualmente

Outra recomendação importante ao lidar com exceções Java é permitir que a JVM chame o método close() nos recursos que estão sendo fechados. Não tente fechá-los sozinho. Isso pode ser facilmente alcançado inicializando os recursos dentro do módulo try-resources . Semântica:

public class TryWithResourcesExample {

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

try (Door door = new Door()) {

door.swing();

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

} finally { .....}

}

}

Como você pode ver, após a conclusão do bloco try...catch, a JVM fecha o recurso para você, eliminando a possibilidade de vazamentos de recursos complexos e difíceis de corrigir.

5. Lançar cedo e tratar exceções depois

Lance uma exceção sempre que ocorrer uma condição de exceção em seu código. Não espere a execução de nenhuma linha de código antes de sair do método em que você está. Ao capturar exceções, a função deve ser colocada no final do método. Isso reduz o número de blocos catch em seus métodos, tornando seu código mais fácil de ler e manter.

6. Exceções Java não devem ser registradas e lançadas novamente

Se ocorrer uma exceção, siga um destes procedimentos:

• Continue trabalhando com seu programa enquanto registra a exceção.
• Lance a exceção novamente e permita uma maneira diferente de registrar dados.

Não combine as duas etapas. Nunca registre e lance novamente a mesma exceção, conforme mostrado no exemplo abaixo:

try {

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

} catch (ClassNotFoundException ex) {

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

throw ex;

}

Isso resulta na duplicação de código e nos arquivos de log obstruídos com entradas duplicadas, tornando muito mais difícil diagnosticar o código.

7. Examine exceções suprimidas

A exceção suprimida é um novo recurso de linguagem que nem todos os desenvolvedores conhecem. Ao implementar um método comprovado com recursos, duas exceções podem ser lançadas ao mesmo tempo. Esta condição pode ser facilmente verificada consultando a presença de uma exceção suprimida. A única maneira de determinar se essa condição ocorreu é verificar se a exceção de destino também contém uma exceção suprimida.

8. Ao usar a instrução throw, especifique as exceções exatas

Ao usar uma instrução throw dentro do corpo de um método, um desenvolvedor descuidado estaria usando uma classe de exceção genérica. Mas esta não é a melhor maneira de lidar com exceções em Java. Em vez disso, sempre especifique as exceções exatas que o método pode lançar. Ajuda outros desenvolvedores a conhecer as diferentes técnicas de tratamento de erros que podem ser usadas quando um determinado método não funciona conforme o esperado.

9. Trate primeiro a exceção mais óbvia

Isso é mais um requisito do compilador do que uma dica para práticas de tratamento de exceções Java, mas um desenvolvedor deve sempre tratar primeiro a exceção mais óbvia e por último a exceção menos certa. Se esta regra não for seguida, a JVM retornará um erro em tempo de compilação com uma mensagem de erro muito enigmática e difícil de entender. Facilite sua vida como desenvolvedor de software sempre lidando com certas exceções em seu código.

10. Use semântica moderna de tratamento de exceções

Java fornece muitos recursos de tratamento de erros e exceções que simplificam o desenvolvimento e reduzem significativamente a quantidade de código Java. Use a capacidade de lidar com múltiplas exceções em um único bloco catch e fechar recursos automaticamente usando um bloco try . Use exceções de tempo de execução para que outros desenvolvedores não precisem lidar com as exceções lançadas.