大家好,欢迎来到IT知识分享网。
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://yundeesoft.com/32913.html