Was ist ein Filter?
Filter geben einem Web-Entwickler die Möglichkeit Http-Requests zu transformieren und bei Bedarf den Http-Response Stream zu modifizieren. Filter fungieren dabei als Pre- bzw. Post-Prozessoren.

Filter arbeiten ähnlich wie Listener und können nicht direkt von einem Web-Client aufgerufen werden. Filter können sowohl den Http-Header als auch den Content eines Requests bzw. der Response verändern/erweitern.

Filter sind seit der Servlet Spezifikation 2.3 Teil des Servlet Standards.

package de.jsp.develop.filter;

import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
import java.io.*;

/**
* Simple trace filter which prints
* output on web-server console.
*/
public class TraceFilter implements Filter {

  /**
  * Initialize simple trace filter
  * @param filter config
  */
  public void init(FilterConfig config) throws ServletException {
  }

  /**
  * Deinitialize simple trace filter 
  */
  public void destroy() {
  }

  /**
  * Handle the tracing (do filter operation)
  * @param servlet request
  * @param servlet response
  * @param filter chain
  */
  public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
 
    // print remote hostname
    System.out.println("Remote host = " + ((HttpServletRequest) request).getRemoteHost());
 
    // print further information
    // ...

    chain.doFilter(request,response);
  }
}

Eintrag in web.xml:
----------------------------

<filter>
<filter-name>TraceFilter</filter-name>
<filter-class>de.jsp.develop.filter.TraceFilter</filter-class>
</filter>

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

Autor: shark

Wie filtere ich den ServletResponse Stream?
Der HttpServletResponse kann mit einem Response-Wrapper gefiltert und zum Beispiel in eine Datei gesplittet bzw. umgeleitet werden.

Das nachfolgende Filter Source Code Beispiel zeigt, wie man den Response Stream in eine Datei ausgeben kann. Die Datei existiert dabei nur temporär und wird bei jedem Request überschrieben. Denkbar ist in diesem Kontext in den WebContent (HTML-, JSP-Seite, etc.) ein Hidden Form Field mit dem Wert - Dateiname - zu integrieren, dass in dem Filter übergebenen ServletRequest-Objekt ausgelesen und in der Folge als Dateiname für die temporäre Datei eingesetzt wird.

/*
* TargetFilter.java
* created 05.07.2004
*/
package de.jsp.develop.filter;

import java.io.CharArrayWriter;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintWriter;

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.HttpServlet;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;

/**
* simple filter class to print response stream in fixed
* - output.html - file. the - output.html - file is overriden
* by each request, therefore request based renaming of - output.html -
* has to be implemented and is not part of this source.
*
* the following entries has to be set in web.xml:
* --------------------------------------------------------------------
*
*  <filter>
*     <filter-name>TargetFilter</filter-name>
*     <display-name>TargetFilter</display-name>
*     <filter-class>de.jsp.develop.filter.TargetFilter</filter-class>
*  </filter>
*   
*  <filter-mapping>
*     <filter-name>TargetFilter</filter-name>
*     <url-pattern>/*</url-pattern>
*  </filter-mapping>
*
*  url-mappings: /* for all requests
*                /*.jsp only for jsp-pages
*/
public class TargetFilter extends HttpServlet implements Filter {
   
   /**
    * inner class to handle response stream wrapping
    */   
   private class CharArrayServletResponseWrapper extends HttpServletResponseWrapper {
      
      /**
       * char array writer
       */
      final private CharArrayWriter writer = new CharArrayWriter();

        /**
        * constructor
        * @param response
        */
      public CharArrayServletResponseWrapper(final HttpServletResponse response) {
         super(response);
      }

        /**
        * get writer
        */
      public final PrintWriter getWriter() throws java.io.IOException {
         return new PrintWriter(writer);
      }

        /**
        * to string
        */
      public final String toString() {
        return writer.toString();
      }
   }
   
   /**
    * fixed filename for html-output
    *------------------------------------
    * The directory - c:\tmp\ - has to be
    * available for output streaming!
    * -----------------------------------
    */
   private final String OUTPUT_FILENAME = "c:\\tmp\\output.html";
   
