Dê uma olhada nos erros de tempo de execução do Java

Feb 26 2023

Uma rápida visão geral dos erros de tempo de execução do Java · O que são erros de tempo de execução em Java?· Erro de tempo de execução VS Erro de tempo de compilação· Tipos de erros de tempo de execução· Como o erro de tempo de execução aparece?· Preciso lançar erros de tempo de execução· O que aconteceu quando você não t catch a Runtime Exceptions· Exemplo de erro de runtime O que são erros de runtime em Java? Os erros que ocorrem no momento da execução do programa são referidos como erros de tempo de execução. Esses tipos de erros não podem ser detectados no momento da compilação, pois não há nada de errado com sua sintaxe.

Uma rápida visão geral dos erros de tempo de execução do Java

· O que são erros de tempo de execução em Java?
· Erro de tempo de execução VS Erro de tempo de compilação
· Tipos de erros de tempo de execução
· Como o erro de tempo de execução aparece?
· Preciso lançar erros de tempo de execução
· O que aconteceu quando você não detectou uma exceção de tempo de execução
· Exemplo de erro de tempo de execução

O que são erros de tempo de execução em Java?

Os erros que ocorrem no momento da execução do programa são referidos como erros de tempo de execução. Esses tipos de erros não podem ser detectados no momento da compilação, pois não há nada de errado com sua sintaxe. Portanto, os erros de tempo de execução ocorrem quando o programa foi compilado com sucesso sem dar nenhum erro e criando um arquivo “.class”. No entanto, o programa não é executado corretamente. Esses erros são detectados em tempo de execução ou no momento da execução do programa.

O compilador Java não detecta erros de tempo de execução porque o compilador Java não possui nenhuma técnica para detectar esses erros, pois não possui todas as informações de tempo de execução disponíveis para ele. Os erros de tempo de execução são detectados pela Java Virtual Machine (JVM) quando o programa está em execução.

Esses erros de tempo de execução são chamados de exceções e encerram o programa de forma anormal, fornecendo uma declaração de erro.

Exceções são erros lançados em tempo de execução. Podemos usar técnicas de manipulação de exceção em Java para lidar com esses erros de tempo de execução. No tratamento de exceções, o trecho de código que o programador acha que pode produzir o erro é colocado dentro do bloco try e o programador pode capturar o erro dentro do bloco catch.

Erro de tempo de execução VS Erro de tempo de compilação

Um erro de tempo de compilação geralmente se refere aos erros que correspondem à semântica ou sintaxe. Um erro de tempo de execução refere-se ao erro que encontramos durante a execução do código durante o tempo de execução . Podemos corrigir facilmente um erro de tempo de compilação durante o desenvolvimento do código. Um compilador não pode identificar um erro de tempo de execução.

Detecção

Os compiladores podem detectar facilmente erros de tempo de compilação durante o desenvolvimento do código. Um compilador não pode detectar facilmente um erro de tempo de execução. Assim, precisamos identificá-lo durante a execução do código.

Referência

Um erro em tempo de compilação geralmente se refere aos erros que correspondem à semântica ou sintaxe. Um erro em tempo de execução refere-se ao erro que não é detectado pelo compilador, mas os encontramos durante a execução do código (durante o tempo de execução).

impacto

Erros de tempo de compilação são erros de semântica ou sintaxe , eles impedem a execução (compilação) do código, pois detectam alguns erros de sintaxe. Wheares Erros de tempo de execução impedem a execução completa do código.

Fixação

Podemos corrigir facilmente um erro de tempo de compilação durante o desenvolvimento do código. Um compilador não pode identificar um erro de tempo de execução. Mas podemos corrigi-lo após a execução do código e identificação do código anterior.

Tipos de erros de tempo de execução

Existem vários tipos de erros de tempo de execução que podemos enfrentar no momento da execução do programa. Alguns erros de tempo de execução encontrados com frequência estão listados abaixo:

