1 学习目标
1. 能够说出过滤器的生命周期
2. 能够写出过滤器的映射路径
3. 能够说出过滤器的四种过滤类型
4. 能够利用FilterConfig获取过滤器的配置参数
5. 能够说出什么是过滤器链
6. 能够说出过滤器链的执行顺序
2 过滤器的入门
Java Web的三大组件（ 1）都需要交给web服务器运行 2）在web.xml文件中配置 ）
1. Servlet： javax.servlet.Servlet 通过HTTP协议接收客户端的请求，并且做出响应的一个Java应用程序。
2. Filter过滤器：javax.servlet.Filter 是一个接口，过滤请求，实现请求的拦截或者放行，并且添加新的功能。
3. Listener 监听器: javax.servlet.XxxListener，用来监听Web容器中各种域的事件
2.1 过滤器的应用场景
1、场景1： 用户表单提交参数，使用POST方法提交，编写Servlet，接收参数： request.getParameter() /getParameterValues() 如果在客户端提交汉字而不做任何处理，就出现中文乱码的问题。
解决编码问题： request.setCharacterEncoding("utf-8");
Ø 问题：如果在项目中的每一个Servlet都加上request.setCharacterEncoding("utf-8");
代码重复，而且后期维护也不方便。能不能把这部分公共代码抽取处理，放在一个地方执行？
2、场景2： 登录 -> 输入信息 -> 登录成功 -> 看到用户主页（欢迎xxx回来。。。）
用于验证用户是否登录成功代码：
HttpSession session = request.getSession()
Object obj = session.getAttribute("loginInfo");
if(obj==null){
//没有登录标记，代表没有登录
}else{
///已经登录了，继续访问此功能
}
如果用户不登录，直接访问用户主页，跳转到登录页面
在其他需要登录才能访问的页面中，同样也需要加上验证用户是否登录成功代码。
Ø 问题： 能不能把这部分公共验证用户是否登录成功代码抽取处理，在一个地方执行？
3. 结论：
以上两种场景出现的问题，可以使用过滤器（Filter）解决！
2.2 过滤器的作用：
1. 作用：
通过Filter技术，对Web服务器管理的所有Web资源：例如Jsp, Servlet, 静态图片文件或静态 html 文件等进行拦截，并且添加功能，从而实现一些“共同”的功能。
2. 例如：
1) 实现URL级别的权限访问控制
2) 过滤敏感词汇
3) 自动登录
4) 压缩响应信息等一些功能。
2.3 过滤器编写步骤：
特点：过滤器不是用户主动调用的，而是根据规则自己执行
1. 编写一个java类，实现Filter接口，并实现其中的所有方法
2. 在web.xml文件中配置Filter
<!-- 过滤器配置 -->
<filter>
<!-- 内部名称 -->
<filter-name>HelloFilter</filter-name>
<!-- 类全名：包+简单类名 -->
<filter-class>org.newboy.filter.HelloFilter</filter-class>
</filter>
<!-- 过滤器映射配置 -->
<filter-mapping>
<!-- 内部名称名称，和上面的名称保持一致！ -->
<filter-name>HelloFilter</filter-name>
<!-- 需要拦截的路径 -->
<url-pattern>/*</url-pattern>
</filter-mapping>
3. 把Filter部署到tomcat服务器运行
4. 示例：
创建一个过滤器HelloFilter，在运行HelloServlet前和后分别输出一句话，在HelloServlet中也输出一句话，观察控制台的运行效果。
1) 过滤器类：
public class HelloFilter implements Filter {
...
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
System.out.println("1.请求的时候运行一次过滤器");
chain.doFilter(request, response);
System.out.println("3.响应的时候运行一次过滤器");
}
...
}
2) web.xml中的配置
<!-- 过滤器的配置 -->
<filter>
<!-- 过滤器的内部名字 -->
<filter-name>hello</filter-name>
<filter-class>org.newboy.filter.HelloFilter</filter-class>
</filter>
<!-- 映射路径 -->
<filter-mapping>
<filter-name>hello</filter-name>
<!-- 过滤的Web资源路径 -->
<url-pattern>/*</url-pattern>
</filter-mapping>
3) HelloServlet类：
public class HelloServlet extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
System.out.println("2.执行了目标资源：HelloServlet被执行");
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
4) 运行结果：
1.请求的时候运行一次过滤器
2.运行了Web资源
3.响应的时候运行一次过滤器
2.4 Filter是如何实现拦截的？
Filter接口中有一个doFilter方法，当开发人员编写好Filter，并配置对哪个Web资源进行拦截后，Web服务器每次在调用Web资源的service方法之前，都会先调用一下filter的doFilter方法，因此，在该方法内编写代码可达到如下目的：
1) 调用目标资源之前，执行一段代码，request执行过滤任务。
2) 是否调用目标资源（即是否让用户访问Web资源）。
Web服务器在调用doFilter方法时，会传递一个filterChain对象进来，filterChain对象是filter接口中最重要的一个对象，它也提供了一个doFilter方法，开发人员可以根据需求决定是否调用此方法，调用该方法，则Web服务器就会调用Web资源的service方法，即Web资源就会被访问，否则Web资源不会被访问。
3) 调用目标资源之后，执行一段代码，response执行过滤任务。
2.5 过滤器的生命周期：
1. 过滤器加载的时机：
过滤器在Web服务器启动的时候就加载了，因为要拦截Web资源，所以必须在所有Web资源启动之前就加载过滤器。
2. 生命周期的方法：
1). init方法：
在创建完过滤器对象之后被调用。只执行一次
注：过滤器在Web服务器中也是单例模式
2). doFilter方法：
执行过滤任务方法。执行多次。
3). destroy方法：
Web服务器停止或者Web应用重新加载，销毁过滤器对象。
3. 示例：生命周期的过程
/**
* 第一个过滤器程序
* @author NewBoy
*/
public class HelloFilter implements Filter{
/**
* 1）构造方法
*/
public HelloFilter(){
System.out.println("1)Filter生命周期-构造方法");
}
/**
* 2）init初始化方法
*/
public void init(FilterConfig filterConfig) throws ServletException {
System.out.println("2)Filter生命周期-init方法");
}
/**
* 3）过滤器执行过滤任务的方法
*/
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {
System.out.println("1.request->执行过滤任务");
/**
* 放行
*/
chain.doFilter(request, response);
System.out.println("3.response->执行完过滤任务");
}
/**
* 4)销毁方法
*/
public void destroy() {
System.out.println("4)Filter生命周期-destory方法");
}
}
3 过滤器映射
3.1 过滤器的映射路径
1. Filter与Servlet中<url-pattern>的区别：
1) Servlet中的url-pattern: 访问地址
2) 过滤器中的url-pattern: 过滤的地址
注：浏览器访问目标资源的路径，就算是目标地址不存在，过滤器依然会正常运行。
2. url-pattern过滤匹配：
问：在Servlet中URL地址有哪些写法？
Ø /* 匹配所有的地址
Ø *.后缀名 如：*.action
1) 精确过滤
/index.jsp
2) 模糊过滤
/* 过滤所有的资源，包含jsp，servlet，图片
*.jpg 过滤所有的图片
/manager/* 过滤某个文件夹下所有的资源
3. 有关匹配的要点：
1) url-pattern要么以斜杠开头，要么以*.扩展名结尾 例如： /* 或*.do
2) 不能同时出现这两种方式。例如 /*.do 是非法的
3) 如果存在多个需要被过滤的资源，可以在一个filter-mapping中写多个url-pattern去匹配。或者一个filter对应多个filter-mapping
如：
<!-- 映射路径 -->
<filter-mapping>
<filter-name>hello</filter-name>
<!-- 过滤多个URL的资源 -->
<url-pattern>*.do</url-pattern>
<url-pattern>/newboy/*</url-pattern>
</filter-mapping>
或：
<!-- 过滤多个URL的资源 -->
<filter-mapping>
<filter-name>hello</filter-name>
<url-pattern>*.do</url-pattern>
</filter-mapping>
<filter-mapping>
<filter-name>hello</filter-name>
<url-pattern>/itcast/*</url-pattern>
</filter-mapping>
4) 如果是动态资源servlet，可以使用servlet的访问URL，也可以使用Servlet名称
如：
<!-- 映射路径 -->
<filter-mapping>
<filter-name>hello</filter-name>
<!-- 要过滤的Servlet的名字 -->
<servlet-name>HelloServlet</servlet-name>
</filter-mapping>
3.2 过滤器的过滤类型：
1. 什么是过滤类型：声明哪种类型的请求才可以被拦截（过滤）
在Servlet2.4中一共有4种过滤类型：
REQUEST、FORWARD、INCLUDE、ERROR
2. 默认：当过滤器的访问地址精确匹配时，默认来自于直接访问的请求才可以被拦截
<filter-mapping>
<filter-name>hello</filter-name>
<url-pattern>/HelloServlet</url-pattern>
<dispatcher>REQUEST</dispatcher>
</filter-mapping>
这个配置与不配置是一样的效果。
3. 来自于转发的请求才可以被拦截
1). 在index.jsp转发到HelloServlet
<jsp:forward page="/HelloServlet"/>
2). 过滤器的配置
<filter-mapping>
<filter-name>hello</filter-name>
<url-pattern>/HelloServlet</url-pattern>
<dispatcher>FORWARD</dispatcher>
</filter-mapping>
4. 来自于包含的请求才可以被拦截
1). 页面上使用包含动作，包含HelloServlet
<!-- 包含HelloServlet -->
<jsp:include page="/HelloServlet"/>
2). 过滤器的配置
<filter-mapping>
<filter-name>hello</filter-name>
<url-pattern>/HelloServlet</url-pattern>
<dispatcher>INCLUDE</dispatcher>
</filter-mapping>
5. 来自于错误的请求才可以被拦截
1). 在index.jsp中产生一个异常，如：100/0
<% int num = 100 / 0; %>
2). 在web.xml中配置，错误页面为/HelloServlet
<error-page>
<error-code>500</error-code>
<location>/HelloServlet</location>
</error-page>
3). 过滤器的配置
<filter-mapping>
<filter-name>hello</filter-name>
<url-pattern>/HelloServlet</url-pattern>
<dispatcher>ERROR</dispatcher>
</filter-mapping>
6. 以上的过滤类型可以同时写多个
<filter-mapping>
<filter-name>hello</filter-name>
<url-pattern>/HelloServlet</url-pattern>
<dispatcher>REQUEST</dispatcher>
<dispatcher>FORWARD</dispatcher>
</filter-mapping>
3.3 FilterConfig对象
类似于ServletConfig：得到Servlet中的一些配置信息
如：得到一个参数名为name的配置参数：
getInitParameter("name")
1. 什么是FilterConfig对象：
过滤器配置对象，用于加载过滤器的参数配置
2. 在web.xml文件中配置
<!-- 过滤器配置 -->
<filter>
<!-- 内部名称 -->
<filter-name>HelloFilter</filter-name>
<!-- 类全名：包+简单类名 -->
<filter-class>gz.itcast.a_hello.HelloFilter</filter-class>
<init-param>
<param-name>AAA</param-name>
<param-value>AAA‘value</param-value>
</init-param>
<init-param>
<param-name>BBB</param-name>
<param-value>BBB‘value</param-value>
</init-param>
</filter>
3. 在过滤器器中使用
public void init(FilterConfig filterConfig) throws ServletException {
System.out.println("2)Filter生命周期-init方法");
/**
* 通过FilterConfig对象得到参数配置信息
*/
//得到一个参数
System.out.println(filterConfig.getInitParameter("AAA"));
Enumeration<String> enums = filterConfig.getInitParameterNames();
//遍历所有参数
while(enums.hasMoreElements()){
String paramName = enums.nextElement();
String paramValue = filterConfig.getInitParameter(paramName);
System.out.println(paramName+"="+paramValue);
}
}
3.4 练习一：POST解码
编写过滤器，过滤所有Servlet中使用POST方法提交的汉字的编码。
1. 需求：
1) 有2个Servlet，一个是LoginServlet登录，一个是RegisterServlet注册
2) 有2个JSP页面，1个是login.jsp，有表单，登录名。1个register.jsp，有表单，登录名。都使用POST提交 用户名使用汉字提交
3) 使用过滤器，对所有的Servlet的POST方法进行过滤。
4) 过滤的编码参数，通过filterConfig得到
2. login.jsp
<body>
用户登录
<form action="login" method="post">
登录名：<input type="text" name="name"/>
<input type="submit" value="登录">
</form>
</body>
3. LoginServlet
public class LoginServlet extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=utf-8");
PrintWriter out = response.getWriter();
out.print("登录成功，欢迎您:" + request.getParameter("name"));
out.close();
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
4. register.jsp
<body>
用户注册
<form action="register" method="post">
注册名：<input type="text" name="user"/>
<input type="submit" value="注册">
</form>
</body>
5. RegisterServlet.java
public class RegisterServlet extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=utf-8");
PrintWriter out = response.getWriter();
out.print(request.getParameter("user") + "，注册成功!");
out.close();
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
6. 过滤器
/**
* 编码过滤器
* @author NewBoy
*/
public class EncodeFilter implements Filter {
@Override
public void destroy() {
}
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
//设置编码
request.setCharacterEncoding(charset);
//放行
chain.doFilter(request, response);
}
String charset = null; //定义成员变量
//得到编码的参数
@Override
public void init(FilterConfig filterConfig) throws ServletException {
charset = filterConfig.getInitParameter("charset");
}
}
7. web.xml
<!-- 编码过滤器 -->
<filter>
<filter-name>encode</filter-name>
<filter-class>com.itheima.a.filter.EncodeFilter</filter-class>
<!-- 指定编码 -->
<init-param>
<param-name>charset</param-name>
<param-value>utf-8</param-value>
</init-param>
</filter>
<!-- 过滤所有 -->
<filter-mapping>
<filter-name>encode</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<!-- servlet的配置 -->
<servlet>
<servlet-name>LoginServlet</servlet-name>
<servlet-class>com.itheima.servlet.LoginServlet</servlet-class>
</servlet>
<servlet>
<servlet-name>RegisterServlet</servlet-name>
<servlet-class>com.itheima.servlet.RegisterServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>LoginServlet</servlet-name>
<url-pattern>/login</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>RegisterServlet</servlet-name>
< url-pattern>/register</url-pattern>
</servlet-mapping>
4 过滤器链
4.1 什么是过滤器链：
在一个Web程序中，如果存在多个过滤器过滤同一个Web资源，这些过滤器按前后顺序就组成了一个过滤器链。
4.2 Filter接口：
1. Filter接口中的方法：
doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
1) 参数一： 请求对象ServletRequest父接口，使用的时候，传入的是HttpServletRequest
2) 参数二： 响应对象，使用的时候，传入的是HttpServletResponse对象
3) 参数三： 过滤器链对象，把请求传递给下一个过滤器
2. FilterChain接口中的方法：
doFilter(ServletRequest request, ServletResponse response)：
如果在过滤器中调用这个方法，则会把请求放行。把请求传递给下一个过滤器。
3. 示例：创建两个过滤器，每个过滤器的请求和响应各输出一句话，观察过滤器的执行过程。
/**
* 第一个过滤器
*/
public class FirstFilter implements Filter {
public void init(FilterConfig filterConfig) throws ServletException {
}
public void destroy() {
}
/**
* 执行过滤任务
*/
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {
System.out.println("1.执行FirstFilter的过滤任务");
/**
* 放行，执行下一个过滤器
*/
chain.doFilter(request, response);
System.out.println("5.执行完毕FirstFilter");
}
}
/**
* 第二个过滤器
*/
public class SecondFilter implements Filter {
public void init(FilterConfig filterConfig) throws ServletException {
}
public void destroy() {
}
/**
* 执行过滤任务
*/
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {
System.out.println("2.执行SecondFilter的过滤任务");
/**
* 放行。执行下一个过滤器。没有下一个过滤器，则执行目标资源
*/
chain.doFilter(request, response);
System.out.println("4.执行完毕SecondFilter");
}
}
/**
Web资源：Servlet
*/
public class SecondServlet extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
System.out.println("3.执行SecondServlet目标资源");
response.setContentType("text/html;charset=utf-8");
response.getWriter().print("6.输出内容到浏览器");
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
4.3 过滤器链的执行顺序：
● 疑问：多个过滤器是按什么样的顺序执行的？
按在web.xml中filter和filter-mapping配置的先后顺序来决定，哪个配置在前面，先运行哪个
/**
* 第一个过滤器
*/
public class FirstFilter implements Filter {
public void init(FilterConfig filterConfig) throws ServletException {
}
public void destroy() {
}
/**
* 执行过滤任务
*/
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {
System.out.println("1.执行FirstFilter的过滤任务");
/**
* 放行，执行下一个过滤器
*/
chain.doFilter(request, response);
System.out.println("5.执行完毕FirstFilter");
}
}
/**
* 第二个过滤器
*/
public class SecondFilter implements Filter {
public void init(FilterConfig filterConfig) throws ServletException {
}
public void destroy() {
}
/**
* 执行过滤任务
*/
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {
System.out.println("2.执行SecondFilter的过滤任务");
/**
* 放行。执行下一个过滤器。没有下一个过滤器，则执行目标资源
*/
chain.doFilter(request, response);
System.out.println("4.执行完毕SecondFilter");
}
}
/**
Web资源：Servlet
*/
public class SecondServlet extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
System.out.println("3.执行SecondServlet目标资源");
response.setContentType("text/html;charset=utf-8");
response.getWriter().print("6.输出内容到浏览器");
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
5 装饰者模式
5.1 装饰者模式：
1. 概念：
Decorator Pattern。装饰者模式是在不改变原类文件，使用继承的情况下，动态地扩展一个类的功能。
它是通过创建一个包装对象，也就是装饰来包裹真实的对象。
2. 装饰者模式的使用场景：
在开发过程中，如果发现某个类的某个（某些）方法不满足需求（不够用），那么可以使用装饰者模式对该类进行装饰，
增强这个类的方法。
装饰者模式的作用：专门对类的方法进行增强！
3. 装饰者模式中的各个角色：
1) 抽象角色：给出一个抽象接口，以规范准备接收附加功能的对象(即具体角色)。
Star HttpServletRequest
2) 具体角色：定义一个将要接收附加功能的类。
BabyStrong HttpServletRequestWrapper
3) 装饰角色：持有一个具体角色的实例，继承于抽象角色或具体角色，给具体角色添加附加功能的类。
Decorator1, Decorator2 MyRequestWrapper
4. 开发步骤：
1）编写一个装饰类，需要继承被装饰类 （被装饰类不能是final）
2）在装饰类中声明一个被装饰类型的成员变量
3）在装饰类的构造方法中，接收传入的被装饰类实例
4）在装饰类中重写需要增强的方法
5 示例：
1) 明星有唱歌的行为，这是抽象角色
2) 春哥是实现类，实现了唱歌的行为，这是具体角色
3) 装饰类继承于春哥类，并且持有了Star的成员对象，Star对象通过构造方法传入SpringBrother。
4) 对现有的唱歌行为进行装饰，增加新的功能。
5) 多个装饰角色可以以不同的顺序调用，产生的装饰效果不同。
/**
* 抽象角色：明星的行为
*/
public interface Star {
/**
* 唱歌的行为
*/
void song();
}
/**
*具体角色： 春哥，有唱歌的行为
*/
public class SpringBrother implements Star {
@Override
public void song() {
System.out.println("春哥：想唱就唱，要唱得漂亮");
}
}
/**
* 装饰角色1
* @author NewBoy
*/
public class StarDecorator1 extends SpringBrother {
//持有一个具体对象的实例，注意这里是Star接口，不是SpringBrother类
Star sb;
public StarDecorator1(Star sb) {
this.sb = sb;
}
@Override
public void song() {
//对现有的功能增强
System.out.println("乐队准备，音乐响起~~");
sb.song();
}
}
/**
* 装饰角色2
* @author NewBoy
*/
public class StarDecorator2 extends SpringBrother {
//持有一个具体对象的实例
Star sb;
public StarDecorator2(Star sb) {
this.sb = sb;
}
@Override
public void song() {
System.out.println("隆重出场，主持人报幕！");
sb.song();
}
}
//操作类
public class Test {
public static void main(String[] args) {
//没有装饰的情况
SpringBrother s1 = new SpringBrother();
s1.song();
System.out.println("=============");
//装饰1
Star d1 = new StarDecorator1(s1);
d1.song();
System.out.println("=============");
//在装饰1的基础上再装饰2
Star d2 = new StarDecorator2(d1);
d2.song();
}
}
5.2 装饰者模式与代理模式的区别：
1) 装饰者模式：关注于在一个对象上对方法的增强，并且可以多个装饰器组合使用，一般使用继承的方式实现。
2) 代理模式：关注于对对象的访问控制，对被代理的对象进行控制、改写其原有的功能。
原文地址：https://www.cnblogs.com/tangyang1318761108/p/10591464.html