Trabalhando com um objeto HttpSession

O aplicativo AffableBean utiliza o objeto HttpSession para identificar usuários entre várias solicitações. Um objeto HttpSession é obtido utilizando getSession() em uma requisição fornecida:

HttpSession session = request.getSession();

Se ainda não existe um objeto de sessão para a requisição, o método cria e retorna um novo objeto de sessão.

É possível utilizar o objeto de sessão como um veículo para a transferência de dados entre as solicitações. É possível utilizar o método setAttribute para vincular objetos à sessão. Da mesma forma, é possível utilizar o método getAttribute para recuperar objetos da sessão. No aplicativo AffableBean, por exemplo, o carrinho de compras do usuário é criado e vinculado à sessão do usuário da seguinte forma:

ShoppingCart cart = new ShoppingCart();
session.setAttribute("cart", cart);

Para recuperar o carrinho da sessão, o método getAttibute é aplicado:

cart = (ShoppingCart) session.getAttribute("cart");

Nas páginas JSP, é possível acessar objetos vinculados à sessão utilizando expressões EL. Continuando com o exemplo acima, se um objeto ShoppingCart chamado "cart" estiver vinculado à sessão, é possível acessá-lo utilizando a seguinte expressão EL:

${cart}

No entanto, acessar o objeto ShoppingCart em si tem pouco valor. O que você realmente quer é um jeito de acessar valores armazenados no objeto. Se explorar a nova classe ShoppingCart no instantâneo do projeto, notará que este contém as seguintes propriedades:

• double total
• int numberOfItems
• List<String, ShoppingCartItem> items

Desde que as propriedades possuam métodos getter correspondentes, é possível acessar valores a partir de propriedades singulares utilizando uma simples notação de ponto em uma expressão EL. Se observar a página cart.jsp, verá que esta é a maneira exata como o valor para numberOfItems é acessado:

<p>Your shopping cart contains ${cart.numberOfItems} items.</p>

A fim de extrair dados de propriedades contendo valores múltiplos, tal como a lista items acima, a página cart.jsp utiliza um loop <c:forEach:

<c:forEach var="cartItem" items="${cart.items}" varStatus="iter">

  <c:set var="product" value="${cartItem.product}"/>

    <tr class="${((iter.index % 2) == 0) ? 'lightBlue' : 'white'}">
        <td>
            <img src="${initParam.productImagePath}${product.name}.png"
                 alt="${product.name}">
        </td>

        <td>${product.name}</td>

        <td>
            &euro; ${cartItem.total}
            <br>
            <span class="smallText">( &euro; ${product.price} / unit )</span>
        </td>
        ...
    </tr>

</c:forEach>

A propriedade do produto ShoppingCartItem identifica o tipo de item do carrinho. O loop acima tira vantagem disso definindo primeiramente uma variável produto para a expressão ${cartItem.product}. A seguir, ele utiliza a variável para obter informações sobre esse produto (ex., nome e preço).

Trabalhando com variáveis de escopos nos aplicativos da Web

Ao trabalhar com a tecnologia JSP/Servlet, há quatro objetos de escopo disponíveis dentro do território do aplicativo. A tecnologia JSP implementa objetos implícitos que permitem acessar classes definidas pelo Servlet API.

Se abrir o arquivo do projeto category.jsp no editor, verá que a expressão EL inclui diversas variáveis de escopo, incluindo ${categories}, ${selectedCategory} e ${categoryProducts}. A variável ${categories} é um aplicativo de escopo, definido no método init do ControllerServlet:

// lista da categoria de armazanamento no contexto servlet
getServletContext().setAttribute("categories", categoryFacade.findAll());

As outras duas, ${selectedCategory} e ${categoryProducts}, são inseridas no escopo da sessão do aplicativo a partir do ControllerServlet. Por exemplo:

// categoria selecionada colocada na sessão scope
session.setAttribute("selectedCategory", selectedCategory);

