Paramètres d’initialisation de contexte et de servlet

Paramètres d'initialisation de contexte et de servlet

1. Vue d'ensemble

Servlets sont des classes Java simples qui s'exécutent dans un conteneur de servlet.

Les servlets HTTP (un type spécifique de servlet) sont des citoyens de première classe dans les applications Web Java. L'API des servlets HTTP estaimed at handling HTTP requests through the typical request-processing-response cycle, implemented in client-server protocols.

De plus, les servlets peuvent contrôler l'interaction entre un client (généralement un navigateur Web) et le serveur en utilisant des paires clé-valeur sous la forme de paramètres de requête / réponse.

Ces paramètres peuvent être initialisés et liés à une étendue d'application (paramètres de contexte) et à une étendue spécifique à un servlet (paramètres de servlet).

Dans ce tutoriel, nous allons apprendrehow to define and access context and servlet initialization parameters.

2. Initialisation des paramètres de servlet

Nous pouvons définir et initialiser les paramètres de servlet à l'aide d'annotations et du descripteur de déploiement standard - le fichier“web.xml”. Il convient de noter que ces deux options ne s’excluent pas mutuellement.

Explorons chacune de ces options en profondeur.

2.1. Utiliser des annotations

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

Dans cette section, nous montrerons comment définir et accéder aux paramètres d'initialisation liés à un servlet spécifique à l'aide d'annotations.

Pour ce faire, nous allons implémenter une classe naïveUserServlet qui collecte les données utilisateur via un simple formulaire HTML.

Tout d'abord, examinons le fichier JSP qui rend notre formulaire:



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

Notez que nous avons codé l’attributaction du formulaire en utilisant leEL (le langage d’expression). Cela lui permet de toujours pointer vers le chemin“/userServlet”, quel que soit l'emplacement des fichiers d'application sur le serveur.

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

Voici notre implémentation initiale 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);
    }
}

Dans ce cas, nous avons défini deux paramètres d’initialisation de servlet,name etemail, parusing initParams and the @WebInitParam annotations.

Veuillez noter que nous avons utilisé la méthodegetParameter() de HttpServletRequest pour récupérer les données du formulaire HTML et la méthodegetInitParameter() pour accéder aux paramètres d'initialisation du servlet.

La méthodegetRequestParameter() vérifie si les paramètres de requêtename etemail sont des chaînes vides.

S'il s'agit de chaînes vides, les valeurs par défaut des paramètres d'initialisation correspondants leur sont affectées.

La méthodedoPost() récupère d'abord le nom et l'adresse e-mail que l'utilisateur a saisis dans le formulaire HTML (le cas échéant). Ensuite, il traite les paramètres de la requête et transmet la requête à un fichier“result.jsp”:



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

Si nous déployons notre exemple d'application Web sur un serveur d'applications, tel queApache Tomcat,Oracle GlassFish ouJBoss WidlFly, et l'exécutons, il doit d'abord afficher la page du formulaire HTML.

Une fois que l'utilisateur a rempli les champsname etemail et soumis le formulaire, il affichera les données:

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

Si le formulaire est juste vide, il affichera les paramètres d'initialisation du servlet:

User Information
Name: Not provided
Email: Not provided

Dans cet exemple, nous avons montréhow to define servlet initialization parameters by using annotations, and how to access them with the getInitParameter() method.

2.2. Utilisation du descripteur de déploiement standard

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

Pour montrer comment définir les paramètres du servlet d'initialisation avec le fichier“web.xml”, supprimons d'abord les annotationsinitParam et@WebInitParam de la classeUserServlet:

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

Ensuite, définissons les paramètres d’initialisation du servlet dans le fichier“web.xml”:



    
        UserServlet
        UserServlet
        
            name
            Not provided
        
        
            email
            Not provided

Comme indiqué ci-dessus, la définition des paramètres d'initialisation du servlet à l'aide du fichier“web.xml” revient simplement à utiliser les balises<init-param>,<param-name> et<param-value>.

De plus, il est possible de définir autant de paramètres de servlet que nécessaire, tant que nous nous en tenons à la structure standard ci-dessus.

Lorsque nous redéployons l'application sur le serveur et l'exécutons à nouveau, il devrait se comporter de la même manière que la version qui utilise des annotations.

3. Initialisation des paramètres de contexte

Parfois, nous devons définir des données immuables qui doivent être partagées de manière globale et accessibles via une application Web.

En raison de la nature globale des données, nous devrionsuse application-wide context initialization parameters for storing the data, rather than resorting to the servlet counterparts.

Même s'il n'est pas possible de définir les paramètres d'initialisation du contexte à l'aide d'annotations, nous pouvons le faire dans le fichier“web.xml”.

Supposons que nous souhaitons fournir des valeurs globales par défaut pour le pays et la province où notre application est exécutée.

Nous pouvons accomplir cela avec quelques paramètres de contexte.

Refactorisons le fichier“web.xml” en conséquence:


    
        province
        Mendoza
    
    
        country
        Argentina

Cette fois, nous avons utilisé les balises<context-param>, <param-name>, et<param-value> pour définir les paramètres de contexteprovince etcountry.

Bien sûr, nous devons refactoriser la classeUserServlet afin qu'elle puisse récupérer ces paramètres et les transmettre à la page de résultats.

Voici les sections pertinentes du 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);
    }
}

Veuillez noter l'implémentation de la méthodegetContextParameter(), quifirst gets the servlet context through getServletContext(), and then fetches the context parameter with the getInitParameter() method.

Ensuite, nous devons refactoriser le fichier“result.jsp” afin qu'il puisse afficher les paramètres de contexte avec les paramètres spécifiques à la servlet:

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

Enfin, nous pouvons redéployer l'application et l'exécuter à nouveau.

Si l'utilisateur remplit le formulaire HTML avec un nom et un courrier électronique, il affichera ces données avec les paramètres de contexte:

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

Sinon, les paramètres d'initialisation du servlet et du contexte seront générés:

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

Alors que l'exemple est artificiel, il montrehow to use context initialization parameters to store immutable global data.

Comme les données sont liées au contexte de l'application, plutôt qu'à un servlet particulier, nous pouvons y accéder depuis une ou plusieurs servlets, en utilisant les méthodesgetServletContext() etgetInitParameter().

4. Conclusion

Dans cet article,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.

Depuis un certain temps, Java a tendance à se débarrasser des fichiers de configuration XML et à migrer vers les annotations chaque fois que cela est possible.

CDI,Spring,Hibernate, pour n'en nommer que quelques-uns, en sont des exemples flagrants.

Néanmoins, l’utilisation du fichier“web.xml” pour définir le contexte et les paramètres d’initialisation du servlet n’a rien de mal en soi.

Même si leServlet API a évolué à un rythme assez rapide vers cette tendance,we still need to use the deployment descriptor for defining context initialization parameters.

Comme d'habitude, tous les exemples de code présentés dans cet article sont disponiblesover on GitHub.

TOC

Paramètres d’initialisation de contexte et de servlet