Parâmetros de inicialização de contexto e servlet

1. Visão geral

Servlets são classes Java simples executadas em um contêiner de servlet.

Servlets HTTP (um tipo específico de servlet) são cidadãos de primeira classe em aplicativos da Web Java. A API de servlets HTTP éaimed at handling HTTP requests through the typical request-processing-response cycle, implemented in client-server protocols.

Além disso, os servlets podem controlar a interação entre um cliente (normalmente um navegador da web) e o servidor usando pares de valores-chave na forma de parâmetros de solicitação / resposta.

Esses parâmetros podem ser inicializados e vinculados a um escopo de todo o aplicativo (parâmetros de contexto) e a um escopo específico do servlet (parâmetros do servlet).

Neste tutorial, aprenderemoshow to define and access context and servlet initialization parameters.

2. Inicializando Parâmetros de Servlet

Podemos definir e inicializar os parâmetros do servlet usando anotações e o descritor de implantação padrão - o arquivo“web.xml”. É importante notar que essas duas opções não são mutuamente exclusivas.

Vamos explorar cada uma dessas opções em profundidade.

2.1. Usando anotações

Initializing servlets parameters with annotations allows us to keep configuration and source code in the same place.

Nesta seção, demonstraremos como definir e acessar os parâmetros de inicialização que estão vinculados a um servlet específico usando anotações.

Para fazer isso, implementaremos uma classeUserServlet ingênua que coleta dados do usuário por meio de um formulário HTML simples.

Primeiro, vamos dar uma olhada no arquivo JSP que renderiza nosso formulário:



    
        Context and Initialization Servlet Parameters
        
    
    
        Please fill the form below:
        
            Name:
            
            Email:

Observe que codificamos o atributoaction do formulário usandoEL (a linguagem de expressão). Isso permite que ele sempre aponte para o caminho“/userServlet”, independentemente da localização dos arquivos do aplicativo no servidor.

A expressão“$\{pageContext.request.contextPath}”sets a dynamic URL for the form, which is always relative to the application’s context path.

Aqui está nossa implementação inicial de servlet:

@WebServlet(name = "UserServlet", urlPatterns = {"/userServlet"}, initParams={
@WebInitParam(name="name", value="Not provided"),
@WebInitParam(name="email", value="Not provided")}))
public class UserServlet extends HttpServlet {
    // ...

    @Override
    protected void doPost(
      HttpServletRequest request,
      HttpServletResponse response)
      throws ServletException, IOException {
        processRequest(request, response);
        forwardRequest(request, response, "/WEB-INF/jsp/result.jsp");
    }

    protected void processRequest(
      HttpServletRequest request,
      HttpServletResponse response)
      throws ServletException, IOException {

        request.setAttribute("name", getRequestParameter(request, "name"));
        request.setAttribute("email", getRequestParameter(request, "email"));
    }

    protected void forwardRequest(
      HttpServletRequest request,
      HttpServletResponse response,
      String path)
      throws ServletException, IOException {
        request.getRequestDispatcher(path).forward(request, response);
    }

    protected String getRequestParameter(
      HttpServletRequest request,
      String name) {
        String param = request.getParameter(name);
        return !param.isEmpty() ? param : getInitParameter(name);
    }
}

Neste caso, definimos dois parâmetros de inicialização do servlet,nameeemail, porusing initParams and the @WebInitParam annotations.

Observe que usamos o métodogetParameter() de HttpServletRequest para recuperar os dados do formulário HTML e o métodogetInitParameter() para acessar os parâmetros de inicialização do servlet.

O métodogetRequestParameter() verifica se os parâmetros de solicitaçãonameeemail são strings vazias.

Se forem cadeias vazias, eles receberão os valores padrão dos parâmetros de inicialização correspondentes.

O métododoPost() primeiro recupera o nome e o e-mail que o usuário inseriu no formulário HTML (se houver). Em seguida, ele processa os parâmetros da solicitação e encaminha a solicitação para um arquivo“result.jsp”:



    
        
        User Data
    
    
        User Information
        Name: ${name}
        Email: ${email}

Se implementarmos nosso aplicativo da web de amostra em um servidor de aplicativos, comoApache Tomcat,Oracle GlassFish ouJBoss WidlFly, e executá-lo, ele deve primeiro exibir a página de formulário HTML.

Assim que o usuário preencher os camposnameeemail e enviar o formulário, ele irá gerar os dados:

User Information
Name: the user's name
Email: the user's email

Se o formulário estiver apenas em branco, ele exibirá os parâmetros de inicialização do servlet:

User Information
Name: Not provided
Email: Not provided

Neste exemplo, mostramoshow to define servlet initialization parameters by using annotations, and how to access them with the getInitParameter() method.

