I. Grundlegendes Funktionsprinzip des Filters

  • 1. Ein Filter-Programm ist eine Java-Klasse, die eine spezielle Schnittstelle implementiert. Ähnlich wie ein Servlet wird es ebenfalls vom Servlet-Container aufgerufen und ausgeführt.
  • 2. Wenn ein Filter in web.xml registriert wird, um ein Servlet-Programm abzufangen, kann er entscheiden, ob die Anfrage weiter an das Servlet-Programm übergeben wird und ob die Anfrage- und Antwortnachrichten geändert werden.
  • 3. Wenn der Servlet-Container beginnt, ein Servlet-Programm aufzurufen, und feststellt, dass ein Filter-Programm registriert wurde, um dieses Servlet abzufangen, ruft der Container nicht mehr direkt die service-Methode des Servlets auf. Stattdessen ruft er die doFilter-Methode des Filters auf, die dann entscheidet, ob die service-Methode aktiviert wird.
  • 4. In der Methode Filter.doFilter können Sie jedoch nicht direkt die service-Methode des Servlets aufrufen. Stattdessen rufen Sie die Methode FilterChain.doFilter auf, um die service-Methode des Ziel-Servlets zu aktivieren. Das FilterChain-Objekt wird über die Parameter der Methode Filter.doFilter übergeben.
  • 5. Solange Sie in der Methode Filter.doFilter vor und nach der Anweisung, die FilterChain.doFilter aufruft, etwas Programmcode hinzufügen, können Sie bestimmte spezielle Funktionen vor und nach der Antwort des Servlets implementieren.
  • 6. Wenn die Methode FilterChain.doFilter nicht in der Methode Filter.doFilter aufgerufen wird, wird die service-Methode des Ziel-Servlets nicht ausgeführt. Auf diese Weise kann der Filter bestimmte unzulässige Zugriffsanfragen blockieren.

II. Filterkette

  • 1. In einer Webanwendung können mehrere Filterprogramme registriert werden, und jedes Filterprogramm kann ein oder eine Gruppe von Servlet-Programmen abfangen. Wenn mehrere Filterprogramme den Zugriffsprozess eines bestimmten Servlet-Programms abfangen können, kombiniert der Webcontainer beim Eintreffen einer Zugriffsanforderung für dieses Servlet diese mehreren Filterprogramme zu einer Filterkette (auch Filterkette genannt).
  • 2. Die Abfangreihenfolge der Filter in der Filterkette entspricht ihrer Zuordnungsreihenfolge in der Datei web.xml. Der Aufruf der Methode FilterChain.doFilter in der doFilter-Methode des vorherigen Filters aktiviert die doFilter-Methode des nächsten Filters, und die in der doFilter-Methode des letzten Filters aufgerufene Methode FilterChain.doFilter aktiviert die service-Methode des Ziel-Servlets.
  • 3. Solange irgendein Filter in der Filterkette die Methode FilterChain.doFilter nicht aufruft, wird die service-Methode des Ziel-Servlets nicht ausgeführt.

III. Filter-Schnittstelle

Ein Filterprogramm ist eine Java-Klasse, und diese Klasse muss die Schnittstelle Filter implementieren. Die Schnittstelle javax.servlet.Filter definiert drei Methoden: init, doFilter und destroy.

1. init-Methode

  • (1) Beim Start der Webanwendung erstellt der Webserver (Webcontainer) für jeden registrierten Filter anhand der Konfigurationsinformationen in seiner Datei web.xml ein Instanzobjekt und speichert es im Speicher.
  • (2) Nachdem der Webcontainer das Filter-Instanzobjekt erstellt hat, ruft er sofort die init-Methode dieses Filterobjekts auf. Die init-Methode wird im Lebenszyklus des Filters nur einmal ausgeführt. Wenn der Webcontainer die init-Methode aufruft, übergibt er ein FilterConfig-Objekt, das die Konfigurations- und Laufzeitumgebungsinformationen des Filters enthält.

    public voic init(FilterConfig filterConfig) throws ServletException
  • (3) Entwickler können in der init-Methode Initialisierungsfunktionen ähnlich wie Konstruktoren ausführen. Beachten Sie, dass, wenn der Initialisierungscode das FilterConfig-Objekt verwenden muss, dieser Code nur in der init-Methode geschrieben werden kann, nicht im Konstruktor (da die init-Methode noch nicht aufgerufen wurde, das FilterConfig-Objekt noch nicht erstellt wurde und seine Verwendung sicherlich einen Fehler verursachen würde).

