Explication détaillée du filtre en Java

Introduction au filtre

Le filtre est également appelé filtre. C'est la technologie la plus pratique de la technologie Servlet. Les développeurs WEB utilisent la technologie Filter pour gérer toutes les ressources Web gérées par le serveur Web : telles que Jsp, Servlet, Intercept. fichiers d'image statiques ou fichiers HTML statiques pour réaliser certaines fonctions spéciales. Par exemple, certaines fonctions avancées telles que le contrôle d'accès aux autorisations au niveau de l'URL, le filtrage du vocabulaire sensible et la compression des informations de réponse peuvent être implémentées.

Il est principalement utilisé pour pré-traiter les demandes des utilisateurs et peut également post-traiter HttpServletResponse. Le processus complet d'utilisation de Filter : Filter prétraite la demande de l'utilisateur, puis transmet la demande à Servlet pour traitement et génère une réponse, et enfin Filter post-traite la réponse du serveur.

Fonction Filtre

Intercepte le HttpServletRequest du client avant qu'il n'atteigne le Servlet. Vérifiez le HttpServletRequest si nécessaire et modifiez l'en-tête et les données HttpServletRequest.

Interceptez HttpServletResponse avant qu'il n'atteigne le client. Vérifiez HttpServletResponse si nécessaire et modifiez l'en-tête et les données HttpServletResponse.

Comment implémenter la fonction d'interception à l'aide de Filter

Il existe une méthode doFilter dans l'interface Filter Lorsque le développeur écrit le filtre et configure la ressource Web à intercepter, le serveur WEB. appellera la ressource Web à chaque fois.Avant d'appeler la méthode de service d'une ressource, la méthode doFilter du filtre sera appelée en premier. Par conséquent, écrire du code dans cette méthode peut atteindre les objectifs suivants :

Laisser un morceau. du code s'exécute avant d'appeler la ressource cible.

S'il faut appeler la ressource cible (c'est-à-dire s'il faut autoriser l'utilisateur à accéder aux ressources Web).

Lorsque le serveur Web appelle la méthode doFilter, il transmettra un objet filterChain. L'objet filterChain est l'objet le plus important de l'interface de filtre. Il fournit également une méthode doFilter. en fonction de leurs besoins. Méthode, lorsque cette méthode est appelée, le serveur Web appellera la méthode de service de la ressource Web, c'est-à-dire que la ressource Web sera accessible, sinon la ressource Web ne sera pas accessible.

Deux étapes pour le développement de Filter

Écrivez une classe Java pour implémenter l'interface Filter et implémentez sa méthode doFilter.

Utilisez les éléments and dans le fichier web.xml pour enregistrer la classe de filtre écrite et définir les ressources qu'elle peut intercepter.

Présentation de chaque nœud de configuration web.xml :

Spécifiez un filtre.

est utilisé pour spécifier un nom pour le filtre. Le contenu de cet élément ne peut pas être vide. L'élément

est utilisé pour spécifier le nom de classe complet du filtre. L'élément

est utilisé pour spécifier les paramètres d'initialisation du filtre. Son sous-élément valeur du paramètre.

Dans un filtre, vous pouvez utiliser l'objet d'interface FilterConfig pour accéder aux paramètres d'initialisation. L'élément

est utilisé pour définir les ressources qu'un filtre est chargé d'intercepter. Les ressources interceptées par un filtre peuvent être spécifiées de deux manières : Nom du servlet et chemin de requête pour l'accès aux ressources. Le sous-élément

Cette valeur doit être le nom du filtre déclaré dans l'élément

