Filter

Filter sind Querschnittkomponenten, die normalerweise auf eine ganze Reihe möglicher Request-URLs, wie zum Beispiel alle Dateien bestimmter Verzeichnisse oder alle *.zip oder *.jsp Dateien einer Webapplikation angewendet werden. Ihre Aufgabe besteht in der Regel nicht darin, Daten an den Client auszugeben. Vielmehr erfüllen Sie zusätzliche Aufgaben, die im Prinzip auch in der JSP oder dem Servlet erfüllt werden könnten. Wenn aber eine Funktionalität in einer ganzen Reihe von Ressourcen zur Verfügung stehen soll, ist es oft einfacher und flexibler, dies mittels Filter zu lösen.

Typische Aufgaben von Filtern sind:

• die Zugriffskontrolle auf bestimmte Bereiche der Website,
• Statistik, Logging und UserTracking,
• Komprimierung und Verschlüsselung von Daten.

Wir werden im Folgenden einen Filter entwickeln, der uns bei jedem Request die HTTP Header sowie ggf. die Request-Parameter anzeigt. Dies kann ein nützliches Werkzeug sein, wenn wir dynamische Webseiten entwickeln.

package jspkurs.bsp.kap4;

import java.io.IOException;
import java.util.Enumeration;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;

/**
 * Dies ist ein kleiner Filter, der nützlich zum 
 * Entwickeln von Webapplikationen ist.
 * Er zeigt Informationen über den Request an.
 *
 * @author Hans Joachim Herbertz
 * @created 05.03.2003
 * 
 * Ein Filter implementiert das Interface 
 * javax.servlet.Filter.
 * Darin sind die Methoden init(..), destroy(..) und doFilter(..) 
 * definiert, die wir implementieren müssen.
 */
public class DebugFilter implements Filter {

	/**
	 * Ab JDK 1.4 steht das Logging Framework zur Verfügung.
	 * Hiermit lässt sich das Verhalten einer Application sehr 
	 * feingesteuert Loggen. 
	 * Falls Sie noch nicht JDK 1.4 verwenden, ersetzen Sie den
	 * Logger unten durch: System.out.println(..);*/
	private Logger logger=Logger.getLogger(getClass().getName());
	
	
	/**
	 * Die init(..) Methode macht hier zwar nichts,
	 * aber wir müssen sie schreiben, da sie im Interface 
	 * javax.servlet.Filter, das wir in dieser Klasse implementieren,
	 * definiert ist.
	 * 
	 * init() wird wie bei Servlets bei der Instanzierung 
	 * (Laden des Filters in den Speicher) aufgerufen.
	 *
	 * @see javax.servlet.Filter#init(FilterConfig)
	 */
	public void init(FilterConfig arg0) throws ServletException {
	}

	/**
	 * doFilter(..) wird aufgerufen, wenn der Filter auf einen Request
	 * angewendet wird. Hier bringen wir gewöhnlich den eigentlichen
	 * Arbeitscode unter.
	 * 
	 * @see javax.servlet.Filter#doFilter(ServletRequest, ServletResponse, FilterChain)
	 */
	public void doFilter(
		ServletRequest request,
		ServletResponse response,
		FilterChain chain)
		throws IOException, ServletException {

			// Das Request Objekt, das wir bekommen, ist von Typ
			// ServletRequst, da prizipiell auch ein anderes Protokoll
			// als HTTP (z.B. FTP) verwendet werden kann. Wir gehen 
			// aber von HTTP aus und casten mutig nach HttpServletRequest.
			HttpServletRequest httpRequest=(HttpServletRequest)request;

			// Wenn Sie eine Zeichenkette zusammenbauen,
			// ist StringBuffer performater als String
			StringBuffer buffer=new StringBuffer();

			// url loggen
			buffer.append("\n\nURL:\n");
			buffer.append(httpRequest.getRequestURL());
			buffer.append('\n');
			
			// headers loggen
			buffer.append("\nHeaders:\n");
			// java.util.Enumeration ist der Vorgänger von java.util.Iterator
			// und macht im Grunde das Gleiche, hat aber etwas veralterte 
			// Methodennamen.
			Enumeration en=httpRequest.getHeaderNames();
			while (en.hasMoreElements()) {
				String key=(String)en.nextElement();
				buffer.append(key);
				buffer.append(": ");
				buffer.append(httpRequest.getHeader(key));
				buffer.append('\n');
			}
			buffer.append('\n');

			// parameters	
			buffer.append("Parameters:\n");
			en=httpRequest.getParameterNames();
			while (en.hasMoreElements()) {
				String key=(String)en.nextElement();
				buffer.append(key);
				buffer.append(": ");
				buffer.append(httpRequest.getParameter(key));
				buffer.append('\n');
			}
			buffer.append('\n');

			logger.log(Level.INFO,buffer.toString());
			
			// Kommentieren Sie den Logger aus, wenn Sie jdk1.3 
			// verwenden und benutzen Sie dies:
			// System.out.println(buffer.toString());
	
			// FilterChain ist die Kette aller Filter,
			// die dieser Request durchlaufen muss. 
			// Das Objekt wurde uns ebenfalls beim Methodenaufruf
			// übergeben. Wir zeigen damit einem möglichen
			// weiterem Filter, dass wir fertig sind und er 
			// dran ist.
			chain.doFilter(request,response);

			// Nach dem Aufruf des letzten Filters kehrt die
			// Programmausführung hierher zurück.
			// Bedenken Sie dies, wenn Sie bedingte
			// Aufrufe von Filtern machen. Es ist eine
			// tückische Fehlerquelle irrtümlich anzunehmen,
			// nach chain.doFilter(..) hat sich die
			// Sache erledigt.
			// Dieser Code hier wird noch ausgeführt!			
			return;
	}

