盒子
盒子
文章目录
  1. Listener介绍
    1. 接口回调
  2. web监听器
  3. 监听三个作用域创建和销毁的监听器
  4. 监听三个作用域属性状态变更的监听器
  5. 监听httpSession里面存值的状态变更
  • Filter
    1. 如何使用Filter
    2. Filter的生命周期
    3. Filter执行顺序
    4. 细节处理

    • 监听器和过滤器

    2019.07.27 Jzh  热度 ℃

    Listener介绍

    监听器

    • 能做什么事？

    监听某一个事件的发生。状态的改变

    • 监听器的内部机制

    其实就是接口回调。

    接口回调

    • 需求：

      A在执行循环，当循环到5的时候，通知B。

    事先先把某一个对象传递给A，当A执行到5的时候，通过这个对象，来调用B中的方法。但是注意，不是直接传递B的实例，而是传递一个接口的实例过去。(B实现了该接口中的方法)

    接口回调

    web监听器

    总共有8个 划分成三种类型

    1. 定义一个类实现接口

    servletContext域的监听器

    1. 注册 | 配置监听器

    注册servletContext域的监听器

    监听三个作用域创建和销毁的监听器

    request ---- httpServletRequest
session ---- httpSession
application ---- ServletContext

1. ServletContextListener

   servletcontext创建：

      1. 启动服务器的时候

   servletContext销毁：

      2. 关闭服务器或者从服务器移除项目


2. ServletRequestListener

   request创建：

      1. 访问服务器上的任意资源都会有请求出现。

   request销毁：

      2. 服务器已经对这次请求作出了响应。



3. HttpSessionListener

   session的创建

      1. 只要调用request.getSession()

      访问html： 不会创建session
      访问jsp： 会（编译成servlet，自动创建了session，所以session是jsp隐私对象）
      访问servlet：不会

   session的销毁

      2. 超时  默认30分钟

      3. 正常关闭服务器(序列化：存到硬盘)

      4. 非正常关闭 销毁

    作用：

    ServletContextListener

    利用他来，在servletcontext创建的时候，

   1. 完成自己想要的初始化工作

   2. 执行自定义任务调度。 执行某一个任务。比如定时器(Timer)，让他服务器启动时，做一个定时任务

    HttpSessionListener

    统计在线人数

    监听三个作用域属性状态变更的监听器

    session — HttpSessionAttributeListener

    request — ServletRequestAttributeListener

    ServletContext — ServletContextAttributeListener

    这三个监听器方法都是一样的，不过方法参数不同：

    作用域属性监听器方法

    属性状态变化：

    添加属性：setAttribute()

    替换属性：也是setAttribute()，同名会替换

    删除属性removeAttribute()

    可以监听在作用域中值 添加 | 替换 | 移除的动作。

    监听httpSession里面存值的状态变更

    这一类监听器不用注册

    • HttpSessionBindingListener

      1. 让javaBean实现该接口即可

        当该javaBean的实例被绑定到session或者从session中解除绑定，就会触发相应的方法。

    • HttpSessionActivationListener

    用于监听现在session的值是 钝化（序列化） 还是活化（反序列化）的动作

    这个session中被监听的值是实现了该监听器的javaBean的实例，当服务器正常关闭会被钝化，当我们取出这个值时才会被活化，服务器开启是不会的，而且最重要钝化活化属于序列化，则该javaBean也同时一定要实现Serializable接口才行

    • 钝化（序列化）

    把内存中的数据存储到硬盘上

    • 活化（反序列化）

    把硬盘中的数据读取到内存中

    • 钝化的数据是存在服务器端的硬盘，因为session是在服务器端的

    • session钝化活化的用意何在

    session中的值可能会很多，并且我们有很长一段时间不使用这个内存中的值，那么可以考虑把session的值存储到硬盘上【钝化】，等下一次再使用的时候，再从硬盘上提取出来。【活化】

    • 如何让session在一定的时间内钝化

    做配置即可

    1. 在tomcat里面conf/context.xml里面配置

      对所有的运行在这个服务器的项目生效

    2. 在conf/Catalina/localhost/context.xml配置

      对localhost生效， localhost:8080

    3. 在自己的web工程项目中的META-INF/context.xml

      只对当前的工程生效

    maxIdleSwap : 1分钟不用就钝化