Erros de entrada de dados: Erros de entrada-saída

Existem inúmeras maneiras pelas quais a entrada do usuário pode corromper um aplicativo.

Em um quadro de comentários baseado em HTML, um usuário que tem permissão para enviar inocentemente um sinal não codificado menor que (<) ou maior que (>) tem o potencial de arruinar completamente a capacidade de renderização dessa página da web. Da mesma forma, os sistemas de processamento de texto construídos para esperar todas as entradas no formato ASCII podem terminar prematuramente se receberem emojis ou entradas de caracteres fora do padrão.

Mais nefastamente, um vetor de ataque favorito dos hackers é a injeção de SQL , que esconde uma consulta de banco de dados executável prejudicial dentro de um campo de entrada inócuo. Isso pode não apenas causar a falha de um aplicativo, mas potencialmente entregar o controle de toda a camada de dados.

O processo de sanitização de entrada, ou depuração de dados , converte o amplo espectro de dados que podem ser inseridos em aplicativos em uma faixa segura de valores que um programa compreende. O uso de tais bibliotecas ajuda a atenuar erros de tempo de execução causados por falhas de sanitização de entrada.

Estruturas Java populares, como Apache BVal e Hibernate Validator, executam uma limpeza de entrada simples baseada em anotações e se integram facilmente a qualquer aplicativo baseado em Java.

Lógica mal implementada

Só porque o código compila não significa que funcione corretamente. O código geralmente contém problemas lógicos que fazem com que um aplicativo falhe no tempo de execução.

Java contém uma construção integrada para lidar com uma classe de erros comuns de tempo de execução relacionados ao código, chamada RuntimeException ou exceção não verificada. O Java 17 define 78 desses erros apenas no SDK, e outros projetos e estruturas também definem seus próprios erros RuntimeException.

Exceção de tempo de execução
ArrayIndexOutOfBoundException
ConcurrentModificationException
ClassCastException
…

No mínimo, todo aplicativo deve incluir um arnês de exceção genérico que pode capturar todas as RuntimeException possíveis, registrar o erro e permitir que o encadeamento problemático de execução morra em vez de abortar todo o aplicativo.

Recursos de tempo de execução insuficientes

Os desenvolvedores de software não assumem a culpa por cada tipo de erro de tempo de execução que ocorre. Muitos erros de tempo de execução em Java envolvem limitações de recursos causadas por problemas com a infraestrutura subjacente. Os exemplos incluem: tempo limite de rede, condições de falta de memória , superutilização da CPU ou incapacidade de agendar um thread no processador.

Uma maneira de evitar erros de tempo de execução relacionados a recursos é usar uma ferramenta de teste de carga, como JMeter ou LoadRunner, no pipeline de CI/CD de um aplicativo. Se essas ferramentas detectarem um possível problema de desempenho, elas poderão interromper o aplicativo antes que ele avance no pipeline em direção à implantação de produção.

A carga de alguns aplicativos varia drasticamente. Por exemplo, um aplicativo de serviços financeiros pode ter carga constante na maior parte do tempo, mas estar extremamente ocupado no final do dia de negociação. Um serviço de impostos pode atingir um pico de carga antes do prazo de apresentação, mas ter uma carga relativamente pequena no resto do ano.

As equipes de DevOps devem monitorar suas métricas de desempenho com ferramentas para detectar e mitigar preventivamente erros de tempo de execução relacionados a recursos. Exemplos dessas ferramentas incluem JDK Flight Recorder e Java Mission Control .

Para aplicativos com cargas de trabalho completamente imprevisíveis, use a tecnologia de balanceamento de carga baseada em nuvem para alocar recursos de forma elástica. Isso elimina recursos subalocados e a armadilha de comprar hardware caro e raramente usado.

Configuração de recurso externo