Observação: Se você estiver continuando a partir de unidades anteriores do tutorial, provavelmente notará que ${selectedCategory} e ${categoryProducts} foram originalmente colocados no escopo da solicitação. Em unidades anteriores, isso não era problema, mas considere agora o que acontece se um usuário clicar no botão 'adicionar ao carrinho' na página de uma categoria. O servidor responde a uma solicitção addToCart retornando a página de categoria em exibição no momento. Portanto, é preciso saber selectedCategory e categoryProducts relacionados à categoria selecionada. Em vez de estabelecer essas informações para cada solicitação, você a coloca no escopo da sessão de uma solicitação de categoria para que sejam mantidas entre várias solicitações e possam ser acessadas quando necessário. Além disso, examine a funcionalidade fornecida pela página do carrinho. (Uma descrição funcional é fornecida abaixo.) O botão 'continuar comprando' resulta no retorno do usuário à categoria exibida previamente. Novamente, as variáveis selectedCategory e categoryProducts são necessárias.

Ao fazer referência às variáveis do escopo na expressão EL, não é necessário especificar o escopo das variáveis (desde que você não possua duas variáveis com o mesmo nome em escopos diferentes). O mecanismo JSP verifica todos os escopos e retorna a primeira variável correspondente que encontrar. Em category.jsp por exemplo, a expressão:

${categoryProducts}

é uma abreviação para:

${sessionScope.categoryProducts}

• Projeto dos aplicativos Enterprise com a plataforma J2EE: escopos de estado
• Compartilhamento de informação > uso de objetos de escopo
• Linguagem da expressão unificada > objetos implícitos

Analisando a comunicação servidor do cliente com o monitor HTTP

Como padrão, o mecanismo servlet utiliza cookies para manter e identificar sessões entre as requisições. Um número alfanumérico aleatório é gerado para cada objeto de sessão, que serve como um identificador exclusivo. Esse identificador é passado como um cookie "JSESSIONID" ao cliente. Quando o cliente faz uma requisição, o mecanismo servlet lê o valor do cookie JSESSIONID para determinar a sessão a qual a requisição pertence.

Para demonstrar isso, nós utilizaremos o depurador em conjunto com o monitor HTTP do IDE.

1. Comece com a ativação do monitor HTTP para o servidor que esteja utilizando. Selecione Ferramentas > Servidores. Na coluna à esquerda da janela Servidores, selecione o servidor que você está utilizando (GlassFish). Em seguida, na coluna principal, selecione a opção Ativar monitor HTTP.
   
2. Se o servidor já estiver sendo executado, será necessário reiniciá-lo. Entretanto, já que planejamos utilizar o depurador, e a execução do mesmo reinicia o servidor para comunicar em um porta diferente, clique no botão Depurar projeto ( ) na barra de ferramentas principal. Quando o servidor é reiniciado, uma sessão de depuração é iniciada e a página de boas vindas do aplicativo é aberta no navegador. O monitor HTTP é exibido na parte inferior do IDE.
   
3. Clique no registro AffableBean na coluna à esquerda (como mostrada na imagem acima). Ao selecionar registros na coluna à esquerda, a coluna à direita (ex., principal) é atualizada para exibir os dados correspondentes. Na imagem acima, a aba Requisição exibe a URI solicitada ( /AffableBean/), o método HTTP ( GET) e indica que nenhuma string de consulta foi enviada com a requisição.
4. Selecione a aba Sessão. Note que há uma declaração: "a sessão foi criada como um resultado desta requisição.&quot Isso se deve ao fato do servidor ter enviado um cabeçalho Set-Cookie para o cookieJSESSIONID na sua resposta. Note também que a nova ID da sessão está listada sob "Propriedades da sessão". Como será mostrado mais tarde, a ID da sessão é o valor do cookie JSESSIONID.
   
   Talvez esteja pensando como um objeto de sessão foi criado a partir de uma requisição para a página de boas vindas do site. Afinal, o ControllerServlet não manipula as solicitações iniciais para /AffableBean/ e em nenhum lugar esta requisição encontra getSession(). Ou encontra? Lembre-se que as páginas JSP são compiladas em servlets na implantação. Uma vez que implantar o projeto no servidor, será possível utilizar o IDE para visualizar o servlet compilado do JSP no seu servidor.
