05-JavaWeb的三大组件：小程序Servlet+过滤器Filter+监听器Listener

最新推荐文章于 2022-09-12 11:03:58 发布
最新推荐文章于 2022-09-12 11:03:58 发布
阅读量321 收藏 1
点赞数 2
分类专栏： 网络编程 文章标签： servlet tomcat java 过滤器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mmmmmCJP/article/details/116400365
版权

文章目录

Java Web的三大组件【掌握】

组件作用实现接口
Servlet小应用程序，在JavaWeb的服务器中主要做为控制器来使用 可以处理用户的请求并且做出响应javax.servlet.Servlet
Filter过滤器，对用户发送的请求或响应进行集中处理，实现请求的拦截javax.servlet.Filter
Listener监听器，在某些框架中会使用到监听器，如：Spring框架 在Web执行过程中，引发一些事件，对相应事件进行处理。主要是监听Servlet的3大域对象的创建销毁以及属性的变化javax.servlet.XxxListener 每个事件有一个接口

Servlet在web分栏的笔记一有中有详细的描述。

一、过滤器Filter

过滤器介绍

过滤器（filter）本质是Java中预先定义好了不同的接口，和servlet类似。可以过滤不同的内容，具体怎么过滤，需要使用者定义一个实现类，然后实现接口中的过滤方法，在方法中书写过滤的条件。

filter是对客户端访问资源的过滤，符合条件放行，不符合条件不放行。

简而言之，是在servlet之前执行，拦截(过滤)请求，将servlet中一些共同的业务代码抽取出来，这就是过滤器作用。比如：请求乱码处理。

在这里插入图片描述

过滤器API介绍

Filter是由Tomcat启动时创建，是javax.servlet包下面的一个接口，

这个接口中定义了3个方法。

方法说明
void init(FilterConfig filterConfig)过滤器对象创建的时候调用的方法
void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)执行过滤的方法
void destory()过滤器销毁的时候调用的方法

1.tomcat服务器一启动就会调用过滤器中的无参构造方法创建过滤器类的对象，然后立刻调用初始化init方法。

2.每次访问拦截的资源都会执行一次执行过滤的方法doFilter

3.正常关闭tomcat服务器，执行销毁过滤器的方法destory

package javax.servlet;
import java.io.IOException;
public interface Filter {
    void init(FilterConfig var1) throws ServletException;
    void doFilter(ServletRequest var1, ServletResponse var2, FilterChain var3) throws IOException, ServletException;
    void destroy();
}

过滤器开发步骤

项目中如果需要使用到过滤器，使用Servlet3.0的注解方式进行创建。

创建步骤如下：

在这里插入图片描述

  • 第一步：新建一个普通java类，实现Filter接口；
  • 第二步：根据提示重写Filter接口的3个方法；
  • 第三步：在这个类上面通过注解的方式配置这个Filter；
  • 注解@WebFilter：配置Filter的注解，这个注解有两个参数；
    • filterName：设置过滤器的名称；
    • urlPatterns：配置这个过滤器要拦截的资源的路径；
  • 第四步：在doFilter（）方法中，书写过滤的业务逻辑；
  • chain.doFilter()方法放行；

过滤器是在请求资源之前执行，这点非常重要

在这里插入图片描述

【参考代码】

Filter的web.xml版本
package cn.itheima.filter01;

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

public class FilterOne implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        //doFilter 每一次请求都会执行  进行过滤业务逻辑处理
        //如果想放行
//        filterChain.doFilter(servletRequest,servletResponse);
    }
    @Override
    public void destroy() {
    }
}

说明：

filterChain.doFilter(servletRequest,servletResponse);方法被执行，相当于放行的功能。

XML配置 和servlet一样，需要在web.xml中进行配置

	 <filter>
        <filter-name>one</filter-name>
        <filter-class>cn.test.filter01.FilterOne</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>one</filter-name>
        <url-pattern>/filter01.html</url-pattern>
    </filter-mapping>

filter01.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>来拦截我啊！</h1>
</body>
</html>

效果：访问http://localhost:8080/filter01.html

浏览器没有得到html资源。
在这里插入图片描述

Filter的注解版本

注解代码参考

package cn.itheima.filter01;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebFilter("/filter02.html")
public class FilterTwo implements Filter {
    public void destroy() {
    }

    /*
    每一次请求，只要路径匹配，都会执行
     */
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        //code...
        //放行
        System.out.println("执行过滤方法。。。");
        chain.doFilter(request, response);  //放行，没有拦截，准许用户访问资源
    }

    public void init(FilterConfig config) throws ServletException {

    }

}

filter02.html页面

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>请不要拦截我</h1>
</body>
</html>

效果：

访问链接：http://localhost:8080/filter02.html

在这里插入图片描述

可以修改idea中的配置过滤器的模板