Os aplicativos corporativos raramente existem em uma bolha isolada. Eles normalmente interagem com tudo, desde bancos de dados NoSQL e sistemas relacionais até filas Kafka e APIs RESTful. Infelizmente, se seu aplicativo não conseguir se conectar a um sistema externo necessário, isso inevitavelmente resultará em um erro de tempo de execução.

Um recurso externo pode precipitar um erro de tempo de execução se qualquer uma das seguintes situações ocorrer sem atualização correspondente no programa de chamada:

um endereço IP muda;
mudança de credenciais;
mudança de configuração de firewall; ou
o sistema externo fica inativo para manutenção.

Da mesma forma, as ferramentas de engenharia de caos encerram aleatoriamente os processos dos quais um aplicativo depende. Essas ferramentas forçam os desenvolvedores a escrever códigos que permaneçam responsivos e resilientes mesmo quando os sistemas externos falham.

O problema inerente aos recursos externos é que os desenvolvedores não podem controlá-los — mas podem controlar como um aplicativo responde quando esses recursos externos falham. Antecipe os erros de tempo de execução gerados pelos sistemas que você não controla e escreva aplicativos que respondam corretamente quando esses sistemas externos falharem.

Vulnerabilidades de bibliotecas de terceiros

Qualquer aplicativo corporativo não trivial inclui dezenas de dependências em bibliotecas de terceiros para executar funções como registro, monitoramento, validação de entrada, manipulação de formulários e muito mais.

Infelizmente, qualquer bug em uma biblioteca de terceiros se torna um bug no aplicativo que você implanta. Isso se tornou desconfortavelmente real para o mundo Java em dezembro de 2021, quando uma falha de injeção de LDAP na biblioteca Log4j 2 amplamente usada forçou as JVMs em todo o mundo a ficarem offline.

Uma maneira de atenuar a possibilidade de que as dependências de software introduzam erros de tempo de execução nos aplicativos é usar apenas bibliotecas confiáveis de organizações como Apache ou Eclipse.

Outra medida de proteção é atualizar regularmente as dependências de um aplicativo para a versão mais recente assim que as atualizações estiverem disponíveis.

Por fim, esteja ciente das dependências secundárias ou terciárias - aquelas nas quais suas próprias dependências primárias dependem - e esteja ciente dos riscos que elas trazem consigo.

No mundo do desenvolvimento de software, “perfeito” é inimigo de “pronto”. Nenhum programa está imune à ameaça de um erro imprevisto de tempo de execução. No entanto, quando os desenvolvedores corporativos aumentam a conscientização sobre as possíveis causas e tomam medidas para mitigar ameaças em potencial, eles podem criar um software que minimiza a probabilidade de encontrar um erro de tempo de execução.

Como o erro de tempo de execução aparece?

Parabéns! Se o seu prompt de comando estiver assim:

Então você compilou com sucesso seu programa em bytecode Java, o que significa que não houve problemas sintáticos com seu código! Mas, como o nome do arquivo indica, quando executamos este programa:

Agora encontramos um erro de tempo de execução. Erros de tempo de execução geralmente ocorrem quando há algo logicamente incorreto com seu código. Este documento explicará como ler e corrigir erros de tempo de execução.

Aqui estão as principais partes do erro de tempo de execução

Exceção no thread “principal” : esta parte aparece para a maioria dos erros de tempo de execução. Ele apenas informa que a exceção ocorreu no método main, o que deve acontecer o tempo todo.

java.lang.ArrayIndexOutOfBoundsException: 5 : Este é o erro que ocorreu. O nome do erro geralmente lhe dará uma ideia do que pode ter acontecido. Nesse caso, sabemos que ele lida com arrays e sai do espaço alocado para um array.

em RunTimeErrors.main(RunTimeErrors.java:10) : Isso é chamado de rastreamento de pilha, que informa a lista dos métodos em execução quando o erro ocorreu.

