Kontext- und Servlet-Initialisierungsparameter

1. Überblick

Servlets sind einfache Java-Klassen, die in einem Servlet-Container ausgeführt werden.

HTTP-Servlets (ein bestimmter Servlet-Typ) sind erstklassige Bürger in Java-Webanwendungen. Die API von HTTP-Servlets istaimed at handling HTTP requests through the typical request-processing-response cycle, implemented in client-server protocols.

Darüber hinaus können Servlets die Interaktion zwischen einem Client (normalerweise einem Webbrowser) und dem Server mithilfe von Schlüssel-Wert-Paaren in Form von Anforderungs- / Antwortparametern steuern.

Diese Parameter können initialisiert und an einen anwendungsweiten Bereich (Kontextparameter) und einen servletspezifischen Bereich (Servletparameter) gebunden werden.

In diesem Tutorial lernen wirhow to define and access context and servlet initialization parameters.

2. Servlet-Parameter initialisieren

Wir können Servlet-Parameter mithilfe von Anmerkungen und dem Standard-Deployment-Deskriptor - der“web.xml”-Datei - definieren und initialisieren. Es ist erwähnenswert, dass sich diese beiden Optionen nicht gegenseitig ausschließen.

Lassen Sie uns jede dieser Optionen genauer erkunden.

2.1. Anmerkungen verwenden

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

In diesem Abschnitt wird gezeigt, wie Sie mithilfe von Anmerkungen Initialisierungsparameter definieren und darauf zugreifen, die an ein bestimmtes Servlet gebunden sind.

Dazu implementieren wir eine naiveUserServlet-Klasse, die Benutzerdaten über ein einfaches HTML-Formular sammelt.

Schauen wir uns zunächst die JSP-Datei an, die unser Formular rendert:



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

Beachten Sie, dass wir dasaction-Attribut des Formulars mithilfe vonEL (der Ausdruckssprache) codiert haben. Dadurch kann immer auf den Pfad von“/userServlet”verwiesen werden, unabhängig vom Speicherort der Anwendungsdateien auf dem Server.

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

Hier ist unsere erste Servlet-Implementierung:

@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);
    }
}

In diesem Fall haben wir zwei Servlet-Initialisierungsparameter,name undemail, umusing initParams and the @WebInitParam annotations definiert.

Beachten Sie, dass wir diegetParameter()-Methode von HttpServletRequest verwendet haben, um die Daten aus dem HTML-Formular abzurufen, und diegetInitParameter()-Methode, um auf die Servlet-Initialisierungsparameter zuzugreifen.

Die MethodegetRequestParameter() prüft, ob die Anforderungsparametername undemailleere Zeichenfolgen sind.

Wenn es sich um leere Zeichenfolgen handelt, werden ihnen die Standardwerte der übereinstimmenden Initialisierungsparameter zugewiesen.

Die MethodedoPost()ruft zuerst den Namen und die E-Mail-Adresse ab, die der Benutzer in das HTML-Formular eingegeben hat (falls vorhanden). Anschließend werden die Anforderungsparameter verarbeitet und die Anforderung an eine“result.jsp”-Datei weitergeleitet:



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

Wenn wir unsere Beispielwebanwendung auf einem Anwendungsserver wieApache Tomcat,Oracle GlassFish oderJBoss WidlFly bereitstellen und ausführen, sollte zuerst die HTML-Formularseite angezeigt werden.

Sobald der Benutzer die Feldername undemail ausgefüllt und das Formular gesendet hat, gibt er die folgenden Daten aus:

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

Wenn das Formular nur leer ist, werden die Servlet-Initialisierungsparameter angezeigt:

User Information
Name: Not provided
Email: Not provided

In diesem Beispiel haben wirhow to define servlet initialization parameters by using annotations, and how to access them with the getInitParameter() method angezeigt.

2.2. Verwenden des Standard Deployment Descriptor

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

Um zu zeigen, wie Initialisierungsservlet-Parameter mit der Datei“web.xml”definiert werden, entfernen wir zunächst die AnmerkungeninitParam und@WebInitParam aus der KlasseUserServlet:

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

