English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

Tutorial básico de JSP

Tutorial avançado de JSP

Depuração JSP

Para testar/Depurar um programa JSP ou servlet sempre é difícil. Programas JSP e Servlets tendem a envolver uma grande quantidade de clientes/A interação entre servidores pode gerar erros com frequência e ser difícil de reproduzir o ambiente de falha.

A seguir, serão fornecidas algumas dicas e sugestões para ajudar a depurar o programa.

Usar System.out.println()

System.out.println() pode marcar convenientemente se um trecho de código foi executado. Claro, também podemos imprimir vários tipos de valores. Além disso:

  • Desde que o objeto System se tornou um objeto nuclear do Java, ele pode ser usado em qualquer lugar sem a necessidade de importar classes adicionais. O escopo de uso inclui Servlets, JSP, RMI, EJB's, Beans, classes e aplicações independentes.

  • Em comparação com parar a execução no ponto de interrupção, a saída com System.out não causa impacto significativo no fluxo de execução do aplicativo, o que é muito útil em aplicativos de mecanismo de tempo importante.

A seguir, é fornecida a sintaxe de uso de System.out.println():

System.out.println("Mensagem de depuração");

Este é um exemplo simples usando System.out.print():

<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head><title>System.out.println</title></head>
<body>
<c:forEach var="counter" begin="1" end="10" step="1">
　　　<c:out value="${counter-5"}/></br>
　　　<% System.out.println( "counter= "　+　
　　　　　　　　　　　　　　　　　　　　　pageContext.findAttribute("counter") ); %>
</c:forEach>
</body>
</html>

Agora, se você executar o exemplo acima, ele produzirá o seguinte resultado:

-4
-3
-2
-1
0
1
2
3
4
5

Se você estiver usando o servidor Tomcat, você pode encontrar o conteúdo adicional no arquivo stdout.log na pasta logs:

counter=1
counter=2
counter=3
counter=4
counter=5
counter=6
counter=7
counter=8
counter=9
counter=10

Usando esse método, podemos output variáveis e outras informações para o log do sistema, usado para analisar e encontrar as causas profundas dos problemas.

Usando JDB Logger

J2A framework de logs SE pode fornecer serviços de registro de logs para qualquer classe executada no JVM. Portanto, podemos usar essa framework para registrar qualquer informação.

Vamos reescrever o código acima, usando a API logger do JDK:

<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@page import="java.util.logging.Logger" %>
<html>
<head><title>Logger.info</title></head>
<body>
<% Logger logger=Logger.getLogger(this.getClass().getName());%>
<c:forEach var="counter" begin="1" end="10" step="1">
　　　<c:set var="myCount" value="${counter-5"}　/>
　　　<c:out value="${myCount}"/></br>
　　　<% String message = "counter="
　　　　　　　　　　　　　　　　　　+　pageContext.findAttribute("counter")
　　　　　　　　　　　　　　　　　　+　" myCount="
　　　　　　　　　　　　　　　　　　+　pageContext.findAttribute("myCount");
　　　　　　　　　　　　　　　　　　logger.info(message);
　　　%>
</c:forEach>
</body>
</html>

Seu resultado de execução é semelhante ao anterior, mas, ele pode obter informações adicionais que são outputadas para o arquivo stdout.log. Aqui usamos o método info do logger. Abaixo está uma captura de tela do arquivo stdout.log:

