13_Filter&Listener

  1. Filter：过滤器
  2. Listener：监听器

Filter：过滤器

  1. 概念：

    • 生活中的过滤器：净水器，空气净化器，土匪
    • web中的过滤器：当访问服务器的资源时，过滤器可以将请求拦截下来，完成一些特殊的功能。

    • 过滤器的作用：

      • 一般用于完成通用的操作。如：登录验证，统一编码处理，敏感字符过滤…

  2. 快速入门：

    1. 步骤：

      1. 定义一个类，实现一个接口Filter
      2. 复写方法

      3. 配置拦截路径

        1. web.xml
        2. 注解 ```java package com.jie.web.filter;

import javax.servlet.*; import javax.servlet.annotation.WebFilter; import java.io.IOException;

/**

  • 过滤器快速入门 / @WebFilter(“/“)//访问所有资源之前都会执行该过滤器 public class FilterDemo1 implements Filter {
  1. @Override
  2. public void init(FilterConfig filterConfig) throws ServletException {
  4. }
  6. @Override
  7. public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
  8.     System.out.println("FilterDemo1被执行了");
  10.     //放行
  11.     chain.doFilter(request,response);
  12. }
  14. @Override
  15. public void destroy() {
  17. }

}

  2. 3. 
  3. 过滤器细节
  5.    1. 
  6. web.xml配置
  7. ```xml
  8. <filter>
  9.     <filter-name>demo1</filter-name>
  10.     <filter-class>com.jie.web.filter.FilterDemo1</filter-class>
  11.   </filter>
  13.   <filter-mapping>
  14.     <filter-name>demo1</filter-name>
  15.     <url-pattern>/*</url-pattern>
  16.   </filter-mapping>

  1. 过滤器执行流程

    1. 执行过滤器
    2. 执行放行后的资源
    3. 回来执行过滤器放行下的代码

  2. 过滤器生命周期方法

    1. init：在服务器启动后创建Filter对象，调用init方法，执行一次。用于加载资源
    2. doFilter：每一次请求被拦截时，会执行，执行多次
    3. destroy：在服务器关闭后Filter对象销毁，如果服务器是正常关闭会执行destroy方法，执行一次

  3. 过滤器配置详解

    • 拦截路径的配置：

      1. 具体的资源路径：/index.jsp：只有访问index.jsp资源时，过滤器才会被执行

      2. 拦截目录：/user/*：访问/user下的所有资源时，过滤器都会被执行

      3. 后缀名拦截：*.jsp：访问所有jsp资源时，过滤器都会被执行

      4. 拦截所有资源：/*：访问所有资源时过滤器都会被执行

    • 拦截方式的配置：资源被访问的方式

      • 注解配置：

        • 设置dispatcherTypes属性

          1. REQUEST：默认值。浏览器直接请求资源。
          2. FORWORD：转发访问资源
          3. INCLUDE：包含访问资源
          4. ERROR：错误跳转资源
          5. ASYNC：异步访问资源

        • web.xml配置

          • 设置<dispatcher></dispatcher>标签即可

  4. 过滤器链（配置多个过滤器）

    • 执行顺序：如果有两个过滤器：过滤器1，过滤器2

      1. 过滤器1
      2. 过滤器2
      3. 资源执行
      4. 过滤器2
      5. 过滤器1

    • 过滤器先后顺序问题：

      1. 注解配置：按照类名字符串比较规则比较，值小的先执行

        • 如：AFilter和BFilter, AFilter先执行
      2. web.xml配置：谁定义在上面谁先执行
    1. 案例：

  5. 案例1_登录验证

    • 需求：

      1. 访问day17案例的资源。验证是否登录
      2. 如果登录了执行
      3. 如果未登录，则跳转到登录页面，提示你登录。

  6. 案例2_敏感词汇过滤

    • 需求

      1. 对day17案例录入的数据进行敏感词汇过滤
      2. 敏感词汇参照敏感词汇.txt
      3. 如果是敏感词汇，替换为*
  1.   -

分析：

  1.      1. 对request对象进行增强。增强获取参数相关方法即可
  2.      2. 放行。传递代理对象
  3.   -

增强对象的功能：

  1.      - 设计模式：一些通用的解决固定问题的方式
  2.      1.

装饰模式

  1.      2.

代理模式

  1.         -

概念：

  1.            1. 真实对象：被代理的对象
  2.            2. 代理对象：
  3.            3. 代理模式：代理对象代理真实对象，达到增强真实对象功能的目的
  4.         -

实现方式

  1.            1. 静态代理：有一个类文件描述代理模式
  2.            2. 动态代理：在内存中形成代理类
  4.               - 实现步骤：
  6.                  1. 代理对象和代理对象实现相同的接口
  7.                  2. 代理对象 = Proxy.newProxyInstance()
  8.                  3. 使用代理对象调用方法。
  9.                  4. 增强方法
  10.               - 增强方式：
  12.                  1. 增强参数列表
  13.                  2. 增强返回值类型
  14.                  3. 增强方法执行逻辑
  1. public class ProxyTest {
  4.     public static void main(String[] args) {
  6.         //1.创建真实对象
  8.         final Lenovo lenovo = new Lenovo();
  10.         //2.动态代理
  11.         /*
  12.             三个参数：
  13.                 1.类加载器：真实对象
  14.                 2.接口数组：真实对象
  15.                 3.处理器
  16.          */
  17.         SaleComputer proxy_lenovo = (SaleComputer) Proxy.newProxyInstance(lenovo.getClass().getClassLoader(), lenovo.getClass().getInterfaces(), new InvocationHandler() {
  19.             /*
  20.                 代理逻辑编写的方法：代理对象调用的所有方法都会触发该方法执行
  21.                     参数:
  22.                         1.proxy:代理对象
  23.                         2.method：代理对象调用的方法被封装为的对象
  24.                         3.args:代理对象调用方法时，传递的实际参数
  25.              */
  26.             @Override
  27.             public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  29. //                System.out.println("该方法执行了  ");
  30. //
  31. //                System.out.println(method.getName());
  32. //                System.out.println(args[0]);
  34.                 //1.增强参数
  35.                 //判断是否为sale方法
  36.                 if (method.getName().equals("sale")){
  37.                     //1.增强参数
  38.                     double money = (double)args[0];
  39.                     money = money*0.85;
  41.                     System.out.println("专车接。。");
  43.                     //使用真实的对象调用该方法
  44.                     String o = (String)method.invoke(lenovo, money);
  45.                     System.out.println("免费送货");
  47.                     //2.增强返回值
  48.                     return o+"鼠标垫";
  49.                 }else {
  50.                     //使用真实的对象调用该方法
  51.                     Object o = method.invoke(lenovo, args);
  52.                     return o;
  53.                 }
  55.             }
  56.         });
  59. //        2.调用方法
  60.         String computer = proxy_lenovo.sale(80000.0);
  61.         System.out.println(computer);
  63. //        proxy_lenovo.show();
  65.     }
  66. }

Listener：监听器

  • 概念：web的三大组件之一。

    • 事件监听机制

      • 事件：一件事情
      • 事件源：事件发生的地方
      • 监听器：一个对象
      • 注册监听：将事件，事件源，监听器绑定在一起。当事件源上发生了某个事件后，执行监听代码

  • ServletContextListener：监听ServletContext对象的创建和销毁

    • 方法：

      • void contextDestroyed(ServletContextEvent sce)：ServletContext对象被销毁之前会调用该方法
      • void contextInitialized(ServletContextEvent sce)：ServletContext对象被创建之前会调用该方法

    • 步骤：

      1. 定义一个类，实现ServletContextListener接口

      2. 复写方法

      3. 配置

        1. web.xml
          1. <listener>
          2. <listener-class>com.jie.web.lisinter.ContextLoaderListener</listener-class>
          3. </listener>
  1.      2.

注解

  1.         - [@WebLisinter ](/WebLisinter )