5. Na janela Projetos, clique com o botão direito do mouse no arquivo index.jsp e selecione Visualizar Servlet. É aberto um arquivo index_jsp.java no editor. Esse é o servlet que foi compilado automaticamente a partir da página index.jsp.
6. Execute uma pesquisa no arquivo para o getSession. Pressione Ctrl-F (⌘-F no Mac), digite "getSession" na barra de pesquisa e, em seguida, pressione Enter.
   
   

   Ctrl-F (⌘-F no Mac) é um atalho do teclado para Editar > Localizar.

   
   O método getSession foi, na verdade, chamado. A razão para isto ocorrer é que as páginas do JSP incluem, por padrão, o objeto implícito pageContextsession. Se o desejado era desativar esse comportamento, você poderia ter adicionado a diretiva a seguir à parte superior do arquivo JSP:

   <%@page session="false" %>

   e o método getSession no servlet compilado seria removido.
   
   

   Para encontrar a localização do servlet compilado no servidor, é possível passar o mouse sobre a aba do nome do servlet acima do editor. Um pop-up exibe o caminho o caminho para o arquivo no computador.

7. No navegador, selecione uma categoria e, em seguida, adicione um item ao seu carrinho. Volte para o IDE. Observe que o depurador é suspenso no ponto de interrupção no ControllerServlet, que foi definido anteriormente (linha 150). Todos os pontos de interrupção são lembrados entre as sessões. Para remover o ponto de interrupção, é possível clicar na identificação do ponto de interrupção ( ) na margem esquerda do editor. No entanto, como há vários pontos de interrupção já definidos no projeto, abra a janela Ponto de interrupção do depurador (Janela > Depuração > Pontos de interrupção).
   
   Na janela Pontos de interrupção, é possível visualizar ações de chamada em todos os pontos de interrupção definidos no projeto aberto no IDE.
8. Clique com o botão direito do mouse no ponto de interrupção definido em header.jspf e selecione Excluir. Em seguida, clique com o botão direito do mouse no ponto de interrupção definido no ControllerServlet e selecione Desabilitar. (Você irá reabilitá-lo mais tarde neste exercício.)
9. Clique no botão Continuar ( ). A execução da requisição termina e a página da categoria é exibida no navegador com um item adicionado ao carrinho.
10. No monitor HTTP, pesquise pela requisição addToCart na coluna esquerda e, em seguida, selecione-a para exibir os detalhes na coluna principal.
    
    

    Clique no botão Ordem ascendente ( ), de forma que os registros mais recentes sejam listados na parte superior.

    
    Sob a aba Requisição, note que a URI requisitada (/AffableBean/addToCart), o método HTTP (POST) e os parâmetros da requisição (productId e submeter).
    
11. Selecione a aba Cookies. Aqui você verá que existe um cookie nomeado JSESSIONID e que foi enviado por um cliente ao servidor. Note que o valor para o cookie é o mesmo que o da ID da sessão exibida sob a aba Sessão.
    
    Da mesma forma, se clicar na aba Cabeçalho, verá o cookie listado, já que "Cookie" é um cabeçalho da requisição enviada pelo cliente.
    

    Consulte a Lista de cabeçalhos HTTP da Wikipédia para mais informações sobre cabeçalhos de solicitações e respostas.

12. Selecione a aba Sessão. Há uma declaração que indica: "a sessão existiu antes desta requisição." Note também que o atributo carrinho é listado sob "Atributos de sessão após a requisição". Isso faz sentido, já que sabemos que o objeto carrinho está vinculado à sessão quando a requisição addToCart é processada pela primeira vez.
    
    
    Nas próximas etapas, localize a ID da sessão e o cookie JSESSIONID na janela Variáveis.