2. doFilter-Methode

Wenn ein Filter-Objekt in der Lage ist, Zugriffsanfragen abzufangen, ruft der Servlet-Container die doFilter-Methode des Filter-Objekts auf.

public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws java.io.IOException.ServletException

Dabei sind die Parameter request und response die Anfrage- und Antwortobjekte, die vom Web-Container oder vom vorherigen Filter in der Filterkette übergeben werden; der Parameter chain ist das Objekt, das die aktuelle Filterkette repräsentiert.

3. destroy-Methode

Diese Methode wird aufgerufen, bevor der Web-Container das Filter-Objekt entlädt, und sie wird ebenfalls nur einmal ausgeführt. Sie kann die entgegengesetzte Funktion der init-Methode ausführen und Ressourcen freigeben, die vom Filter-Objekt geöffnet wurden, wie das Schließen von Datenbankverbindungen und IO-Streams.


IV. FilterChain-Schnittstelle

Diese Schnittstelle dient dazu, die Methoden zu definieren, die ein Filterkettenobjekt nach außen bereitstellen sollte. Diese Schnittstelle definiert nur eine doFilter-Methode.

public void doFilter(ServletRequest request, ServletResponse response) throws java.io.IOException.ServletException

Die doFilter-Methode der FilterChain-Schnittstelle wird verwendet, um den Web-Container zu benachrichtigen, die Anfrage zur Verarbeitung an den nächsten Filter in der Filterkette weiterzugeben. Wenn das aktuelle Filter-Objekt, das diese Methode aufruft, der letzte Filter in der Filterkette ist, wird die Anfrage zur Verarbeitung an das Ziel-Servlet-Programm übergeben.


V. FilterConfig-Schnittstelle

  • 1. Wie gewöhnliche Servlet-Programme müssen auch Filter-Programme möglicherweise auf den Servlet-Container zugreifen. Die Servlet-Spezifikation kapselt das ServletContext-Objekt und die Konfigurationsparameterinformationen des Filters in einem Objekt namens FilterConfig.
  • 2. Das FilterConfig-Interface wird verwendet, um die Methoden zu definieren, die ein FilterConfig-Objekt nach außen bereitstellen sollte, damit in einem Filter-Programm diese Methoden aufgerufen werden können, um das ServletContext-Objekt sowie den benutzerfreundlichen Namen und die für den Filter in der Datei web.xml festgelegten Initialisierungsparameter abzurufen.
  • 3. Vom FilterConfig-Interface definierte Methoden:

    • Methode getFilterName: gibt den im Element <filter-name> festgelegten Wert zurück.

    • Methode getServletContext: gibt eine Referenz auf das im FilterConfig-Objekt gekapselte ServletContext-Objekt zurück.

    • Methode getInitParameter: wird verwendet, um den Wert eines Initialisierungsparameters mit einem angegebenen Namen zurückzugeben, der für den Filter in der Datei web.xml festgelegt wurde.

    • Methode getInitParameterNames: gibt ein Enumeration-Sammlungsobjekt zurück.


VI. Registrierung und Mapping eines Filters

1. Registrieren eines Filters

Ein <filter>-Element wird verwendet, um einen Filter zu registrieren. Davon ist das <filter-name>-Element erforderlich, das <filter-class>-Element ebenfalls erforderlich und das <init-param>-Element optional; es kann mehrere <init-param>-Elemente geben.

<filter>
    <filter-name>FirstFilter</filter-name>
    <filter-class>FirstFilter</filter-class>
    <init-param>
        <param-name>encoding</param-name>
        <param-value>GB2312</param-value>
    </init-param>
</filter>

2. Mapping eines Filters

Das <filter-mapping>-Element wird verwendet, um die Ressourcen festzulegen, für deren Abfangen ein Filter zuständig ist. Die von einem Filter abgefangenen Ressourcen können auf zwei Arten angegeben werden: der Zugriffsanfragepfad der Ressource und der Servlet-Name.

Erste Methode: den Zugriffspfad der Ressource angeben

<filter-mapping>
    <filter-name>FirstFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

