JavaWeb——Listener和Filter

发表于： 分类于：
字数： 5036 阅读：≈ 11分钟 浏览： 评论：

监听器 listener

其中 servlet规范包括三个技术点：servlet listener filter

什么是监听器？

监听器就是监听某个对象的的状态变化的组件

监听器的相关概念： 事件源：被监听的对象 —– 三个域对象 request、session、servletContext 监听器：监听事件源对象 事件源对象的状态的变化都会触发监听器 —6+2 注册监听器：将监听器与事件源进行绑定 响应行为：监听器监听到事件源的状态变化时 所涉及的功能代码 —程序员编写代码

监听器有哪些？

第一维度：按照被监听的对象划分：ServletRequest域 HttpSession域 ServletContext域 第二维度：监听的内容分：监听域对象的创建与销毁的 监听域对象的属性变化的

mark

监听三大域对象的创建与销毁

监听ServletContext域的创建与销毁的监听器：ServletContextListener

Servlet域的生命周期

何时创建：服务器启动创建 何时销毁：服务器关闭销毁

监听器的编写步骤（重点）

a、编写一个监听器类去实现监听器接口 b、覆盖监听器的方法 c、需要在web.xml中进行配置—注册

监听的方法： 
 1public class MyServletContextListener implements ServletContextListener{
 2
 3@Override
 4//监听context域对象的销毁
 5public void contextDestroyed(ServletContextEvent con) {
 6System.out.println("context销毁...");
 7}
 8
 9@Override
10//监听context域对象的创建
11public void contextInitialized(ServletContextEvent arg0) {
12System.out.println("context创建...");
13}
14}

1<!-- 在web.xml中注册监听器 -->
2<listener>
3<listener-class>com.xpu.create.MyServletContextListener</listener-class>
4</listener>
ServletContextListener监听器的主要作用
  • 初始化的工作：初始化对象 初始化数据 —- 加载数据库驱动 连接池的初始化
  • 加载一些初始化的配置文件 — spring的配置文件
  • 任务调度—-定时器—-Timer/TimerTask

监听Httpsession域的创建于销毁的监听器：HttpSessionListener

HttpSession对象的生命周期

何时创建：第一次调用request.getSession时创建

何时销毁：服务器关闭销毁、session过期、手动销毁

HttpSessionListener的方法 
 1public class MyHTTPSessionListener implements HttpSessionListener {
 2
 3@Override
 4public void sessionCreated(HttpSessionEvent se) {
 5System.out.println("sessionCreated:"+se.getSession().getId());
 6}
 7
 8@Override
 9public void sessionDestroyed(HttpSessionEvent se) {
10System.out.println("sessionDestroyed:"+se.getSession().getId());
11}
12}

监听ServletRequest域创建与销毁的监听器：ServletRequestListener

ServletRequest的生命周期

何时创建：每一次请求都会创建request

何时销毁：请求结束

ServletRequestListener的方法 
 1public class MyServletRequqestListener implements ServletRequestListener {
 2
 3@Override
 4public void requestDestroyed(ServletRequestEvent sre) {
 5System.out.println("创建request");
 6}
 7
 8@Override
 9public void requestInitialized(ServletRequestEvent sre) {
10System.out.println("销毁request");
11}
12}

监听三大域对象的属性变化

域对象的通用的方法

setAttribute(name,value) 方法创建或改变某个新属性

getAttribute(name) 方法通过名称获取属性的值

removeAttribute(name) 方法通过名称删除属性的值

ServletContextAttibuteListener的方法 

 1public class MyServletContextAttributeListener implements ServletContextAttributeListener{
 2
 3@Override
 4public void attributeAdded(ServletContextAttributeEvent scae) {
 5System.out.println(scae.getName());//放到域中的name
 6System.out.println(scae.getValue());//放到域中的value
 7}
 8
 9@Override
10public void attributeRemoved(ServletContextAttributeEvent scae) {
11System.out.println(scae.getName());//获得修改前的name
12System.out.println(scae.getValue());//获得修改前的value
13}
14
15@Override
16public void attributeReplaced(ServletContextAttributeEvent scae) {
17System.out.println(scae.getName());//修改域中的name
18System.out.println(scae.getValue());//修改域中的value
19}
20}