#if (${PACKAGE_NAME} && ${PACKAGE_NAME} != "")package ${PACKAGE_NAME};#end
#parse("File Header.java")
@javax.servlet.annotation.WebFilter("/${Entity_Name}")
public class ${Class_Name} implements javax.servlet.Filter {
    @Override
    public void destroy() {
    }
    @Override
    public void doFilter(javax.servlet.ServletRequest req, javax.servlet.ServletResponse resp, javax.servlet.FilterChain chain) throws javax.servlet.ServletException, java.io.IOException {
        javax.servlet.http.HttpServletRequest request = (javax.servlet.http.HttpServletRequest)req;
        javax.servlet.http.HttpServletResponse response = (javax.servlet.http.HttpServletResponse)resp;
        //your  code.... 
        chain.doFilter(request, response);
    }
    @Override
    public void init(javax.servlet.FilterConfig config) throws javax.servlet.ServletException {
    }
}

总结:

**chain.doFilter(request, response)**方法的作用:

当不写**chain.doFilter(request, response)方法时候，html文件访问不到，被拦截；当有了chain.doFilter(request, response)**方法时候，html文件可以访问，被放行；

所以：**chain.doFilter(request, response)**具有放行的作用。

过滤器的执行流程

1、过滤器中代码执行顺序

在这里插入图片描述

说明：servlet响应给浏览器的内容，过滤器也对其进行了拦截过滤。

代码演示

ProcessFilter.java

@WebFilter("/process")
public class ProcessFilter implements Filter {
    @Override
    public void destroy() {
    }
    @Override
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        //your  code....
        System.out.println("doFilter()之前执行。。。");
        chain.doFilter(request, response);
        System.out.println("doFilter()之后执行。。。");
    }
    @Override
    public void init(FilterConfig config) throws ServletException {
    }
}

ProcessServlet.java

@WebServlet("/process")
public class ProcessServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("Servlet执行了。。。");
    }
}

执行效果图：

在这里插入图片描述

2、过滤器中请求和响应对象

过滤器的doFilter(ServletRequest req, ServletResponse resp, FilterChain chain)方法中的request对象和response对象

与servlet中请求对象和响应对象相同。

过滤器的执行流程如下：

  1. 客户端（浏览器）的HttpRequest到达Servlet之前，被Filter的doFilter()方法拦截；
  2. 根据需要，我们可以获取或者修改HttpRequest对象中的数据；
  3. 在这个请求响应给浏览器之前，Filter拦截了HttpResponse对象；
  4. 根据需要，我们可以获取或者修改HttpReponse对象中的数据；
  5. 最后，由doFilter中的chain决定是否让这个请求通过；

代码演示

ProcessServlet.java

@WebServlet("/processServlet")
public class ProcessServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //代码肯定被执行
        System.out.println(request);
        System.out.println(response);
        System.out.println("servlet被执行了。。。");
    }
}

ProcessFilter.java

@WebFilter("/processServlet")
public class ProcessFilter implements Filter {
    public void destroy() {
    }
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        //code...
        System.out.println("在doFilter()之前执行。。。");
        System.out.println(request);
        System.out.println(response);
        chain.doFilter(request, response);
        System.out.println("在doFilter()之后执行。。。");
        // 拦截请求对象和响应对象就是servlet请求对象和响应对象
    }

    public void init(FilterConfig config) throws ServletException {

    }

}

控制台运行效果图

在这里插入图片描述

3、多个Filter执行顺序

问题：如果多个过滤器都对相同路径进行匹配，执行顺序该是什么？

同一包下，拦截同一资源Filter默认是按照字母顺序执行的，如果过滤器名字第一个字母相同，再看过滤器名字的第二个字母，以此类推。从而形成一个执行链条。

执行流程图：

在这里插入图片描述

代码演示

AFilter.java

@WebFilter("/apple")
public class AFilter implements Filter {
    @Override
    public void destroy() {
    }
    @Override
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        //your  code....
        System.out.println("这是在AFilter之前执行。。。");
        chain.doFilter(request, response);
        System.out.println("这是在AFilter之后执行。。。");
    }
    @Override
    public void init(FilterConfig config) throws ServletException {
    }
}

BFilter.java

@WebFilter("/apple")
public class BFilter implements Filter {
    @Override
    public void destroy() {
    }
    @Override
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        //your  code....
        System.out.println("这是在BFilter之前执行。。。");
        chain.doFilter(request, response);
        System.out.println("这是在BFilter之后执行。。。");
    }
    @Override
    public void init(FilterConfig config) throws ServletException {
    }
}

CFilter.java

@WebFilter("/apple")
public class CFilter implements Filter {
    @Override
    public void destroy() {
    }
    @Override
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        //your  code....
        System.out.println("这是在CFilter之前执行。。。");
        chain.doFilter(request, response);
        System.out.println("这是在CFilter之后执行。。。");
    }
    @Override
    public void init(FilterConfig config) throws ServletException {
    }
}

AppleServlet.java

@WebServlet("/apple")
public class AppleServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("AppleServlet");
    }
}

上述代码执行效果图：
在这里插入图片描述

过滤器的生命周期

之前学习过servlet生命周期，并且上面，分析了Filter的执行流程。

那么，当我们并没有向Filter发送请求，请求是怎么进入到doFilter()中的呢？

