Pra que serve e como funciona o ServletRequestAttributeListener

O ServletRequestAttributeListener é uma interface que serve para monitorar os atributos adicionados, alterados e removidos de uma requisição. Sempre que se adiciona um atributo no objeto ServletRequest, o método attributeAdded do listener que implementa essa interface é chamado. Sempre que se substitui um atributo do objeto ServletRequest, o método attributeReplaced do listener que implementa essa interface é chamado. E finalmente, sempre que se remove um atributo do objeto ServletRequest o método attributeRemoved é chamado.

Veja abaixo o exemplo de uma classe que implementa esse listener para exibir o nome e o valor do parâmetro que foi adicionado, alterado e removido:

import javax.servlet.ServletRequestAttributeListener;
import javax.servlet.ServletRequestAttributeEvent;
import javax.servlet.http.HttpServletRequest;

public class MeuServletRequestAttributeListener implements ServletRequestAttributeListener
{
    public void attributeAdded(ServletRequestAttributeEvent e)
    {
        System.out.println("Atributo adicionado -> nome: " 
            + e.getName() + ", valor: " + e.getValue() );
    }
    
    public void attributeRemoved(ServletRequestAttributeEvent e)
    {
        System.out.println("Atributo removido -> nome: " 
            + e.getName() + ", valor: " + e.getValue() );
    }
    
    public void attributeReplaced(ServletRequestAttributeEvent e)
    {
        System.out.println("Atributo alterado -> nome: " 
            + e.getName() + ", valorAntigo: " + e.getValue() );
    }
}

Para testar esse listener criei ainda um Servlet mapeado com o endereço /TesteAtributoRequest.do. Este Servlet faz forward para si mesmo decrementando o atributo "numero" que é guardado na requisição. Veja como fica o código:

public void doGet(HttpServletRequest request, HttpServletResponse response) 
 throws IOException, ServletException
{
    int numero;
    
    if( request.getAttribute("numero") != null )
    {
        numero = ( (Integer)request.getAttribute("numero") ).intValue();
        numero--;
    }
    else
    {
        try
        {
            numero = Integer.parseInt( request.getParameter("numero") );
        }
        catch(NumberFormatException e)
        {
            numero = 3;
        }
    }
    
    if( numero <= 0 ) 
    {
        request.removeAttribute("numero");
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        out.print("Acaboooou");
    }
    else
    {
        request.setAttribute("numero", new Integer(numero));
        request.getRequestDispatcher( "/TesteAtributoRequest.do" ).forward(request,response);
    }
}

Ao executá-lo mandando o parâmetro "numero" com valor igual a 5 por exemplo, o listener configurado irá exibir a seguinte saída:

Atributo adicionado -> nome: numero, valor: 5
Atributo alterado -> nome: numero, valorAntigo: 5
Atributo alterado -> nome: numero, valorAntigo: 4
Atributo alterado -> nome: numero, valorAntigo: 3
Atributo alterado -> nome: numero, valorAntigo: 2
Atributo removido -> nome: numero, valor: 1

Pra que serve e como funciona o ServletRequestListener

O ServletRequestListener serve para ser notificado quando uma aplicação recebe uma requisição e quando esta requisição é destruída. Nomea-se no caso uma requisição como um objeto ServletRequest. Assim que o objeto ServletRequest é inicializado o método requestInitialized do listener que implementa a interface ServletRequestListener é chamado. Quando o objeto ServletRequest é destruído, o método requestDestroyed é chamado.

Veja um exemplo de um listener que implementa ServletRequestListener abaixo:

import javax.servlet.ServletRequestListener;
import javax.servlet.ServletRequestEvent;
import javax.servlet.http.HttpServletRequest;

public class MeuServletRequestListener implements ServletRequestListener
{
    public void requestInitialized(ServletRequestEvent e)
    {
        HttpServletRequest r = (HttpServletRequest)e.getServletRequest();
        System.out.println("Requisicao inicializada: " + 
            r.getRequestURI()  );
    }
    
    public void requestDestroyed(ServletRequestEvent e)
    {
        HttpServletRequest r = (HttpServletRequest)e.getServletRequest();
        System.out.println("Requisicao finalizada: " + 
            r.getRequestURI()  );
    }
}

No caso, o que o listener faz é escrever na saída padrão a URI requisitada quando uma nova requisição chega à aplicação e quando a requisição é finalizada. É importante notar que mesmo quando é feito uma requisição cujo resultado é um 404, o objeto de requisição é criado e em consequência os métodos do listener são chamados.

Pra que serve e como funciona o ServletContextAttributeListener?