Définir le chemin de la requête interceptée par le filtre (le modèle d'URL associé au filtre)

Spécifie le nom du Servlet intercepté par le filtre.

Spécifie la manière dont les ressources interceptées par le filtre sont appelées par le conteneur Servlet. Il peut s'agir de REQUEST, INCLUDE, FORWARD et ERROR. Les utilisateurs peuvent définir plusieurs sous-éléments pour spécifier Filter afin d'intercepter plusieurs méthodes d'appel de ressources.

Les valeurs que les sous-éléments peuvent être définis et leurs significations

REQUETE : lorsque l'utilisateur accède directement à la page, le conteneur Web appelle le filtre. Si la ressource cible est accessible via la méthode include() ou forward() de RequestDispatcher, alors ce filtre ne sera pas appelé.

INCLUDE : Si la ressource cible est accessible via la méthode include() de RequestDispatcher, alors ce filtre sera appelé. Sinon, le filtre n'est pas appelé.

FORWARD : Si la ressource cible est accédée via la méthode forward() de RequestDispatcher, alors ce filtre sera appelé. Sinon, ce filtre ne sera pas appelé.

ERREUR : Si la ressource cible est appelée via le mécanisme déclaratif de gestion des exceptions, alors ce filtre sera appelé. Sinon, le filtre ne sera pas appelé.

Chaîne de filtres

Dans une application Web, plusieurs filtres peuvent être développés et écrits. La combinaison de ces filtres est appelée une chaîne de filtres.

Le serveur Web détermine quel filtre appeler en premier en fonction de l'ordre d'enregistrement du filtre dans le fichier web.xml. Lorsque la méthode doFilter du premier filtre est appelée, le serveur Web créera un objet FilterChain représentant. la chaîne Filter et passez-la Donnez la méthode. Dans la méthode doFilter, si le développeur appelle la méthode doFilter de l'objet FilterChain, le serveur web vérifiera s'il existe un autre filtre dans l'objet FilterChain. Si tel est le cas, le deuxième filtre sera appelé. Sinon, la ressource cible le sera. être appelé.

Cycle de vie du filtre

public void init(FilterConfig filterConfig) throws ServletException;//初始化

Semblable au programme Servlet que nous avons écrit, la création et la destruction de Filter sont de la responsabilité du serveur WEB. Lorsque l'application Web démarre, le serveur Web crée un objet d'instance de Filter, appelle sa méthode init, lit la configuration web.xml et complète la fonction d'initialisation de l'objet, préparant ainsi l'interception des requêtes utilisateur ultérieures (l'objet filtre ne sera créée 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 actuelle du filtre via les paramètres de la méthode init.

public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException;//拦截请求

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

public void destroy();//销毁

Les objets filtres résideront en mémoire après leur création et seront détruits lorsque l'application Web sera supprimée ou que le serveur sera arrêté. Appelé avant que le conteneur Web ne décharge l'objet Filter. Cette méthode n'est exécutée qu'une seule fois dans le cycle de vie du filtre. Dans cette méthode, les ressources utilisées par le filtre peuvent être libérées.

Interface FilterConfig

Lors de la configuration du filtre, l'utilisateur peut configurer certains paramètres d'initialisation pour le filtre. Lorsque le conteneur Web instancie l'objet Filter et appelle sa méthode init, les paramètres d'initialisation du filtre seront. encapsulated L'objet filterConfig est transmis. Par conséquent, lorsque les développeurs écrivent des filtres, ils peuvent obtenir le contenu suivant via la méthode de l'objet filterConfig :

String getFilterName();//得到filter的名称。 String getInitParameter(String name);//返回在部署描述中指定名称的初始化参数的值。如果不存在返回null. Enumeration getInitParameterNames();//返回过滤器的所有初始化参数的名字的枚举集合。 public ServletContext getServletContext();//返回Servlet上下文对象的引用。

Cas d'utilisation du filtre

Utiliser le filtre pour vérifier le contrôle de sécurité de la connexion de l'utilisateur

J'ai participé à la maintenance d'un projet il y a quelque temps. Une fois que l'utilisateur a quitté le système, il se rend dans la barre d'adresse pour accéder à l'historique. Selon l'URL, il peut toujours accéder à la page de réponse du système. J'ai vérifié et constaté que la demande n'était pas filtrée pour vérifier la connexion de l'utilisateur. Ajoutez un filtre pour résoudre le problème !

Configurez d'abord

<filter>
    <filter-name>SessionFilter</filter-name>
    <filter-class>com.action.login.SessionFilter</filter-class>
    <init-param>
        <param-name>logonStrings</param-name><!-- 对登录页面不进行过滤 -->
        <param-value>/project/index.jsp;login.do</param-value>
    </init-param>
    <init-param>
        <param-name>includeStrings</param-name><!-- 只对指定过滤参数后缀进行过滤 -->
        <param-value>.do;.jsp</param-value>
    </init-param>
    <init-param>
        <param-name>redirectPath</param-name><!-- 未通过跳转到登录界面 -->
        <param-value>/index.jsp</param-value>
    </init-param>
    <init-param>
        <param-name>disabletestfilter</param-name><!-- Y:过滤无效 -->
        <param-value>N</param-value>
    </init-param></filter><filter-mapping>
    <filter-name>SessionFilter</filter-name>
    <url-pattern>/*</url-pattern></filter-mapping>

dans web.xml puis écrivez FilterServlet.java :

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;/**
 *    判断用户是否登录,未登录则退出系统
 */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");        // 登录登陆页面
        String includeStrings = config.getInitParameter("includeStrings");    // 过滤资源后缀参数
        String redirectPath = hrequest.getContextPath() + config.getInitParameter("redirectPath");// 没有登陆转向页面
        String disabletestfilter = config.getInitParameter("disabletestfilter");// 过滤器是否有效

        if (disabletestfilter.toUpperCase().equals("Y")) {    // 过滤无效
            chain.doFilter(request, response);            return;
        }
        String[] logonList = logonStrings.split(";");
        String[] includeList = includeStrings.split(";");        if (!this.isContains(hrequest.getRequestURI(), includeList)) {// 只对指定过滤参数后缀进行过滤
            chain.doFilter(request, response);            return;
        }        if (this.isContains(hrequest.getRequestURI(), logonList)) {// 对登录页面不进行过滤
            chain.doFilter(request, response);            return;
        }

        String user = ( String ) hrequest.getSession().getAttribute("useronly");//判断用户是否登录
        if (user == null) {
            wrapper.sendRedirect(redirectPath);            return;
        }else {
            chain.doFilter(request, response);            return;
        }
    }    public void init(FilterConfig filterConfig) throws ServletException {
        config = filterConfig;
    }
}