Filter类的对象是在什么时候创建的呢？创建之后又是怎么工作的呢？最后是在什么时候销毁的呢？这些问题就是Filter的生命周期问题。

接下来看下过滤器filter的生命周期，和servlet的生命周期差不多。

在这里插入图片描述

1、Filter生命周期代码演示

接下来我们可以通过以下代码对Filter的生命周期问题进行验证

LifecycleFilter.java

@WebFilter("/lifecycle")
public class LifecycleFilter implements Filter {
    @Override
    public void destroy() {
        System.out.println("被销毁了。。。");
    }

    @Override
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        //your  code....
        System.out.println("doFilter()被执行了。。。");
        chain.doFilter(request, response);
    }

    @Override
    public void init(FilterConfig config) throws ServletException {
        System.out.println("初始化了。。。");
    }

    public LifecycleFilter() {
        System.out.println("构造方法被执行了。。。");
    }
}

重启服务器：在浏览器输入访问过滤器地址，并查看控制台。

http://localhost:8080/lifecycle

在这里插入图片描述

【结论】

  1. Filter类的对象是在服务器启动的时候创建的；
  2. Filter类对象创建完成后会调用init()方法；
  3. 每当一个请求的路径是满足过滤器的配置路径，那么就会执行一次过滤器的doFilter方法 (类似于service方法)
  4. 当服务器停止的时候，销毁过滤器，执行过滤器的destory方法
2、doFilter()方法三个参数

doFilter()方法是拦截请求的方法，只要一个请求符合Filter拦截路径，都会被doFilter()方法拦截。doFilter()方法有3个参数，这3个参数的作用分别如下：

参数说明
ServletRequest reqServletRequest是HttpServletRequest类的父接口，其中包含了被拦截的请求的信息
ServletResponse respServletResponse是HttpServletResponse类的父接口，其中包含了被拦截的响应的信息
FilterChain chain**FilterChain给Filter提供了放行的方法。chain.doFilter();**FilterChain 是一个接口，里面doFilter(req，resp)方法，作用是将浏览器提交请求对象和响应对象传到过滤器的资源里面去，所以doFilter()方法具有放行的作用。
3、destory()方法

过滤器的销毁方法。服务器停止的时候，销毁过滤器，调用一次destory方法。

【测试】

    @Override
    public void destroy() {
      System.out.println("服务器关闭");
        System.out.println("LifecycleFilter的destory方法执行了.......................");
    }

【关闭tomcat】查看结果

在这里插入图片描述

Filter生命周期小结
  1. 当服务器启动的时候，过滤器就被初始化了，执行过滤器的init方法
  2. 每当一个请求的路径是满足过滤器的配置路径，那么就会执行一次过滤器的doFilter方法
  3. 当服务器停止的时候，销毁过滤器，之后，执行过滤器的destory方法

过滤器的映射路径

映射路径指的是当前这个Filter需要拦截的路径。这个路径的配置方式有3种：

  1. 精确匹配**：匹配指定的urlpattern；**
  2. 模糊匹配：匹配复合条件的一类路径；
  3. 多路径匹配：一个filter匹配多个资源；
1、精确匹配

精确匹配，要求访问的资源路径必须与Filter的urlPatterns中的配置一致。

精确匹配说明
urlPatterns = “/index.jsp”拦截对index.jsp页面的请求
urlPatterns = “/loginServlet”拦截对loginServlet的请求
urlPatterns = “/a.jsp”拦截对a.jsp的请求
2、模糊匹配

有时候，我们需要对这个服务器中的所有请求都有所特殊处理，比如处理post请求的乱码问题。

我们就需要对所有的请求都设置乱码处理。这时候，就需要对所有的请求进行拦截。

如果通过上面的精确匹配模式，需要配置很多的请求，这样就比较麻烦了。

如果通过urlPatterns的模糊匹配，就能够对这些请求进行统一处理。

​ 模糊匹配主要有以下3种写法：

