简谈Java中的Filter过滤器

Introduzione al Filter

Il Filter è anche chiamato filtro, è la tecnologia più utile nella tecnologia Servlet, i sviluppatori web utilizzano la tecnologia Filter per intercettare tutte le risorse web gestite dal server web: ad esempio Jsp, Servlet, file di immagini statiche o file html statici, ecc., per realizzare alcune funzioni speciali. Ad esempio, implementare il controllo dell'accesso ai livelli di URL, filtrare parole sensibili, compressione delle informazioni di risposta, ecc., alcune funzioni avanzate.

Questo viene principalmente utilizzato per la pre-elaborazione delle richieste degli utenti, ma può anche essere utilizzato per il post-trattamento di HttpServletResponse. Il flusso completo dell'uso del Filter: il Filter effettua la pre-elaborazione della richiesta dell'utente, quindi consegna la richiesta al Servlet per essere elaborata e generare una risposta, infine il Filter effettua il post-trattamento della risposta del server.

Funzione del Filter

Interceptare l'HttpServletRequest prima che arrivi al Servlet. Secondo necessità, controllare l'HttpServletRequest, anche modificare l'intestazione e i dati dell'HttpServletRequest.

Interceptare l'HttpServletResponse prima che arrivi al client. Secondo necessità, controllare l'HttpServletResponse, anche modificare l'intestazione e i dati dell'HttpServletResponse.

Come utilizzare Filter per implementare la funzione di intercettazione

L'interfaccia Filter ha un metodo doFilter, quando gli sviluppatori scrivono un Filter e configurano quale risorsa web intercettare, il web server chiama il metodo doFilter del filtro ogni volta prima di chiamare il metodo service della risorsa web, quindi è possibile raggiungere gli obiettivi seguenti scrivendo codice all'interno di questo metodo:

Eseguire un pezzo di codice prima di chiamare la risorsa target.

