Tutorial Básico de JSP

Tutorial Avançado de JSP

Depuração JSP Linguagem de expressão JSP

Tratamento de exceções JSP

Quando se escreve um programa JSP, o programador pode esquecer alguns BUGs, que podem aparecer em qualquer lugar do programa. O código JSP geralmente possui os seguintes tipos de exceções:

Exceção verificada: Uma exceção verificada é um erro típico do usuário ou um erro que o programador não pode prever. Por exemplo, se um arquivo vai ser aberto, mas não puder ser encontrado, uma exceção é lançada. Essas exceções não podem ser simplesmente ignoradas no tempo de compilação.
Exceção de tempo de execução: Uma exceção de tempo de execução pode já ter sido evitada pelo programador, e essa exceção será ignorada no tempo de compilação.
Erro: O erro não é uma exceção, mas o problema é que ele está fora do controle do usuário ou do programador. Erros geralmente são ignorados no código e você quase não pode fazer nada com eles. Por exemplo, erros de pilha cheia. Esses erros são ignorados no tempo de compilação.

Esta seção fornecerá algumas maneiras simples e elegantes de lidar com exceções e erros de tempo de execução.

Usar o objeto Exception

O objeto exception é um exemplo de subclasse de Throwable, disponível apenas na página de erro. A tabela a seguir lista alguns métodos importantes da classe Throwable:

Número	Método&Descrição
1	public String getMessage() Retorna a mensagem da exceção. Esta mensagem é inicializada no construtor de Throwable
2	public Throwable getCause() Retorna a causa da exceção, do tipo objeto Throwable
3	public String toString() Retorna o nome da classe
4	public void printStackTrace() Escreve a pilha de chamadas da exceção no System.err
5	public StackTraceElement [] getStackTrace() Retorna a pilha de chamadas da exceção na forma de um array de elementos de pilha de chamadas
6	public Throwable fillInStackTrace() Usar a pilha de chamadas atual para preencher o objeto Throwable

O JSP oferece opções para especificar uma página de erro para cada página JSP. Sempre que uma página lançar uma exceção, o contêiner JSP chamará automaticamente a página de erro.

O exemplo seguinte especifica uma página de erro para o main.jsp. Use a instrução <%@page errorPage="XXXXX"%> para especificar uma página de erro.

<%@ page errorPage="ShowError.jsp" %>
<html>
<head>
   <title>Exemplo de Manipulação de Erros</title>
</head>
<body>
<%
   // Lançar uma exceção para invocar a página de erro
   int x = 1;
   if (x == 1)
   {
      throw new RuntimeException("Condição de erro!!!");
   }
%>
</body>
</html>

Agora, escreva o arquivo ShowError.jsp da seguinte forma:

<%@ page isErrorPage="true" %>
<html>
<head>
<title>Mostrar Página de Erro</title>
</head>
<body>
<h1>Opps...</h1>
<p>Desculpe, ocorreu um erro.</p>
<p>Aqui está o rastreamento da pilha de exceções: </p>
<pre>
<% exception.printStackTrace(response.getWriter()); %>

Notar que o arquivo ShowError.jsp utiliza a instrução <%@page isErrorPage="true"%>, que informa ao compilador do JSP que deve ser gerado um exemplo de variável de exceção.

Agora, tente acessar a página main.jsp, que resultará em:

java.lang.RuntimeException: Condição de erro!!!
......
Opps...
Desculpe, ocorreu um erro.
Aqui está o rastreamento da pilha de exceções:

Uso de tags do JSTL na página de erro

Pode-se usar as tags do JSTL para escrever a página de erro ShowError.jsp. O código deste exemplo é praticamente idêntico ao do exemplo anterior, mas com uma estrutura melhor e mais informações:

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@page isErrorPage="true" %>
<html>
<head>
<title>Mostrar Página de Erro</title>
</head>
<body>
<h1>Opps...</h1>
<table width="100%" border="1">
<tr valign="top">
<td width="40%"><b>Error:</b></td>
<td>${pageContext.exception}</td>
</tr>
<tr valign="top">
<td><b>URI:</b></td>
<td>${pageContext.errorData.requestURI}</td>
</tr>
<tr valign="top">
<td><b>Status code:</b></td>
<td>${pageContext.errorData.statusCode}</td>
</tr>
<tr valign="top">
<td><b>Trace da pilha:</b></td>
<td>
<c:forEach var="trace" 
         items="${pageContext.exception.stackTrace}">
<p>${trace}</p>
</c:forEach>
</td>
</tr>
</table>
</body>
</html>

O resultado da execução é o seguinte:

Uso do bloco try…catch

Se você quiser colocar o tratamento de exceções em uma página e tratar diferentes exceções de maneira diferente, você precisará usar o bloco try…catch.

O próximo exemplo mostra como usar o bloco try…catch, coloque este código no main.jsp:

<html>
<head>
   <title>Exemplo Try...Catch</title>
</head>
<body>
<%
   try{
      int i = 1;
      i = i / 0;
      out.println("A resposta é ") + i);
   }
   catch (Exception e){
      out.println("Ocorreu uma exceção: ") + e.getMessage());
   }
%>
</body>
</html>

Tente acessar main.jsp, ele produzirá o seguinte resultado:

Ocorreu uma exceção: / por zero

Depuração JSP Linguagem de expressão JSP