Die Einstellung des Zugriffspfads im Element <url-pattern> folgt der Servlet-URL-Zuordnungsspezifikation.

  • /*Gibt an, dass alle Zugriffsanforderungen abgefangen werden.
  • /filter/*Gibt an, dass alle Zugriffsanforderungen unter dem Verzeichnis filter abgefangen werden, wie z. B.: http://localhost:8888/testFilter_001/filter/xxxxxx.
  • /test.htmlGibt an, dass Zugriffsanforderungen mit test.html als Ressourcennamen im Stammverzeichnis abgefangen werden; der Zugriffslink ist dann nur: http://localhost:8888/test.html.

Zweite Methode: den Servlet-Namen angeben

<filter-mapping>
    <filter-name>FirstFilter</filter-name>
    <servlet-name>default></servlet-name>
    <dispatcher>INCLUDE</dispatcher>
    <dispatcher>REQUEST</dispatcher>
</filter-mapping>

(1) Das Element <servlet-name> und das Element <url-pattern> schließen sich gegenseitig aus; ihr Wert ist der registrierte Name eines Servlets in der Datei web.xml.

(2) Das Element <dispatcher> hat vier mögliche Werte: REQUEST, INCLUDE, FORWARD, ERROR, die jeweils den vier Arten entsprechen, wie der Servlet-Container Ressourcen aufruft:

  • Wird über normale Zugriffsanforderungen aufgerufen;

  • Wird über die Methode RequestDispatcher.include aufgerufen;

  • Wird über die Methode RequestDispatcher.forward aufgerufen;

  • Wird als Fehlerantwortressource aufgerufen.

Wenn das untergeordnete Element <dispatcher> nicht festgelegt ist, entspricht es dem Fall REQUEST. Es können auch mehrere untergeordnete Elemente <dispatcher> festgelegt werden, um anzugeben, dass der Filter mehrere Aufrufmethoden der Ressource abfängt.


VII. Filter-Programmbeispiel

FitstFilter.java

import java.io.IOException; import java.io.PrintWriter; import java.util.Enumeration; import javax.servlet.Filter; import javax.servlet.FilterChain; import javax.servlet.FilterConfig; import javax.servlet.ServletException; import javax.servlet.ServletRequest; import javax.servlet.ServletResponse; import javax.servlet.http.HttpServletRequest; public class FirstFilter implements Filter { private FilterConfig filterConfig = null; String paramValue = null; @Override public void init(FilterConfig filterConfig) throws ServletException { this.filterConfig = filterConfig; paramValue = filterConfig.getInitParameter("encoding"); } @Override public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { System.out.println("Header beginnen-------------------"); Enumeration<?> headerNames = ((HttpServletRequest)request).getHeaderNames(); while(headerNames.hasMoreElements()) { String headerName = (String)headerNames.nextElement(); System.out.println(headerName + ": " + ((HttpServletRequest)request).getHeader(headerName)); } System.out.println("Header beenden-------------------"); //Antwortinhalt vor dem Aufruf des Ziels schreiben response.setContentType("text/html; charset=gb2312"); PrintWriter out = response.getWriter(); out.println("Die IP-Adresse ist:" + request.getRemoteHost() + "<br>"); chain.doFilter(request, response); //Antwortinhalt nach der Rückkehr des Ziels schreiben out.println("<br>Der Wert des Initialisierungsparameters namens encoding ist:" + paramValue); out.println("<br>Der reale Pfad der aktuellen Webanwendung ist:" + filterConfig.getServletContext().getRealPath("/")); //out.println("<br>Die Datei test.html wurde geändert!"); } @Override public void destroy() { this.filterConfig = null; } }

web.xml

<filter> <filter-name>FirstFilter</filter-name> <filter-class>FirstFilter</filter-class> <init-param> <param-name>encoding</param-name> <param-value>GB2312</param-value> </init-param> </filter> <filter-mapping> <filter-name>FirstFilter</filter-name> <url-pattern>/*</url-pattern> </filter-mapping>

test.html (befindet sich im Verzeichnis filter unter dem WebContent-Pfad)

<html> <head> <meta charset="UTF-8"> <title>Titel hier einfügen</title> </head> <body>Dies ist der ursprüngliche Inhalt der Seite test.html!</body> </html>

Zugriff:http://localhost:8888/testFilter_001/filter/test.html

Artikelquelle: https://my.oschina.net/u/1171518/blog/265467