JavaWeb学习笔记之——Filter & Listener

最新推荐文章于 2022-09-29 21:53:22 发布
最新推荐文章于 2022-09-29 21:53:22 发布
阅读量745 收藏
点赞数
分类专栏： Java基础+JavaWeb 文章标签： java 服务器 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36879493/article/details/121252530
版权

Filter & Listener

文章目录

1、Filter：过滤器

1.1、概念

生活中的过滤器：净水器，空气净化器，“土匪”…

在这里插入图片描述

web 中的过滤器：当访问服务器的资源时，过滤器可以将请求拦截下来，完成一些特殊的功能。

过滤器的作用：

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

1.2、快速入门

  1. 步骤：
    1. 定义一个类，实现接口 Filter；
    2. 复写方法；
    3. 配置拦截路径：
      • web.xml
      • 注解

创建一个 FilterDemo1 类：

package com.example.day19_filter_listener.filter;

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

/**
 * 过滤器快速入门
 */
@WebFilter("/*")//访问所有资源之前，都会执行该过滤器
public class FilterDemo1 implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        Filter.super.init(filterConfig);
    }

    @Override
    public void destroy() {
        Filter.super.destroy();
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("FilterDemo1被执行了...");

    }
}

访问 index.jsp：

在这里插入图片描述

可以发现：index.jsp 的内容无法显示，但是执行了 doFilter() 的方法。

在 doFilter() 的方法中添加 “放行” 方法：

//放行
filterChain.doFilter(servletRequest, servletResponse);

在这里插入图片描述

发现，可以展示 index.jsp 的内容了。

1.3、过滤器细节

1.3.1、web.xml 配置

修改 FilterDemo1：（注释掉注解和 “放行”）

package com.example.day19_filter_listener.filter;

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

/**
 * 过滤器快速入门
 */
//@WebFilter("/*")//访问所有资源之前，都会执行该过滤器
public class FilterDemo1 implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        Filter.super.init(filterConfig);
    }

    @Override
    public void destroy() {
        Filter.super.destroy();
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("FilterDemo1被执行了...");

        //放行
        //filterChain.doFilter(servletRequest, servletResponse);
    }
}

