Depurando JSP usando lomboz

Prefácio
Qualquer pessoa que tenha experiência em escrita JSP terá dificuldades de depuração de JSP. Devido à falta de ferramentas de depuração automatizadas, um grande número de instruções de impressão devem ser usadas em arquivos durante a depuração de JSP. Esta abordagem é um método simples e eficaz para localizar erros no escopo do JSP, mas é um pouco inadequada para localizar de forma rápida e eficaz erros internos de objetos chamados em JSP. Porque isso terá que compilar, publicar, iniciar e parar o servidor com frequência, o que traz grandes transtornos para a depuração.

A lendária ferramenta de depuração WYSIWYG JSP não existe até onde o autor sabe atualmente. Se os leitores tiverem alguma informação sobre isso, por favor me avisem. Mas existem ferramentas de depuração JSP e são gratuitas! É Lomboz. Endereço para download: http://www.objectlearn.com/products/download.jsp

Este artigo começa com um exemplo simples para descrever como usar o lomboz para depurar JSP. O ambiente de desenvolvimento deste exemplo é o seguinte:

-Versão JDK: 1.4.1;

-JAVA IDE: Eclipse 2.1;

-lomboz

: plug-in para Eclipse2.1;

Introdução ao lomboz
Estritamente falando, lomboz é um plug-in J2EE para Eclipse. Ele integra muitos servidores de aplicativos Java, componentes J2EE e desenvolvimento de aplicativos da Web no Eclipse, o que pode ajudar os desenvolvedores Java a usar o Eclipse para construir, testar e implementar aplicativos J2EE. Para o foco deste artigo, depuração JSP, ele também possui suporte relacionado:

-Suporta gravação JSP, incluindo: coloração de sintaxe e verificação de sintaxe;

-Suporta depuração JSP;

Para depuração JSP, o princípio do lomboz é depurar o código java gerado pela página JSP a ser depurada. Todo o processo de depuração é igual ao de um aplicativo Java, de modo que tanto a depuração do próprio JSP quanto a depuração do objeto chamado pelo JSP estejam perfeitamente interligadas.

Antes de iniciar os exemplos deste artigo, vamos dar uma olhada na instalação do lomboz e na configuração para uso normal de sua função de depuração JSP.

Instalação e configuração
O processo de instalação do lomboz é muito simples. A maioria dos processos de instalação do plug-in Eclipse são muito simples. As etapas principais são as seguintes:

1. Faça download do endereço de download do lomboz ( http://www.objectlearn.com/products/download. jsp ) para suportar o Eclipse 1 (ou outras versões do Eclipse).

2. Se o Eclipse já estiver em execução, feche-o primeiro.

3. Extraia o arquivo transferido por download para o diretório plugins no diretório de instalação do Eclipse.

4. Reinicie o Eclipse e abra "Sobre os plug-ins da plataforma Eclipse" (Ajuda -> Sobre a plataforma Eclipse -> Detalhes do plug-in). Se o lomboz for instalado com sucesso, informações sobre ele aparecerão. Conforme mostrado abaixo:

Nota: Se você deseja desinstalar o lomboz, você só precisa excluir o diretório correspondente ao lomboz no diretório de plugins.

5. Configure o Lomboz J2EE View, abra Janela -> Personalizar Perspectiva, conforme mostrado na figura:

1. Configure o JDK, selecione "Windows -> Preferências", selecione Lomboz e configure o JDK. Conforme mostrado na legenda:

2. Defina o servidor Se o seu servidor já estiver incluído na lista de servidores padrão do Lomboz, esta etapa pode ser ignorada. A lista de servidores padrão do Lomboz pode ser obtida expandindo o Lomboz na interface da etapa anterior e selecionando "Definições de Servidor". A seguir, adicionamos Tomcat4.1.18 como exemplo para explicar como adicionar um servidor. As etapas relevantes são as seguintes:

a) Entre no subdiretório servidores do diretório de instalação do Lomboz, copie um arquivo .server (como tomcat410.server) e renomeie-o para tomcat418.server.

b) Abra este arquivo e altere os seguintes locais deste arquivo:

- <serverDefinition....../>, altere o valor do nome para o nome desejado (como Apache Tomcat v4.1.8), este nome é usado para exibir na parte da lista de servidores da interface "Definições de Servidor"

- <property id="serverRootDirectory" ........./>, onde o valor padrão é alterado para o diretório onde o Tomcat está localizado em seu computador. máquina, como D:/Program Files/Java/tomcat- 4.1.18

- <property id="classPathVariableName" .../>, onde o valor padrão é alterado para qualquer nome (como TOMCAT418). usado para representar o nome da variável ClassPath padrão do projeto Lomboz

- <property id ="classPath" .../>, onde o valor padrão é alterado para o diretório onde o Tomcat está localizado em sua máquina, como D:/Programa; Arquivos/Java/tomcat-4.1.18;

c) Adicione jasper-runtime.jar. Por padrão, o arquivo TomcatX.server contém apenas 2 arquivos jar: servlet.jar e bootstrap.jar, mas jasper-runtime.jar está faltando. Este arquivo jar desempenha um papel muito importante no processo de depuração JSP, portanto, adicione-o. Existem duas maneiras de adicionar um jar a um servidor:

Método 1:

Adicione uma linha na seção <serverClassPath> do arquivo .server que você acabou de editar: <jar type="variable">${classPathVariableName}/common/lib/ jasper-runtime.jar</jar>;

Método 2: Use a interface "Definições do Servidor", que não será descrita novamente aqui.