模糊匹配使用示例说明
urlPatterns = “/*”urlPatterns = “/*”对所有的请求都进行拦截
urlPatterns = “/xxx/*”urlPatterns = “/user/*”对映射路径中/user下的所有资源进行拦截
urlPatterns = “*.xxx”urlPatterns = “*.jsp”对指定后缀的请求进行拦截 不加/
使用场景一

今天电商狂欢日，产品经理要求对所有购买的电脑进行打9折

http://localhost:8080/computer/dell

http://localhost:8080/computer/xiaomi

http://localhost:8080/computer/thinkpad

效果：我们只要过滤器中路径设置为：/computer/*，那么任何电脑的请求都会被过滤器拦截。
在这里插入图片描述

使用场景二

网站有很多种请求：浏览商品，购买商品，删除商品；用户登录，修改用户信息，注册用户信息。

我们可以将请求分为两类：xxx.action和xxx.do

这样可以分清楚网站请求的类别。

效果：我们只要在过滤器中设置路径为：*.action，那么，所有以.action结尾的请求都会被过滤器拦截。

代码演示

对所有的请求都进行拦截:

@WebFilter("/*")
public class OneFilter implements Filter {
    public void destroy() {
    }
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        System.out.println("OneFilter执行了。。。");
//        chain.doFilter(request, response);
    }
    public void init(FilterConfig config) throws ServletException {
    }
}

对映射路径中/user下的所有资源进行拦截:

@WebFilter("/user/*")
public class TwoFilter implements Filter {
    public void destroy() {
    }
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        System.out.println("TwoFilter执行了。。。。。");
//        chain.doFilter(request, response);
    }
    public void init(FilterConfig config) throws ServletException {
    }
}

对指定后缀的请求进行拦截:

@WebFilter("*.action")
public class ThrFilter implements Filter {
    public void destroy() {
    }
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        System.out.println("ThrFilter执行了。。。。");
//        chain.doFilter(request, response);
    }
    public void init(FilterConfig config) throws ServletException {
    }
}
3、多个路径匹配

一个过滤器可以匹配多个路径

xml实现方式

在这里插入图片描述

注解实现方式

在这里插入图片描述

温馨提示：路径如果不加 /，Tomcat会报错！

在这里插入图片描述

过滤器的拦截方式

什么是拦截方式：对浏览器或服务器过来的请求进行拦截。

1.通过浏览器发送的请求：默认拦截
2.请求转发：默认不拦截

**案例：**演示过滤器的拦截方式。分别从浏览器和服务器转发过来的请求。

【代码如下】

1、浏览器请求【默认的拦截】

只对从浏览器直接发送过来的请求进行拦截，值：REQUEST

HelloServlet:

@WebServlet("/helloServlet")
public class HelloServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("helloServlet 接收了请求。。。。。");
        //响应数据
        response.getWriter().print("hello");
    }
}

HelloFilter:

@WebFilter("/helloServlet")
public class HelloFilter implements Filter {
    public void destroy() {
    }

    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        System.out.println("HelloFilter拦截了请求。。。。");
        chain.doFilter(request, response);
        System.out.println("HelloFilter拦截了响应。。。。");
    }
    public void init(FilterConfig config) throws ServletException {
    }
}

在浏览器中直接访问HelloServlet，显示是被拦截了。

2. 请求转发【默认不拦截】
拦截类型作用
REQUEST只对直接来源于浏览器的请求才过滤(包含重定向)
FORWARD对服务器的转发进行过滤

在filter.jsp转发到HelloServlet，查看过滤器是否拦截。

filter.jsp页面代码：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
   <%-- <jsp:forward page="/helloServlet"/>--%>
     <%
      request.getRequestDispatcher("/helloServlet").forward(request, response);
  	 %>
</body>
</html>

在浏览器上直接访问filter.jsp页面。
在这里插入图片描述

idea控制台：
在这里插入图片描述

我们发现直接访问jsp,然后在jsp页面转发访问helloServlet，过滤器没有拦截。

因为过滤器默认只拦截从浏览器的直接请求，不拦截请求转发的请求。

如果希望过滤器对请求转发的请求进行拦截，我们必须按照如下进行配置。

过滤器配置web.xml拦截
	<!--配置一个过滤器-->
    <filter>
        <!--过滤器名字-->
        <filter-name>hello</filter-name>
        <!--过滤器的类全名-->
        <filter-class>com.itheima.sh.demo01.HelloFilter</filter-class>
    </filter>
    <filter-mapping>
        <!--过滤器名字，必须与上面的名字相同-->
        <filter-name>hello</filter-name>
        <!--过滤的地址-->
        <url-pattern>/helloServlet</url-pattern>
        <!--配置拦截方式，为转发-->
        <dispatcher>FORWARD</dispatcher>
        <!--配置拦截方式，浏览器的请求-->
        <dispatcher>REQUEST</dispatcher>
    </filter-mapping>

1）在web.xml中配置之后必须去掉过滤器中的注解

2）如果只配置 FORWARD 只会拦截转发的请求，

​ 必须还得配置 REQUEST同时还得拦截浏览器的请求。

//@WebFilter("/helloServlet")
public class HelloFilter implements Filter {
    public void destroy() {
    }
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        System.out.println("HelloFilter拦截了请求。。。。");
        chain.doFilter(request, response);
        System.out.println("HelloFilter拦截了响应。。。。");
    }
    public void init(FilterConfig config) throws ServletException {
    }
}
过滤器配置注解拦截

注意：去掉web.xml文件中的拦截代码。

@WebFilter(urlPatterns = "/helloServlet", dispatcherTypes = {DispatcherType.FORWARD,DispatcherType.REQUEST})
public class HelloFilter implements Filter {
    public void destroy() {
    }
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        System.out.println("HelloFilter拦截了请求。。。。");
        chain.doFilter(request, response);
        System.out.println("HelloFilter拦截了响应。。。。");
    }
    public void init(FilterConfig config) throws ServletException {
    }
}

过滤器Filter应用案例

【案例一】Filter统一解决post请求乱码问题

8.0版本以上的tomcat为我们解决了get请求的乱码问题。我们需要自己处理post请求的乱码问题，因为我们的一个项目中可能有很多的请求。

当然，我们可以在每一个Servlet中都对post的乱码进行处理。

但是，Filter给我们提供了一个更加便捷的方式。

我们自定义一个Filter类，拦截所有的请求，然后对这些请求进行post乱码处理即可。

【代码演示】

1）页面：register.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>form</title>
</head>
<body>
<form action="/registerServlet" method="post">
    用户名：<input type="text" name="name"><br>
    密码：<input type="password" name="password"><br>
    <input type="submit" value="提交">
</form>
</body>
</html>

2）后台 servlet代码

RegisterServlet.java

@WebServlet("/registerServlet")
public class RegisterServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //处理请求乱码
        //request.setCharacterEncoding("utf-8");
        //处理响应乱码
        //response.setContentType("text/html;charset=utf-8");
        /*
            在这里我们需要处理post请求乱码和响应乱码，如果多个servlet，那么我们就会每个servlet
            中都会进行处理，这样代码会冗余，我们可以考虑使用过滤器来解决处理乱码问题
         */
        //获取用户数据
        String name = request.getParameter("name");
        String password = request.getParameter("password");
        System.out.println("name = " + name);
        response.getWriter().println("哈哈，乱码解决楼！");
    }
}

