Como lidar com exceções em páginas JSP

Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Para efetuar o download você precisa estar logado. Clique aqui para efetuar o login
Confirmar voto
0
 (0)  (0)

Veja nesse artigo como uma página JSP lida com a exceção em tempo de execução. Veja também como lidar com ela em algumas situações onde geralmente a exceção ocorre.

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: http://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:

o arquivo index.jsp carregado.

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:

Página de resultado para entradas de usuário - 36 & 3. Isso mostra o resultado como 12.

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:

ocorreu uma exceção quando o usuário digitou um texto em vez de valor numérico.

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:

ocorreu uma exceção quando o usuário digitou no 0 campo divisor.

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

 
Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Receba nossas novidades
Ficou com alguma dúvida?