Les filtres sont exécutés par le conteneur de servlets suite à la réception d'une requête http.
Le fichier de déploiement web.xml définit les patrons des requêtes http qui déclencheront l'exécution des filtres.

À noter que Les filtres sont exécutés avant l'exécution des Servlets.
Et ils sont responsables de passer le contrôle au prochain filtre ou Servlet.

Les filtres sont principalement utilisés pour intercepter une requête http et faire un traitement avant l'exécution de la cible de la requête http (typiquement une Servlet ou une page JSP) et/ou avant le transfert de la réponse au client.

requête http doFilter doFilter doFilter +--------+ ==============> +------------+ ==========> +------------+ ==========> +------------+ ==========> +-------------+ | Client | | Filtre (1) | | Filtre (2) | | Filtre (3) | | Servlet (1) | +--------+ <============== +------------+ <========== +------------+ <========== +------------+ <========== +-------------+ réponse http
Dans l'exemple précédent, un client (typiquement le navigateur) envoie une requête http qui cible la Servlet (1).
Le conteneur de servlets reconnaît qu'il y a trois filtres qui correspondent à la requête http.
L'exécution des trois filtres est faite selon leurs ordres de définition dans le fichier de déploiement.
Chaque filtre exécuté décide si le contrôle peut être passé ou non à la prochaine ressource (filtre ou Servlet).
Une fois la dernière ressource (filtre ou Servlet) est exécutée, le contrôle est retourné aux ressources précédentes dans l'ordre inverse (la JVM va retourner à la méthode appelante dans la pile d'exécution et continuer l'exécution du code et ainsi de suite jusqu'à la méthode principale qui a déclenchée la chaîne d'exécution).

1. Chargement de la classe du filtre en mémoire
   Une classe d'un filtre peut être chargée en mémoire :
   - au démarrage du conteneur de servlets,
   - au déploiement de l'application,
   - à la réception de la première requête qui nécessite l'exécution du filtre,
   - ou à n'importe quel moment entre le démarrage du conteneur de servlets et la réception de la première requête qui nécessite l'exécution du filtre ; le conteneur de servlets, en absence de configuration spéciale, lui seul décide quand !
   
   Après le chargement de la classe :
   - tous les champs statiques de la classe seront initialisés (exemple : static String myVar1 = "";)
   - tous les blocs de code statiques de la classe seront exécutés (exemple : static { /* doSomeThing */ }).
   
2. Instanciation de la classe du filtre
   Se produit juste après le chargement de la classe ou si le conteneur de servlets décide de créer une nouvelle instance du filtre.
   
   Après l'instanciation de la classe :
   - tous les champs d'instance de la classe seront initialisés
   - tous les blocs de code d'instance de la classe seront exécutés.
   - le constructeur sans argument (si définit) sera aussi invoqué.
   
   Rappel : Si le constructeur sans argument n'est pas défini dans le code, alors il sera par défaut ajouté dans le bytecode de la classe à condition que le code ne déclare pas un constructeur avec des arguments.
   
3. Invocation de la méthode init()
   Se produit juste après l'instanciation de la classe.
   Elle est appelée une et une seule fois pour une instance.
   Vous pouvez écrire un code pour sauvegarder l'instance du FilterConfig (envoyé en paramètre à l'appel de la méthode) dans une variable d'instance et ainsi l'utiliser pour les différents de la méthode doFilter du filtre.
   
4. Invocation de la méthode doFilter()
   Exécutée à la réception de chaque nouvelle requête sur le filtre.
   Le paramètre de type FilterChain permet de passer le contrôle au prochain Filtre si présent, sinon le contrôle passera à la ressource ciblée par la requête http (servlet, jsp, ...).
   Si la méthode doFilter de la classe FilterChain n'est pas appelée par le filtre, alors le traitement de la requête http s'arrêtera et la réponse sera retournée au client.
   