RunTimeErrors.main nos informa que esse erro ocorreu dentro do método principal da classe RunTimeErrors.
RunTimeErrors.java:10 nos informa em que arquivo isso ocorreu e em que linha isso aconteceu. Nesse caso, isso aconteceu em nossa classe principal na linha 10 .

Algumas vezes você precisa realizar uma checagem para decidir quando lançar uma exceção de tempo de execução se o sistema não puder fazer isso sozinho, geralmente quando se trabalha com IllegalArgumentException, mas na maioria das vezes você não precisa realizar uma checagem porque isso faz parte do a verificação de tempo de execução padrão que o Java executa para você.

vamos pegar NullPointerException como exemplo:

if(t == null) 
 throw new NullPointerException();

if(t != null) {
  // work with t reference
}

O que acontece quando você não captura exceções de tempo de execução? Uma vez que o compilador não impõe especificações de exceção para eles, é bastante plausível que uma RuntimeException percorra todo o caminho até seu método main( ) sem ser detectada. Para ver o que acontece neste caso, tente o seguinte exemplo:

//: exceptions/NeverCaught.java 
// Ignoring RuntimeExceptions. 
// {ThrowsException} 
public class NeverCaught { 
 static void f() { 
 throw new RuntimeException("From f()"); 
 } 
 static void g() { 
 f(); 
 } 
 public static void main(String[] args) { 
 g(); 
 } 
} ///:~

Exception in thread "main" Java.lang.RuntimeException: From f() 
    at NeverCaught.f(NeverCaught.Java:7) 
    at NeverCaught.g(NeverCaught.Java:10) 
    at NeverCaught.main(NeverCaught.Java:13)

Lembre-se de que apenas exceções do tipo RuntimeException (e subclasses) podem ser ignoradas em sua codificação, pois o compilador aplica cuidadosamente o tratamento de todas as exceções verificadas. O raciocínio é que um RuntimeException representa um erro de programação, que é:

Um erro que você não pode prever. Por exemplo, uma referência nula que está fora de seu controle.

Um erro que você, como programador, deveria ter verificado em seu código (como ArraylndexOutOfBoundsException onde você deveria ter prestado atenção no tamanho do array). Uma exceção que ocorre no ponto 1 geralmente se torna um problema para o ponto

Você pode ver que grande benefício é ter exceções neste caso, pois elas ajudam no processo de depuração.

É interessante notar que você não pode classificar o tratamento de exceções Java como uma ferramenta de propósito único. Sim, ele foi projetado para lidar com aqueles erros incômodos de tempo de execução que ocorrerão devido a forças fora do controle do seu código, mas também é essencial para certos tipos de bugs de programação que o compilador não consegue detectar.

Exemplo de erro de tempo de execução

public class Temp {
public static void main(String[] args) {
  Temp t = initT();
  
  t.foo("Hi");
  
 }
 private static Temp initT() {
  return null;
 }
 public void foo(String s) {
  System.out.println(s.toLowerCase());
 }
}

Exception in thread "main" java.lang.NullPointerException
	at Temp.main(Temp.java:7)

Há todo um grupo de tipos de exceção nessa categoria. Eles sempre são lançados automaticamente pelo Java e você não precisa incluí-los em suas especificações de exceção. Convenientemente, eles são todos agrupados, colocando-os em uma única classe base chamada RuntimeException , que é um exemplo perfeito de herança: ela estabelece uma família de tipos que possuem algumas características e comportamentos em comum. Além disso, você nunca precisa escrever uma especificação de exceção dizendo que um método pode lançar uma RuntimeException (ou qualquer tipo herdado de RuntimeException ), porque são exceções não verificadas. Porque eles indicam bugs, você normalmente não pega um RuntimeException- é tratado automaticamente. Se você fosse forçado a verificar RuntimeExceptions , seu código poderia ficar muito confuso. Mesmo que você normalmente não capture RuntimeExceptions , em seus próprios pacotes você pode optar por lançar algumas das RuntimeExceptions .