   /**
    * do filter
    * @param servlet request
    * @param servlet response
    * @param filter chain
    * @throws IOException, ServletException
    */      
   public void doFilter(final ServletRequest request,
                       final ServletResponse response,
                       final FilterChain filterChain) throws IOException, ServletException {
       
        // create response wrapper              
        final CharArrayServletResponseWrapper wrapper = new CharArrayServletResponseWrapper((HttpServletResponse) response);
       
        // create the output stream       
      final FileOutputStream stream = new FileOutputStream(OUTPUT_FILENAME);
      
      // do the filter chain      
      filterChain.doFilter(request, wrapper);
      
      // get the response stream as string
      final String responseStr = wrapper.toString();
                     
      // write to the filesystem                        
      stream.write(responseStr.getBytes());
                  
      // write the response stream            
      response.setContentLength(responseStr.length());
      response.getWriter().write(responseStr);                  
    }

  /**
   * init method
   * @param config
   * @throws ServletException
   */
   public void init(FilterConfig config) throws ServletException {}
   
   /**
    * destroy method
    */
    public void destroy() {}
}

Autor: shark

Wie implementiert man einen einfachen Filter in dem nach Ablauf einer Session und späterer Benutzerinteraktion automatisch zu einer definierten Session Timeout-Seite gesprungen wird?
Der nachfolgende Filter prüft mittels "((HttpServletRequest) request).getSession(false))" ob die Session noch gültig ist und verzweigt im Falle das die Session nicht mehr gültig ist zu einer Session Timeout-Seite:

import java.io.IOException;
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;

/**
* Simple filter to handle session
* timeout page dispatching
*/
public class SessionListener implements Filter  {

    /**
    * session timeout page
    */
    private final String SESSION_TIMEOUT_PAGE = "sessionTimeout.jsp";
   
    /**
    * do filter method
    * @param servlet request
    * @param servlet response
    * @param filter chain
    */
  public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
    throws ServletException, IOException {
       
    // check session availability                 
    if(null == ((HttpServletRequest) request).getSession(false)) {
       
        // dispatch to session timeout page, due to the session is not available 
        request.getRequestDispatcher(SESSION_TIMEOUT_PAGE).forward(request,response);
    } else {
        chain.doFilter(request,response);
    }
  }
     
  public void destroy() {/* nothing to do */}
  public void init(FilterConfig arg0) throws ServletException {/* nothing to do */}
}

Autor: shark

Hinweis: Auf dieser Seite liegen Links zu anderen Seiten im Internet. Für alle diese Links gilt: Wir betonen ausdrücklich, daß wir keinerlei Einfluß auf die Gestaltung und die Inhalte der gelinkten Seiten haben. Deshalb distanzieren wir uns hiermit ausdrücklich von allen Inhalten aller gelinkten Seiten auf dieser Homepage und machen uns ihre Inhalte nicht zueigen. Diese Erklärung gilt für alle auf unserer Homepage angebrachten Links

Redaktion/Betreiber von JSP-Develop übernehmen keinerlei Gewährleistung und Verantwortung für die Richtig- und/oder Vollständigkeit von den auf den Webseiten JSP-Develop veröffentlichten Source Codes. Die Verantwortung der Verwendung/Anwendung sowie etwaige Modifikation der hier veröffentlichten Sourcen obliegt einzig dem Benutzer der Webseite, welche die veröffentlichten Sourcen in einer Applikation/Anwendung einsetzt. Durch das Kopieren und/oder Benutzen der Sourcen in einer Applikation/Anwendung bzw. etwaigen Abschriften wird dieser Rechtshinweis anerkannt.

Java, JSP, JavaServer Pages, J2EE, EJB, JDBC, JNDI, JTA, Sun, Sun Microsystems are trademarks or registered trademarks of Sun Microsystems, Inc. in the United States and in other countries. IBM, WebSphere are trademarks or registered trademarks of International Business Machines Corporation. Other trademarks and registered trademarks are the property of their respective owners.