Chiamare la risorsa target (cioè permettere all'utente di accedere alla risorsa web).

Quando il web server chiama il metodo doFilter, passing through un oggetto filterChain, l'oggetto filterChain è uno degli oggetti più importanti dell'interfaccia filter, fornisce anche un metodo doFilter, gli sviluppatori possono decidere di chiamare questo metodo in base alle esigenze, chiamando questo metodo, il web server chiamerà il metodo service della risorsa web, ossia la risorsa web sarà accessibile, altrimenti la risorsa web non sarà accessibile.

Due passi per lo sviluppo di Filter

Scrivere una classe java che implementi l'interfaccia Filter e implementi il metodo doFilter.

　Nel file web.xml viene registrato il filtro scritto e vengono impostate le risorse che può intercettare.

Introduzione ai nodi di configurazione web.xml:

• L'elemento <filter> specifica un filtro.
• L'elemento <filter-name> viene utilizzato per specificare un nome per il filtro, il contenuto di questo elemento non può essere vuoto.
• L'elemento <filter-class> viene utilizzato per specificare il nome completo della classe del filtro.
• L'elemento <init-param> viene utilizzato per specificare i parametri di inizializzazione del filtro, il suo elemento figlio <param-name> specifica il nome del parametro, <param-value> specifica il valore del parametro.
• Nel filtro, è possibile accedere ai parametri di inizializzazione utilizzando l'oggetto interfaccia FilterConfig.
• L'elemento <filter-mapping> viene utilizzato per impostare le risorse responsabili di un Filter. Le risorse interceptate da un Filter possono essere specificate in due modi: il nome del Servlet e il percorso di accesso alla risorsa.
• L'elemento <filter-name> viene utilizzato per impostare il nome di registrazione del filtro. Questo valore deve essere il nome del filtro dichiarato nell'elemento <filter>.
• L'elemento <url-pattern> imposta il percorso della richiesta che il filtro intercetta (stile di URL associato al filtro)
• L'elemento <servlet-name> specifica il nome del servlet che il filtro intercetta.
• L'elemento <dispatcher> specifica il modo in cui il container del servlet chiama le risorse che il filtro intercetta. Può essere uno dei seguenti: REQUEST, INCLUDE, FORWARD o ERROR, con DEFAULT REQUEST. È possibile impostare più elementi <dispatcher> per specificare diversi modi di intercettare le chiamate di risorsa dal filtro.
• Valori che possono essere impostati per l'elemento <dispatcher> e il loro significato
• REQUEST: Quando l'utente accede direttamente alla pagina, il container web chiama il filtro. Se la risorsa di destinazione viene acceduta tramite il metodo include() o forward() di RequestDispatcher, il filtro non viene chiamato.
• INCLUDE: Se la risorsa di destinazione viene acceduta tramite il metodo include() di RequestDispatcher, il filtro viene chiamato. Altrimenti, il filtro non viene chiamato.
• FORWARD: Se la risorsa di destinazione viene acceduta tramite il metodo forward() di RequestDispatcher, il filtro viene chiamato. Altrimenti, il filtro non viene chiamato.
• ERROR: Se la risorsa di destinazione viene chiamata tramite il meccanismo di gestione delle eccezioni dichiarative, il filtro viene chiamato. Altrimenti, il filtro non viene chiamato.

Catena di Filter

In un'applicazione web, è possibile sviluppare e scrivere più Filter. Questi Filter combinati formano una catena di Filter.

Il server web decide quale Filter chiamare in base all'ordine di registrazione del Filter nel file web.xml. Quando il metodo doFilter del primo Filter viene chiamato, il server web crea un oggetto FilterChain che rappresenta la catena di Filter e lo passa al metodo. Nel metodo doFilter, se lo sviluppatore chiama il metodo doFilter dell'oggetto FilterChain, il server web verifica se ci sono altri filter nella catena di Filter. Se ci sono, chiama il secondo filter; altrimenti, chiama la risorsa di destinazione.

Ciclo di vita del Filter

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

Come i nostri programmi Servlet, la creazione e la distruzione del Filter sono responsabilità del server web. Al momento dell'avvio dell'applicazione web, il server web crea l'istanza dell'oggetto Filter e chiama il metodo init per leggere la configurazione web.xml e completare la funzione di inizializzazione dell'oggetto, preparandosi così a intercettare le richieste successive degli utenti (l'oggetto filter viene creato una sola volta e il metodo init viene eseguito una sola volta). Gli sviluppatori possono ottenere l'oggetto FilterConfig che rappresenta le informazioni di configurazione del filtro corrente tramite i parametri del metodo init.

public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException; // Interrompe la richiesta

Questo metodo esegue l'operazione di filtraggio effettiva. Quando il client richiede di accedere all'URL associato al filtro, il Servlet Filter esegue prima il metodo doFilter. Il parametro FilterChain viene utilizzato per accedere ai filtri successivi.

public void destroy(); // Distruggi

L'oggetto Filter viene creato e rimane in memoria fino a quando l'applicazione web non viene rimossa o il server si ferma. Viene chiamato prima di scaricare l'oggetto Filter dal web container. Questo metodo viene eseguito una sola volta durante il ciclo di vita del Filter. In questo metodo, è possibile liberare le risorse utilizzate dal filtro.

Interfaccia FilterConfig

Quando si configura il filtro, l'utente può configurare alcuni parametri di inizializzazione per il filtro. Quando il web container istanzia l'oggetto Filter, chiama il metodo init e passinga all'interno l'oggetto filterConfig che contiene i parametri di inizializzazione del filtro. Pertanto, gli sviluppatori possono ottenere i seguenti contenuti tramite i metodi dell'oggetto filterConfig:

String getFilterName(); // Ottiene il nome del filtro. 
String getInitParameter(String name); // Restituisce il valore del parametro di inizializzazione specificato nel file deployment descriptor. Se non esiste, restituisce null. 
Enumeration getInitParameterNames(); // Restituisce un insieme enumerativo dei nomi di tutti i parametri di inizializzazione del filtro. 
public ServletContext getServletContext(); // Restituisce il riferimento all'oggetto ServletContext.

Esempi di utilizzo di Filter

Utilizza Filter per verificare la sicurezza del login dell'utente