配置 web.xml：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <filter>
        <filter-name>demo1</filter-name>
        <filter-class>com.example.day19_filter_listener.filter.FilterDemo1</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>demo1</filter-name>
        <!-- 拦截路径 -->
        <url-pattern>/*</url-pattern>
    </filter-mapping>

</web-app>

再次访问 index.jsp：

在这里插入图片描述

1.3.2、过滤器执行流程

创建 FilterDemo2：

package com.example.day19_filter_listener.filter;

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

@WebFilter("/*")
public class FilterDemo2 implements Filter {
    public void init(FilterConfig config) throws ServletException {
    }

    public void destroy() {
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws ServletException, IOException {
        //对request对象的请求消息增强
        System.out.println("filterDemo2执行了...");

        //放行
        chain.doFilter(request, response);
        //对response对象的响应消息的增强
        System.out.println("filterDemo2回来了...");
    }
}

修改 index.jsp：

<body>
index.jsp...
    <%
        System.out.println("index.jsp...");
    %>
</body>

执行结果：

filterDemo2执行了...
index.jsp...
filterDemo2回来了...

可以看到，过滤器的执行流程如下：

  1. 执行过滤器；
  2. 执行 “放行” 后的资源；
  3. 回来执行过滤器放行代码下边的代码。
1.3.3、过滤器生命周期
  1. init：在服务器启动后，会创建 Filter 对象，然后调用 init 方法。只执行一次。用于加载资源；
  2. doFilter：每一次请求被拦截资源时，会执行。执行多次；
  3. destroy：在服务器关闭后，Filter 对象被销毁。如果服务器是正常关闭，则会执行 destroy 方法。只执行一次。用于释放资源。

创建 FilterDemo2：

package com.example.day19_filter_listener.filter;

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

@WebFilter("/*")
public class FilterDemo3 implements Filter {
    /**
     * 在服务器启动后，会创建Filter对象，然后调用init方法，只执行一次
     * 用于加载资源
     * @param config
     * @throws ServletException
     */
    public void init(FilterConfig config) throws ServletException {
        System.out.println("init...");
    }

    /**
     * 在服务器关闭后，Filter对象被销毁，如果服务器是正常关闭，则会执行destroy方法，只执行一次
     * 用于释放资源
     */
    public void destroy() {
        System.out.println("destory...");
    }

    /**
     * 每一次请求被拦截资源时，会执行，执行多次
     * @param request
     * @param response
     * @param chain
     * @throws ServletException
     * @throws IOException
     */
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws ServletException, IOException {
        System.out.println("doFilter...");

        //放行
        chain.doFilter(request, response);
    }
}
1.3.4、过滤器配置详解

  • 拦截路径配置：

    1. 具体资源路径：/index.jsp 只有访问 index.jsp 资源时，过滤器才会被执行；
    2. 拦截目录：/user/* 访问 /user下的所有资源时，过滤器都会被执行；
    3. 后缀名拦截：*.jsp 访问所有后缀名为 jsp 资源时，过滤器都会被执行；
    4. 拦截所有资源：/* 访问所有资源时，过滤器都会被执行。

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

    • 注解配置：

      设置：设置 dispatcherTypes 属性

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

      创建 FilterDemo5：（演示 dispatcherTypes = DispatcherType.REQUEST，其他参数同理）

      package com.example.day19_filter_listener.filter;

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

//浏览器直接请求index.jsp资源时，过滤器会被执行
@WebFilter(value = "/index.jsp", dispatcherTypes = DispatcherType.REQUEST)
public class FilterDemo5 implements Filter {
    public void init(FilterConfig config) throws ServletException {
    }

    public void destroy() {
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws ServletException, IOException {
        System.out.println("filterDemo5...");

        //放行
        chain.doFilter(request, response);
    }
}

      浏览器直接请求index.jsp资源时，过滤器会被执行。而浏览器转发到 index.jsp 时，不会被执行。我们再创建一个 ServletDemo2 转发到 index.jsp：

      package com.example.day19_filter_listener.servlet;

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


@WebServlet("/user/updateServlet")
public class ServletDemo2 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request, response);
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("updateServlet");

        //转到到index.jsp
        request.getRequestDispatcher("/index.jsp").forward(request, response);
    }
}

      我们使用浏览器直接访问 index.jsp：（过滤器被执行）

      在这里插入图片描述

      我们访问 updateServlet（转发到 index.jsp）：（过滤器不会被执行）

      在这里插入图片描述

      同时，dispatcherTypes 属性也可以设置多个值：

      //浏览器直接请求和转发请求index.jsp资源时，过滤器会被执行
@WebFilter(value = "/index.jsp", dispatcherTypes ={DispatcherType.REQUEST, DispatcherType.FORWARD})

    • web.xml 配置

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

1.3.5、过滤器链（配置多个过滤器）

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

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

创建 FilterDemo6：

package com.example.day19_filter_listener.filter;

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

@WebFilter("/*")
public class FilterDemo6 implements Filter {
    public void init(FilterConfig config) throws ServletException {
    }

    public void destroy() {
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws ServletException, IOException {
        System.out.println("filterDemo6执行了...");

        //放行
        chain.doFilter(request, response);

        System.out.println("filterDemo6回来了...");
    }
}

创建 FilterDemo7：

package com.example.day19_filter_listener.filter;

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

@WebFilter("/*")
public class FilterDemo7 implements Filter {
    public void init(FilterConfig config) throws ServletException {
    }

    public void destroy() {
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws ServletException, IOException {
        System.out.println("filterDemo7执行了...");

        //放行
        chain.doFilter(request, response);

        System.out.println("filterDemo7回来了...");
    }
}

在这里插入图片描述

过滤器先后顺序问题：

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

    如： AFilter 和 BFilter，AFilter 就先执行了。

  2. web.xml 配置： <filter-mapping> 谁定义在上边，谁先执行

2、Listener

2.1、概念

web 的三大组件之一。

时间监听机制：

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

2.2、ServletContextListener

监听 ServletContext 对象的创建和销毁。

方法：

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

步骤：

  1. 定义一个类，实现 ServletContextListener 接口
  2. 复写方法
  3. 配置

创建一个类 ContextLoaderListener 继承 ServletContextListener，复写其中的方法：

package com.example.day19_filter_listener.listener;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

public class ContextLoaderListener implements ServletContextListener {
    /**
     * 监听ServletContext对象创建。ServletContext对象服务器启动后自动创建
     * 在服务器启动后自动调用
     * @param sce
     */
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        System.out.println("ServletContext对象被创建了...");
        ServletContextListener.super.contextInitialized(sce);
    }

    /**
     * 在服务器关闭后，SevletContext对象被销毁。当服务器关闭后方法被调用
     * @param sce
     */
    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        System.out.println("ServletContext对象被销毁了...");
        ServletContextListener.super.contextDestroyed(sce);
    }
}

