Criando um projeto da Web a partir dos arquivos de código-fonte fornecidos

1. Escolha Arquivo > Novo projeto (Ctrl-Shift-N). Em Categorias, selecione Web. Em Projetos, selecione Projeto da Web com códigos-fontes existentes. Clique em Próximo.
2. Em Localização, clique em Explorar para selecionar a raiz do documento da aplicação Web. A raiz do documento é $UNZIPHOME, que é chamado de midnight, caso você tenha seguido as instruções acima. Essa é a pasta na qual você descompactou o arquivo midnight.zip.
3. Em Nome do projeto, observe que midnight foi definido. Coloque o nome "Midnight" em maiúscula, apenas para fins de exibição, pois a letra inicial do nome do projeto geralmente fica em maiúscula. Altere Local do projeto para qualquer pasta do computador. De agora em diante, nos referiremos a essa pasta como $PROJECTHOME

   Observação: }Criar um projeto no NetBeans 6.1 inclui novas opções que podem ser deixadas como padrão. Por exemplo, a caixa de verificação Usar pasta dedicada para armazenar bibliotecas pode ficar desmarcada.

4. Se você estiver usando o NetBeans IDE 6.1, clique em Próximo; caso contrário, continue na etapa 5.
5. Selecione o servidor no qual deseja implantar a aplicação. Somente os servidores registrados com o IDE estão listados.
6. Em Versão de Java EE, certifique-se de que Java EE 5 está selecionado. Observe que o caminho de contexto é /Midnight. Clique em Próximo.
7. Em Pasta de páginas da Web, selecione a raiz do documento ($UNZIPHOME). Observe que as pastas $PROJECTHOME/Midnight/WEB-INF/lib e $PROJECTHOME/Midnight/WEB-INF/classes são selecionadas automaticamente como suas pastas lib e sources, respectivamente, como mostrado aqui:
   
   Clique em Terminar.

   Você é solicitado a deixar o IDE excluir seus arquivos de classe, pois eles serão compilados automaticamente na pasta build do seu projeto quando constrói o projeto.

   
   

   Clique em Excluir para deixar o IDE fazer isso.

   O IDE importa seus códigos-fontes, exclui os arquivos de classe e cria o projeto Midnight no IDE.

   Você pode ver a estrutura lógica na janela Projetos e a estrutura de arquivos na janela Arquivos.
   
   

Criando um controlador front usando um servlet

Um controlador de frente é responsável por rotear solicitações de entrada do usuário e pode melhorar a navegação em aplicações Web. Um controlador front fornece um único ponto de entrada através do qual passam as solicitações de vários recursos em uma aplicação Web. Um controlador front pode reduzir a duplicação de código em páginas JSP, especialmente em casos em que os vários recursos requerem o mesmo processamento. Para obter mais informações sobre controladores front, consulte o catálogo de padrões do J2EE.

