需要了解的过滤器

过滤器

1. 概念

过滤器： 从名字上理解就是对于事件的过滤操作，在web 中的过滤器，就是对于请求进行过滤操作，我们使用过滤器，就可以对于请求进行拦截操作，然后进行响应的处理操作，实现很多的特殊的功能，比如登录控制、权限控制操作、过滤敏感词汇.

2. 过滤器原理

流程：

​ 浏览器 和web 资源之间存在一个过滤器，对于资源进行处理操作，浏览器进行Http请求操作，首先经过过滤器，然后携带放行的request 和 Reponse 进入到web 资源 ，然后将资源进行返回操作，http 进行响应。

​ 注意拦截器的工作不仅仅对于请求进行拦截操作，而且也会对响应进行拦截操作。

3. 配置

过滤器的使用总共有两种方式： 一种是通过注解的形式进行实现操作。一种是通过web.xml进行实现。需要相关的配置文件Filter就在servlet-api.jar中，我们将该jar包放到WEB-INF下的lib目录下面，然后加入项目。如果是使用的maven 则需要进行如下的操作

<dependency><groupId>javax.servlet</groupId><artifactId>javax.servlet-api</artifactId><version>4.0.1</version><scope>provided</scope>
</dependency>

3.1 注解式配置

对于注解的源码进行分析

String[] value() default {};
String[] urlPatterns() default {};
// 其中两者的含义是相同的，urlPatterns和value只能配置一个，不能两个都配置，两个都配置就会报错。

进行条件的过滤操作的时候，设置过滤器的限制过滤的条件路径。

@WebFilter(urlPatterns = {"/Day45/user", "/Day45/admin"})@WebFilter("/Day45/user") ==> 注解中的value属性

3.2 web.xml式配置

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"version="3.1"><filter><!-- 当前过滤器名字 --><filter-name>BFilter</filter-name><!-- 对应当前过滤器的.class文件 --><filter-class>com.java.a_filter.BFilter</filter-class></filter><filter-mapping><!-- 对应过滤器的名字 --><filter-name>BFilter</filter-name><!-- 限制过滤路径 --><url-pattern>/*</url-pattern></filter-mapping><filter-mapping><!-- 对应过滤器的名字 --><filter-name>BFilter</filter-name><!-- 限制过滤路径 --><url-pattern>/andmin/user</url-pattern></filter-mapping>
</web-app>

4. 过滤器链

FilterChain

​ 过滤器链就是 在浏览器和 web 资源之间 有多个过滤器组成的一条过滤器链，返回的数据会经过每一个过滤器，中间多个过滤器形成一个过滤器链。

4.1 执行顺序

过滤器链的执行顺序，两种情况下需要进行考虑操作：

1. 使用注解的方式进行配置过滤器，这个时候需要考虑的是类的名称在字典中的顺序，顺序在前的优先进行执行操作。在后的将靠后进行执行操作。
2. 使用web.xml 文件进行配置filter 过滤器，根据在web.xml文件中的顺序来决定过滤器链的执行流程。靠前的优先进行执行操作。
3. 如果两者进行混合使用，那么在web.xml 文件中的配置会优先进行操作执行。

4.2 FilterChain

​ 通过查看源码能够得到的结论是： FilterChain 就只有一个方法。其实这个方法就是用来对于拦截进行放行操作的，如果有多个拦截器，那么就会继续调用下一个Filter 进行拦截。doFilter 方法需要传入个参数，一个是ServletRequest 参数 ，一个是ServletReponse 参数，这个直接进行传入就行。

​ Tomcat 在调用过滤器的时候，默认会传入Request 和 Reponse ，这个参数封装了请求和响应，我们直接使用就行。ServletResquest和ServletResponse可以直接强转成HttpServletRequest和HttpServletResponse，然后使用相应的方法。

//将ServletRequest 转换为 HttpServletRequest HttpServletRequest httpServletRequest =(HttpServletRequest) servletRequest;