13. Reabilite o ponto de interrupção definido anteriormente no ControllerServlet. Pressione Alt-Shift-5 (Ctrl-Shift-5 no Mac) para abrir a janela Pontos de interrupção e, em seguida, clique na caixa de verificação ao lado da entrada do ponto de interrupção para reativá-lo.
14. No navegador, clique no botão "adicionar ao carrinho" para um dos produtos listados.
15. Alterne para o IDE e note que o depurador é suspenso no ponto de interrupção definido no ControllerServlet. Clique no botão Passar sobre ( ) de forma que a variável sessão seja atribuída ao objeto de sessão.
16. Abra a janela Variáveis (Alt-Shift-1; Ctrl-Shift-1 no Mac) e expanda sessão > sessão. Você encontrará o ID da sessão listado como o valor para a variável id.
17. Para localizar o cookie JSESSIONID, lembre-se de que pode acessar normalmente os cookies a partir do servlet chamando o método getCookies no HttpServletRequest. Portanto, entre no objeto requisitado: requisição > Herdado > requisição > requisição > Herdado > cookies. É possível ver aqui a ArrayList cookies. Se expandir a lista, encontrará o cookie JSESSIONID, cujo valor é a ID de sessão.
18. Clique no botão Terminar sessão ( ) para finalizar a sessão de depuração.

Manutenção de sessões com a reescrita URL

Como mencionado, o mecanismo servlet detecta se os cookies estão suportados para o navegador do cliente e, caso não estejam, ele alterna para a reescrita URL, como uma forma de manter as sessões. Isso tudo ocorre de um modo transparente para o cliente. Para o desenvolvedor, o processo não é totalmente transparente.

É necessário certificar-se de que os aplicativos podem reescrever a URL caso os cookies estejam desativados. É possível fazer isto chamando o método de resposta encodeURL em todas as URLs retornadas pelos servlets no aplicativo. Ao fazê-lo, habilita a ID da sessão para ser anexada à URL no caso do uso de cookies não ser uma opção, do contrário, ela retornará à URL sem alteração.

Por exemplo, o navegador envia uma requisição para a terceira categoria (padaria): AffableBeancategoria?3. O servidor responde com a ID de sessão incluído na URL:

/AffableBean/category;jsessionid=364b636d75d90a6e4d0085119990?3

Como foi declarado acima, todas as URLs retornadas pelos servlets do aplicativo devem estar codificadas. Lembre-se de que as páginas JSP são compiladas em servlets. Como é possível codificar as URLs em páginas JSP? A marcação <c.url> da JSTL serve para esse propósito. O exercício a seguir demonstra o problema e ilustra a solução.

1. Desative os cookies temporariamente no navegador. Se estiver utilizando o Firefox, pode selecionar Ferramentas > Opções (Firefox > Preferências no Mac). Na janela exibida, selecione a aba Privacidade e, em seguida, sob Histórico, selecione "utilizar configurações personalizadas para o histórico" na lista suspensa. Desmarque a opção "aceitar cookies de sites".
   
2. Execute o projeto AffableBean. Quando a página de boas vindas for exibida, clique na categoria e, em seguida, tente adicionar um item ao seu carrinho. Você verá que a funcionalidade do aplicativo está comprometida severamente no seu estado atual.
   
   Como antes, o servidor gera uma sessão e vincula objetos à ela. Isso mostra como a página categoria é capaz de exibir a categoria e os produtos selecionados. Entretanto, o servidor falhou na sua tentativa de definir um cookie JSESSIONID. Portanto, quando o cliente faz um segundo pedido (quando o usuário clica em "adicionar ao carrinho"), o servidor não tem como identificar a sessão a qual o pedido pertence. Portanto, ele não pode localizar nenhum dos atributos definidos previamente na sessão, tais como selectedCategory e categoryProducts. Essa é a razão pela qual falta informações na resposta renderizada especificada por esses atributos.
3. Abra a página de projeto category.jsp no editor. Localize a linha que implementa o botão "adicionar ao carrinho" (linha 58). O elemento <form> do atributo ação determina que o pedido foi enviado ao servidor.

   <form action="addToCart" method="post">

4. Modifique o pedido, de forma que seja passado através da marcação <c.url>.

   <form action="<c:url value='addToCart'/>" method="post">

