1. Introdução ao filtro
O filtro também é chamado de filtro. É a tecnologia mais emocionante na tecnologia de servlet. Através da tecnologia de filtro, os desenvolvedores da Web interceptam todos os recursos da Web gerenciados por servidores da Web: como JSP, servlet, arquivos de imagem estática ou arquivos HTML estáticos, alcançando assim algumas funções especiais. Por exemplo, implemente algumas funções avançadas, como controle de acesso à permissão no nível de URL, filtragem de vocabulário sensível e compactação de informações de resposta.
A API do servlet fornece uma interface de filtro. Ao desenvolver aplicativos da Web, se a classe Java escrita implementar essa interface, a classe Java será chamada de filtro de filtro. Através da tecnologia do filtro, os desenvolvedores podem implementar as solicitações e respostas de acesso dos usuários antes de acessar um recurso de destino, como mostrado abaixo:
2. Como o filtro é a interceptação?
Existe um método Dofilter na interface do filtro. Quando escrevemos filtro e configurarmos qual recurso da Web para interceptar, o servidor da Web chama o método Dofilter de filtro sempre antes de ligar para o método de serviço do recurso da Web. Portanto, escrever código neste método pode alcançar o seguinte objetivo:
1. Deixe um pedaço de código executar antes de chamar o recurso de destino.
2. se deve chamar o recurso de destino (ou seja, permitir que os usuários acessem o recurso da Web).
3. Depois de chamar o recurso de destino, deixe um pedaço de código executar.
Quando o servidor da Web chama o método Dofilter, ele passa um objeto de filtragem. O objeto FilterChain é o objeto mais importante na interface do filtro. Ele também fornece um método Dofilter. Os desenvolvedores podem decidir se devem chamar esse método de acordo com suas necessidades. Se esse método for chamado, o servidor da Web chamará o método de serviço do recurso da Web, ou seja, o recurso da Web será acessado; caso contrário, o recurso da Web não será acessado.
3. Começar com o desenvolvimento do filtro
3.1. Etapas de desenvolvimento de filtro
O desenvolvimento do filtro é dividido em duas etapas:
1. Escreva uma classe Java para implementar a interface do filtro e implementar seu método Dofilter.
2. Use os elementos <filter> e <filter-mapping> no arquivo web.xml para registrar a classe de filtro escrita e definir os recursos que ele pode interceptar.
Exemplo de filtro:
pacote me.gacl.web.filter; importar java.io.ioException; importar javax.servlet.filter; importar javax.servlet.filterchain; importar javax.servlet.filterconfig; import javax.servlet.sertleStleSception; import javax.servlesslente; javax.servlet.servletResponse;/*** @className: filterDemo*@Description: Três aplicações típicas do filtro:*, você pode decidir se deve chamar o metro de Chain. O recurso é executado, o resultado da execução do recurso de destino pode ser capturado, realizando assim algumas funções especiais* @author: 小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小小 � Resposta, cadeia de filtragem) lança ioexception, servletexception {// por favor, algum pré -processamento mediante solicitação e resposta request.setcharacterencoding ("utf-"); Response.SetcharAcTerEncoding ("utf-"); Response.SetContentType ("text/html; charset = utf-"); System.out.println ("filtroDemo antes da execução !!! // Deixe o recurso de destino executar e lançar System.out.println ("FilterDemo após a execução!!");}@SubsteridePublic void Destruction () {System.out.println ("---- Filtro Destruição ----");}}}} Configure filtros em web.xml:
<? xml versão = "." coding = "utf-"?> <web-app versão = "." xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w.org//XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app__.xsd "> <play-name> </senge-name> <lorde-file-list> <lorde-file> index.jsp </ld-Welcome> filtro-> <filter> <filter-name> filtrodemo </filter-name> <filter-Class> me.gacl.web.filter.filterdemo </filter-class> </filter> <!-mapeando filtro-> <filter-Mapping> <filter-Name> filtrodemo </filter> <!-"/*" significa Solicitações-> <url-tattern>/*</url-tattern> </filter-Mapping> </web-app>
3.2. Corrente de filtro
Em um aplicativo da Web, vários filtros podem ser desenvolvidos e escritos, que são combinados em uma corrente de filtro.
O servidor da Web decide qual filtro para ligar primeiro de acordo com a ordem em que o filtro é registrado no arquivo web.xml. Quando o método Dofilter do primeiro filtro for chamado, o servidor da Web criará um objeto FilterChain que representa a cadeia do filtro e o passa para o método. No método Dofilter, se o desenvolvedor chamar o método Dofilter do objeto FilterChain, o servidor da Web verificará se ainda existe um filtro no objeto FilterChain. Se houver, o segundo filtro é chamado e, se não houver, o recurso de destino será chamado.
4. O ciclo de vida do filtro
4.1. Criação de filtro
A criação e destruição do filtro é de responsabilidade do servidor da web. Quando o aplicativo da Web for iniciado, o servidor da Web criará um objeto de instância do filtro e chama seu método init para concluir a função de inicialização do objeto, preparando -se para a interceptação para as solicitações subsequentes do usuário. O objeto de filtro será criado apenas uma vez e o método init será executado apenas uma vez. Através dos parâmetros do método init, um objeto FilterConfig que representa as informações de configuração do filtro atual pode ser obtido.
4.2. Destruição do filtro
O contêiner da web chama o método Destroy para destruir o filtro. O método de destruição é executado apenas uma vez durante o ciclo de vida do filtro. No método de destruição, os recursos usados pelo filtro podem ser libertados.
4.3. Interface FilterConfig
Ao configurar os filtros, os usuários podem usar <iit-param> para configurar alguns parâmetros de inicialização para filtros. Quando o contêiner da web instancia o objeto de filtro e chama seu método init, o objeto FilterConfig que encapsula os parâmetros de inicialização do filtro será passado. Portanto, quando os desenvolvedores escrevem filtros, eles podem obter:
String getFiltername (): Obtenha o nome do filtro.
String getInitParameter (nome da string): Retorna o valor do parâmetro de inicialização com o nome especificado na descrição da implantação. Retorne nulo se não existir.
Enumeração getInitParameterNames (): retorna um conjunto de enumeração de nomes de todos os parâmetros de inicialização do filtro.
public servletContext getServletContext (): retorna uma referência ao objeto de contexto do servlet.
Exemplo: use o filterConfig para obter informações de configuração do filtro
pacote me.gacl.web.filter; importar java.io.ioException; importar java.util.enumeration; importar javax.servlet.filter; import javax.servlet.filterchain; import javax.servlet.filterconfig; import javax.sertleTleptlexception; javax.servlet.servletResponse; classe pública filterDemo implementa filtro {/* filtro Inicialização* @see javax.servlet.filter#init (javax.servlet.filterConfig)*/ @Substérmidepublic Void (filterConfig)-servleTexception {Substituypublic Void (filterConfig). Inicialização ---- ");/*** <filter> <filtro-name> filterdemo </filter-name> <filter-Class> me.gacl.web.filter.filterdemo </filter-class> <!-Configurar parâmetros de inicialização do filtro de filtro-> <emit-paparam> <cription> Configurando filtro </cription> <param-name> nome </amam-name> <amam-value> gacl </amam-value> </irit-param> <init-p aram> <cription> configure os parâmetros de inicialização do filtroDEMO filtro </cription> <amam-name> como </param-name> <amam-value> java </param-value> </irit-param> </filter> <filter-mapping> <filter-name> filterdemo </filter-name> <!-"/*" significa interceptar todas as solicitações-> <battern>/*</url--plastn> filterConfig.getFiltername (); // Obtenha o parâmetro de inicialização configurado no web.xml file string initparam = filterConfig.getInitParameter ("nome"); String initParam = filterConfig.getInitParameter ("como"); // Retorna um conjunto de enumeração de nomes de todos os parâmetros de inicialização do filtro. Enumeração <string> initParameterNames = filterConfig.getInitParameterNames (); System.out.println (filterame); System.out.println (initParam); System.out.println (initParam); System.out.println (initParam); while (initParameterNames.hasMoreElements ()) {String paramname = (string) initParameterNames.nextElement (); System.out.println (paramName);}}@substituir o void void dofilter (servletRexet, resposta servletResponse, filter -cadeia) {System.out.println ("FilterDemo antes da execução !!!"); Chain.Dofilter (solicitação, resposta); // Deixe o recurso de destino ser executado e System.out.println ("FilterDemo após a execução !!!");}@substituição de vazio de destruição () {System.out.println ("--- filtro destruição ----");}} 5. Implantação de filtro
A implantação do filtro é dividida em duas etapas:
1. Filtro de registro
2. Filtro de mapeamento
5.1. Filtro de registro
Após o desenvolvimento do filtro, você precisa se registrar no arquivo web.xml para poder ser chamado pelo servidor da Web.
Registre o exemplo do filtro no arquivo web.xml:
<filter> <cription> filtrodemo filtro </cription> <filter-name> filterdemo </filter-name> <filter-Class> me.gacl.web.filter.filterdemo </filter-class> <!-Configurar parâmetros de inicialização do filtro de filtro-> <emo-param> <! ript> <param-name> nome </param-name> <amul-value> gacl </param-value> </init-param> <iit-param> <crection> configure os parâmetros de inicialização do filtro filtro/paramo </creption> <air-name> como </param> <ancam-value> java </param-value> <air-name>
<Descrição> é usado para adicionar informações de descrição. O conteúdo desse elemento pode estar vazio e <cription> não pode ser configurado.
<Filter-Name> é usado para especificar um nome para o filtro e o conteúdo do elemento não pode estar vazio.
O elemento <Filter-Class> é usado para especificar o nome completo da classe qualificado do filtro.
O elemento <Iit-Param> é usado para especificar parâmetros de inicialização para o filtro, e seu elemento filho <Mam-Name> especifica o nome do parâmetro e <amam-value> especifica o valor do parâmetro. No filtro, o objeto FilterConfig da interface pode ser usado para acessar os parâmetros de inicialização. Se o filtro não precisar especificar parâmetros de inicialização, o elemento <Iit-Param> não poderá ser configurado.
5.2. Filtro de mapeamento
Depois de registrar o filtro no arquivo web.xml, você também deve mapear o filtro no arquivo web.xml
<!-Filtro de mapeamento-> <filtro-mapping> <filtro-name> filtrodemo </filter-name> <!-"/*" significa interceptar todas as solicitações-> <url-tattern>/*</url-pattern> </filter-mapping>
O elemento <Filter-Mapping> é usado para definir o recurso que um filtro é responsável por interceptar. Um filtro intercepta um recurso pode ser especificado de duas maneiras: o nome do servlet e o caminho de solicitação para acesso a recursos.
O elemento filho <name> é usado para definir o nome de registro do filtro. Este valor deve ser o nome do filtro declarado no elemento <url-padrão>. Defina o caminho de solicitação interceptado por filtro (o estilo URL associado ao filtro)
<ame-name> especifica o nome do servlet interceptado pelo filtro.
<Pispatcher> Especifica a maneira como o recurso interceptado pelo filtro é chamado pelo contêiner do servlet. Pode ser uma solicitação, incluir, encaminhamento e erro, e a solicitação padrão. Os usuários podem definir vários sub-elementos <Dispatcher> para especificar
O filtro intercepta várias maneiras de chamar recursos. do seguinte modo:
<Filter-Mapping> <filter-name> testFilter </filter-name> <url-tattern> /index.jsp </url-tattern> <pispatcher> request </sispatcher> <pispather> forward </sispather> </filter-mapping>
Os valores que o elemento filho pode definir e seus significados:
1.E -requisição: quando o usuário acessar diretamente a página, o contêiner da web chamará o filtro. Se o recurso de destino for acessado através do método incluir () ou forward () do requestDispatcher, o filtro não será chamado.
2. Include: se o recurso de destino for acessado através do método incluir () do requestDispatcher, o filtro será chamado. Fora isso, o filtro não será chamado.
3. Paraward: se o recurso de destino for acessado através do método Forward () do requestDispatcher, o filtro será chamado e o filtro não será chamado além.
4.Error: se o recurso de destino for chamado através do mecanismo de manuseio de exceção declarativo, o filtro será chamado. Fora isso, o filtro não será chamado.