@WebFilter("/*")
public class Filter01 implements Filter {@Overridepublic void init(FilterConfig filterConfig) throws ServletException {}@Overridepublic void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {System.out.println("调用过滤器01对请求进行过滤~~~~");//放行,如果还有过滤器，那么就执行下一个过滤器filterChain.doFilter(servletRequest,servletResponse);System.out.println("调用过滤器01对响应进行过滤~~~~");}@Overridepublic void destroy() {}
}

@WebFilter("/*")
public class Filter02 implements Filter {@Overridepublic void init(FilterConfig filterConfig) throws ServletException {}@Overridepublic void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {System.out.println("调用过滤器02对请求进行过滤~~~~");//放行,如果还有过滤器，那么就执行下一个过滤器filterChain.doFilter(servletRequest,servletResponse);System.out.println("调用过滤器02对响应进行过滤~~~~");}@Overridepublic void destroy() {}
}

运行结果：调用过滤器01对请求进行过滤调用过滤器02对请求进行过滤调用过滤器02对响应进行过滤调用过滤器01对响应进行过滤

5.过滤器初始化参数

​ 指 加载一定的资源的时候，敏感词汇的过滤操作，跟当前的过滤器进行绑定操作，这里能够使用初始化参数，两种方式：

1. 通过注解的方式来完成配置操作。
2. 通过web.xml 实现配置操作

5.1 注解实现初始化

// 注解方式完成
@WebFilter(value = "/*",initParams = {@WebInitParam(name = "filename", value = "saolei.properties")})

5.2 xml 实现初始化

<!-- XML配置方式完成  -->
<filter><filter-name>EFilter</filter-name><filter-class>com.qfedu.a_filter.EFilter</filter-class><!-- 初始化参数 --><init-param><param-name>filename</param-name><param-value>saolei.xml</param-value></init-param></filter>
<filter-mapping><filter-name>EFilter</filter-name><url-pattern>/*</url-pattern>
</filter-mapping>

6. 过滤器的声明周期

过滤器也有声明周期，Filter 的声明周期和Servlet 的声明周期十分相似。

​

过滤器总共有三个阶段： 初始化、拦截过滤、销毁

1. 初始化阶段：当服务器启动的时候，我们的服务器就会读取配置文件，扫描注解，然后来创建我们的过滤器。
2. 拦截和过滤阶段：只要请求资源的路径和拦截的路径相同，则过滤器就会对请求进行过滤操作，这个阶段在服务器运行的过程中会一直循环。
3. 销毁阶段： 当服务器进行关闭的时候，服务器创建的过滤器也会随之销毁。

创建一个Filter类，实现其中所有的方法

import javax.servlet.*;
import java.io.IOException;public class LifeCycleFilter implements Filter {@Overridepublic void init(FilterConfig filterConfig) throws ServletException {// 该方法是初始化方法、在Filter 创建的时候调用}@Overridepublic void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {// 该方法是过滤和拦截的方法，当请求和拦截匹配的时候进行调用}@Overridepublic void destroy() {// 这个方法是销毁方法，在Filter 销毁前进行调用}
}1.启动服务器时，调用初始化方法
2.进行拦截时调用doFilter方法
3.关闭服务器的时候调用销毁方法

7. FilterConfig

​ FilterConfig 和 FilterChain 这两个对象是通过服务器在创建和调用Filter 对象的时候所传入的，这两个对象十分有用，FilterConfig 对象能够读取我们的配置的初始化参数、FilterChain 可以实现多个Filter 之间的连接操作。

源码剖析：

1. getFilterName()：获取filter的名称
2. getServletContext()：获取ServletContext
3. getInitparamter(String var1)：获取配置的初始参数的值
4. getInitParamterNames()：获取配置的所有参数名称

分析：

​ 我们在init方法中使用FilterConfig 来读取配置的数据库信息，然后进行输出操作。FilterConfig 的作用就是用来读取配置文件。

public class MyFilterConfig implements Filter {@Overridepublic void init(FilterConfig filterConfig) throws ServletException {System.out.println("-----------获取全部key:value------------");//得到所有配置参数的名字Enumeration<String> names = filterConfig.getInitParameterNames();while (names.hasMoreElements()) {//得到每一个名字String name = names.nextElement();System.out.println(name+" = "+filterConfig.getInitParameter(name));}System.out.println("-----------end.....------------");}// 输出的结果是配置信息的键值对数据@Overridepublic void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {}@Overridepublic void destroy() {}
}

<filter><filter-name>myFilterConfig</filter-name><filter-class>com.clucky.filter.MyFilterConfig</filter-class><init-param><param-name>driver</param-name><param-value>com.mysql.jdbc.Driver</param-value></init-param><init-param><param-name>url</param-name><param-value>jdbc:mysql://localhost:3306/equip_employ_manage?serverTimezone=GMT</param-value></init-param><init-param><param-name>username</param-name><param-value>root</param-value></init-param><init-param><param-name>password</param-name><param-value>root</param-value></init-param></filter><filter-mapping><filter-name>myFilterConfig</filter-name><url-pattern>/*</url-pattern></filter-mapping>

8. 实例实现

8.1 编码操作

@WebFilter("/*")
public class AEncodingFilter implements Filter {@Overridepublic void init(FilterConfig filterConfig) throws ServletException {}@Overridepublic void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {// 获取当前Tomcat服务器版本信息String serverInfo = request.getServletContext().getServerInfo();HttpServletRequest httpServletRequest = (HttpServletRequest) request;HttpServletResponse httpServletResponse = (HttpServletResponse) response;if (serverInfo.startsWith("Apache Tomcat/7") || serverInfo.startsWith("Apache Tomcat/6")) {// 存在ISO-8859-1// 留下一个小问题System.out.println("Tomcat 6 or 7");} else {// Tomcat 8以及以上处理POST请求中文乱码问题和对应Response响应乱码问题System.out.println("Tomcat 8 or 9");httpServletRequest.setCharacterEncoding("utf-8");httpServletResponse.setContentType("text/html;charset=utf-8");}// 过滤链进行放行操作chain.doFilter(httpServletRequest, httpServletResponse);}@Overridepublic void destroy() {}
}

8.2 登录过滤操作

​ 先进行封装操作，使用抽象类能够保证该类不会被实例化，实例化的话只能够使用匿名内部类。

下面是相关的代码总结。

public abstract class BaseFilter implements Filter {/*** 过滤器的初始化操作** @param filterConfig  初始化参数 过滤器的配置* @throws ServletException Servlet异常*/@Overridepublic void init(FilterConfig filterConfig) throws ServletException {Filter.super.init(filterConfig);}/*** 过滤的销毁方法*/@Overridepublic void destroy() {Filter.super.destroy();}
}

@WebFilter("/*")
public class MyFilter extends BaseFilter{/*** 【核心方法】用于制定针对于用户请求和响应的过滤规则，需要通过 FilterChain 进行请求放行操作** @param servletRequest  ServletRequest 用户请求符合 Servlet 要求的 request 对象* @param servletResponse ServletResponse 根据用户请求绑定创建的符合 Servlet 要求的 Response 对象* @param filterChain     FilterChain 过滤器链类型，用于【放行】请求* @throws IOException    IO异常* @throws ServletException Servlet 异常*/@Overridepublic void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {//1.强制类型转换HttpServletRequest request = (HttpServletRequest)servletRequest;HttpServletResponse response = (HttpServletResponse)servletResponse;//3. 获取请求路径String uri = request.getRequestURI();StringBuffer requestURL = request.getRequestURL();System.out.println(requestURL);System.out.println(uri);//未进行登录时能够放行的操作if (uri.endsWith("/")||uri.endsWith("login.html")|| uri.endsWith("loginServlet")){// 放行操作filterChain.doFilter(request, response);} else {// 判断是否存在对象，如果存在过Object id1 = request.getSession().getAttribute("u_account");// 如果已经登录成功if (id1 != null){filterChain.doFilter(request,response);} else {response.setContentType("text/html;charset=utf-8");response.getWriter().write("<script>" +"alert('请先登录');"+"location.href='/login.html'</script>");}}}
}

8.3 实现敏感词汇过滤操作

// Filter 代码import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.annotation.WebInitParam;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;@WebFilter(servletNames = {"comment"},initParams = {@WebInitParam(name = "sensitiveWord", value = "zz")})
public class CommentFilter implements Filter {private List<String> sensitiveWords = new ArrayList<>();@Overridepublic void init(FilterConfig filterConfig) throws ServletException {//得到敏感词汇String word = filterConfig.getInitParameter("sensitiveWord");//加入集合sensitiveWords.add(word);}@Overridepublic void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {//设置编码servletRequest.setCharacterEncoding("utf-8");servletResponse.setContentType("text/html;charset=utf-8");//得到评论String message = servletRequest.getParameter("message");for (String sensitiveWord : sensitiveWords) {//对所有敏感词汇进行过滤if (message.contains(sensitiveWord)){//替换敏感词汇message = message.replace(sensitiveWord, "**");}}//存入request域servletRequest.setAttribute("comment",message);//放行filterChain.doFilter(servletRequest,servletResponse);}@Overridepublic void destroy() {}
}

// Servlet 代码import javax.servlet.*;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.*;
import java.io.IOException;
import java.util.HashSet;@WebServlet(name = "comment",value = "/comment")
public class CommentServlet extends HttpServlet {//记录评论敏感词汇的ipprivate HashSet<String> hashSet = new HashSet<>();@Overrideprotected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {String message = request.getParameter("message");String comment = (String) request.getAttribute("comment");if (message.equals(comment)){System.out.println("没有敏感词汇.....");//设置名字request.setAttribute("name","good boy：");}else {//有敏感词汇，记录IPString localAddr = request.getLocalAddr();System.out.println(localAddr);hashSet.add(localAddr);//设置名字request.setAttribute("name","bad boy：");}//转发到comment.jsp页面request.getRequestDispatcher("/comment.jsp").forward(request,response);}@Overrideprotected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {this.doGet(request, response);}
}

// JSP 页面<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head><title>评论</title>
</head>
<body>
<h1>输入评论内容</h1>
<form action="${pageContext.request.contextPath}/comment" method="post"><textarea name="message" cols="30" rows="10"></textarea><input type="submit" value="提交">
</form>
<p >${requestScope.get("name")}<span style="color: red">${requestScope.get("comment")}</span></p>
</body>
</html>