说明：

上述代码中我们需要处理post请求乱码和响应乱码，如果多个servlet，那么我们就会每个servlet中都会进行处理，这样代码会冗余，我们可以考虑使用过滤器来解决处理乱码问题。

即将处理乱码的代码放到过滤器中来处理。

3）过滤器EncodingFilter中的代码：

@WebFilter("/*")
public class EncodingFilter implements Filter {
    public void destroy() {
    }
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        //统一处理post请求乱码
        request.setCharacterEncoding("utf-8");
        //统一处理响应乱码
        response.setContentType("text/html;charset=utf-8");
        //放行
        chain.doFilter(request, response);
    }
    public void init(FilterConfig config) throws ServletException {
    }
}
【案例二】登录权限校验

【需求】

  1. 登录之后：能够访问hack.html，然后下载黑客视频资源，成为黑客；
  2. 未登录：跳转到登录页面，并提示"请先登录"；
  3. 我们对hack.html页面进行过滤，

1.页面：hack.html 访问这个页面要求必须先登录，不登录不能访问使用过滤器书写代码让其跳转到登录页面login.html.

2.登录LoginServlet中获取用户名和密码，存放到User对象中，然后在session中。最后重定向到hack.html

3.使用一个过滤器对hack.html 进行拦截，先从session中获取用户信息，如果没有登录，获取的是null。跳转到登录页面。如果不为null，说明登录了，可以访问hack.html。

下载资源页面：hack.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>黑客。。</h1>
<a href="javascript:;">黑客资源</a>
</body>
</html>

login.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
 <form action="/loginServlet" method="post">
     用户名：<input type="text" name="name"><br>
     密码：<input type="password" name="password"><br>
     <input type="submit" value="登录">
 </form>
</body>
</html>

JavaBean：User类

public class User {
    private String name;
    private String password;

    public User(String name, String password) {
        this.name = name;
        this.password = password;
    }

    public User() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

LoginServlet代码

@WebServlet("/loginServlet")
public class LoginServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //获取用户名和密码
        String name = request.getParameter("name");
        String password = request.getParameter("password");
        User user = new User(name,password);
        System.out.println("user = " + user);
        //将用户信息保存session中
        request.getSession().setAttribute("user",user);
        response.sendRedirect("/hack.html");
    }
}

LoginFilter代码

@WebFilter("/hack.html")
public class LoginFilter implements Filter {
    public void destroy() {
    }

    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        //获取用户信息
        User user = (User) request.getSession().getAttribute("user");
        if (user == null) {
            //没有登陆
            response.sendRedirect("/login.html");
            return;
        } else {
            //放行。。
            chain.doFilter(request, response);
        }
    }
    public void init(FilterConfig config) throws ServletException {
    }
}

二、监听器Listener

监听器介绍

Listener作用

监听作用域(请求域，会话域，上下文域)中发生的各种事件，并且对事件做出响应。

1)域对象的创建和销毁
2)域对象中属性添加、删除和修改

监听器的接口分类
事件源监听器接口时机
ServletContextServletContextListener上下文域创建和销毁
ServletContextServletContextAttributeListener上下文域属性增删改的操作
**HttpSession **HttpSessionListener会话域创建和销毁
**HttpSession **HttpSessionAttributeListener会话域属性增删改的操作
HttpServletRequestServletRequestListener请求域创建和销毁
HttpServletRequestServletRequestAttributeListener请求域属性增删改的操作
ServletContextListener使用

演示最经常使用的监听器ServletContextListener，其余监听器不经常使用，使用的话，方式都一样的。

【1】作用

用于监听上下文域ServletContext的创建和销毁

【2】ServletContext运行时机

a)创建：Web服务器启动，加载项目的时候
b)销毁：Web项目关闭的时候

【3】接口中的方法