5. Pressione Ctrl-S (⌘-S no Mac) para salvar as alterações do arquivo. Lembre-se de que o IDE fornece o recurso Implantar ao salvar, que é ativado por padrão. Isso significa que quaisquer alterações são implantadas automaticamente no servidor.
6. No navegador, selecione uma categoria diferente de forma que o aplicativo renderize a página da categoria modificada recentemente.
7. Examine o código-fonte para a página. No Firefox, é possível pressionar Ctrl-U (⌘-U no Mac). O botão "adicionar ao carrinho" para cada produto é exibido com a ID da sessão anexada à URL.

   <form action="addToCart;jsessionid=4188657e21d72f364e0782136dde" method="post">

8. Clique no botão "adicionar ao carrinho" para qualquer item. Você verá que o servidor agora é capaz de determinar a sessão à qual o pedido pertence e de renderizar a resposta de forma adequada.
9. Antes de prosseguir, certifique-se de reabilitar cookies para o navegador.

Em cada link em que o usuário puder clicar no aplicativo, cuja resposta exija alguma forma de dados relacionados à sessão, precisa ser codificado corretamente. As vezes a implementação não é direta, como o exemplo mostrado acima. Por exemplo, o assistente "limpar carrinho" utilizado no cart.jsp define atualmente um parâmetro limpar como verdadeiro quando o link é clicado.

<%-- clear cart widget --%>
<c:if test="${!empty cart && cart.numberOfItems != 0}">
    <a href="viewCart?clear=true" class="bubble hMargin">clear cart</a>
</c:if>

A marcação <c.url> pode ser aplicada à URL da seguinte forma:

<%-- clear cart widget --%>
<c:if test="${!empty cart && cart.numberOfItems != 0}">

    <c:url var="url" value="viewCart">
        <c:param name="clear" value="true"/>
    </c:url>

    <a href="${url}" class="bubble hMargin">clear cart</a>
</c:if>

O parâmetro clear=true é definido quando uma marcação <c:param é adicionado entre as marcações <c.url>. Uma variável nomeada "url" é definida quando o atributo var do <c.url> é utilizado e o var é então acessado na marcação âncora HTML utilizando a expressão ${url}.

É possível baixar e examinar o instantâneo 6 para ver como todos os links no projeto foram codificados.

A reescrita URL só deve ser utilizada no caso dos cookies não serem um método de rastreamento disponível. A reescrita URL é geralmente considerada como uma solução de qualidade inferior porque ela expõe a ID da sessão nos registros, marcadores, cabeçalhos de referência e HTML em cachê, além da barra de endereço do navegador. São necessários também mais recursos do lado do servidor, já que o servidor precisa executar etapas adicionais para cada entrada de pedido, a fim de extrair a ID da sessão da URL e emparelhá-la com uma sessão existente.

Configurando os intervalos de tempo da sessão

É necessário considerar o intervalo de tempo máximo no qual o servidor mantém as sessões. No caso de o site receber um tráfico intenso, um grande número de sessões poderiam gastar a capacidade de memória do servidor. É necessário portanto, encurtar o intervalo no intuito de remover as sessões não utilizadas. Por outro lado, você certamente não desejaria encurtar muito as sessões, já que isto poderia se tornar um problema de uso que poderia ter um impacto negativo nos negócios ligados ao site. Obtendo o exemplo do aplicativo AffableBean, onde uma usuária faz o check-out após encher seu carrinho de compras com itens. Ela então percebe que precisa inserir os detalhes do seu cartão de crédito e sai para pegar sua carteira. Após retornar ao computador com o cartão de crédito em mãos, preenche o formulário de check-out e clica em submeter. No entanto, durante esse tempo, sua sessão foi expirada no servidor. A usuária nota que seu carrinho de compras está vazio e é redirecionada à página inicial. Será que ela realmente irá gastar tempo percorrendo todo o processo novamente?

Os passos a seguir, demonstram como definir o intervalo de tempo de espera da sessão no projeto AffableBean para 10 minutos. Claro que a duração atual depende dos recursos do servidor, dos objetivos do negócios do aplicativo e da popularidade do seu site.