5. Invocation de la méthode destroy()
   Se produit quand le conteneur de servlets décide de ne plus utiliser l'instance d'un filtre :
   Possiblement à l'arrêt du conteneur de servlets, à l'arrêt de l'application, ou à n'importe quel moment où le conteneur de servlets décide de détruire l'instance parce qu'il est n'est plus utilisé ou juste pour libérer temporairement de la mémoire.
   

Exemple :
package com.mtitek.filters.test1; 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; public class MyFilter1 implements Filter { FilterConfig filterConfig; @Override public void init(FilterConfig filterConfig) throws ServletException { this.filterConfig = filterConfig; System.out.println("com.mtitek.filters.test1.MyFilter1 - " + this.filterConfig.getFilterName() + " : init(FilterConfig)"); } @Override public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException { System.out.println("com.mtitek.filters.test1.MyFilter1 - " + this.filterConfig.getFilterName() + " : doFilter(ServletRequest, ServletResponse, FilterChain) : Start"); filterChain.doFilter(servletRequest, servletResponse); System.out.println("com.mtitek.filters.test1.MyFilter1 - " + this.filterConfig.getFilterName() + " : doFilter(ServletRequest, ServletResponse, FilterChain) : End"); } @Override public void destroy() { System.out.println("com.mtitek.filters.test1.MyFilter1 - " + this.filterConfig.getFilterName() + " : destroy()"); } }
La classe FilterConfig definit les méthodes suivantes :
- String getFilterName() : retourne le nom du filtre tel que définit dans le fichier du déploiement.
- ServletContext getServletContext() : retourne une référence vers le scope APPLICATION.
- String getInitParameter(String) : retourne la valeur du paramètre d'initialisation du filtre.
- Enumeration<String> getInitParameterNames() : retourne une Enumération de tous les paramètres d'initialisation du filtre.

Les filtres sont exécutés par le conteneur de servlets suite à la réception d'une requête http qui match avec un des patrons des requêtes définis dans le fichier de déploiement.
Les deux principaux éléments qui concernent la configuration des filtres sont : <filter-mapping> et <filter>.
Si un match est reconnu pour un élément <filter-mapping>, le conteneur de Servlet cherchera un élément <filter> dont le nom correspond à celui de l'élément <filter-mapping>.

• L'élément <filter-mapping>
  <filter-mapping> <filter-name> <!-- toujours 1 --> <url-pattern> OR <servlet-name> <!-- toujours 1 --> <dispatcher> <!-- [0 à 4] {REQUEST, FORWARD, INCLUDE, ERROR} -->
  
  • La valeur de l'élément <filter-name> est un nom logique attribué au filtre.
    
    
  • Si l'élément <url-pattern> est spécifié alors le filtre est exécuté chaque fois qu'une requête http match avec la valeur de cet élément.
    
    
  • Si l'élément <servlet-name> est spécifié alors le filtre est exécuté chaque fois que la valeur de cet élément match avec la valeur du sous-élément <servlet-name> de l'élément <servlet> et que cette dernière match avec la requête http.
    
    
  • La valeur de l'élément <dispatcher> permet de contrôler l'origine de la requête http qui déclenchera l'exécution du filtre. Il y a quatre options possibles :
    
    • REQUEST (valeur par défaut) : le filtre sera exécuté pour les requêtes http externes provenant du client.
      
      
    • FORWARD : le filtre sera exécuté pour les requêtes http provenant d'une redirection (suite à l'appel de la méthode forward de la classe RequestDispatcher).
      
      
    • INCLUDE : le filtre sera exécuté pour les requêtes http provenant d'une inclusion (suite à l'appel de la méthode include de la classe RequestDispatcher).
      
      
    • ERROR : le filtre sera exécuté pour les requêtes http internes qui ciblent une page specifiée dans l'élément <error-page>.
      
      
    Il est possible de combiner plusieurs options en répétant l'élément <dispatcher> pour chaque option nécessaire. De cette façon le filtre va être exécuté pour chacune des options configurées.
    
    
  
  