HttpSessionAttributeListener、ServletRequestAriibuteListenr监听器方法同上，故此不再赘述

与session中的绑定的对象相关监听器

与session中的绑定的对象相关监听器即是对象感知监听器

绑定状态：就一个对象被放到session域中

解绑状态：就是这个对象从session域中移除了

钝化状态：是将session内存中的对象持久化（序列化）到磁盘

活化状态：就是将磁盘上的对象再次恢复到session内存中

当用户很多时，怎样对服务器进行优化？这就涉及到对象的钝化与活化，只要把内存中的对象存储到磁盘中就可以从很大程度上减轻内存的消耗，从而达到服务器优化的目的！

绑定与解绑的监听器：HttpSessionBindingListener 

 1public class Person implements HttpSessionBindingListener{
 2
 3@Override
 4//绑定的方法
 5public void valueBound(HttpSessionBindingEvent event) {
 6System.out.println("Person 被绑定");
 7}
 8
 9@Override
10//解绑的方法
11public void valueUnbound(HttpSessionBindingEvent event) {
12System.out.println("Person 解绑");
13}
14}

1protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
2HttpSession session = request.getSession();
3Person p = new Person("tom", 19);
4
5//触发绑定的监听器方法valueBound()
6session.setAttribute("person", p);
7//触发解除绑定的监听器方法valueUnbound()
8session.removeAttribute("person");
9}

钝化与活化的监听器:HttpSessionActivationListener 

 1public class Students implements HttpSessionActivationListener,Serializable{
 2private String name;
 3private int age;
 4//钝化（内存---->硬盘）
 5@Override
 6public void sessionWillPassivate(HttpSessionEvent se) {
 7System.out.println("Student对象被钝化了！");
 8}
 9//活化（硬盘---->内存）
10@Override
11public void sessionDidActivate(HttpSessionEvent se) {
12System.out.println("Student对象被活化了！");
13}
14}

想要实现对象的钝化和活化的时候需要实现Serializable接口，这个属于对象序列化的接口就不赘述了

1public class AServlet extends HttpServlet {
2protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
3HttpSession session = request.getSession();
4Students students = new Students("tom", 19);
5
6session.setAttribute("students", students);
7System.out.println("students被放入session域中");
8}
9}

首先我们访问这个AServlet，然后关掉服务器，注意：不要点击控制台那个停止，如图所示：

mark

此时session域的对象会转储到apache-tomcat-7.0.92\work\Catalina\localhost\你的工程路径这个文件夹中

重新启动服务器后访问BServlet的时候，对象便会活化，重新加载到内存，监听器监听到后便会执行相关的函数：

1public class BServlet extends HttpServlet {
2protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
3//从session域中获得students
4HttpSession session = request.getSession();
5Students attribute = (Students)session.getAttribute("students");
6
7System.out.println(attribute.getName()+":"+attribute.getAge());
8}
9}

可以通过配置文件指定对象钝化时间 —> 对象多长时间不用被钝化

在META-INF下创建一个context.xml：

 1<Context>
 2<!-- maxIdleSwap:session中的对象多长时间不使用就钝化(以分钟为单位) -->
 3<!-- directory:钝化后的对象的文件写到磁盘的哪个目录下 配置钝化的对象文件在 work/catalina/localhost/钝化文件 -->
 4<Manager
 5className="org.apache.catalina.session.PersistentManager"
 6maxIdleSwap="1">
 7<Store className="org.apache.catalina.session.FileStore"
 8directory="mydirectory" />
 9</Manager>
10</Context>

过滤器 filter

filter的简介