1. Abra o descritor de implantação do aplicativo no editor. Pressione Alt-Shift-O (Ctrl-Shift-O no Mac) para utilizar a caixa de diálogo do IDE Vá para o arquivo. Digite 'web' e, em seguida, clique em OK.
   
   O editor exibe o arquivo web.xml na visualização XML. O modelo que o NetBeans fornece para o arquivo web.xml inclui uma configuração padrão para 30 minutos.

   <session-config>
       <session-timeout>
           30
       </session-timeout>
   </session-config>

2. Clique na aba Geral e digite "10" no campo Tempo limite da sessão.
   
3. Salve o arquivo (Ctrl-S; ⌘-S on Mac).
   
   Se voltar para a visualização XML, verá que o elemento <session-timeout> foi atualizado.

   <session-config>
       <session-timeout>10</session-timeout>
   </session-config>

Observação: Alternativamente, é possível remover completamente o elemento <session-timeout> e editar o elemento session-properties no descritor de implementação específico do GlassFish (sun-web.xml). Isso definiria o tempo limite global para todos os aplicativos no módulo da web do servidor. Consulte o O Guia de desenvolvimento de aplicativos do Sun GlassFish Server 3.0.1: Criando e gerenciando sessões para obter mais detalhes.

Manipulando de forma programática o tempo limite das sessões

Se seu aplicativo se baseia em sessões, será necessário tomar medidas para assegurar que ele possa lidar confortavelmente com situações nas quais um pedido é recebido para uma sessão que possui tempo limite ou que não pode ser identificada. É possível alcançar isso no aplicativo AffableBean criando um filtro simples que intercepta os pedidos enviados para o ControllerServlet. O filtro verifica se a sessão existe, se não existir, ele encaminha o pedido à página de boas vindas do site.

1. Comece examinando o problema que aparece quando a sessão expira durante uma visita do usuário ao site. Redefina temporariamente o intervalo de tempo limite da sessão para um minuto. Abra o descritor de implantação da web (web.xml) e insira "1" entre as marcações <session-timeout>.

   <session-config>
       <session-timeout>1</session-timeout>
   </session-config>

2. Execute o projeto AffableBean. No navegador, clique na página da categoria, adicione vários itens ao carrinho e, em seguida, clique em "Ver carrinho".
   
3. Espere pelo menos um minuto completo.
4. Atualize a quantidade para um dos itens exibidos na página do carrinho. (Qualquer número entre 1 e 99 é aceitável.) Clique em "atualizar". O servidor retorna uma mensagem HTTP Status 500.
   
5. Examine o registro do servidor GlassFish no IDE. Abra a janela Saída (Ctrl-4, ⌘-4 no Mac) e selecione a aba Servidor GlassFish. Vá para a parte inferior do registro para examinar o rastro da pilha fornecido pelo erro.
   
   O registro do servidor indica que uma NullPointerException ocorreu na linha 184 no ControllerServlet. A janela Saída forma um link com a linha onde ocorreu a exceção.
6. Clique no link. É possível navegar diretamente até a linha 184 no ControllerServLet. Passar o mouse sobre a identificação do erro na margem esquerda do editor fornece uma dica de ferramenta que descreve a exceção.
   
   Como a sessão já havia expirado antes do pedido ser recebido, o mecanismo servlet não pode associar o pedido à sua sessão correspondente. Portanto, ele não foi capaz de localizar o objeto cart (linha 151). A exceção ocorreu finalmente na linha 184 quando o mecanismo tentou chamar um método em uma variável equivalente a null.
   
   Agora que identificamos o problema, vamos corrigi-lo implementando um filtro.