• L'élément <filter>
  <filter> <description> <!-- 0 ou plusieurs --> <display-name> <!-- 0 ou plusieurs --> <icon> <!-- 0 ou plusieurs --> <small-icon> <!-- 0 ou 1 --> <large-icon> <!-- 0 ou 1 --> <filter-name> <!-- toujours 1 --> <filter-class> <!-- toujours 1 --> <init-param> <!-- 0 ou plusieurs --> <description> <!-- 0 ou 1 --> <param-name> <!-- toujours 1 --> <param-value> <!-- toujours 1 -->
  - La valeur de l'élément <filter-name> doit correspondre à la valeur du sous-élément <filter-name> de l'élément <filter-mapping>.
  
  - La valeur de l'élément <filter-class> doit correspondre au nom complet de la classe du filtre.
  
  

Un filtre est exécuté si la requête http match avec la valeur de l'élément <url-pattern> ou si la requête http match avec la config d'une Servlet dont le nom est spécifié dans l'élément <servlet>.
Il peut y avoir plusieurs filtres qui correspondent à la requête http.
L'ordre d'exécution des filtres est déterminé comme suit:

1. En premier, seront exécutés les filtres dont la valeur de l'élément <url-pattern> match avec la requête http.
   L'ordre d'exécution de ces filtres est déterminé en fonction de l'ordre de déclaration des éléments <filter-mapping> dans le fichier de déploiement.
   
   
2. En deuxième, seront exécutés les filtres dont la valeur de l'élément <servlet-name> match avec la Servlet cible de la requête http.
   L'ordre d'exécution de ces filtres est déterminé en fonction de l'ordre de déclaration des éléments <filter-mapping> dans le fichier de déploiement.
   
   

Dans l'exemple suivant, si la requête http est : http://localhost:8181/test/MyServlet1
Alors les filtres seront exécutés dans l'ordre suivant : MyFilter1, MyFilter2, MyFilter3
<filter-mapping> <filter-name>MyFilter1</filter-name> <url-pattern>/*</url-pattern> </filter-mapping> <filter-mapping> <filter-name>MyFilter3</filter-name> <servlet-name>MyServlet1</servlet-name> </filter-mapping> <filter-mapping> <filter-name>MyFilter2</filter-name> <url-pattern>/*</url-pattern> </filter-mapping>

- Lecture des paramètres d'initialisation :
. String getInitParameter(String) . Enumeration<String> getInitParameterNames()
- Saisie des paramètres d'initialisation dans le fichier "web.xml" :
<init-param> <param-name>PARAM_NAME</param-name> <param-value>PARAM_VALUE</param-value> </init-param>
- Exemple :

• web.xml :
  <filter> <filter-name>MyFilter1</filter-name> <filter-class>com.mtitek.filters.test1.MyFilter1</filter-class> <init-param> <param-name>filter1_paramname_1</param-name> <param-value>filter1_paramvalue_1</param-value> </init-param> <init-param> <param-name>filter1_paramname_2</param-name> <param-value>filter1_paramvalue_2</param-value> </init-param> </filter>
  
  
• MyFilter1 :
  package com.mtitek.filters.test1; import java.io.IOException; 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; public class MyFilter1 implements Filter { FilterConfig filterConfig; @Override public void init(FilterConfig filterConfig) throws ServletException { this.filterConfig = filterConfig; } @Override public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException { Enumeration<String> initParameterNames = this.filterConfig.getInitParameterNames(); while (initParameterNames.hasMoreElements()) { String initParameterName = (String) initParameterNames.nextElement(); String initParameterValue = this.filterConfig.getInitParameter(initParameterName); System.out.println(initParameterName + " : " + initParameterValue); } filterChain.doFilter(servletRequest, servletResponse); } @Override public void destroy() { } }
  
  
• tomcat-stdout :
  filter1_paramname_1 : filter1_paramvalue_1 filter1_paramname_2 : filter1_paramvalue_2