directory ： 钝化后的那个文件存放的目录位置


    1
    2
    3
    4
    5
    <Context>
    	<Manager className="org.apache.catalina.session.PersistentManager" maxIdleSwap="1">
    		<Store className="org.apache.catalina.session.FileStore" directory="store"/>
    	</Manager>
    </Context>

    Filter

    过滤器 ，其实就是对客户端发出来的请求进行过滤。浏览器发出，然后服务器派servlet处理。在中间就可以过滤，其实过滤器起到的是拦截的作用。

    • 作用

      1. 对一些敏感词汇进行过滤

      2. 统一设置编码

      3. 自动登录

        …

    如何使用Filter

    1. 定义一个类，实现Filter
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    public class FilterDemo implements Filter{
    	public void destroy(){

    	}
    	public void doFilter(ServletRequest request,ServletResponse response,FilterChain chain) throws IOException,ServletException {
    		System.out.println("来到过滤器了...");
    		chain.doFilter(request,response);
    	}
    	public void init(FilterConfig fConfig) throws ServletException{

    	}
    }
    1. 注册过滤器

    在web.xml里面注册，注册的手法与servlet基本一样。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    <filter>
           <display-name>FilterDemo</display-name>
           <filter-name>FilterDemo</filter-name>
           <filter-class>com.nj.xt.filter.FilterDemo</filter-class>
       </filter>
       <filter-mapping>
           <filter-name>FilterDemo</filter-name>
           <url-pattern>/*</url-pattern>
       </filter-mapping>

    Filter的生命周期

    • 创建

    在服务器启动的时候就创建

    • 销毁

    服务器停止的时候

    Filter执行顺序

    1. 客户顿发出请求，先经过过滤器，如果过滤器放行，那么才能到servlet

    2. 如果有多个过滤器，那么他们会按照注册的映射顺序来排队。只要有一个过滤器，不放行，那么后面排队的过滤器以及servlet都不会收到请求。

    • 定义三个过滤器
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    public class FilterDemo1 implements Filter{
    	public void destroy(){

    	}
    	public void doFilter(ServletRequest request,ServletResponse response,FilterChain chain) throws IOException,ServletException {
    		System.out.println("来到过滤器了...");
    		chain.doFilter(request,response);
    	}
    	public void init(FilterConfig fConfig) throws ServletException{

    	}
    }


    public class FilterDemo2 implements Filter{
    	public void destroy(){

    	}
    	public void doFilter(ServletRequest request,ServletResponse response,FilterChain chain) throws IOException,ServletException {
    		System.out.println("来到过滤器了...");
    		chain.doFilter(request,response);
    	}
    	public void init(FilterConfig fConfig) throws ServletException{

    	}
    }



    public class FilterDemo3 implements Filter{
    	public void destroy(){

    	}
    	public void doFilter(ServletRequest request,ServletResponse response,FilterChain chain) throws IOException,ServletException {
    		System.out.println("来到过滤器了...");
    		chain.doFilter(request,response);
    	}
    	public void init(FilterConfig fConfig) throws ServletException{

    	}
    }
    • 配置三个过滤器
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    <filter>
           <display-name>FilterDemo1</display-name>
           <filter-name>FilterDemo1</filter-name>
           <filter-class>com.nj.xt.filter.FilterDemo1</filter-class>
       </filter>
       <filter-mapping>
           <filter-name>FilterDemo1</filter-name>
           <url-pattern>/*</url-pattern>
       </filter-mapping>

       <filter>
           <display-name>FilterDemo2</display-name>
           <filter-name>FilterDemo2</filter-name>
           <filter-class>com.nj.xt.filter.FilterDemo2</filter-class>
       </filter>
       <filter-mapping>
           <filter-name>FilterDemo2</filter-name>
           <url-pattern>/*</url-pattern>
       </filter-mapping>

       <filter>
           <display-name>FilterDemo3</display-name>
           <filter-name>FilterDemo3</filter-name>
           <filter-class>com.nj.xt.filter.FilterDemo3</filter-class>
       </filter>
       <filter-mapping>
           <filter-name>FilterDemo3</filter-name>
           <url-pattern>/*</url-pattern>
       </filter-mapping>

    过滤器顺序为1,2,3 他的顺序是按filter-mapping的先后顺序来的。然后，这里定义所有的url都经过这三个过滤器，每次经过一个，必须放行，才能进入下一个，不然会被堵住。然后，响应时也会经过他们，顺序会相反。响应回来不会被堵住了。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    public class FilterDemo implements Filter{
    	public void destroy(){

    	}
    	public void doFilter(ServletRequest request,ServletResponse response,FilterChain chain) throws IOException,ServletException {
    		System.out.println("去服务器经过该过滤器了...");
    		//放行代码（这行代码不写，就不会放行，会被堵住去不了服务器）
    		chain.doFilter(request,response);
    		System.out.println("去完服务器回来又经过他了");
    	}
    	public void init(FilterConfig fConfig) throws ServletException{

    	}
    }

    细节处理

    1. init方法的参数：FilterConfig，可以用于获取filter在注册的名字，以及初始化参数。其实这里的设计的初衷与ServletConfig是一样的。

    2. 如果想放行，那么在doFilter方法里面操作，使用参数chain

      chain.doFilter(request,response);放行，让请求到达下一个目标。

    3. <url-pattern>/*</url-pattern>配置拦截哪些请求，写法格式与servlet一样。

      1. 全路径匹配 以/开始

        /LoginServlet

      2. 以目录匹配 以/开始 以*结束

        /demo01/*

      3. 以后缀名匹配，以*开始，以后缀名结束

        *.jsp *.html

    4. 针对dispatcher设置

    REQUEST:只要是请求过来，都拦截，默认就是REQUEST
    FORWARD:只要是转发都拦截。
    ERROR:页面出错发生跳转就拦截。
    INCLUDE：包含页面的时候就拦截。

    1
    2
    3
    4
    5
    6
    <filter-mapping>
           <filter-name>FilterDemo3</filter-name>
           <url-pattern>/*</url-pattern>
           <dispatcher>FORWARD</dispatcher>
           <dispatcher>REQUEST</dispatcher>
       </filter-mapping>
    联系我
    扫一扫，添加JzhBetter
    • 微信扫一扫
    • qq扫一扫