1. Expanda o nó do projeto Midnight e o nó Pacotes de códigos-fonte.
2. Clique com o botão direito do mouse no nó do projeto com.midnightcookies e escolha Novo > Servlet.
3. Indique FrontController na caixa de texto Nome da classe e certifique-se de que o pacote com.midnightcookies esteja selecionado na lista suspensa Pacote. Clique em Próximo.
4. Altere o valor da caixa de texto Padrão(ões) de URL para o seguinte:

    /docs/*, /

   
   
   Observe que "," na linha acima é um delimitador entre os mapeamentos de URL. Ele permite que você crie vários mapeamentos de URL para cada servlet.
5. Clique em Terminar.

   FrontController.java se abre no editor de código fonte.

6. Expanda o nó Páginas da Web e o nó WEB-INF. Clique duas vezes no nó web.xml node. O conteúdo do arquivo do descritor de deployment, web.xml, é exibido no editor gráfico. Clique em Servlets na parte superior do editor. Expanda o nó da entrada do servlet FrontController. Observe os Padrões de URL do servlet, que você definiu na etapa 4 acima:
   

   O mapeamento do servlet "/docs/*" evita que o servlet FrontController encaminhe páginas para si mesmo, enquanto o mapeamento do servlet "/" oferece ao servlet FrontController um mapeamento de servlet para manipular uma solicitação como http://hostname:portnumber/midnight/.

   Clique em XML na parte superior do editor. O conteúdo do arquivo do descritor de deployment é mostrado em formato XML. Os mapeamentos do servlet são os seguintes:

   
   

Adicionando os métodos aos solicitações do processo e para criar um cookie

Agora você editará o arquivo FrontController.java para incluir a lógica necessária para processar as solicitações recebidas pela aplicação Web. Você modificará o método processRequest e criará um novo método chamado createCookie, que demonstra como criar um cookie usado em uma aplicação Web.

1. Abra o Navegador (Ctrl-7) e selecione o nó FrontController.java na janela Projetos. Agora você vê os métodos da classe no Navegador:
   
2. Clique duas vezes no nó do método processRequest no Navegador. O editor de código-fonte exibe o método processRequest.
3. Substitua o método processRequest padrão pelo código seguinte:

   protected void processRequest(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
   
        String id = request.getRequestURI();
        id = id.substring(request.getContextPath().length());
        getServletContext().log
          ("Midnight Cookies FrontController received a request for " + id);
   
        // The page variable holds the path to the page that will be included
        // in the content area of the template page /WEB-INF/docs/main.jsp.
        // It is passed to the template in a request attribute.
        String page;
   
        // If no request is received or if the request received is
        // for the root, serve /WEB-INF/docs/index.jsp
        if (id == null || id.trim().equals("") || id.equals("/")){
            page = "/WEB-INF/docs/index.jsp";
        }
   
        // If a request received is for a file that does not end in
        // .jsp or .html, there was an error. Include the
        // error page (nonesuch.jsp) and set the nonesuch attribute with
        // the path requested.
        else if (!id.endsWith(".jsp") && !id.endsWith(".html")) {
            page = "/WEB-INF/docs/nonesuch.jsp";
            request.setAttribute("nonesuch", id);
        }
        else {
            page = "/WEB-INF".concat(id);
   
            if (id.equals("/docs/cookies/CookieMake.jsp")) {
                Cookie cookie = createCookie(request);
                if (cookie == null) {
                    page = "/WEB-INF/docs/cookies/CookieCutter.jsp";
                }
                else {
                    response.addCookie(cookie);
                    request.setAttribute("cookie", cookie);
                }
            }
        }
   
        request.setAttribute("page", page);
        try {
            request.getRequestDispatcher("/WEB-INF/docs/main.jsp").forward(request, response);
        }
        catch(Throwable t) {
            getServletContext().log(t.getMessage());
        }
   }

   Observação: Depois de indicar o código (digitando ou copiando e colando) no editor de código-fonte, coloque o cursor no editor de código-fonte e pressione Alt-Shift-F para formatar o código automaticamente. Para mostrar os números de linha, clique com o botão direito do mouse na margem esquerda e escolha Mostrar números de linha no menu contextual.

   A linha com a chamada ao método createCookie é sublinhada e marcada como um erro, semelhante à ilustração seguinte. Isso acontece porque o método ainda não existe.

   Clique em Alt-Enter na linha com o erro e observe que o IDE apresenta uma sugestão de como resolver o problema:

   

4. Selecione a sugestão. O IDE cria o método createCookie de esqueleto no fim do arquivo.
5. Preencha o novo método createCookie copiando o código seguinte e colando-o no editor de código-fonte:

   private Cookie createCookie(HttpServletRequest request) {
   
           String name = (String)request.getParameter("name");
           if (name == null || name.trim().equals("")) {
               request.setAttribute("noname", "noname");
               request.setAttribute("error", "true");
                return null;
           }
   
           String value = (String)request.getParameter("value");
           if (value == null || value.trim().equals("")) {
               request.setAttribute("novalue", "novalue");
               request.setAttribute("error", "true");
                return null;
           }
   
            System.out.println(name);
            System.out.println(value);
   
            Cookie cookie = null;
            try {
                cookie = new Cookie(name, value);
            }
            catch(IllegalArgumentException ex) {
                // Probably an illegal name
                ex.printStackTrace();
                request.setAttribute("error", "true");
                request.setAttribute("noname", "badname");
                return null;
            }
   
            String maxage = request.getParameter("maxage");
            if (maxage != null && !maxage.trim().equals("")) {
                try {
                    cookie.setMaxAge(Integer.parseInt(maxage));
                }
                catch(NumberFormatException nfe) {
                    nfe.printStackTrace();
                    request.setAttribute("badnumber", "badnumber");
                    request.setAttribute("error", "true");
                    return null;
                }
            }
   
            String domain = request.getParameter("domain");
            if (domain != null && !domain.trim().equals("")) {
                cookie.setDomain(domain);
            }
   
            String path = request.getParameter("path");
            if (path != null && !path.trim().equals("")) {
                cookie.setPath(path);
            }
   
            String secure = request.getParameter("secure");
            if (secure != null && secure.equals("on")) {
                cookie.setSecure(true);
            } else {
                cookie.setSecure(false);
            }
           return cookie;
   }

6. O asterisco na aba do arquivo na parte superior do editor de código-fonte aparece sempre que há alterações que não foram salvas no disco:
   

   Pressione Ctrl-S para salvar o arquivo. O asterisco na aba do arquivo na parte superior do editor de código-fonte desaparece.

7. Na janela Projetos, clique com o botão direito do mouse no nó FrontController.java e selecione Compilar arquivo (F9) para verificar se não há erros introduzidos nas etapas que você concluiu. A janela Saída exibe mensagens do compilador, incluindo quaisquer erros. Você pode clicar duas vezes nos links nas mensagens de erro para localizar a origem do erro. Resolva todos os erros listados na janela Saída antes de continuar com o tutorial.

Criando a página JSP que recebe todas as solicitações

A página main.jsp recebe toda sas solicitações que o servlet FrontController processa. Uma instrução include dinâmica e uma LinksHandler são usadas para criar a página.

1. Expanda o nó do projeto Midnight e o nó WEB-INF. Clique com o botão direito do mouse no nó docs, escolha Novo > JSP, e chame o arquivo JavaServer Pages de main. Clique em Terminar.
   Agora main.jsp se abre no editor de código-fonte.
2. No editor de código-fonte, substitua o conteúdo do arquivo main.jsp pelo seguinte código:

   
     <%@page contentType="text/html;charset=UTF-8"%>
     <%@page buffer="none"%>
     <%-- The <midnight:content/> tag which handles the contents section
     is simplistically implemented to use an include. Hence this page
     cannot be buffered --%>
   
     <%@taglib prefix="midnight" uri="http://www.midnightcookies.com/midnight"%>
   
     <html>
       <head><title>The Midnight Cookie Company</title></head>
       <body text="#996633" link="#cc6600" vlink="#993300" alink="#000000">
           <span font-style="sans-serif">
               <TABLE border="0">
                    <tr>
                        <table border="0">
                            <tr><td width="80" height="100">&nbsp;</td>
                                <td width="500" height="100"
   
                                    text="#996633" bgcolor="#ffff99"
                                    valign="center"halign="center">
                                    <jsp:include page="/WEB-INF/docs/header.jsp"
                                                 flush="true"/>
                                </td>
                            </tr>
                            <tr><td width="90" height="300"
                                    text="#996633" bgcolor="#ffff99"
                                    valign="top">
                                    <midnight:links separator="<br>"/>
                                </td>
                                <td width="500" height="300"
                                    valign="top"cellpadding="15"
                                    cellspacing="15">
                                    <midnight:content/>
                                </td>
                            </tr>
                        </table>
                    </tr>
                    <tr><td width="580" height="50" text="#996633"
                            bgcolor="#ffff99" valign="top">
                            <midnight:links separator="|"/>
                        </td>
                    </tr>
                </TABLE>
           </span>
       </body>
     </html>

   Observação: Depois de indicar o código (digitando ou copiando e colando) no editor de código-fonte, coloque o cursor no editor de código-fonte e pressione Alt-Shift-F para formatar o código automaticamente.

3. Pressione Ctrl-S para salvar as alterações.

Criando os arquivos de parâmetro usados para manipular a entrada do usuário

Os arquivos de parâmetro que você cria nesta seção ilustram o uso de bibliotecas de marcas para manipular a internacionalização. Eles também mostram como a entrada é passada através de parâmetros de solicitação, especificamente por meio da expressão de linguagem (EL) da expressão JSP ${param.input}, que é definida no campo de entrada da página Input.jsp.

1. Clique com o botão direito do mouse no nó docs e selecione Novo > Outro no menu contextual. Em Categorias, selecione Outro e em Tipos de arquivo, selecione Pasta. Clique em Próximo.
2. No painel Nome e localização, digite parâmetros no campo de texto Nome da pasta e clique em Terminar. A nova pasta parâmetros aparece na janela Projetos sob o nó docs.
3. Clique com o botão direito do mouse no nó parameters e escolha Novo > JSP. Digite Input no campo de texto Nome do arquivo JSP e verifique se WEB-INF/docs/parameters é selecionado no campo de texto Pasta. Clique em Terminar. Agora Input.jsp abre no editor de código-fonte.
4. No editor de código-fonte, substitua o conteúdo do arquivo Input.jsp pelo código seguinte:

     <%@page contentType="text/html;charset=UTF-8"%>
     <%@taglib prefix="fmt" uri="http://java.sun.com/jstl/fmt" %>
     <%@taglib prefix="c" uri="http://java.sun.com/jstl/core" %>
     <%@taglib prefix="midnight" uri="/WEB-INF/tlds/midnight.tld"%>
   
     <fmt:setBundle basename="com.midnightcookies.Midnight" var="bundle"
                   scope="page"/>
   
     <h3><fmt:message key="provide_input" bundle="${bundle}"/></h3>
     <form method="POST" action="Output.jsp">
           <table>
               <tr>
                    <td><fmt:message key="type_input" bundle="${bundle}"/>:</td>
                    <%-- The value of the Input field will be placed in a
                          request parameter named "input" and it will be
                          passed to Output.jsp --%>
                    <td><input type="text" size="20" name="input" value=""></td>
               </tr>
                <tr>
                    <td><fmt:message key="submit" bundle="${bundle}"
                                     var="buttonLabel" scope="page"/>
                        <midnight:button/>
                   </td>
                   <td></td>
               </tr>
           </table>
      </form>

   Pressione Ctrl-S para salvar as alterações.
5. Crie um arquivo Output.jsp na pasta Parâmetros usando o mesmo método que você usou para criar o arquivo Input.jsp.
6. No editor de código-fonte, substitua o conteúdo do arquivo Output.jsp pelo código seguinte:

     <%@page contentType="text/html;charset=UTF-8"%>
     <%@ taglib prefix="fmt" uri="http://java.sun.com/jstl/fmt" %>
     <%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %>
   
     <fmt:setBundle basename="com.midnightcookies.Midnight" var="bundle" scope="page"/>
     <h3><fmt:message key="display_input" bundle="${bundle}"/></h3>
     <fmt:message key="datareceived" bundle="${bundle}"/>:
   
     <!--The following line gets the value of the request parameter named
     "input". Este é uma aplicação demonstrativa. Para motivos de segurança, você nunca deve deve fazer eco da entrada do usuário sem analisá-la primeiro. -->
     <c:out value="${param.input}"/>

7. Pressione Ctrl-S para salvar as alterações.

Usando JSTL para manipular a internacionalização

A página Tray.jsp que você criou nesta seção ilustra o uso do JSTL, em vez de script, para internacionalizar a página. O arquivo CookieCutter.jsp, o arquivo CookieMaker.jsp e os arquivos de propriedade do pacote de recursos foram fornecidos com o arquivo midnight.zip. Você pode observar mais de perto esses arquivos e o arquivo Tray.jsp para obter exemplos de como a internacionalização é manipulada neste aplicativo.

1. Expanda o nó docs e expanda o nó cookies.
2. Crie um arquivo Tray.jsp na pasta cookies usando o mesmo método usado para criar os outros arquivos JSP. Certifique-se de colocá-lo na pasta cookies.
3. No editor de código-fonte, substitua o conteúdo do arquivo Tray.jsp pelo código seguinte:

     <%@page contentType="text/html;charset=UTF-8"%>
     <%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %>
     <%@ taglib prefix="fmt" uri="http://java.sun.com/jstl/fmt" %>
   
     <fmt:setBundle basename="com.midnightcookies.Midnight" var="bundle" scope="page"/>
     <h3><fmt:message key="cookies" bundle="${bundle}"/></h3>
   
     <table border="1">
        <tr>
           <th halign="center">#</th>
            <th align="left">
                <fmt:message key="name" bundle="${bundle}"/>
           </th>
           <th align="left">
                <fmt:message key="value" bundle="${bundle}"/>
           </th>
        <tr>
        <%-- We have to use expression to get at an array.
             If we use ${cookie} then we get a map and
             the entries are not automatically cast --%>
        <% request.setAttribute("cookies", request.getCookies()); %>
        <c:set var="i" value="0"/>
   
        <c:forEach var="ck" items="${cookies}">
            <c:set var="i" value="${i+1}"/>
            <tr>
                <td><c:out value="${i}"/></td>
                <td><c:out value="${ck.name}"/></td>
                <td><c:out value="${ck.value}"/></td>
           </tr>
        </c:forEach>
     </table>

4. Pressione Ctrl-S para salvar as alterações.

Empacotando

Quando você tiver concluído o estágio de desenvolvimento como descrito acima, as visualizações na janela Projetos e na janela Arquivos devem ter a seguinte aparência:

Observação: A aplicação ilustrada acima implanta no servidor da aplicação do servidor Web Tomcat. Caso tenha registrado e selecionado um servidor de destino diferente, você não terá um arquivo META-INF/context.xml. Por exemplo, se o seu servidor for GlassFish, você terá um arquivo WEB-INF/sun-web.xml como seu descritor de deployment.

Ativando o Monitor HTTP

O Monitor HTTP é ativado por padrão para o servidor Web Tomcat. Entretanto, para outros servidores, você deve ativar manualmente o Monitor HTTP. Além disso, o Servidor HTTP deve ser iniciado para o Monitor HTTP funcionar para outros servidores.

Faça o seguinte para preparar o uso do Monitor HTTP:

1. Escolha Ferramentas > Servidores na janela principal.
2. Selecione o servidor.
3. Clique em Ativar monitor HTTP e clique em Fechar.
4. Na janela Tempo de execução, clique com o botão direito do mouse no nó Servidor HTTP e escolha Iniciar servidor HTTP.

Verificando o caminho do contexto

1. Clique com o botão direito do mouse no nó do projeto Midnight e escolha Propriedades.
2. Na caixa de diálogo Propriedades do projeto, clique em Executar.
3. Certifique-se de que o caminho de contexto esteja definido como /Midnight.
4. Certifique-se de que a URL relativa esteja definida como docs/index.jsp

Executando a aplicação

1. Na janela Projetos, clique com o botão direito do mouse no nó do projeto Midnight e escolha Executar no menu contextual.

   Uma janela do monitor de progresso aparece conforme a aplicação é preparada e implantada no servidor Web.

   O navegador da Web é iniciado com a URL definida como http://hostname:port/Midnight. O exemplo seguinte mostra o navegador da Web em execução em uma plataforma Microsoft Windows.

   

2. No IDE, observe que o Monitor HTTP é exibido.

   As seções seguintes ilustram como você pode usar o Monitor HTTP para monitorar solicitações, sessões e cookies.

Monitorando solicitações e sessões

1. No Monitor HTTP, selecione a última entrada sob o no Registros atuais.

   A última entrada representa a solicitação da aplicação Web Midnight.

2. Selecione a aba Solicitação e veja informações semelhantes às seguintes.

   

3. Selecione a aba Sessão e você verá informações semelhantes às seguintes.
   
4. Em seu navegador da Web, clique no link Parâmetros para exibir a página Input.jsp. Seu navegador da Web exibe informações semelhantes às seguintes.

   

5. No campo de texto Entrada de texto, digite hello e clique em Enviar dados.
   Seu navegador da Web exibe o conteúdo da página Output.jsp, semelhante ao seguinte.

   

6. No Monitor HTTP , selecione pela menos a última entrada em Registros atuais e selecione a aba Solicitação.
   O Monitor HTTP exibe informações semelhantes às seguintes.

   

Monitorando cookies

1. Em seu navegador da Web, clique no link Cookies.
   Seu navegador da Web exibe a página CookieCutter.jsp.
2. No campo de texto Nome, digite cookie, e no campo de texto Valor, digite chocolate.
   
3. Clique em "Criar um cookie para mim agora!".
   Seu navegador da Web exibe informações semelhantes às seguintes.

   

4. No Monitor HTTP, selecione a última entrada sob o no Registros atuais.
   A aba Cookies no Monitor HTTP exibe informações semelhantes ao seguinte.

   

5. Em seu navegador da Web, clique na bandeja Cookie e seu navegador da Web exibe informações semelhantes às seguintes.
   
6. No Monitor HTTP, selecione a última entrada sob o nó Registros atuais e selecione a aba Cookies.
   O Monitor HTTP exibe informações semelhantes às seguintes.

   

7. Selecione a aba Solicitação e o Monitor HTTP exibe informações semelhantes às seguintes.
   
8. No Monitor HTTP, clique com o botão direito do mouse na mesma entrada (GET Tray.jsp) sob o nó Registros atuais e escolha Editar e reproduzir no menu contextual. Na caixa de diálogo Editar e reproduzir, clique na aba Cookies e clique em Adicionar cookie. Defina o nome como Ingrediente e o valor como Açúcar. Clique em Enviar solicitação de HTTP. O navegador exibe novamente a página com o novo cookie.

Monitorando solicitações para páginas não existentes

1. Em seu navegador da Web, digite uma URL para uma página que não existe para ver como a página nonesuch.jsp é usada. Por exemplo, você deve digitar http://localhost:8084/Midnight/docs/Bake.jsp para a URL e o seu navegador da Web exibe algo semelhante ao seguinte.
   
2. No Monitor HTTP, selecione a aba Solicitação e você verá informações semelhantes às seguintes.
   

   Observe que o conteúdo da página nonesuch.jsp é exibido no lugar da página Bake.jsp não-existente.

Ativado internacionalização

1. Modifique a preferência de idioma usada por seu navegador da Web para francês ou sueco a fim de ver o recurso de internacionalização desta aplicação Web Midnight Cookie Company.

   Observe que talvez você tenha que adicionar esses dois idiomas à lista de idiomas disponíveis no momento em seu navegador da Web.

2. Recarregue ou atualize as páginas que você visualizou nas etapas anteriores.

   Observe como os links na barra esquerda do navegador, os links na parte inferior das páginas e o conteúdo de algumas páginas JSF da aplicação foram traduzidos para o idioma que você escolheu.

   A aplicação Web usa os arquivos de propriedade do pacote de recursos para ajuda a traduzir algumas das páginas usadas nesta aplicação Web. Portanto, a tradução é somente tão extensa quanto o conteúdo dos arquivos de propriedade do pacote de recursos.

Adicione um link Editar que leva o usuário para uma página que diz "Até logo" no idioma apropriado

1. Clique com o botão direito do mouse no arquivo com/midnightcookies/Midnight.properties e escolha Abrir no menu contextual. Adicione as palavras-chave e os valores seguintes.
   

   Palavra-chave	Padrão	francês	sueco
   exit	Sair	Sortie	Utgång
   closingRemark	Goodbye	Au revoir	Hej då

   Use å para exibir o caractere å.

2. Adicione um arquivo de conteúdo Exit.jsp. Use a marca de mensagem da biblioteca de marcas fmt para exibir a mensagem para a palavra-chave closingRemark (Dica: observe Output.jsp). Não se esqueça de adicionar uma diretiva taglib da biblioteca de marcas fmt.
3. Abra o arquivo com/midnightcookies/taghandlers/LinksHandler.java no editor de código-fonte e adicione um link ao arquivo Exit.jsp. Use a palavra-chave exit para obter o texto do link do pacote de propriedades. Compile a classe.
4. Execute a aplicação Web.

Examinando a biblioteca de marcas Midnight

Expanda o nó tlds/Midnight para ver a lista de marcas na biblioteca. Observe a marca Links no editor de código-fonte e seus atributos para ver que ela usa um atributo separador.

Depurando aplicações Web

Abra o arquivo docs/main.jsp no editor de código-fonte e defina um ponto de interrupção, clicando na marca aproximadamente na linha 32 (a linha que chama midnight:content). Na janela Projetos ou Arquivos, clique com o botão direito do mouse no nó do projeto e escolha Depurar projeto no menu contextual. A aplicação Web irá parar no ponto de interrupção que você definiu. Pressione F7 para passar pelo código. Sempre que aparece uma caixa de diálogo devido a código-fonte faltando, pressione OK para selecionar o padrão de parada na primeira linha com o código-fonte. Continue pressionando F7 até indicar a função otherDoStartTagOperations() na classe ContentHandler. Defina um ponto de interrupção na linha 50 (request.getRequestDispatcher(page).include(request, response)) e pressione Ctrl-F5 (continuar). Coloque o cursor sobre "page", "request" e "response" para ver os valores. Você também pode ver os valores na aba Variáveis locais. Observe que a aba Pilha de chamadas mostra a relação entre o código JSP e os métodos de servlet gerados. Tente definir outros pontos de interrupção. Clique com o botão direito do mouse em uma variável e escolha Nova inspeção no menu contextual. Clique na aba Inspeções para ver os valores se alterarem conforme você executa as várias páginas na aplicação Web. Escolha Depurar > Terminar sessão para sair da sessão de depuração.

Testando arquivos JSP

Para executar um arquivo JSP público (um que não esteja na pasta WEB-INF), simplesmente clique com o botão direito do mouse no nó do arquivo e escolha Executar no menu contextual. Se uma página for carregada, clicar no botão de recarga do navegador exibirá quaisquer modificações que você faça. Arquivos JSP privados, como os deste tutorial, são um pouco mais difíceis de executar. Uma forma de testar um arquivo JSP privado modificado sem ter que reiniciar a aplicação Web e navegar para essa página é usar a ação de reprodução do Monitor HTTP. Modifique o arquivo docs/cookies/Tray.jsp, definindo a borda da tabela para 10 e salve suas alterações. No Monitor HTTP, clique com o botão direito do mouse no registro GET Tray.jsp e escolha Reproduzir no menu contextual. A página Tray.jsp deve aparecer no navegador com uma borda de tabela maior.

Visualização composta

Um padrão de design que é usado para apresentar informações em páginas JSP. Esse padrão de design cria uma visualização agregada das visualizações de componente. As visualizações de componente devem incluir partes dinâmicas e modulares da página. O padrão de design Visualização composta pertence ao design de aplicação Web quando você está criando uma visualização a partir de várias subvisualizações. Páginas da Web complexas geralmente consistem em conteúdo derivado de vários recursos. O layout da página é gerenciado independentemente do conteúdo de suas subvisualizações. Por exemplo, uma visualização talvez tenha subvisualizações tais como Navegação, Pesquisa, Histórico de recurso e Título.

Ao criar uma visualização composta, você pode incluir conteúdo estático e conteúdo dinâmico. O conteúdo estático deve consistir em um arquivo HTML. O conteúdo dinâmico é um fragmento de uma página JSP. O conteúdo específico pode ser determinado no tempo de tradução JSP ou no tempo de design.

Controlador front

Os controladores front são responsáveis por rotear as solicitações de entrada e forçar a navegação em aplicações Web. Para obter mais informações sobre o uso do padrão de design Controlador do front, consulte o catálogo de padrões J2EE.

Página JSP

As páginas que são usadas em aplicações Web para apresentar informações para os usuários finais e para permitir que dados dos usuários finais sejam retornados para o servidor. As páginas JSP devem ser colocadas em uma aplicação Web para que possam ser executadas no IDE.

Servlet

Servlets são classes Java que são executadas em um contêiner de servlet, que é geralmente executado em um servidor Web. Os Servlets são usados para fazer o seguinte:

• Gerar conteúdo dinâmico.
• Estenda os recursos dos serviços Web e dos servidores da aplicação baseados em Web.
• Interaja com os clientes da Web (geralmente um aplicativo navegador tal como o Firefox ou o Internet Explorer) usando um paradigma solicitação-resposta