Discours sur le filtre Filter en Java

Introduction au Filter

Le Filter, également appelé filtre, est l'une des techniques les plus pratiques de la technologie Servlet. Les développeurs Web utilisent la technologie Filter pour intercepter tous les resources gérés par le serveur web : par exemple, Jsp, Servlet, fichiers d'images statiques ou fichiers html statiques, etc., afin de réaliser des fonctionnalités spéciales. Par exemple, la contrôle d'accès aux niveaux d'URL, le filtrage des mots sensibles, la compression des informations de réponse, etc. des fonctionnalités avancées.

Il est principalement utilisé pour la prétraitement des demandes des utilisateurs et peut également effectuer des traitements après la réponse du serveur. Le flux complet d'utilisation du Filter : le Filter effectue le prétraitement des demandes des utilisateurs, puis transmet la demande au Servlet pour traitement et génération de la réponse, et enfin, le Filter effectue le traitement après la réponse du serveur.

Fonction du Filter

Intercepter l'HttpServletRequest avant qu'il ne soit envoyé au Servlet. Selon les besoins, vérifier l'HttpServletRequest et modifier l'en-tête et les données de l'HttpServletRequest.

Intercepter l'HttpServletResponse avant qu'elle ne soit envoyée au client. Selon les besoins, vérifier l'HttpServletResponse et modifier l'en-tête et les données de l'HttpServletResponse.

Comment utiliser Filter pour réaliser la fonction d'interception

L'interface Filter contient une méthode doFilter. Lorsque les développeurs ont terminé l'écriture du Filter et configuré l'interception de quel resource web, le serveur web appelle d'abord la méthode doFilter du Filter avant de chaque appel à la méthode service du resource web. Par conséquent, il est possible d'atteindre les objectifs suivants en écrivant du code dans cette méthode :

Exécuter un segment de code avant d'appeler la ressource cible.

Appeler ou non la ressource cible (c'est-à-dire permettre ou non à l'utilisateur d'accéder au resource web).

Le serveur web, lors de l'appel à la méthode doFilter, transmet un objet filterChain, qui est l'un des objets les plus importants de l'interface filter. Il fournit également une méthode doFilter, que les développeurs peuvent appeler ou non selon leurs besoins. Si cette méthode est appelée, le serveur web appellera la méthode service du resource web, c'est-à-dire que le resource web sera visité; sinon, le resource web ne sera pas visité.

Deux étapes pour le développement de Filter

Écrivez une classe java qui implémente l'interface Filter et implémente sa méthode doFilter.

　Enregistrez la classe filter écrite dans le fichier web.xml et configurez les ressources qu'elle peut intercepter.

Introduction des différents nœuds de configuration web.xml :

• <filter> spécifie un filtre.
• <filter-name> est utilisé pour spécifier un nom pour le filtre, le contenu de cet élément ne peut pas être vide.
• <filter-class> est utilisé pour spécifier le nom complet qualifié de la classe du filtre.
• <init-param> est utilisé pour spécifier les paramètres d'initialisation du filtre, son élément fils <param-name> spécifie le nom du paramètre, <param-value> spécifie la valeur du paramètre.
• Dans le filtre, l'objet FilterConfig peut être utilisé pour accéder aux paramètres d'initialisation.
• <filter-mapping> est utilisé pour configurer la ressource interceptée par un Filter. Une ressource interceptée par un Filter peut être spécifiée de deux manières : le nom du Servlet et l'URL d'accès à la ressource
• <filter-name> est utilisé pour configurer le nom d'enregistrement du filtre. Cette valeur doit être le nom du filtre déclaré dans l'élément <filter>.
• <url-pattern> configure l'URL de requête拦截 par le filtre (style d'URL associé au filtre)
• <servlet-name> spécifie le nom du Servlet intercepté par le filtre.
• <dispatcher> spécifie la manière dont le conteneur Servlet appelle les ressources interceptées par le filtre, qui peut être l'un des suivants : REQUEST, INCLUDE, FORWARD et ERROR, par défaut REQUEST. L'utilisateur peut définir plusieurs éléments <dispatcher> pour spécifier plusieurs modes d'appel de la ressource interceptée par le Filter.
• Les valeurs que peut prendre l'élément <dispatcher> et leur signification
• REQUEST : Lorsque l'utilisateur accède directement à la page, le conteneur Web appelle le filtre. Si la ressource cible est accédée par les méthodes include() ou forward() du RequestDispatcher, alors ce filtre ne sera pas appelé.
• INCLUDE : Si la ressource cible est accédée par le méthode include() du RequestDispatcher, alors ce filtre sera appelé. Sinon, ce filtre ne sera pas appelé.
• FORWARD : si la ressource cible est accessible via la méthode forward() du RequestDispatcher, alors ce filtre sera appelé, à part cela, ce filtre ne sera pas appelé.
• ERROR : si la ressource cible est appelée par le mécanisme de gestion des exceptions déclaratives, alors ce filtre sera appelé. À part cela, le filtre ne sera pas appelé.