O servidor configurado será exibido no formulário “Definições de Servidor”, conforme mostrado abaixo:

Nota: Os servidores Tomcat4.x precisam ser corrigidos para que o Lomboz funcione corretamente. O endereço de download do patch é:

http://www.sysdeo.com/

Neste ponto, a instalação e configuração do Lomboz foram concluídas, então vamos. criaremos um exemplo "Hello World!" para experimentar o processo de depuração JSP do Lomboz.

Depurando JSPs
Criar um projeto Para usar o Lomboz para depurar JSP, você deve primeiro criar um projeto Lomboz. Os passos são os seguintes:

1. Abra Arquivo->Novo->Projeto Lomboz J2EE e crie um projeto chamado debugJsp

2. Selecione "Avançar" para entrar na página de seleção de propriedades do projeto Lomboz e adicionar o módulo Web e o servidor utilizado. Como nossa principal tarefa é depurar JSP, o módulo EJB pode estar vazio. Conforme mostrado abaixo:

3. Selecione Concluir e o projeto Lomboz será criado. Neste momento, a estrutura de arquivos gerada pelo Lomboz é a seguinte:

A seguir, podemos criar os arquivos JSP necessários. Neste exemplo, uso diretamente o index.jsp padrão e altero seu conteúdo para:

<!-- Copyright (c) 2002 por ObjectLearn -->

<html>

<cabeça>
<título>Bem-vindo</título>
</head>
<corpo>
<center><%= "Olá, mundo!"%></center>
</body>
</html>

Até agora, nossos preparativos para depuração de JSP foram praticamente concluídos, mas aqueles que usam o Tomcat4.x ainda precisam de etapas extras (essas etapas são causadas principalmente pelo próprio tomcat4.x):

1. No Tomcat Adicione as seguintes linhas ao o arquivo server.xml no diretório de configuração (para localizações específicas, consulte a documentação relacionada a server.xml):

<Context path="/TestJsp" docBase="D:DebugJspdebugJsp" workDir="D: DebugJspj2srcorgapachejsp">

Entre eles, path representa o nome da URL da aplicação web; docBase representa a localização física da aplicação web; workDir representa o local onde o arquivo java correspondente ao jsp é gerado. Você deve crie orgapachejsp como esta estrutura e nome de diretório.

2. Crie a estrutura de subdiretório correspondente no diretório j2src correspondente de acordo com orgapachejsp e defina j2src como o diretório de origem do projeto.

Verificação de sintaxe Agora, vamos aproveitar o processo de depuração do JSP. Antes da depuração, o JSP não deve apresentar erros de sintaxe. Lomboz fornece a função de verificação de sintaxe JSP. A operação específica é:

1. Selecione o arquivo JSP a ser verificado com a sintaxe e clique com o botão direito

2. Selecione Lomboz j2ee... -> Verificar sintaxe Jsp

Após depurar e resolver os erros de sintaxe, a próxima etapa é hora de resolver os erros lógicos. Esse tipo de erro só pode ser resolvido por meio de depuração. O processo de utilização do Lomboz para depurar JSP é muito semelhante à depuração de aplicações JAVA comuns, pois seu princípio é primeiro usar o servidor para gerar arquivos JAVA correspondentes ao JSP e depois depurá-los.

Os passos para depurar JSP são os seguintes:

1. Abra o Lomboz J2EE View, selecione o servidor, clique com o botão direito do mouse e selecione "debug server". Como mostrado na imagem:

Se o arquivo .server estiver definido corretamente, o Tomcat será iniciado. Se o Tomcat não iniciar conforme o esperado, solucione o problema a partir destes dois aspectos: variáveis ​​de ambiente do Tomcat e arquivo do servidor Lomboz.

2. Abra um navegador, como o IE, e digite: http://127.0.0.1:8080/debugJsp/index.jsp na barra de endereço. Se não houver erro de sintaxe no arquivo JSP, o arquivo JAVA correspondente ao arquivo JSP será gerado no diretório j2srcorgapachejsp do projeto. Atualize o projeto para ver esses arquivos. Como mostrado na imagem:

Esta etapa serve principalmente para acionar o servidor para gerar arquivos java para depuração com base em jsp. Você não precisa se preocupar muito se os resultados estão corretos. Porque uma vez gerado o arquivo java, esses erros podem ser eliminados por meio da depuração.

3. Abra o arquivo java, defina um ponto de interrupção nele e insira a URL novamente na barra de endereços do IE. Neste momento, a função de depuração do Eclipse será ativada. Neste ponto, o JSP pode ser depurado de maneira direcionada. A situação neste momento é mostrada na figura:

Quanto à depuração do objeto chamado por JSP, após completar os passos acima, então no java correspondente ao objeto

Basta definir pontos de interrupção no arquivo.

Conclusão Embora a depuração JSP atual não seja tão conveniente quanto a depuração de arquivos Java comuns, o surgimento de ferramentas como o Lomboz pelo menos encerrou o estágio de depuração manual de JSP. A partir de agora, os desenvolvedores de aplicações web Java não precisam parar o programa de vez em quando para adicionar manualmente instruções de impressão para observar os valores das variáveis ​​​​devido a alguns erros, pelo contrário, eles podem observar alterações nesses valores. enquanto o programa está sendo executado como se estivesse depurando aplicativos JAVA comuns. Isto facilita muito o desenvolvimento de aplicações baseadas na WEB e reduz o tempo anteriormente desperdiçado na depuração.