Uma exceção em qualquer linguagem de programação é uma situação que provoca interrupções no fluxo de execução normal do programa. Abaixo iremos ver alguns dos cenários onde geralmente as exceções ocorrem:
- tentando se conectar a um banco de dados que não existe;
- tentando acessar um arquivo no disco e o arquivo não está disponível;
- tentando se conectar a camada de serviço e a camada não está disponível, etc.
Manipulação de exceção é o processo que lida com estas (ou mais) situações imprevistas em tempo de execução, semelhante a um programa Java, estas exceções podem também ocorrer em páginas JSP. Uma forma eficiente de tratamento de exceções em páginas JSP é redirecionar o usuário para uma página de erro padrão. Em JSP's, existem várias maneiras de lidar com as exceções:
- usando tributos errorPage e isErrorPage da página;
- usando elemento <error-page> no arquivo web.xml.
- usando scriplets Java dentro de um arquivo jsp.
Tratamento de exceções usando page directive
Nesta abordagem, nós devemos definir uma página jsp para manipular a exceção. Neste exemplo, nossa página de manipulação de exceção é - error.jsp. O jsp onde pode ocorrer a exceção deve ter definido o atributo de erro na page directive (para maior conhecimento sobre page directive: https://www.devmedia.com.br/conhecendo-as-diretivas-jsp/5397).
No nosso caso, isso é feito no processo, jsp file.
Listagem 1: Arquivo de index. jsp - exemplo de arquivo para tirar a entrada do usuário
<form action = "process.jsp" >
<h3> Devide the first number by 2nd number </h3>
Number 1 : <input type = "text" name="n1" /> <br/> <br/>
Number 2 : <input type = "text" name="n2" /> <br/> <br/>
<input type="submit" value="Compute"/> </form>
Listagem 2: process.jsp file - arquivo de exemplo, para processar a entrada do usuário
<%@ page errorPage = "error.jsp" %>
<%
String num1 =request.getParameter( "n1" );
String num2 =request.getParameter( "n2" );
int a = Integer.parseInt(num1);
int b = Integer.parseInt(num2);
int c = a/b;
out.print( "division of numbers is: " +c );
%>
Listagem 3: error.jsp file - arquivo de exemplo, para capturar o erro
<form action = "index.jsp" >
<%@ page isErrorPage = "true" %>
<h3>Sorry an exception has occured!</h3>
Exception is: <%= exception %> <br/>
<input type="submit" value="Re-Compute"/> </form>
Listagem 4: O web.xml file - contém a primeira página
<?xml version="1.0" encoding="UTF-8"?>
<web-app version = "2.5" xmlns = "http://java.sun.com/xml/ns/javaee "
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance "
xsi:schemaLocation = "http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" >
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>
Como podemos ver no arquivo web.xml, o aplicativo começa a carregar o arquivo index.jsp. Esta página surge como:
Figura 1: O arquivo index.jsp carregado.
Uma vez que o usuário insere dois números na caixa de texto fornecida e tecla no botão calcular, o arquivo process.jsp é invocado a partir daqui. Baseado na entrada fornecida pelo usuário, o process.jsp ou produz um resultado ou uma página de erro, como abaixo:
Figura 2: Página de resultado para entradas de usuário - 36 & 3. Isso mostra o resultado como 12.
Se o usuário insere entradas inválidas, por exemplo, um valor alfanumérico em qualquer um dos campos, o process.jsp resulta na página de saída a seguir:
Figura 3: ocorreu uma exceção quando o usuário digitou um texto em vez de valor numérico.
Aqui o usuário insere um texto - 'dfg' no campo divisor. O aplicativo é incapaz de analisar a seqüência de caracteres 'dfg' em um valor numérico. Se o usuário insere zero - a saída de campo de 0 no divisor é como abaixo:
Figura 4: ocorreu uma exceção quando o usuário digitou no '0' campo divisor.
Qualquer exceção que é lançada no corpo de uma página JSP é encaminhada para errorPage URL que é especificado na JSP page directive. Por exemplo:
<%@ page errorPage = "error.jsp" %>
O código acima redireciona o navegador para a página JSP error.jsp se uma exceção ocorre enquanto o pedido está em processo. A página de erro jsp deve indicar uma página de erro definindo o atributo isErrorPage para true. No exemplo acima, a página de error.jsp indica que é uma página de erro de processamento através da diretiva:
<%@ page isErrorPage="true" %>
Neste caso, linguagem implícita de exceção de script desta página, é inicializado para a referência de java.lang.Throwable. Os seguintes pontos devem ser mantidos em mente ao usar a abordagem da page directive:
- O desenvolvedor deve usar sempre uma URL relativa ao valor do atributo errorPage na page directive.
- Se o autoFlash é definido como verdadeiro.
autoFlush=true
Então, se o conteúdo do Jsp-escritor inicial foi liberado para o ServletResponse fluxo de saída, então qualquer tentativa subsequente para despachar uma exceção não tratada de página incorreta para um errorPage pode falhar.
Se a página de erro também é indicada no descritor web.xml, a página de erro JSP é aplicada primeiro, e depois o web.xml.
Tratamento de exceções usando o elemento de página de erro no arquivo ‘web.xml’ .
Essa abordagem é melhor quando o usuário não precisa usar a page directive para declarar a página de erro em cada arquivo jsp. Fazer uma única entrada no arquivo web.xml serve para isto. Nós podemos especificar o tipo de exceção ou o código de erro com o location element. Para tratar todas as exceções, precisamos especificar o java.lang.Exception no elemento de tipo de exceção. O arquivo web.xml para cada um desses casos é dado como abaixo:
Listagem 5: Arquivo de exemplo para lidar com qualquer tipo de exceções
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="<http://java.sun.com/xml/ns/javaee>"
xmlns:xsi="<http://www.w3.org/2001/XMLSchema-instance>"
xsi:schemaLocation="<http://java.sun.com/xml/ns/javaee>
<http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd>">
<error-page>
<exception-type>java.lang.Exception</exception-type> <location>/error.jsp</location>
</error-page>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>
Arquivo web.xml que manipula a exceção para um código de erro específico:
Listagem 6: Arquivo de exemplo para lidar com o erro específico
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="<http://java.sun.com/xml/ns/javaee>"
xmlns:xsi="<http://www.w3.org/2001/XMLSchema-instance>"
xsi:schemaLocation="<http://java.sun.com/xml/ns/javaee>
<http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd>">
<error-page>
<error-code>500</error-code>
<location>/error.jsp</location>
</error-page>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>
index. jsp e os arquivos error.jsp são exatamente o mesmo que no exemplo acima. process.jsp é um pouco diferente. Vejamos isso abaixo:
Listagem 7: Exemplo de cálculo
<%
String num1 = request.getParameter("n1");
String num2 = request.getParameter("n2");
int a = Integer.parseInt(num1);
int b = Integer.parseInt(num2);
int c = a / b;
out.print("division of numbers is: " + c);
%>
Como podemos ver aqui o arquivo process.jsp não precisa declarar a page directive - errorPage.
Manipulando exceções usando scriplets
Essa abordagem é a forma tradicional de tratamento de exceções. Essa não é considerada a melhor maneira de lidar com exceção, mas é necessariamente usada no caso de depuração rápida. Nesta abordagem o desenvolvedor pode simplesmente usar o try... catch... formato dentro do arquivo jsp. Um exemplo é mostrado abaixo:
Listagem 8: Exemplo de código para manipular a exceção usando o script
<%
try{
String num1 = request.getParameter("n1");
String num2 = request.getParameter("n2");
int a = Integer.parseInt(num1);
int b = Integer.parseInt(num2);
int c = a / b;
out.print("division of numbers is: " + c);
} catch (Exception ex) {
out.println("An exception hs occurred - " +ex.getMessage());
}
%>
Conclusão
Em qualquer linguagem de programação, a exceção é o evento que indica se algo deu errado com a execução do programa. Uma exceção altera a rota do fluxo do programa. Uma página JSP manipula exceções das seguintes maneiras:
- usando atributos errorPage e isErrorPage da page directive;
- usando o element <error-page> no arquivo web.xml;
- usando java scriplets dentro de um arquivo jsp.
A classe java.lang.Throwable é inicializada quando há uma exceção que é tratada usando a page directive.
Artigo traduzido e originalmente publicado em: http://mrbool.com/how-to-handle-exception-in-jsp-page/28346
