Kontext- und Servlet-Initialisierungsparameter

1. Übersicht

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 zielt darauf ab, HTTP-Anforderungen über den typischen Anforderungsverarbeitungs-Antwortzyklus zu verarbeiten, der in Client-Server-Protokollen implementiert ist .

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 (Servlet-Parameter) gebunden werden.

In diesem Tutorial erfahren Sie, wie Sie Kontext- und Servlet-Initialisierungsparameter definieren und darauf zugreifen .

2. Servlet-Parameter initialisieren

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

Lassen Sie uns jede dieser Optionen genauer untersuchen.

2.1. Anmerkungen verwenden

Durch das Initialisieren von Servlet-Parametern mit Anmerkungen können wir Konfiguration und Quellcode an derselben Stelle belassen .

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

Zu diesem Zweck implementieren wir eine naive UserServlet- 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 das Aktionsattribut des Formulars mithilfe der EL (Ausdruckssprache) codiert haben . Dadurch kann immer auf den Pfad "/ userServlet" verwiesen werden , unabhängig vom Speicherort der Anwendungsdateien auf dem Server.

Der Ausdruck "$ {pageContext.request.contextPath}" legt eine dynamische URL für das Formular fest, die immer relativ zum Kontextpfad der Anwendung ist .

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 und E-Mail , mithilfe von initParams und den Annotationen @WebInitParam definiert .

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

Die Methode getRequestParameter () prüft, ob die Parameter name und email request leere Zeichenfolgen sind.

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

Die Methode doPost () 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 Datei "result.jsp" weitergeleitet :

    User Data   

User Information

Name: ${name}

Email: ${email}

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

Sobald der Benutzer die Felder Name und E-Mail ausgefüllt und das Formular gesendet hat, werden die Daten ausgegeben:

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 wir gezeigt, wie Servlet-Initialisierungsparameter mithilfe von Annotationen definiert werden und wie mit der Methode g etInitParameter () auf sie zugegriffen wird .

2.2. Verwenden des Standard Deployment Descriptor

Dieser Ansatz unterscheidet sich von dem, bei dem Anmerkungen verwendet werden, da Konfiguration und Quellcode voneinander isoliert bleiben können .

Um zu veranschaulichen, wie Initialisierungsservlet-Parameter mit der Datei "web.xml" definiert werden, entfernen wir zunächst die Annotationen initParam und @WebInitParam aus der UserServlet- Klasse:

@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 mithilfe der Datei "web.xml" auf die Verwendung von , und Stichworte.

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 wie die Version verhalten, die Anmerkungen verwendet.

3. Initialisieren von Kontextparametern

Manchmal müssen wir unveränderliche Daten definieren, die global freigegeben werden müssen und auf die über eine Webanwendung zugegriffen werden muss.

Aufgrund der globalen Natur der Daten sollten wir anwendungsweite Kontextinitialisierungsparameter zum Speichern der Daten verwenden, anstatt auf die Servlet-Gegenstücke zurückzugreifen .

Even though it's not possible to define context initialization parameters using annotations, we can do this in the “web.xml” file.

Let's suppose that we want to provide some default global values for the country and province where our application is running.

We can accomplish this with a couple of context parameters.

Let's refactor the “web.xml” file accordingly:

  province Mendoza   country Argentina   

This time, we've used the , , and tags to define the province and country context parameters.

Of course, we need to refactor the UserServlet class so that it can fetch these parameters and pass them on to the result page.

Here are the servlet's relevant sections:

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

Please notice the getContextParameter() method implementation, which first gets the servlet context through getServletContext(), and then fetches the context parameter with the getInitParameter() method.

Next, we need to refactor the “result.jsp” file so that it can display the context parameters along with the servlet-specific parameters:

Name: ${name}

Email: ${email}

Province: ${province}

Country: ${country}

Lastly, we can redeploy the application and execute it once again.

If the user fills the HTML form with a name and an email, then it will display this data along with the context parameters:

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

Otherwise, it would output the servlet and context initialization parameters:

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

While the example is contrived, it shows how to use context initialization parameters to store immutable global data.

As the data is bound to the application context, rather than to a particular servlet, we can access them from one or multiple servlets, using the getServletContext() and getInitParameter() methods.

4. Conclusion

In this 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.

For quite some time, there has been a strong tendency in Java to get rid of XML configuration files and migrate to annotations whenever possible.

CDI, Spring, Hibernate, to name a few, are glaring examples of this.

Trotzdem ist die Verwendung der Datei "web.xml" zum Definieren von Kontext- und Servlet-Initialisierungsparametern von Natur aus nichts Falsches .

Obwohl sich die Servlet-API ziemlich schnell in Richtung dieser Tendenz entwickelt hat, müssen wir dennoch den Bereitstellungsdeskriptor zum Definieren von Kontextinitialisierungsparametern verwenden .

Wie üblich sind alle in diesem Artikel gezeigten Codebeispiele auf GitHub verfügbar.