过滤器可以拦截所有访问web资源的请求或响应操作。执行过滤任务的对象，这些任务是针对对某一资源（servlet 或静态内容）的请求或来自某一资源的响应执行的，抑或同时针对这两者执行 ，是对客户端访问资源的过滤，符合条件放行，不符合条件不放行，并且可以对目标资源访问前后进行逻辑处理，下面是Filter的基本使用流程：

  1. 编写一个过滤器的类实现Filter接口
  2. 实现接口中尚未实现的方法(着重实现doFilter方法)
  3. 在web.xml中进行配置(主要是配置要对哪些资源进行过滤)

mark

filter生命周期及其API

Filter接口有三个方法，并且这个三个都是与Filter的生命相关的方法

init(Filterconfig)：代表filter对象初始化方法 filter对象创建时执行

doFilter(ServletRequest,ServletResponse,FilterCha)：代表filter执行过滤的核心方法，如果某资源在已经被配置到这个filter进行过滤的话，那么每次访问这个资源都会执行doFilter方法

destory()：代表是filter销毁方法 当filter对象销毁时执行该方法

Filter对象的生命周期：

Filter何时创建：服务器启动时就创建该filter对象

Filter何时销毁：服务器关闭时filter销毁

 1public class QuickFilter1 implements Filter{
 2
 3@Override
 4public void init(FilterConfig filterConfig) throws ServletException {
 5System.out.println("init");
 6}
 7
 8@Override
 9public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
10throws IOException, ServletException {
11//拦截别人的访问
12System.out.println("quick1 running ...");
13//放行请求
14chain.doFilter(request, response);
15}
16
17@Override
18public void destroy() {
19System.out.println("destroy");
20}
21}

web.xml文件的配置：

注意：Filter的过滤顺序是按照filter-mapping的顺序过滤的

 1<filter>
 2<filter-name>QuickFilter</filter-name>
 3<filter-class>com.xpu.web.filter.QuickFilter1</filter-class>
 4</filter>
 5<filter-mapping>
 6<filter-name>QuickFilter1</filter-name>
 7<!-- 默认过滤所有url -->
 8<url-pattern>/*</url-pattern>
 9</filter-mapping>
10
11<filter-mapping>
12<filter-name>QuickFilter2</filter-name>
13<url-pattern>/*</url-pattern>
14</filter-mapping>

Filter的API详解

init(FilterConfig)方法

其中参数config代表 该Filter对象的配置信息的对象，内部封装是该filter的配置信息。

假设web.xml配置了如下的Filter：

1<filter>
2<display-name>QuickFilter3</display-name>
3<filter-name>QuickFilter3</filter-name>
4<filter-class>com.xpu.web.filter.QuickFilter3</filter-class>
5<init-param>
6<param-name>aaa</param-name>
7<param-value>AAA</param-value>
8</init-param>
9</filter>

那么在filterConfig中就油API可以获取这些配置：

 1//Filter的过滤顺序是按照filter-mapping的顺序过滤的
 2public void init(FilterConfig fConfig) throws ServletException {
 3//fConfig维护着Filter的配置信息
 4System.out.println(fConfig.getFilterName());//<filter-name>QuickFilter3</filter-name>
 5
 6//获取初始化参数
 7System.out.println(fConfig.getInitParameter("aaa")); //AAA
 8
 9//获取servletContext
10ServletContext servletContext = fConfig.getServletContext();
11System.out.println("init");
12}

destory()方法

filter对象销毁时执行

doFilter方法 

1doFilter(ServletRequest,ServletResponse,FilterChain)

其中的参数：

ServletRequest/ServletResponse：每次在执行doFilter方法时 web容器负责创建一个request和一个response对象作为doFilter的参数传递进来。该request个该response就是在访问目标资源的service方法时的request和response。

FilterChain：过滤器链对象，通过该对象的doFilter方法可以放行该请求

mark

Filer的配置

url-pattern配置时：

  • 完全匹配 /sertvle1
  • 目录匹配 /aaa/bbb/* 使用的最多的方法

/user/*：访问前台的资源进入此过滤器

/admin/*：访问后台的资源时执行此过滤器

  • 扩展名匹配 *.txt 、*.jsp

注意：url-pattern可以使用servlet-name替代，也可以混用

dispatcher：该属性指定了对某种访问方式的过滤：

REQUEST：默认值，代表直接访问某个资源时执行filter

FORWARD：转发时才执行filter

INCLUDE: 包含资源时执行filter

ERROR：发生错误时 进行跳转是执行filter mark

Filter的作用

  • 公共代码的提取

  • 可以对request和response中的方法进行增强(装饰者模式/动态代理)

这个特点用一个示例来解决get请求或者post请求乱码的问题

对于POST请求：

1//第一种
2request.setCharacterEncoding("utf-8");
3
4//第二种
5request.setCharacterEncoding(this.getServletContext().getInitParameter("charset"));
6//备注：这种获取方式是因为在web.xml中进行了如下配置

1<!-- 设置编码 -->
2<context-param>
3<param-name>charset</param-name>
4<param-value>UTF-8</param-value>
5</context-param>

对于GET请求：

 1public class EncodingFilter implements Filter{
 2
 3@Override
 4public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
 5throws IOException, ServletException {
 6//在传递request之前对request的getParameter方法进行增强
 7/*
 8* 装饰者模式(包装)
 9*
10* 1、增强类与被增强的类要实现统一接口
11* 2、在增强类中传入被增强的类
12* 3、需要增强的方法重写 不需要增强的方法调用被增强对象的
13*/
14
15//被增强的对象
16HttpServletRequest req = (HttpServletRequest) request;
17//增强对象
18EnhanceRequest enhanceRequest = new EnhanceRequest(req);
19
20chain.doFilter(enhanceRequest, response);
21}
22
23@Override
24public void destroy() { }
25
26@Override
27public void init(FilterConfig filterConfig) throws ServletException { }
28}
29
30class EnhanceRequest extends HttpServletRequestWrapper{
31
32private HttpServletRequest request;
33
34public EnhanceRequest(HttpServletRequest request) {
35super(request);
36this.request = request;
37}
38
39//对getParaameter增强
40@Override
41public String getParameter(String name) {
42String parameter = request.getParameter(name);//乱码
43if(value == null || value.trim().equals("")){
44value="";
45}
46try {
47parameter = new String(parameter.getBytes("iso8859-1"),"UTF-8");
48} catch (UnsupportedEncodingException e) {
49e.printStackTrace();
50}
51return parameter;
52}
53}
  • 进行权限控制