O ServletContextAttributeListener é um listener que recebe sinais quando um atributo é adicionado, removido ou alterado no contexto. Para quem não sabe, um atributo de contexto é válido para todos os servlets, threads e sessões de uma aplicação. Para testar seu funcionamento criei uma classe implementando a interface ServletContextAttributeListener e um servlet para adicionar, remover e alterar atributos do contexto.

Segue o código do listener:

package meupacote.listeners;

import javax.servlet.ServletContextAttributeListener;
import javax.servlet.ServletContextAttributeEvent;

public class MeuServletContextAttributeListener implements ServletContextAttributeListener
{
    public void attributeAdded(ServletContextAttributeEvent e)
    {
        System.out.println("Atributo adicionado: nome=" +
                e.getName() + ", valor=" + e.getValue()
            );
    }

    public void attributeRemoved(ServletContextAttributeEvent e)
    {
        System.out.println("Atributo removido: nome=" +
                e.getName() + ", valor=" + e.getValue()
            );
    }

    public void attributeReplaced(ServletContextAttributeEvent e)
    {
        System.out.println("Atributo alterado: nome=" +
                e.getName() + ", valorAntigo=" + e.getValue()
            );
    }
}

Veja que para implementar esse listener é preciso sobrescrever os métodos attributeAdded, que é chamado quando um atributo é adicionado, attributeRemoved, que é chamado quando um atributo é removido e attributeReplaced que é chamado quando um atributo é alterado.

O evento que esses métodos recebem possue dois métodos: getName e getValue, eles servem para pegar o nome e o valor do atributo manejado na ação. É preciso observar que no attributeReplaced, o getValue do evento retorna o valor anterior ao que foi alterado.

Agora veja o código do servlet que inclui, altera e remove atributos do contexto:

public class MudaAtributoContexto extends HttpServlet
{
    public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException
    {
        String acao = request.getParameter("acao");
        String nome = request.getParameter("nome");
        String valor = request.getParameter("valor");

        response.setContentType("text/html");
        PrintWriter out = response.getWriter();

        if( nome!=null )
        {
            if( "remover".equals(acao) )
            {
                getServletContext().removeAttribute(nome);
                out.print("Removido: " + nome);
            }
            else
            {
                getServletContext().setAttribute(nome, valor);
                out.print("Setado: " + nome + " = " + valor);
            }
        }
  
        StringBuilder s = new StringBuilder("<form><b>Incluir: </b>")
        .append(" nome: <input name=\"nome\"/>")
        .append(" valor: <input name=\"valor\"/>")
        .append(" <input type=\"submit\"/>")
        .append("</form><hr />");
  
        Enumeration e = getServletContext().getAttributeNames();
        while( e.hasMoreElements() )
        {
             String n = (String)e.nextElement();
             Object v = getServletContext().getAttribute(n);
      
             s.append("<form>")
             .append(" nome: <input name=\"nome\" value=\"" + n + "\">")
             .append(" valor: <input name=\"valor\" value=\"" + v + "\">")
             .append(" Remover? <input name=\"acao\" value=\"remover\" type=\"checkbox\">")
             .append(" <input value=\"Alterar\" type=\"submit\">")
             .append("</form>");
        }
  
        out.print(s);
    }
}

Depois de registrado o servlet e o listener no web.xml é só testar. Se por exemplo adicionarmos um atributo de nome pais e valor igual a Brasil, depois alterarmos esse mesmo atributo para Guatemala e ao final removê-lo. Teremos as seguintes linhas escritas no output:

Atributo adicionado: nome=pais, valor=Brasil
Atributo alterado: nome=pais, valorAntigo=Brasil
Atributo removido: nome=pais, valor=Guatemala

Pra que serve e como funciona o ServletContextListener?

A interface ServletContextListener é um listener utilizado para verificar quando uma aplicação é iniciada e finalizada. A classe que implementa essa interface deve sobrescrever os métodos contextInitialized e contextDestroyed que serão chamado assim que a aplicação é iniciada e finalizada respectivamente.

Veja um exemplo de classe implementando este listener:

package meupacote.listeners;

import javax.servlet.ServletContextListener;
import javax.servlet.ServletContextEvent;

public class MeuServletContextListener implements ServletContextListener
{
   public void contextInitialized(ServletContextEvent e)
   {
       System.out.println("MeuServletContextListener - iniciado: " +
               e.getServletContext().getServerInfo()
           );
   }

   public void contextDestroyed(ServletContextEvent e)
   {
       System.out.println("MeuServletContextListener - finalizado");
   }
}

Assim que registrármos esse listener no web.xml da aplicação, sempre que o contexto for recriado o método contextInitialized será chamado, escrevendo no output "MeuServletContextListener - iniciado: " seguido das informações do container utilizado. Como eu utilizo o tomcat 5, é apresentada a seguinte: "Apache Tomcat/5.5.17". Já o método contextDestroyed será chamado sempre que a aplicação for finalizada.