Di recente, ho partecipato alla manutenzione di un progetto, dopo che l'utente ha effettuato il logout e ha visitato l'indirizzo nella barra degli indirizzi, secondo l'url, è stato possibile accedere alla pagina di risposta del sistema. Ho controllato e ho scoperto che non c'era una verifica di filtraggio della richiesta per il login dell'utente. Ho aggiunto un filter per risolvere il problema!

Prima configura in web.xml

<filter>
  <filter-name>SessionFilter</filter-name>
  <filter-class>com.action.login.SessionFilter</filter-class>
  <init-param>
    <param-name>logonStrings</param-name><!-- Non filtra le pagine di login -->
    <param-value>/project/index.jsp;login.do</param-value>
  </init-param>
  <init-param>
    <param-name>includeStrings</param-name><!-- Filtra solo i parametri specifici dopo la stringa -->
    <param-value>.do;.jsp</param-value>
  </init-param>
  <init-param>
    <param-name>redirectPath</param-name><!-- Non autorizzato, reindirizza alla pagina di login -->
    <param-value>/index.jsp</param-value>
  </init-param>
  <init-param>
    <param-name>disabletestfilter</param-name><!-- Y: Filtra inutili -->
    <param-value>N</param-value>
  </init-param>
</filter>
<filter-mapping>
  <filter-name>SessionFilter</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>

Successivamente, scrivi 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;
*/
 /*  判断用户是否登录,未登录则退出系统
 */
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"); // Filtraggio del filtro è valido o no
    if (disabletestfilter.toUpperCase().equals("Y")) { // Filtraggio non valido
      chain.doFilter(request, response);
      return;
    }
    String[] logonList = logonStrings.split(";");
    String[] includeList = includeStrings.split(";");
    if (!this.isContains(hrequest.getRequestURI(), includeList)) { // Filtrare solo i parametri di filtro specificati
      chain.doFilter(request, response);
      return;
    }
    if (this.isContains(hrequest.getRequestURI(), logonList)) { // Non filtrare la pagina di login
      chain.doFilter(request, response);
      return;
    }
    String user = (String) hrequest.getSession().getAttribute("useronly"); // Verifica se l'utente è loggato
    if (user == null) {
      wrapper.sendRedirect(redirectPath);
      return;
    } else {
      chain.doFilter(request, response);
      return;
    }
  }
  public void init(FilterConfig filterConfig) throws ServletException {
    config = filterConfig;
  }
}

In questo modo è possibile completare la verifica dell'autenticazione dell'utente per tutte le richieste dell'utente attraverso questo Filter.

Filtro di prevenzione dei caratteri cinesi confusi

Quando il progetto utilizza il framework Spring, quando la pagina JSP前台 e il codice Java utilizzano set di caratteri differenti per la codifica, possono verificarsi problemi di malfunzionamento dei dati di invio del modulo o dei file cinesi in nome con caratteri cinese durante il caricamento/scaricamento, in questo caso si può utilizzare questo filtro.

<filter>
  <filter-name>encoding</filter-name>
  <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
  <init-param>
    <param-name>encoding</param-name><!--usato per specificare un set di caratteri specifico-->
    <param-value>UTF-8</param-value>
  </init-param>
  <init-param>
    <param-name>forceEncoding</param-name><!--true：non importa se il request ha specificato o meno un set di caratteri, utilizza sempre encoding；false：se il request ha già specificato un set di caratteri, non utilizzare encoding-->
    <param-value>false</param-value>
  </init-param>
</filter>
<filter-mapping>
  <filter-name>encoding</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>

Questo è tutto il contenuto dell'articolo, speriamo che sia utile per la tua apprendimento e che tu sostenga fortemente il tutorial urla.

Dichiarazione: il contenuto di questo articolo è stato tratto da Internet, il copyright spetta ai rispettivi proprietari, il contenuto è stato contribuito e caricato autonomamente dagli utenti di Internet, questo sito non detiene i diritti di proprietà, non è stato editato manualmente e non assume alcuna responsabilità legale. Se trovi contenuti sospetti di violazione del copyright, ti preghiamo di inviare una e-mail a: notice#oldtoolbag.com (al momento dell'invio dell'e-mail, sostituisci # con @) per segnalare il problema e fornire prove pertinenti. Una volta verificata, questo sito rimuoverà immediatamente il contenuto sospetto di violazione del copyright.