Chaîne de Filter

Dans une application web, il est possible de développer plusieurs Filter, ces Filter combinés forment une chaîne de Filter.

Le serveur web décide de l'ordre d'appel des Filter en fonction de l'ordre d'enregistrement du Filter dans le fichier web.xml. Lorsque la méthode doFilter du premier Filter est appelée, le serveur web crée un objet FilterChain représentant la chaîne de Filter et le passe à cette méthode. Dans la méthode doFilter, si le développeur appelle la méthode doFilter de l'objet FilterChain, le serveur web vérifie s'il y a d'autres filter dans l'objet FilterChain. S'il y en a, il appelle le prochain filter.2un filter, s'il n'y en a pas, appelle la ressource cible.

Cycle de vie du Filter

public void init(FilterConfig filterConfig) throws ServletException;//Initialisation

Comme nos programmes Servlet, la création et la destruction du Filter sont gérées par le serveur web. Lors du lancement de l'application web, le serveur web crée une instance de Filter, appelle sa méthode init, lit la configuration web.xml et complète la fonction d'initialisation de l'objet, en préparant ainsi l'interception des demandes utilisateur ultérieures (l'objet Filter ne sera créé qu'une seule fois, et la méthode init ne sera exécutée qu'une seule fois). Les développeurs peuvent obtenir l'objet FilterConfig représentant les informations de configuration du filter via les paramètres de la méthode init.

public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException;//Intercepter la requête

Cette méthode effectue l'opération de filtrage réelle. Lorsque le client demande d'accéder à l'URL associée au filtre, le filtre Servlet exécute d'abord la méthode doFilter. Le paramètre FilterChain est utilisé pour accéder aux filtres suivants.

public void destroy();//Destruction

Après la création du Filter objet restera en mémoire, jusqu'à ce que l'application web soit supprimée ou que le serveur s'arrête, puis il est détruit. Appelé avant que le conteneur Web ne décharge l'objet Filter. Cette méthode ne s'exécute qu'une fois dans le cycle de vie du Filter. Dans cette méthode, vous pouvez libérer les ressources utilisées par le Filter.

Interface FilterConfig

Lorsque l'utilisateur configure le filtre, il peut configurer des paramètres d'initialisation pour le filtre. Lorsque le conteneur web instancie l'objet Filter, il appelle la méthode init et transmet l'objet filterConfig encapsulé les paramètres d'initialisation du filtre. Par conséquent, les développeurs peuvent obtenir le contenu suivant en écrivant le filtre via les méthodes de l'objet filterConfig :

String getFilterName();//Obtenez le nom du filtre. 
String getInitParameter(String name);//Retournez la valeur du paramètre d'initialisation spécifié dans la description de déploiement. Si il n'existe pas, retournez null. 
Enumeration getInitParameterNames();//Retournez une collection d'ensembles d'enumération des noms de paramètres d'initialisation de tous les filtres. 
public ServletContext getServletContext();//Retournez une référence à l'objet ServletContext.

Cas d'utilisation du Filter

Utilisez Filter pour vérifier la sécurité de la connexion utilisateur

Récemment, j'ai participé à la maintenance d'un projet, après que l'utilisateur ait quitté le système, si vous accédez à l'historique de l'adresse en barre, selon l'url, vous pouvez toujours entrer dans la page de réponse du système. J'ai vérifié et découvert que les demandes n'ont pas été filtrées et vérifiées pour l'authentification utilisateur. Ajoutez un filtre pour résoudre le problème !

Configurez d'abord dans web.xml

<filter>
  <filter-name>SessionFilter</filter-name>
  <filter-class>com.action.login.SessionFilter</filter-class>
  <init-param>
    <param-name>logonStrings</param-name><!-- ne pas filtrer la page de connexion -->
    <param-value>/project/index.jsp;login.do</param-value>
  </init-param>
  <init-param>
    <param-name>includeStrings</param-name><!-- ne filtrer que les paramètres de filtre spécifiés -->
    <param-value>.do;.jsp</param-value>
  </init-param>
  <init-param>
    <param-name>redirectPath</param-name><!-- Non-approuvé, redirigez vers l'interface de connexion -->
    <param-value>/index.jsp</param-value>
  </init-param>
  <init-param>
    <param-name>disabletestfilter</param-name><!-- Y: Filtrage inefficace -->
    <param-value>N</param-value>
  </init-param>
</filter>
<filter-mapping>
  <filter-name>SessionFilter</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>

Ensuite, écrivez FilterServlet

package com.action.login;
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;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;
/**
 *  Vérifier si l'utilisateur est connecté, sinon quitter le système
 */
public class SessionFilter implements Filter {
  public FilterConfig config;
  public void destroy() {
    this.config = null;
  }
  public static boolean isContains(String container, String[] regx) {
    boolean result = false;
    for (int i = 0; i < regx.length; i++) {
      if (container.indexOf(regx[i]) != -1) {
        return true;
      }
    }
    return result;
  }
  public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
    HttpServletRequest hrequest = (HttpServletRequest)request;
    HttpServletResponseWrapper wrapper = new HttpServletResponseWrapper((HttpServletResponse) response);
    String logonStrings = config.getInitParameter("logonStrings");    // page de connexion de connexion
    String includeStrings = config.getInitParameter("includeStrings");  // filtrer les paramètres de suffixe de ressource
    String redirectPath = hrequest.getContextPath() + config.getInitParameter("redirectPath");// rediriger vers la page de redirection si non connecté
    String disabletestfilter = config.getInitParameter("disabletestfilter");// le filtre est-il valide
    if (disabletestfilter.toUpperCase().equals("Y")) {  // filtrage non valide
      chain.doFilter(request, response);
      return;
    }
    String[] logonList = logonStrings.split(";");
    String[] includeList = includeStrings.split(";");
    if (!this.isContains(hrequest.getRequestURI(), includeList)) {// ne filtrer que les paramètres de filtre spécifiés
      chain.doFilter(request, response);
      return;
    }
    if (this.isContains(hrequest.getRequestURI(), logonList)) {// ne pas filtrer la page de connexion
      chain.doFilter(request, response);
      return;
    }
    String user = ( String ) hrequest.getSession().getAttribute("useronly");//vérifier si l'utilisateur est connecté
    if (user == null) {
      wrapper.sendRedirect(redirectPath);
      return;
    }else {
      chain.doFilter(request, response);
      return;
    }
  }
  public void init(FilterConfig filterConfig) throws ServletException {
    config = filterConfig;
  }
}