Als Nächstes definieren wir die Servlet-Initialisierungsparameter in der Datei“web.xml”:



    
        UserServlet
        UserServlet
        
            name
            Not provided
        
        
            email
            Not provided

Wie oben gezeigt, läuft das Definieren von Servlet-Initialisierungsparametern unter Verwendung der Datei“web.xml” nur auf die Verwendung der Tags<init-param>,<param-name> und<param-value> hinaus.

Darüber hinaus ist es möglich, so viele Servlet-Parameter wie nötig zu definieren, solange wir uns an die obige Standardstruktur halten.

Wenn wir die Anwendung erneut auf dem Server bereitstellen und erneut ausführen, sollte sie sich genauso verhalten wie die Version, in der Anmerkungen verwendet werden.

3. Kontextparameter initialisieren

Manchmal müssen wir unveränderliche Daten definieren, die global gemeinsam genutzt und über eine Webanwendung abgerufen werden müssen.

Aufgrund der globalen Natur der Daten sollten wiruse application-wide context initialization parameters for storing the data, rather than resorting to the servlet counterparts.

Obwohl es nicht möglich ist, Kontextinitialisierungsparameter mithilfe von Anmerkungen zu definieren, können wir dies in der Datei“web.xml”tun.

Nehmen wir an, wir möchten einige globale Standardwerte für das Land und die Provinz bereitstellen, in denen unsere Anwendung ausgeführt wird.

Wir können dies mit ein paar Kontextparametern erreichen.

Lassen Sie uns die“web.xml”-Datei entsprechend umgestalten:


    
        province
        Mendoza
    
    
        country
        Argentina

Dieses Mal haben wir die Tags<context-param>, <param-name>, und<param-value> verwendet, um die Kontextparameterprovince undcountryzu definieren.

Natürlich müssen wir die KlasseUserServletumgestalten, damit sie diese Parameter abrufen und an die Ergebnisseite weitergeben kann.

Hier sind die relevanten Abschnitte des Servlets:

@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);
    }
}

Bitte beachten Sie die Methodenimplementierung vongetContextParameter(), diefirst gets the servlet context through getServletContext(), and then fetches the context parameter with the getInitParameter() method.

Als nächstes müssen wir die Datei“result.jsp”umgestalten, damit sie die Kontextparameter zusammen mit den servletspezifischen Parametern anzeigen kann:

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

Zuletzt können wir die Anwendung erneut implementieren und erneut ausführen.

Wenn der Benutzer das HTML-Formular mit einem Namen und einer E-Mail ausfüllt, werden diese Daten zusammen mit den Kontextparametern angezeigt:

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

Andernfalls werden die Servlet- und Kontextinitialisierungsparameter ausgegeben:

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

Während das Beispiel erfunden ist, zeigt eshow to use context initialization parameters to store immutable global data.

Da die Daten nicht an ein bestimmtes Servlet, sondern an den Anwendungskontext gebunden sind, können wir mit den MethodengetServletContext() undgetInitParameter() von einem oder mehreren Servlets aus auf sie zugreifen.

4. Fazit

In diesem Artikel werdenwe 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.

Seit geraumer Zeit gibt es in Java eine starke Tendenz, XML-Konfigurationsdateien loszuwerden und nach Möglichkeit zu Anmerkungen zu migrieren.

CDI,Spring,Hibernate, um nur einige zu nennen, sind eklatante Beispiele dafür.

Es ist jedoch an sich nichts Falsches daran, die Datei“web.xml”zum Definieren von Kontext- und Servlet-Initialisierungsparametern zu verwenden.

Obwohl sichServlet API ziemlich schnell in Richtung dieser Tendenz entwickelt hat,we still need to use the deployment descriptor for defining context initialization parameters.

Wie üblich sind alle in diesem Artikel gezeigten Codebeispieleover on GitHub verfügbar.

TOC

Kontext- und Servlet-Initialisierungsparameter