过滤器: 从名字上理解就是对于事件的过滤操作,在web 中的过滤器,就是对于请求进行过滤操作,我们使用过滤器,就可以对于请求进行拦截操作,然后进行响应的处理操作,实现很多的特殊的功能,比如登录控制、权限控制操作、过滤敏感词汇.
流程:
浏览器 和web 资源之间存在一个过滤器,对于资源进行处理操作,浏览器进行Http请求操作,首先经过过滤器,然后携带放行的request 和 Reponse 进入到web 资源 ,然后将资源进行返回操作,http 进行响应。
注意拦截器的工作不仅仅对于请求进行拦截操作,而且也会对响应进行拦截操作。
过滤器的使用总共有两种方式: 一种是通过注解的形式进行实现操作。一种是通过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>
对于注解的源码进行分析
String[] value() default {}; String[] urlPatterns() default {}; // 其中两者的含义是相同的,urlPatterns和value只能配置一个,不能两个都配置,两个都配置就会报错。
进行条件的过滤操作的时候,设置过滤器的限制过滤的条件路径。
@WebFilter(urlPatterns = {"/Day45/user", "/Day45/admin"}) @WebFilter("/Day45/user") ==> 注解中的value属性
<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>BFilterfilter-name>
<filter-class>com.java.a_filter.BFilterfilter-class>
filter>
<filter-mapping>
<filter-name>BFilterfilter-name>
<url-pattern>/*url-pattern>
filter-mapping>
<filter-mapping>
<filter-name>BFilterfilter-name>
<url-pattern>/andmin/userurl-pattern>
filter-mapping>
web-app>
FilterChain
过滤器链就是 在浏览器和 web 资源之间 有多个过滤器组成的一条过滤器链,返回的数据会经过每一个过滤器,中间多个过滤器形成一个过滤器链。
过滤器链的执行顺序,两种情况下需要进行考虑操作:
- 使用注解的方式进行配置过滤器,这个时候需要考虑的是类的名称在字典中的顺序,顺序在前的优先进行执行操作。在后的将靠后进行执行操作。
- 使用web.xml 文件进行配置filter 过滤器,根据在web.xml文件中的顺序来决定过滤器链的执行流程。靠前的优先进行执行操作。
- 如果两者进行混合使用,那么在web.xml 文件中的配置会优先进行操作执行。
通过查看源码能够得到的结论是: FilterChain 就只有一个方法。其实这个方法就是用来对于拦截进行放行操作的,如果有多个拦截器,那么就会继续调用下一个Filter 进行拦截。doFilter 方法需要传入个参数,一个是ServletRequest 参数 ,一个是ServletReponse 参数,这个直接进行传入就行。
Tomcat 在调用过滤器的时候,默认会传入Request 和 Reponse ,这个参数封装了请求和响应,我们直接使用就行。ServletResquest和ServletResponse可以直接强转成HttpServletRequest和HttpServletResponse,然后使用相应的方法。
//将ServletRequest 转换为 HttpServletRequest HttpServletRequest httpServletRequest =(HttpServletRequest) servletRequest;
@WebFilter("/*")
public class Filter01 implements Filter {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
System.out.println("调用过滤器01对请求进行过滤~~~~");
//放行,如果还有过滤器,那么就执行下一个过滤器
filterChain.doFilter(servletRequest,servletResponse);
System.out.println("调用过滤器01对响应进行过滤~~~~");
}
@Override
public void destroy() {
}
}
@WebFilter("/*")
public class Filter02 implements Filter {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
System.out.println("调用过滤器02对请求进行过滤~~~~");
//放行,如果还有过滤器,那么就执行下一个过滤器
filterChain.doFilter(servletRequest,servletResponse);
System.out.println("调用过滤器02对响应进行过滤~~~~");
}
@Override
public void destroy() {
}
}
运行结果:
调用过滤器01对请求进行过滤
调用过滤器02对请求进行过滤
调用过滤器02对响应进行过滤
调用过滤器01对响应进行过滤
指 加载一定的资源的时候,敏感词汇的过滤操作,跟当前的过滤器进行绑定操作,这里能够使用初始化参数,两种方式:
- 通过注解的方式来完成配置操作。
- 通过web.xml 实现配置操作
// 注解方式完成
@WebFilter(value = "/*",
initParams = {@WebInitParam(name = "filename", value = "saolei.properties")})
<filter>
<filter-name>EFilterfilter-name>
<filter-class>com.qfedu.a_filter.EFilterfilter-class>
<init-param>
<param-name>filenameparam-name>
<param-value>saolei.xmlparam-value>
init-param>
filter>
<filter-mapping>
<filter-name>EFilterfilter-name>
<url-pattern>/*url-pattern>
filter-mapping>
过滤器也有声明周期,Filter 的声明周期和Servlet 的声明周期十分相似。
过滤器总共有三个阶段: 初始化、拦截过滤、销毁
- 初始化阶段:当服务器启动的时候,我们的服务器就会读取配置文件,扫描注解,然后来创建我们的过滤器。
- 拦截和过滤阶段:只要请求资源的路径和拦截的路径相同,则过滤器就会对请求进行过滤操作,这个阶段在服务器运行的过程中会一直循环。
- 销毁阶段: 当服务器进行关闭的时候,服务器创建的过滤器也会随之销毁。
创建一个Filter类,实现其中所有的方法
import javax.servlet.*;
import java.io.IOException;
public class LifeCycleFilter implements Filter {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
// 该方法是初始化方法、在Filter 创建的时候调用
}
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
// 该方法是过滤和拦截的方法,当请求和拦截匹配的时候进行调用
}
@Override
public void destroy() {
// 这个方法是销毁方法,在Filter 销毁前进行调用
}
}
1.启动服务器时,调用初始化方法
2.进行拦截时调用doFilter方法
3.关闭服务器的时候调用销毁方法
FilterConfig 和 FilterChain 这两个对象是通过服务器在创建和调用Filter 对象的时候所传入的,这两个对象十分有用,FilterConfig 对象能够读取我们的配置的初始化参数、FilterChain 可以实现多个Filter 之间的连接操作。
源码剖析:
- getFilterName():获取filter的名称
- getServletContext():获取ServletContext
- getInitparamter(String var1):获取配置的初始参数的值
- getInitParamterNames():获取配置的所有参数名称
分析:
我们在init方法中使用FilterConfig 来读取配置的数据库信息,然后进行输出操作。FilterConfig 的作用就是用来读取配置文件。
public class MyFilterConfig implements Filter {
@Override
public 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.....------------");
}
// 输出的结果是配置信息的键值对数据
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
}
@Override
public void destroy() {
}
}
<filter>
<filter-name>myFilterConfigfilter-name>
<filter-class>com.clucky.filter.MyFilterConfigfilter-class>
<init-param>
<param-name>driverparam-name>
<param-value>com.mysql.jdbc.Driverparam-value>
init-param>
<init-param>
<param-name>urlparam-name>
<param-value>jdbc:mysql://localhost:3306/equip_employ_manage?serverTimezone=GMTparam-value>
init-param>
<init-param>
<param-name>usernameparam-name>
<param-value>rootparam-value>
init-param>
<init-param>
<param-name>passwordparam-name>
<param-value>rootparam-value>
init-param>
filter>
<filter-mapping>
<filter-name>myFilterConfigfilter-name>
<url-pattern>/*url-pattern>
filter-mapping>
@WebFilter("/*")
public class AEncodingFilter implements Filter {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
@Override
public 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);
}
@Override
public void destroy() {
}
}
先进行封装操作,使用抽象类能够保证该类不会被实例化,实例化的话只能够使用匿名内部类。
下面是相关的代码总结。
public abstract class BaseFilter implements Filter {
/**
* 过滤器的初始化操作
*
* @param filterConfig 初始化参数 过滤器的配置
* @throws ServletException Servlet异常
*/
@Override
public void init(FilterConfig filterConfig) throws ServletException {
Filter.super.init(filterConfig);
}
/**
* 过滤的销毁方法
*/
@Override
public 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 异常
*/
@Override
public 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("");
}
}
}
}
// 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<>();
@Override
public void init(FilterConfig filterConfig) throws ServletException {
//得到敏感词汇
String word = filterConfig.getInitParameter("sensitiveWord");
//加入集合
sensitiveWords.add(word);
}
@Override
public 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);
}
@Override
public 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 {
//记录评论敏感词汇的ip
private HashSet<String> hashSet = new HashSet<>();
@Override
protected 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 {
//有敏感词汇,记录IP
String localAddr = request.getLocalAddr();
System.out.println(localAddr);
hashSet.add(localAddr);
//设置名字
request.setAttribute("name","bad boy:");
}
//转发到comment.jsp页面
request.getRequestDispatcher("/comment.jsp").forward(request,response);
}
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
this.doGet(request, response);
}
}
// JSP 页面
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
评论
输入评论内容
${requestScope.get("name")}${requestScope.get("comment")}