JavaWeb- Filter 和 Listener

---

Filter和Listener

---

1. Filter

1. 概念：Filter（过滤器），当访问服务器资源时，过滤器可以将请求拦截下来完成一系列特殊的功能。
2. 作用：Filter一般用于完成通用的操作，如：登录验证，统一编码处理，敏感字符的过滤。
3. 使用步骤：
   1. 定义一个类并实现接口Filter
   2. 复写Filter接口中的方法
   3. 配置拦截路径：
      • web.xml配置拦截路径

        
        
        
            
            demo
            
            com.hsh.study.web.filter.FilterDemo
        
        
        
            
            demo
            
            /*
        
        

      • 通过注解的方式配置拦截路径

        // 访问所有资源之前，都会执行该过滤器
        @WebFilter("/*")
        // 定义的类实现Filter
        public class FilterDemo1 implements Filter {
            // 过滤器初始化方法
            @Override
            public void init(FilterConfig filterConfig) throws ServletException {
            }
            // 主要方法
            @Override
            public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
                // 访问资源文件之前会先执行此重写方法，只有资源放行后才能访问
                System.out.println("filterDemo1被执行了....");
                // 放行
                filterChain.doFilter(servletRequest,servletResponse);
            }
            // 过滤器销毁方法
            @Override
            public void destroy() {
            }
        }
        

4. 过滤器的执行执行过程：
   1. 执行过滤器
   2. 执行放行后的资源
   3. 回来执行过滤器放行代码后的代码
5. 过滤器的生命周期：
   1. init：在服务器启动后，创建Filter对象然后调用init方法。只执行一次，通常用于加载资源。
   2. doFilter：在每一次请求被拦截资源时执行，执行多次。
   3. destory：在服务器关闭后，Filter对象被销毁。如果服务器时正常关闭，则执行destory方法。只执行一次，通常用于释放资源
6. 过滤器的配置：
   • 拦截路径配置
     1. 具体的资源路径： /index.jsp 只有访问index.jsp时，过滤器才会被执行。
     2. 拦截目录： /user/* 访问/user下的资源时，过滤器都会被执行。
     3. 后缀名拦截： *.jsp 访问所有后缀名为.jsp的文件时，过滤器都会被执行。
     4. 拦截所有资源： /* 访问所有资源时，过滤器都会被执行。
   • 拦截方式配置：资源被访问的方式
     1. 注解配置
        • 设置dispatcherTypes属性：
          1. REQUEST：默认值，浏览器直接请求资源
          2. FORWARD：转发访问资源
          3. INCLUDE：包含访问资源
          4. ERROR：错误跳转资源
          5. ASYNC：异步访问资源
     2. web.xml配置
        • 设置标签即可
7. 过滤器链（配置多个过滤器时）
   • 执行顺序：假设有两个过滤器<过滤器1，过滤器2>

     graph LR
     A[过滤器1]-->B[过滤器2]
     B[过滤器2]-->C[放行后资源执行]
     C[放行后资源执行]-->D[过滤器2]
     D[过滤器2]-->E[过滤器1]
     

   • 过滤器执行顺序：
     1. 注解配置
        • 按照类名的字符串比较规则比较，值小的先执行。如 AFilter和BFilter，先执行AFilter
     2. web.xml配置
        • 谁的定义在上边，谁先执行。

代理模式

• 概念：
  1. 真实对象：被代理的对象
  2. 代理对象：代理真实的对象
  3. 代理模式：代理对象代理真实对象，达到增强真实对象功能的目的
• 实现方法：
  1. 静态代理：有一个类文件描述代理模式
  2. 动态代理：在内存中形成代理类
     • 实现步骤：
       1. 代理对象和真实对象实现相同的接口
       2. 代理对象 = Proxy.newProxyInstance();
       3. 使用代理对象调用方法
       4. 增强原有对象的方法
     • 增强方式：
       1. 增强参数列表
       2. 增强返回值类型
       3. 增强方法体执行逻辑
• 具体的实现

    // 接口类
    public interface SaleComputer {
        public String sale(double money);
        public void show();
    }
    // 实现接口的实体类
    public class Lenovo implements SaleComputer {
        @Override
        public String sale(double money) {
            System.out.println("花了"+money+"元买了一台联想电脑...");
            return "联想电脑";
        }
        @Override
        public void show() {
            System.out.println("展示电脑....");
        }
    }

    //动态代理实现类
    public class ProxyTest {
        public static void main(String[] args) {
            //1.创建真实对象
            Lenovo lenovo = new Lenovo();
            //2.动态代理增强lenovo对象
            /*
                三个参数：
                    1. 类加载器：真实对象.getClass().getClassLoader()
                    2. 接口数组：真实对象.getClass().getInterfaces()
                    3. 处理器：new InvocationHandler()
            */
            SaleComputer proxy_lenovo = (SaleComputer) Proxy.newProxyInstance(lenovo.getClass().getClassLoader(), lenovo.getClass().getInterfaces(), new InvocationHandler() {
           /*
               代理逻辑编写的方法：代理对象调用的所有方法都会触发该方法执行
                   参数：
                       1. proxy:代理对象
                       2. method：代理对象调用的方法，被封装为的对象
                       3. args:代理对象调用的方法时，传递的实际参数
            */
           @Override
           public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
               /*System.out.println("该方法执行了....");
               System.out.println(method.getName());
               System.out.println(args[0]);
               */
               //判断是否是sale方法
               if(method.getName().equals("sale")){
                   //1.增强参数
                   double money = (double) args[0];
                   money = money * 0.85;
                   System.out.println("专车接你....");
                   //使用真实对象调用该方法
                   String obj = (String) method.invoke(lenovo, money);
                   System.out.println("免费送货...");
                   //2.增强返回值
                   return obj+"_鼠标垫";
               }else{
                   Object obj = method.invoke(lenovo, args);
                   return obj;
               }
             }
         });
         //3.调用方法
         String computer = proxy_lenovo.sale(8000);
         System.out.println(computer);
         proxy_lenovo.show();
        }
    }

2. Listener

1. 概念：
   • 事件监听机制：
     1. 事件：一件事情
     2. 事件源：事件发生的地方
     3. 监听器：一个对象
     4. 注册监听：将事件、事件源、监听器绑定在一起。当事件源上发生指定事件时，执行监听器处理事件。
2. 按监听的对象Servlet监听器可以分为如下几类：
   1. 监听应用程序环境（ServletContext）
   2. 监听绘画对象（HttpSession）
   3. 监听请求消息对象（ServletRequest）
3. 监听器常用接口
   1. ServletContextListener接口
      • 用于监听代表Web应用程序的ServletContext对象创建和销毁的事件
   2. HttpSessionListener接口
      • 用于监听Web应用程序中的用户会话HttpSession对象的创建和销毁的事件
      • HttpSessionListener接口可以在session创建后或session无效前得到通知，接口中的方法为：
        1. sessionCreated()：session创建时调用此方法
        2. sessionDestoryed()：session销毁前调用该方法
   3. ServletRequestListener接口
      • 用于监听Web应用程序中的ServletRequest对象的创建和销毁的事件
4. ServletContextListener：监听ServletContext对象的创建和销毁
   • 方法：
     • void contextDestoryed(ServletContextEvent sce) ： ServletContext对象被销毁之前会调用该方法
     • void contextInitialized(ServletContextEvent sce) ： ServletContext对象创建后会调用该方法
   • 步骤：
     1. 定义一个类，实现ServletContextListener接口
     2. 复写方法
     3. 配置
        • web.xml的配置

              
              
              com.hsh.study.ContextLoaderListener
              
          

        • 注解配置： @WebListener