7. Clique no botão Novo arquivo ( ) na barra de ferramentas do IDE. (Outra alternativa é pressionar Ctrl-N; ⌘-N no Mac.)
8. Selecione a categoria Webe, em seguida, selecione Filtro e clique em Avançar.
9. Nomeie o filtroSessionTimeoutFilter. Digite filtro no campo Pacotes, de forma que a classe do filtro seja colocada em um novo pacote quando for criada.
10. Clique em Avançar. Aceite as configurações padrão e clique em Terminar. Um modelo para o SessionTimeoutFilter é gerado e aberto no editor.
    
    

    Nota: atualmente, no NetBeans 6.9, não é possível utilizar o assistente para definir um mapeamento a um servlet que não seja registrado no descritor de implantação da web. (O ControllerServlet foi registrado usando a anotação @WebServlet.) Portanto, modificaremos o código gerado na próxima etapa.

11. Modifique a assinatura da anotação @WebFilter, de maneira que apareça da seguinte forma.

    @WebFilter(servletNames = {"Controller"})
    public class SessionTimeoutFilter implements Filter {

    Isso define o filtro para interceptar qualquer pedido que seja manipulado pelo ControllerServlet. (Alternativamente, você poderia ter mantido o atributo urlPatterns e listado todos os padrões que manipulam o ControllerServlet.)
    
    Note que o "Controlador" é o nome do ControllerServlet, como especificado na assinatura da anotação @WebServlet. Note também que o atributo foi removido filterName, já que o nome da classe do filtro já foi utilizado por padrão.
    
    O modelo do filtro do IDE fornece vários códigos interessantes que valem a pena inspecionar por si só. No entanto, a maioria deles não é necessário para o nosso propósito. Qualquer classe de filtro deve implementar a interface Filtro, que define três métodos:
    • init: executa qualquer ação após o filtro ser inicializado, mas antes de começar a funcionar
    • destroy: remove o filtro do serviço. Esse método também pode ser utilizado para executar qualquer operação de limpeza.
    • doFilter: utilizado para executar operações para cada pedido que o filtro interceptar.

    Utilize a opção Pesquisa do índice Javadoc para puxar a documentação na interface Filtro. Pressione Shift-F1 (fn-Shift-F1 no Mac) e, em seguida, digite "Filtro" no campo pesquisar e tecle Enter. Selecione a entrada "Interface no javax.servlet". A documentação Javadoc é exibida no painel inferior da ferramenta de pesquisa do índice.

12. Substitua o corpo do SessionTimeoutFilter pelos conteúdos a seguir.

    @WebFilter(servletNames = {"Controller"})
    public class SessionTimeoutFilter implements Filter {
    
        public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
                throws IOException, ServletException {
    
            HttpServletRequest req = (HttpServletRequest) request;
    
            HttpSession session = req.getSession(false);
    
            // se a sessão não existe, encaminhe o usuário a página bem vindo
            if (session == null) {
                try {
                    req.getRequestDispatcher("/index.jsp").forward(request, response);
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
                return;
            }
    
            chain.doFilter(request, response);
        }
    
        public void init(FilterConfig filterConfig) throws ServletException {}
    
        public void destroy() {}
    
    }

13. Pressione Ctrl-Shift-I (⌘-Shift-I no Mac) para corrigir instruções de importações. (As importações precisam ser adicionadas às HttpServletRequest e HttpSession.) Além disso, use as dics do editor para adicionar a anotação @Override aos métodos init, destroy e doFilter.
    
    Nas etapas a seguir, você executará o depurador no projeto e percorrerá o método doFilter para ver como ele determina se o pedido está vinculado a uma sessão existente.
14. Abra a janela Pontos de interrupção (Alt-Shift-5; Ctrl-Shift-5 no Mac) e assegure-se de que não haja nenhum ponto de interrupção definido. Para excluir um ponto de interrupção, clique com o botão direito do mouse no ponto de interrupção e escolha Excluir. (Se você concluiu o exercício acima, Examinando a comunicação cliente-servidor com o monitor de HTTP, poderá ter um ponto de verificação pendente definido no ControllerServlet.)
15. Execute o depurador. Clique no botão Depurar projeto () na barra de ferramentas principal do IDE.
16. Quando a página de boas vindas for exibida no navegador, selecione uma categoria e, em seguida, adicione vários itens ao seu carrinho de compras.
17. Defina um ponto de interrupção na linha no método doFilter do SessionTimeoutFilter que tenta acessar a sessão (linha 32).
    
18. No navegador, clique no botão "ver carrinho". Alterne para o IDE e note que o depurador foi suspenso no ponto de interrupção.
    
    Lembre-se que getSession() cria um novo objeto de sessão caso o atual não exista. Aqui, utilizamos o getSession(falso), que se abstém de criar um novo objeto caso não seja encontrado nenhum. Em outras palavras, o método retorna null se a sessão não existir.
19. Clique no botão Passar sobre ( ) e, em seguida, passe o mouse sobre a variável sessão. Desde que não tenha passado um minuto de quando o pedido anterior foi enviado, você verá que a variável foi atribuída à StandardSessionFacade. Isso representa o objeto de sessão para o pedido.
    
20. Continue percorrendo o método até que a solicitação seja processada. Como session não é igual a null, salte a declaração if e a chain.doFilter e, em seguida, encaminhe o pedido ao ControllerServlet (linha 44).
21. No navegador, certifique-se de que se passou um minuto completo e, em seguida, atualize a quantidade para um dos itens de produtos no carrinho. Esse é o mesmo procedimento que executamos anteriormente no exercício, quando foi retornada a mensagem Status 500. Agora que o filtro intercepta os pedidos direcionados ao ControllerServlet, veremos o que acontece quando ocorrer o tempo limite da sessão.
22. Após clicar em "atualizar", alterne para o IDE e note que o depurador é suspenso novamente no pontos de interrupção definido no filtro.
23. Realce a expressão req.getSession(falsa)e, em seguida, passe o mouse sobre ela. Aqui você verá que a expressão equivale a null, já que a sessão já foi expirada.
    
24. Continue percorrendo o código. Agora que a variável session se equivale a null, a declaração if na linha 35 é processada e o pedido é encaminhado para /index.jsp. Quando o depurador finalizar a execução, você verá que o navegador exibe a página de boas vindas do site.
25. Clique no botão Terminar sessão ( ) para finalizar a sessão de depuração.
26. Abra o arquivo do projeto web.xml e mude o intervalo do tempo de espera para 10 minutos.

    <session-config>
        <session-timeout>10</session-timeout>
    </session-config>

27. Salve o arquivo (Ctrl-S; ⌘-S no Mac).

// se o pedido foi processado com sucesso, enviar usuário para a página de confirmação
if (orderId != 0) {

    // desassociar o carrinho de compras da sessão
    cart = null;

    // end session
    session.invalidate();

    ...
}

Recursos do NetBeans

• Recursos do NetBeans: Depurador
• Depurando aplicativos multissegmentados
• Vídeo de depuração de multissegmentados no NetBeans IDE
• Vídeo sobre o uso do avaliador de fragmentos do código no depurador do NetBeans
• Tutoriais e demonstrações de vídeos para o NetBeans IDE 6.x
• Atalhos do teclado & Cartão de modelos de código
• Introdução aos aplicativos do Java EE 6
• Introdução à tecnologia Java EE
• Trilha de aprendizado do Java EE e Java Web

Recursos do GlassFish

• Screencasts do GlassFish
• Documentação do GlassFish v3
• Aprendizagem do GlassFish para usuários do Tomcat
• Guia de administração do Oracle GlassFish Server 3.0.1
• Guia de implantação de aplicativos do Sun GlassFish Server 3.0.1
• Guia de desenvolvimento de aplicativos do Sun GlassFish Server 3.0.1

Artigos técnicos & Recursos variados

• Modelos de código do Java EE & Aplicativos
• Ferramenta Javadoc [página inicial do produto]
• Como gravar comentários doc na ferramenta Javadoc
• Os fundamentos dos filtros
• Padrões Core J2EE: Filtro interceptador
• Tutoriais do Servlet, do JSP e do JDBC para os níveis iniciante e intermediário
• Tutoriais avançados do Servlet e JSP
• Tutoriais do Java 5 & Java 6
• Uma cartilha JSTL, Parte 1: A linguagem de expressão
• Uma cartilha JSTL, Parte 2: Chegando até o centro do problema