De cette manière, toutes les demandes de l'utilisateur doivent être vérifiées par ce Filter pour la connexion de l'utilisateur.

Filtre anti-caractères chinois malformés

Lorsque le projet utilise le cadre Spring. Lorsque les pages JSP de l'interface utilisateur et le code Java utilisent différents jeux de caractères pour l'encodage, des données de soumission de formulaire ou des/Problème de caractères malformés lors du téléchargement de fichiers de nom chinois, vous pouvez utiliser ce filtre.

<filter>
  <filter-name>encoding</filter-name>
  <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
  <init-param>
    <param-name>encoding</param-name><!--Utilisé pour spécifier un jeu de caractères spécifique-->
    <param-value>UTF-8</param-value>
  </init-param>
  <init-param>
    <param-name>forceEncoding</param-name><!--true : que le request spécifie ou non un jeu de caractères, utilisez toujours encoding ; false : si le request a spécifié un jeu de caractères, n'utilisez pas encoding-->
    <param-value>false</param-value>
  </init-param>
</filter>
<filter-mapping>
  <filter-name>encoding</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>

Voici la totalité du contenu de cet article, j'espère qu'il vous aidera dans vos études, et j'espère que vous soutiendrez également le tutoriel d'encouragement.

Déclaration : le contenu de cet article est issu du réseau, et appartient aux auteurs originaux. Le contenu est contribué et téléversé par les utilisateurs d'Internet, ce site n'appartient pas aux droits de propriété intellectuelle, n'a pas été traité par l'éditeur humain et n'assume pas la responsabilité juridique connexe. Si vous trouvez du contenu suspect de violation de droits d'auteur, veuillez envoyer un e-mail à : notice#oldtoolbag.com (veuillez remplacer # par @ lors de l'envoi d'un e-mail pour signaler une violation, et fournir des preuves pertinentes. Une fois vérifié, le site supprimera immédiatement le contenu suspect de violation de droits d'auteur.)