De cette façon, toutes les requêtes adressées à l'utilisateur doivent passer par ceci Filtrer Vérifier la connexion de l'utilisateur.

Filtre pour éviter les caractères chinois tronqués

Lorsque le projet utilise le framework Spring. Lorsque différents jeux de caractères sont utilisés pour l'encodage dans la page JSP frontale et le code JAVA, les données soumises par le formulaire ou le fichier de nom chinois téléchargé/téléchargé seront tronquées, vous pouvez donc 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><!--用来指定一个具体的字符集-->
        <param-value>UTF-8</param-value>
    </init-param>
    <init-param>
        <param-name>forceEncoding</param-name><!--true：无论request是否指定了字符集，都是用encoding；false：如果request已指定一个字符集，则不使用encoding-->
        <param-value>false</param-value>
    </init-param></filter><filter-mapping>
    <filter-name>encoding</filter-name>
    <url-pattern>/*</url-pattern></filter-mapping>

OpenSessionInViewFilter de Spring Hibernate contrôle le changement de session

Lorsque Spring Hibernate est utilisé ensemble, si lazy=true (chargement paresseux) est défini, alors lors de la lecture des données, après avoir lu le parent data, hibernate fermera automatiquement la session. De cette façon, lorsque vous souhaitez utiliser les données qui y sont associées et les données enfants, le système générera une erreur lazyinit. Dans ce cas, vous devez utiliser le filtre OpenSessionInViewFilter fourni par spring. .

OpenSessionInViewFilter maintient principalement l'état de session jusqu'à ce que la requête envoie toutes les pages au client, et ne ferme pas la session tant que la requête n'est pas terminée, résolvant ainsi les problèmes causés par un chargement retardé.

Remarque : la configuration OpenSessionInViewFilter doit être écrite devant la configuration struts2. Étant donné que le conteneur Tomcat charge les filtres dans l'ordre. Si le fichier de configuration écrit d'abord la configuration du filtre struts2, puis la configuration du filtre OpenSessionInViewFilter, l'ordre de chargement entraîne la déconnexion de la session lorsque l'action obtient les données non gérées par Spring.

<filter><!-- lazy loading enabled in spring -->
    <filter-name>OpenSessionInViewFilter</filter-name>
    <filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class>
    <init-param>
        <param-name>sessionFactoryBeanName</param-name><!-- 可缺省。默认是从spring容器中找id为sessionFactory的bean，如果id不为sessionFactory，则需要配置如下，此处SessionFactory为spring容器中的bean。 -->
        <param-value>sessionFactory</param-value>
    </init-param>
    <init-param>
        <param-name>singleSession</param-name><!-- singleSession默认为true,若设为false则等于没用OpenSessionInView -->
        <param-value>true</param-value>
    </init-param></filter><filter-mapping>
    <filter-name>OpenSessionInViewFilter</filter-name>
    <url-pattern>*.do</url-pattern></filter-mapping>

Configuration de Struts2 web.xml

L'utilisation de Struts2 dans le projet nécessite également la configuration de filtres dans web.xml pour intercepter les requêtes et les transférer vers Struts2 Action pour traitement.

Remarque : Si la version de Struts2 est antérieure à 2.1.3, le filtre utilise org.apache.struts2.dispatcher.FilterDispatcher. Sinon, utilisez org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter. À partir de Struts2.1.3, le filtre ActionContextCleanUp sera abandonné et la fonctionnalité correspondante sera incluse dans le filtre StrutsPrepareAndExecuteFilter.

Trois configurations de paramètres d'initialisation :

Paramètre config : Spécifiez le fichier de configuration à charger. Virgule séparée.

Paramètre actionPackages : Spécifiez l'espace du package où se trouve la classe Action. Virgule séparée.

paramètre configProviders : fournisseur de fichiers de configuration personnalisé, qui doit implémenter la classe d'interface ConfigurationProvider. Virgule séparée.

<!-- struts 2.x filter --><filter>
    <filter-name>struts2</filter-name>
    <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class></filter><filter-mapping>
    <filter-name>struts2</filter-name>
    <url-pattern>*.do</url-pattern></filter-mapping>

Pour des explications plus détaillées sur Filter en Java et des articles connexes, veuillez faire attention au site Web PHP chinois !