下面是一个使用了过滤器自动登录的示例：

mark

过滤器的核心代码：（其他业务逻辑如上图所示）

 1public class AutoLoginFilter implements Filter{
 2
 3@Override
 4public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
 5throws IOException, ServletException {
 6
 7HttpServletRequest req = (HttpServletRequest) request;
 8HttpServletResponse resp = (HttpServletResponse) response;
 9HttpSession session = req.getSession();
10
11//获得cookie中用户名和密码 进行登录的操作
12//定义cookie_username
13String cookie_username = null;
14//定义cookie_password
15String cookie_password = null;
16//获得cookie
17Cookie[] cookies = req.getCookies();
18if(cookies!=null){
19for(Cookie cookie : cookies){
20//获得名字是cookie_username和cookie_password
21if("cookie_username".equals(cookie.getName())){
22cookie_username = cookie.getValue();
23//恢复中文用户名
24cookie_username = URLDecoder.decode(cookie_username, "UTF-8");
25}
26if("cookie_password".equals(cookie.getName())){
27cookie_password = cookie.getValue();
28}
29}
30}
31
32//判断username和password是否是null
33if(cookie_username!=null&&cookie_password!=null){
34//登录的代码
35UserService service = new UserService();
36User user = null;
37try {
38user = service.login(cookie_username,cookie_password);
39} catch (SQLException e) {
40e.printStackTrace();
41}
42//将登录的用户的user对象存到session中
43session.setAttribute("user", user);
44}
45
46//放行
47chain.doFilter(req, resp);
48}
49
50@Override
51public void init(FilterConfig filterConfig) throws ServletException { }
52
53@Override
54public void destroy() { }
55}