接口中的方法功能
void contextDestroyed(ServletContextEvent sce)上下文域销毁的时候执行1次
void contextInitialized(ServletContextEvent sce)上下文域初始化的时候执行1次

上述方法参数都有一个ServletContextEvent 事件类，

可以调用该类中的方法获取域对象ServletContext

ServletContextEvent中的方法
ServletContext getServletContext()  // 得到上下文对象

监听器开发步骤

对于监听器使用描述

ServletContext对象创建完成：表示tomcat启动完成。

在实际开发中我们可以在监听器的初始化方法contextInitialized中书写加载配置文件，获取连接池。

然后存储到ServletContext域对象中，当前项目其他的servlet就可以使用了。

1)编写一个类，实现ServletContextListener监听器的接口
2)重写接口中所有的方法
3)在web.xml中配置listener，或者使用注解@WebListener

【代码实现】

监听器：

public class ContextDemoListener implements ServletContextListener{
    @Override
    public void contextInitialized(ServletContextEvent servletContextEvent) {
        System.out.println("监听器：ServletContext对象创建了。。。。。");
        /*
            ServletContext对象创建完成：表示tomcat启动完成。
            我们可以加载配置文件(连接池)
         */
        ServletContext servletContext = servletContextEvent.getServletContext();
        servletContext.setAttribute("dataSource","连接池");
    }
    @Override
    public void contextDestroyed(ServletContextEvent servletContextEvent) {
        System.out.println("监听器：ServletContext对象销毁了。。。。。");
    }
}
web.xml注册监听器

告知tomcat服务器具有监听器。

 <!--注册监听器-->
    <listener>
        <listener-class>com.itheima.sh.listener.demo02.ContextDemoListener</listener-class>
    </listener>
使用注解注册监听

直接在监听器上面添加注解@WebListener即可。

@WebListener
public class ContextDemoListener implements ServletContextListener{
    @Override
    public void contextInitialized(ServletContextEvent servletContextEvent) {
        System.out.println("监听器：ServletContext对象创建了。。。。。");
        /*
            ServletContext对象创建完成：表示tomcat启动完成。
            我们可以加载配置文件(连接池)
         */
        ServletContext servletContext = servletContextEvent.getServletContext();
        servletContext.setAttribute("dataSource","连接池");
    }

    @Override
    public void contextDestroyed(ServletContextEvent servletContextEvent) {
        System.out.println("监听器：ServletContext对象销毁了。。。。。");

    }
}

ServletContextListener案例

【案例一】模拟spring框架

需求：可以在项目启动时读取配置文件。

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_3_1.xsd"
         version="3.1">
    

    <!--全局配置参数-->
    <context-param>
        <param-name>configLocation</param-name>
        <param-value>words.properties</param-value>
    </context-param>
</web-app>

监听器代码：

@WebListener
public class MyListener implements ServletContextListener {

    // 监听ServletContext创建
    /*
        ServletContextEvent 上下文事件对象，获取ServletContext
     */
    @Override
    public void contextInitialized(ServletContextEvent servletContextEvent) {
        System.out.println("ServletContext已经创建了...");

        // 通过servletContextEvent获取上下文对象
        ServletContext servletContext = servletContextEvent.getServletContext();
        // 我可以去加载公司定义配置文件的名称....
        String configLocation = servletContext.getInitParameter("configLocation");
        System.out.println("动态获取配置文件名称：" + configLocation);
    }

    // 监听ServletContext销毁
    @Override
    public void contextDestroyed(ServletContextEvent servletContextEvent) {
        System.out.println("ServletContext已经销毁了....");
    }
}

【案例二】统计在线人数

需求：有用户使用网站,在线人数就+1;用户退出网站,在线人数就-1

使用 ServletContext域对象 存储在线总人数

使用 ServletContextListener监听器，在项目启动时，初始化总人数为0

使用 HttpSessionListener监听器，用户访问，人数+1，用户退出，人数-1

使用 LogoutServlet控制器，对当前会话的session销毁

代码演示

① InitNumberListener

@WebListener
public class InitNumberListener implements ServletContextListener {

    @Override
    public void contextInitialized(ServletContextEvent servletContextEvent) {
        // 获取上下文域对象
        ServletContext servletContext = servletContextEvent.getServletContext();
        // 初始化在线人数
        servletContext.setAttribute("number", 0);
    }

    @Override
    public void contextDestroyed(ServletContextEvent servletContextEvent) {

    }
}

② NumberChangeListener

@WebListener
public class NumberChangeListener implements HttpSessionListener {

    // 会话建立，在线人数+1
    @Override
    public void sessionCreated(HttpSessionEvent httpSessionEvent) {
        // 获取session域对象
        HttpSession session = httpSessionEvent.getSession();
        // 获取上下文域对象
        ServletContext servletContext = session.getServletContext();
        // 取出在线人数
        Integer number = (Integer) servletContext.getAttribute("number");
        // +1
        servletContext.setAttribute("number", number + 1);
    }