配置 web.xml：

<listener>
    <listener-class>com.example.day19_filter_listener.listener.ContextLoaderListener</listener-class>
</listener>

启动服务器：

在这里插入图片描述

关闭服务器：

在这里插入图片描述

跟 Servlet 的生命周期很像！

前丨尘忆·梦
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
javaWeb学习笔记+狂神说
01-13
本学习笔记结合了“狂神说”的教学资源，旨在帮助初学者和有经验的开发者深入理解JavaWeb开发技术。 一、Servlet Servlet是Java Web应用程序的核心组件，用于扩展服务器的功能。它是一个Java类，遵循Java Servlet ...
javaweb笔记+狂神+知识总结
04-01
"狂神"可能是指一位知名的JavaWeb讲师或教程作者，他的笔记为学习者提供了深入理解和实践该技术的宝贵资源。下面将详细阐述JavaWeb的主要知识点。 1. **Servlet**：Servlet是Java Web应用程序的核心组件，它是一个...
javaweb学习笔记
11-28
在JavaWeb开发中，过滤器（Filter）和监听器（Listener）是两个重要的辅助组件。过滤器可以拦截HTTP请求和响应，进行预处理或后处理，比如身份验证、字符编码转换等。开发者通过实现javax.servlet.Filter接口，并...
JavaWeb核心学习笔记
04-17
Tomcat+*Servlet+Jsp+Filter+Listener
传智的javaweb学习笔记，比较全的
03-13
这份“传智的javaweb学习笔记”是针对这一领域的全面学习资料，主要包含了以下几个重要知识点： 1. **Servlet基础**：Servlet是JavaWeb的核心，用于处理HTTP请求。学习笔记可能详细解释了Servlet生命周期、如何创建...
Java基础之——Java 线程
前尘忆梦的博客
02-03 4810
Java 线程 1、创建线程类（方法一） Java使用 java.lang.Thread 类代表线程，所有的线程对象都必须是 Thread 类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java 使用线程执行体来代表这段程序流。 Java 中通过继承 Thread 类来创建并启动多线程的步骤如下： 定义 Thread 类的子类，并重写该类的 run() 方法，该 run() 方法的方法体就代表了线程需要完成的任务，因此把 run() 方法称为线程执行体。
Java基础之——数据结构（Map）以及Debug调试
前尘忆梦的博客
02-19 814
数据结构（Map） 1、概述 现实生活中，我们常会看到这样的一种集合：IP 地址与主机名，身份证号与个人，系统用户名与系统用户对象等， 这种一一对应的关系，就叫做映射。Java 提供了专门的集合类用来存放这种对象关系的对象，即 java.util.Map 接口。 我们通过查看 Map 接口描述，发现 Map 接口下的集合与 Collection 接口下的集合，它们存储数据的形式不同，如下图。 Collection 中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。 Ma
JavaWeb学习笔记之——Ajax & Json
前尘忆梦的博客
11-18 792
Ajax & Json 文章目录Ajax & Json1、Ajax1.1、概念1.2、实现方式2、Json2.1、概念2.2、语法 1、Ajax 1.1、概念 ASynchronous JavaScript And XML 异步的 JavaScript 和 XML 异步和同步：客户端和服务器端相互通信的基础上 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pDvc79CJ-1637242119112)(素材/同步和异步.png)] 同步：客户端必须等待服务器
Java内存区域与内存溢出异常
最新发布
前尘忆梦的博客
09-29 689
Java内存区域与内存溢出异常
Java Web 相关知识点（3）： HTML + CSS + JS（及其框架 JQuery） + Bootstrap + Ajax & Json
前尘忆梦的博客
02-28 554
Java基础之——IO
前尘忆梦的博客
02-20 459
IO 1、概述 生活中，你肯定经历过这样的场景。当你编辑一个文本文件，忘记了 ctrl+s ，可能文件就白白编辑了。当你电脑上插入一个 U盘，可以把一个视频，拷贝到你的电脑硬盘里。那么数据都是在哪些设备上的呢？键盘、内存、硬盘、外接设备等等。 我们把这种数据的传输，可以看做是一种数据的流动，按照流动的方向，以内存为基准，分为输入 input 和输出 output ，即流向内存是输入流，流出内存的输出流。 Java 中 I/O 操作主要是指使用 java.io 包下的内容，进行输入、输出操作。输入也叫做读取数
JavaWeb学习笔记之——Response
前尘忆梦的博客
11-05 397
Response 1、HTTP 协议：响应消息 1.1、请求消息：客户端发送给服务器端的数据 数据格式： 请求行 请求头 请求空行 请求体 1.2、响应消息：服务器发送给客户端的数据 数据格式： 响应行 组成：协议/版本 响应状态码 状态码描述 响应状态码：服务器告诉客户端浏览器本次请求和响应的一个状态。 状态码都是 3 位数字 分类： 1xx：服务器就收客户端消息，但没有接受完成，等待一段时间后，发送 1xx 多状态码 2xx：成功。代表：200 3xx：重定向。代表：
Java基础之——Stream 流、方法引用
前尘忆梦的博客
09-17 351
Stream 流、方法引用 1、Stream 流 1.1、引言 传统集合的多步遍历代码 几乎所有的集合（如 Collection 接口或 Map 接口等）都支持直接或间接的遍历操作。而当我们需要对集合中的元素进行操作的时候，除了必需的添加、删除、获取外，最典型的就是集合遍历。例如： import java.util.ArrayList; import java.util.List; /* 使用传统的方式，遍历集合，对集合中的元素进行过滤 */ public class Demo01ForEa
Java基础之——函数式接口及编程
前尘忆梦的博客
09-14 342
函数式接口及编程 1、函数式接口 1.1、概念 函数式接口在 Java 中是指：有且仅有一个抽象方法的接口。 函数式接口，即适用于函数式编程场景的接口。而Java中的函数式编程体现就是 Lambda，所以函数式接口就是可以适用于Lambda 使用的接口。只有确保接口中有且仅有一个抽象方法，Java 中的 Lambda 才能顺利地进行推导。 备注：“语法糖” 是指使用更加方便，但是原理不变的代码语法。例如在遍历集合时使用的 for-each 语法，其实底层的实现原理仍然是迭代器，这便是 “语法糖”。从应用层
JavaWeb学习笔记之——EL & JSTL
前尘忆梦的博客
11-08 306
EL & JSTL 1、JSP 1.1、指令 作用：用于配置 JSP 页面，导入资源文件。 格式：<%@ 指令名称 属性名1=属性值1 属性名2=属性值2 ... %> 分类： page：配置 JSP 页面的 contentType：等同于 response.setContentType() 设置响应体的 mime 类型以及字符集； 设置当前 jsp 页面的编码（只能是高级的 IDE 才能生效，如果使用低级工具，则需要设置 pageEncoding 属性设置当前页面的字符集）。
JavaWeb学习笔记之——Maven
前尘忆梦的博客
02-14 303
Maven 1、Maven 概述 一个对 Maven 比较正式的定义是这么说的： Maven 是一个项目管理工具，它包含了一个项目对象模型 (POM： Project Object Model)，一组标准集合，一个项目生命周期（Project Lifecycle），一个依赖管理系统（Dependency Management System），和用来运行定义在生命周期阶段（phase）中插件（plugin）目标（goal）的逻辑。 maven 能解决什么问题？ 我们需要引用各种 jar 包，尤其是比较大的工
JavaWeb学习笔记之——JDBC 数据库连接池
前尘忆梦的博客
09-29 282
JDBC 数据库连接池 1、数据库连接池 1.1、概念 其实就是一个容器（集合），存放数据库连接的容器。 当系统初始化好后，容器被创建，容器中会申请一些连接对象，当用户来访问数据库时，从容器中获取连接对象，用户访问完之后，会将连接对象归还给容器。 好处： 节约资源 用户访问高效 1.2、实现 标准接口：DataSource javax.sql 包下的 方法： 获取连接：getConnection() 归还连接：Connection.close()。如果连接对象Connection 是从连接池中
Java基础之——Lambda表达式
前尘忆梦的博客
02-20 271
Lambda 表达式 1、函数式编程思想概述 在数学中，函数就是有输入量、输出量的一套计算方案，也就是 “拿什么东西做什么事情”。相对而言，面向对象过分强调 “必须通过对象的形式来做事情”，而函数式思想则尽量忽略面向对象的复杂语法——强调做什么，而不是以什么形式做。 面向对象的思想： 做一件事情，找一个能解决这个事情的对象，调用对象的方法，完成事情。 函数式编程思想： 只要能获取到结果，谁去做的，怎么做的都不重要，重视的是结果，不重视过程。 2、 冗余的 Runnable 代码 2.1、传统写法 当需要启

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值