24-Set-2013　23:31:31　org.apache.jsp.main_jsp _jspService
INFO: counter=1　myCount=-4
24-Set-2013　23:31:31　org.apache.jsp.main_jsp _jspService
INFO: counter=2　myCount=-3
24-Set-2013　23:31:31　org.apache.jsp.main_jsp _jspService
INFO: counter=3　myCount=-2
24-Set-2013　23:31:31　org.apache.jsp.main_jsp _jspService
INFO: counter=4　myCount=-1
24-Set-2013　23:31:31　org.apache.jsp.main_jsp _jspService
INFO: counter=5　myCount=0
24-Set-2013　23:31:31　org.apache.jsp.main_jsp _jspService
INFO: counter=6　myCount=1
24-Set-2013　23:31:31　org.apache.jsp.main_jsp _jspService
INFO: counter=7　myCount=2
24-Set-2013　23:31:31　org.apache.jsp.main_jsp _jspService
INFO: counter=8　myCount=3
24-Set-2013　23:31:31　org.apache.jsp.main_jsp _jspService
INFO: counter=9　myCount=4
24-Set-2013　23:31:31　org.apache.jsp.main_jsp _jspService
INFO: counter=10　myCount=5

As mensagens podem ser enviadas com várias prioridades, usando os métodos sever(), warning(), info(), config(), fine(), finer(), finest(). O método finest() é usado para registrar as melhores informações, enquanto o método sever() é usado para registrar as informações mais graves.

Use Log4Use o J Framework para registrar mensagens em diferentes arquivos, essas mensagens são classificadas com base na gravidade e na importância.

Ferramenta de depuração

O NetBeans é uma estrutura em árvore, é um ambiente de desenvolvimento integrado Java open-source, que suporta o desenvolvimento de aplicativos Java independentes e aplicativos de rede, além de suportar a depuração de JSP.

O NetBeans suporta várias funções básicas de depuração:

  • Ponto de parada

  • Rastreamento passo a passo

  • Ponto de observação

Mais informações podem ser encontradas no manual de uso do NetBeans.

Use o JDB Debugger

Pode-se usar o comando jdb para depurar JSP e servlets, da mesma forma que se depura aplicativos comuns.

Normalmente, depuramos o objeto sun.servlet.http.HttpServer diretamente para verificar o que o HttpServer executa ao responder a solicitações HTTP./Situação do Servlets. Isso é muito semelhante ao depuração de applets. A diferença está na verdade, o programa de applets que está sendo depurado é sun.applet.AppletViewer.

A maioria dos depuradores consegue ignorar automaticamente alguns detalhes ao depurar applets, pois sabe como depurar applets. Se quiser transferir o objeto de depuração para o JSP, é necessário fazer os seguintes dois pontos:

  • Configure o classpath do depurador para que ele possa encontrar sun.servlet.http.Http-Server e classes relacionadas.

  • Configure o classpath do depurador para que ele possa encontrar seus arquivos JSP e classes relacionadas.

Depois de configurar o classpath, comece a depurar sun.servlet.http.Http-Server 。Você pode definir um ponto de parada em qualquer lugar do arquivo JSP, sempre que quiser, e enviar uma solicitação ao servidor usando o navegador para ver o programa parado no ponto de parada.

Use comentários

Os comentários no código podem ajudar na depuração de programas de várias maneiras. Os comentários podem ser usados em muitos aspectos da depuração do programa.

O JSP usa comentários Java. Se um BUG desaparecer, verifique o código que você acabou de comentar, geralmente pode encontrar a razão.

Cabeçalhos do Cliente e do Servidor

Às vezes, quando o JSP não funciona conforme o esperado, verificar o request e a resposta HTTP bruta também pode ser útil. Se você estiver familiarizado com a estrutura do HTTP, você pode observar diretamente o request e a response e ver o que está errado com esses cabeçalhos.

Dica de Depuração Importante

Aqui estão duas dicas adicionais para depurar JSP:

  • Use o navegador para exibir o conteúdo original da página, para distinguir se é um problema de formatação. Esta opção geralmente está no menu Exibir.

  • Certifique-se de que o navegador não capturou a saída do request anterior ao recarregar a página forçadamente. Se você estiver usando o navegador Netscape Navigator, use Shift-Recarregar；se você estiver usando o navegador IE, use Shift-Recarregar。

Internacionalização JSPTratamento de Exceções JSP