    // 会话销毁，在线人数-1
    @Override
    public void sessionDestroyed(HttpSessionEvent httpSessionEvent) {
        // 获取session域对象
        HttpSession session = httpSessionEvent.getSession();
        // 获取上下文域对象
        ServletContext servletContext = session.getServletContext();
        // 取出在线人数
        Integer number = (Integer) servletContext.getAttribute("number");
        // -1
        servletContext.setAttribute("number", number - 1);
    }
}

③ index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>${NAME}</title>
  </head>
  <body>
  <h3>listener知识学习</h3>

  <h5>在线人数：${applicationScope.number}</h5>
  <a href="${pageContext.request.contextPath}/LogoutServlet">用户退出</a>
  </body>
</html>

④ LogoutServlet

@WebServlet("/LogoutServlet")
public class LogoutServlet extends HttpServlet {

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request, response);
    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // 销毁session
        request.getSession().invalidate();

        response.getWriter().write("logout");
    }

}
编程小栈
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
JavaWeb的三大组件(Servlet、Filter、Listener)
白日梦
04-07 640
前言： 之前介绍了关于JavaWeb的一些知识点。其中包括一些JavaWeb的核心内容。前几篇有对JavaWeb三大组件之一的Servlet作了一定的知识了解。因此这篇文章主要介绍JavaWeb三大组件的Servlet和Filter(过滤器)和Listenter(监听器)的知识。 Servlet 1. Servlet相关信息 1.概念： Servlet就是一个接口，定义了Java类被浏览器访问到(tomcat识别)的规则。运行在服务器端的小程序。 将来我们自定义一个类，实现Servlet接口，复写方法。 2
Servlet的基本理解
少年啦飞啦的博客
01-08 762
什么是Servlet Servlet（Server Applet），全称Java Servlet Applet，直译过来就是运行在服务器端的应用程序。是用Java编写的服务器端程序。其主要功能在于交互式地浏览和修改数据，生成动态Web内容。狭义的Servlet是指Java语言实现的一个接口，广义的Servlet是指任何实现了这个Servlet接口的类，一般情况下，人们将Servlet理解为后者。...
JavaWeb三大组件（Servlet、Filter、Listener）
热门推荐
xiaojie119120的博客
06-15 4万+
JavaWeb三大组件指的是：Servlet、Filter、Listener，这三个组件在JavaWeb开发中分别提供不同的功能，然而很多人可能只用过其中一个或者两个（Servlet、Filter，比如我），很难接触到第三个组件，因此对原始JavaWeb开发还不够熟悉，在这种情况下进行框架学习，这种做法是并不可取，框架是大牛们对原始JavaWeb进行封装的结果，没有原始JavaWeb开发基础是很难真
javaweb基础第二十二课：Listener
Geek
01-09 357
写在前面： 监听器用的不多，了解下就行，毕竟万一用到了呢。 这课不录视频。教程内容我直接复制其他人的，毕竟不是很重要，我也不怎么用，而且也太简单了。   教程： Listener(监听器) 简介 Listener用于监听JavaWeb程序中的事件。 例如：ServletContext、HttpSession、ServletRequest的创建、修改和删除。 Listener和我们...
JavaWeb详解（第三篇）之Servlet基础简介-过滤器Filter&Listener监听器
小仙儿
10-28 486
JavaWeb详解（第三篇）之Servlet基础简介-过滤器、监听器 JavaWeb的三大组件分别是：Servlet 程序、Filter 过滤器、Listener 监听器。前面我们学习了Servlet ，接下来我们在了解一下Filter 过滤器和Listener 监听器。 1、Filter 过滤器 1.1、什么是Filter 过滤器 Filter 过滤器它是 JavaEE 的规范。也就是接口。可以对指定URL请求进行拦截，拦截之后在过滤器中进行相应的处理/判断。 Filte...
（重温）JavaWeb–Filter 过滤器（JavaWeb 的三大组件之一）
12-21
JavaWeb 技术中，Filter（过滤器）是三大核心组件之一，与Servlet程序和Listener监听器并列。Filter 是 JavaEE 规范的一部分，它定义了一个接口，允许开发者在请求被处理之前或之后进行拦截，对请求或响应进行预处理...
JavaWebServlet+JSP+EL表达式+JSTL标签库+Filter过滤器+Listener监听器
最新发布
05-05
JavaWeb技术是构建基于Java平台的Web应用程序的重要框架，它包括了Servlet、JSP、EL表达式、JSTL标签库、Filter过滤器以及Listener监听器等多个关键组件。这些组件协同工作，使得开发者能够创建动态、交互式的Web...
JavaWeb两大组件FILTER&LISTENER
06-30
在JavaWeb开发中，"FILTER（过滤器）"和"LISTENER（监听器）"是两个重要的组件，它们极大地增强了应用程序的功能和灵活性。本案例将深入探讨这两个组件的原理、用法及其在实际项目中的应用。 一、FILTER（过滤器） ...
快速学习JavaWeb中监听器(Listener)的使用方法
09-01
在JavaWeb开发中，监听器（Listener）是一种重要的组件，主要用于监听和响应Web应用程序中的特定事件。通过监听器，开发者可以实现在特定事件触发时执行相应的处理逻辑，例如用户登录、注销、session创建、销毁等。...
IDEA版JavaWeb从入门到精通之Filter过滤器第15天
06-19
课程涵盖：Servlet程序、Filter过滤器、Listener监听器、JSP页面、EL表达式、JSTL标签库、jQuery框架、Cookie技术、Session会话、JSON使用、Ajax请求等全部Web开发核心技术点，并在讲解知识点过程中带领大家完成一个...
JavaWeb三大组件【Servlet】【Filter】【Listener】学习笔记
热爱编程、热爱生活、热爱探索
09-12 1543
本文主要详细讲解JavaWeb的三大组件：Servlet、Filter、Listener。内容包括三者的基本语法、用法，同时包含一个三者的综合案例，同时案例富有详细的解说
JavaWeb三大组件（Servlet、Filter、Listener）和JSP相关知识，看这篇就够了
qq_42839595的博客
01-19 1160
Servlet概述： Servlet是JavaWeb三大组件之一，是基础中的基础，核心中的核心，我们必须要掌握它，其他两个组件是Filter(过滤器)、Listener(监听器)，之后会进行介绍。 Servlet的直译就是小型应用程序，正如字面意思，Servlet是运行在Web服务器（如Tomcat）中的小型Java程序。当客户端发送请求到Tomcat时，由Tomcat去找到处理对应请求的Servlet进行处理。 我们编写的Servlet程序，需要直接（实现Servlet）或间接（继承HttpServlet
Servlet请求+Filter过滤+Listener监听器
qq_57147093的博客
08-08 314
charset=utf-8”): 响应头类型和编码。charset=utf-8”): 响应头类型和编码。Req.getRequestDispatcher().forward(“本地资源或当前项目”)Filter的xml的配置顺序决定了执行的顺序。setCharacterEncoding(“utf-8”): 请求编码。setCharacterEncoding(“utf-8”): 请求编码。setCharacterEncoding(“utf-8”)响应编码。......
过滤器、监听器及Servlet3.0注解
L6_6Lwz的博客
09-09 206
过滤器、监听器及Servlet3.0注解 一、过滤器 1.1流程 单个过滤器流程：Filter 对用户请求进行预处理，接着将请求交给 Servlet 进行处理并生成响应，最后 Filter 再对服务器响应进行后处理。 多个过滤器流程：Filter 对用户请求进行预处理接着交给下一个过滤器处理，过滤器处理完后将请求交给 Servlet 进行处理并生成响应，最后 Filter 再对服务器响应进行一系...
第二阶段（day18）过滤器监听器 servlet3注解
sunshine195的博客
05-11 223
...
JavaWeb学习笔记：一文叙说Servlet、Session与Cookie、Servlet3.0注解、过滤器与监听器
lijinghua的博客
04-25 400
文章目录1. Java Web1.1基本概念1.2 web的分类1.3 web应用程序1.4 web服务器2. Http协议简介2.1 基本概念2.2 网站的访问2.2.1 访问的简要过程2.2.2 http请求2.2.2.1 请求行（**General**，不属于headers，只用于收集请求url和响应的status等信息）2.2.2.2 请求头（**Request Headers**）2.2.3 Http响应2.2.3.1 响应头（**Response Headers**）2.2.3.2 响应状态码3
Listener Servlet和filter的应用
gaile的专栏
05-16 119
下面这段话是小总结：   Listener是Servlet的监听器，它可以监听客户端的请求、服务端的操作等。通过监听器，可以自动激发一些操作，比如监听在线的用户的数量。当增加一个HttpSession时，就激发sessionCreated(HttpSessionEvent se)方法，这样就可以给在线人数加1。常用的监听接口有以下几个： ServletContextAttribute...
SpringBoot中Servlet&Listener&Filter的应用
海锋博客
01-06 2103
在spring boot中添加自己的Servlet有两种方法，代码注册Servlet和注解自动注册： 一、代码注册通过ServletRegistrationBean、 FilterRegistrationBean 和 ServletListenerRegistrationBean 获得控制。 二、在 SpringBootApplication 上使用@ServletComponentScan 注解后，Servlet、Filter、Listener 可以直接通过 @WebServlet、@WebFilter
Servlet/listener/filter应用大全
小蜜蜂
01-11 740
服务器servlet/listener/filter 11 http/tomcat  - http协议版本 使用最广泛的是1.1的版本。  它是一种请求 - 响应  模型的协议。  1.0请求 - 响应完毕后，连接关闭  ， 如果还想接着请求，必须得重新连接  1.1 请求 - 响应完毕后，连接未关闭 ，还可以继续发起请求 Get请求和post请求的区别   如果action 都写成 a...
JavaWeb实战：Servlet过滤器与监听器应用解析
在Java Web开发中，Servlet过滤器（Filter）和监听器（Listener）是两个非常重要的组件，它们能够帮助开发者扩展和增强应用程序的功能，提高代码的可维护性和扩展性。以下是这两个概念的详细说明： 1. Servlet过滤...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

编程小栈

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值