	/**
	 * Wird beim entladen des Filters aus dem Speicher
	 * aufgrufen.
	 * @see javax.servlet.Filter#destroy()
	 */
	public void destroy() {
	}

}

Alle Filter implementieren das Interface javax.servlet.Filter (Zeile 24). Darin sind die Methoden init(..), destroy(..) und doFilter(..) definiert, die wir implementieren müssen. init(..) (Zeile 46) und destroy(..) (Zeile 135) werden wie bei Servlets vom Container aufgerufen, wenn der Filter erzeugt, bzw. aus dem Speicher entladen wird. Sie können dort entsprechende Initialisierung- bzw. Finalisierungsroutinen unterbringen. In unserem Beispiel bleiben sie leer, da wir sie nicht benötigen.

Die Methode doFilter(..) (Zeile 57) wird vom Container jedes Mal aufgerufen, wenn eine URL aufgerufen wurde, mit der dieser Filter verknüpft ist. Hier müssen wir das unterbringen, was der Filter tun soll.

Wie Sie sehen, bekommen wir mit doFilter(..) vom Container drei Objekte übergeben: Request, Response und FilterChain.

javax.servlet.FilterChain ist eine Abstraktion einer Reihe von hintereinandergeschalteter Filter, die nacheinander ausgeführt werden. Tatsächlich können Sie mehrere Filter auf einer URL ausführen. Das Objekt wird nur dazu zu gebraucht, den nächsten Filter in der Kette aufzurufen:

chain.doFilter(request,response);

Der Request, den wir bekommen, ist vom Type javax.servlet.ServletRequest. Wenn Sie sich die Dokumentation dazu anschauen bemerken Sie unweigerlich, dass wir es schwer haben werden, hier irgendwelche Informationen über den HTTP-Header herauszuholen. Das liegt daran, dass ServletRequest nicht nur für HTTP-Requests geschrieben wurde, sondern auch für andere Protokolle (z.B. FTP, IIOP usw.). ServletRequest enthält daher keine Informationen über Dinge, die typisch für ein bestimmtes Protokoll sind, wie z.B. HTTP-Header.

Da wir davon ausgehen können, dass unser Client mit HTTP anfragt (schiesslicht ist Tomcat ein HTTP-Server), casten wir ohne besondere Maßnahmen der Request nach HttpServletRequest:

HttpServletRequest httpRequest=(HttpServletRequest)request;

Nun können wir die benötigten Daten aus dem Request auslesen und ausgeben (Zeilen 71 bis 102).

Wie ein Servlet wird auch ein Filter in der web.xml konfiguriert. Die Einträge sind denen bei Servlets sehr ähnlich. Zunächst definieren Sie den Filter mit Name und Klasse:

       DebugFilter
       jspkurs.bsp.kap4.DebugFilter
 

Anschließend geben Sie an, auf welche URLs der Filter angewendet werden soll. Sie können dabei den Asterix (*) innerhalb gewisser Grenzen als Wildcard benutzen:

    
        DebugFilter
        /bsp/nodir/*

Ändern Sie das Filter mapping auf: Alle Beispiele der Webapplikation (also alles unterhalb von "/jspkurs/bsp". Sie könne auch bestimmte oder bestimmte Dateien (<url-pattern>*.jsp</url-pattern>) wie alle JSP wählen. Was mit Tomcat zur Zeit noch nicht geht, sind z.B. alle JSP eines Verzeichnisses; das wird aber von anderen Server bereits unterstützt.

Wenn Sie einen Filter auf zwei unabhängige Verzeichnisse setzen wollen, müssen Sie zwei komplette filter-mappings definieren. Sie können nichtden url-pattern Parameter zweimal in einem Mapping angeben.