2.2. Usando o descritor de implantação padrão

This approach differs from the one that uses annotations, as it allows us to keep configuration and source code isolated from each other.

Para mostrar como definir os parâmetros do servlet de inicialização com o arquivo“web.xml”, vamos primeiro remover as anotaçõesinitParame@WebInitParam da classeUserServlet:

@WebServlet(name = "UserServlet", urlPatterns = {"/userServlet"})
public class UserServlet extends HttpServlet { ... }

A seguir, vamos definir os parâmetros de inicialização do servlet no arquivo“web.xml”:



    
        UserServlet
        UserServlet
        
            name
            Not provided
        
        
            email
            Not provided

Como mostrado acima, definir os parâmetros de inicialização do servlet usando o arquivo“web.xml” se resume em usar as tags<init-param>,<param-name>e<param-value>.

Além disso, é possível definir quantos parâmetros de servlet forem necessários, contanto que nos atenhamos à estrutura padrão acima.

Quando reimplantamos o aplicativo no servidor e o executamos novamente, ele deve se comportar da mesma forma que a versão que usa anotações.

3. Inicializando Parâmetros de Contexto

Às vezes, precisamos definir alguns dados imutáveis que devem ser compartilhados e acessados globalmente em um aplicativo da web.

Devido à natureza global dos dados, devemosuse application-wide context initialization parameters for storing the data, rather than resorting to the servlet counterparts.

Mesmo que não seja possível definir parâmetros de inicialização de contexto usando anotações, podemos fazer isso no arquivo“web.xml”.

Vamos supor que desejamos fornecer alguns valores globais padrão para o país e a província onde nosso aplicativo está sendo executado.

Podemos fazer isso com alguns parâmetros de contexto.

Vamos refatorar o arquivo“web.xml” de acordo:


    
        province
        Mendoza
    
    
        country
        Argentina

Desta vez, usamos as tags<context-param>, <param-name>,e<param-value> para definir os parâmetros de contextoprovinceecountry.

Claro, precisamos refatorar a classeUserServlet para que ela possa buscar esses parâmetros e passá-los para a página de resultados.

Aqui estão as seções relevantes do servlet:

@WebServlet(name = "UserServlet", urlPatterns = {"/userServlet"})
public class UserServlet extends HttpServlet {
    // ...

    protected void processRequest(
      HttpServletRequest request,
      HttpServletResponse response)
      throws ServletException, IOException {

        request.setAttribute("name", getRequestParameter(request, "name"));
        request.setAttribute("email", getRequestParameter(request, "email"));
        request.setAttribute("province", getContextParameter("province"));
        request.setAttribute("country", getContextParameter("country"));
    }

    protected String getContextParameter(String name) {-
        return getServletContext().getInitParameter(name);
    }
}

Observe a implementação do métodogetContextParameter(), quefirst gets the servlet context through getServletContext(), and then fetches the context parameter with the getInitParameter() method.

Em seguida, precisamos refatorar o arquivo“result.jsp” para que ele possa exibir os parâmetros de contexto junto com os parâmetros específicos do servlet:

Name: ${name}
Email: ${email}
Province: ${province}
Country: ${country}

Por fim, podemos reimplementar o aplicativo e executá-lo novamente.

Se o usuário preencher o formulário HTML com um nome e um email, ele exibirá esses dados junto com os parâmetros de contexto:

User Information
Name: the user's name
Email: the user's email
Province: Mendoza
Country: Argentina

Caso contrário, ele produziria os parâmetros de inicialização do servlet e do contexto:

User Information
Name: Not provided
Email: Not provided
Province: Mendoza
Country: Argentina

Embora o exemplo seja inventado, ele mostrahow to use context initialization parameters to store immutable global data.

Como os dados estão vinculados ao contexto do aplicativo, em vez de a um servlet específico, podemos acessá-los a partir de um ou vários servlets, usando os métodosgetServletContext()egetInitParameter().

4. Conclusão

Neste artigo,we learned the key concepts of context and servlet initialization parameters and how to define them and access them using annotations and the “web.xml” file.

Por algum tempo, tem havido uma forte tendência em Java de se livrar dos arquivos de configuração XML e migrar para anotações sempre que possível.

CDI,Spring,Hibernate, para citar alguns, são exemplos flagrantes disso.

No entanto, não há nada inerentemente errado em usar o arquivo“web.xml” para definir o contexto e os parâmetros de inicialização do servlet.

Mesmo queServlet API tenha evoluído em um ritmo muito rápido em direção a essa tendência,we still need to use the deployment descriptor for defining context initialization parameters.

Como de costume, todos os exemplos de código mostrados neste artigo estão disponíveisover on GitHub.

TOC

Parâmetros de inicialização de contexto e servlet