环境搭建

我这里是 IDEA2020.3.x 版本

首先创建一个web工程

配置tomcat

访问即可

默认的访问路径是WEB-INF index.jsp页面

servlet技术

什么是servlet？

Java Servlet 是运行在 Web 服务器或应用服务器上的程序，它是作为来自 Web 浏览器或其他 HTTP 客户端的请求和 HTTP 服务器上的数据库或应用程序之间的中间层。使用 Servlet，您可以收集来自网页表单的用户输入，呈现来自数据库或者其他源的记录，还可以动态创建网页。

1、Servlet 是 JavaEE 规范之一。规范就是接口
2、Servlet 就 JavaWeb 三大组件之一。三大组件分别是：Servlet 程序、Filter 过滤器、Listener 监听器。
3、Servlet 是运行在服务器上的一个 java 小程序，它可以接收客户端发送过来的请求，并响应数据给客户端。

第一个Servlet程序

在创建Servlet的时候没有发现Setvlet接口可能是没有将相关的jar添加进来需要手动的添加一下Jar包

创建HelloWorldServlet实现servlet接口，可以看到有如下几个方法。

public class HelloWorldServlet implements Servlet {
    @Override
    public void init(ServletConfig servletConfig) throws ServletException {}
    @Override
    public ServletConfig getServletConfig() { return null; }
    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException { }
    @Override
    public String getServletInfo() { return null; }
    @Override
    public void destroy() { }
}

配置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">
        <!--servlet标签给tomcat配置servlet程序-->
         <servlet>
             <!--给servlet程序起一个别名-->
             <servlet-name>HelloWorldServlet</servlet-name>
             <!--设置servlet的全类名-->
             <servlet-class>com.niu.servlet.HelloWorldServlet</servlet-class>
         </servlet>
        <!--servlet程序配置访问地址-->
        <servlet-mapping>
            <!--告诉服务器，当前配置的地址给那个servlet程序使用-->
            <servlet-name>HelloWorldServlet</servlet-name>
            <!--配置访问地址 / 在服务器解析的时候 表示的地址为：http://ip:port/工程路径 -->
            <!--
                -   全路径匹配：`/a`
                -   前半段匹配：`/a/b/c/*`
                -   扩展名匹配：`*.action`
            -->
            <url-pattern>/hello</url-pattern>
        </servlet-mapping>
</web-app>

1、init：Servlet初始化时调用方法的时候会执行

2、getServletConfig：获取当前Servlet的配置信息

3、service：调用Servlet真正去处理逻辑的方法

4、getServletInfo：它提供有关Servlet的信息，如作者、版本、版权

5、destroy：Servlet销毁时调用的方法

Servlet的生命周期

Servlet的声明周期主要分成以下的三个阶段

1、init() 方法

在Servlet容器创建完成，并且第一次调用方法的时候会执行init方法，并且只会执行一次。

2、service() 方法

service() 方法是 Servlet 工作的核心方法。当客户端请求访问 Servlet 时，Servlet 容器就会调用 service() 方法去处理来自客户端的请求，并把处理后的响应返回给客户端。

3、destroy()

停止这个Web工程的时候会调用到destroy方法，并且只会调用一次

这个声明周期的流程：

初始化阶段

当用户第一次向 Servlet 容器发出 HTTP 请求要求访问某个 Servlet 时，Servlet 容器会在整个容器中搜索该 Servlet 对象，发现这个 Servlet 对象没有被实例化，于是创建这个 Servlet 对象，然后调用该对象的 init() 方法完成初始化。

当用户第二次访问这个 Servlet 时，Servlet 容器仍然在容器中搜索该 Servlet 对象，结果找到了该对象的实例，则不去创建而直接使用该对象。

找到了对应的 Servlet 对象，随后 Servlet 进入到运行阶段。

需要注意的是，在 Servlet 的整个生命周期内，它的 init() 方法只被调用一次。

运行阶段

这是 Servlet 生命周期中最核心的阶段。在该阶段中，Servlet 容器会为当前的请求创建一个 ServletRequest 对象和一个 ServletResponse 对象（它们分别代表 HTTP 请求和 HTTP 响应），并将这两个对象作为参数传递给 Servlet 的 service() 方法。

service() 方法从 ServletRequest 对象中获得用户的详细请求信息并处理该请求，通过 ServletResponse 对象生成响应结果。

需要强调的是，在 Servlet 的整个生命周期内，用户每次请求访问 Servlet 时，Servlet 容器都会调用一次 Servlet 的 service() 方法，并且创建新的 ServletRequest 和 ServletResponse 对象。

销毁阶段

当服务器停止时，Servlet 容器需要回收 Servlet 对象所占用的内存，在回收之前，会自动调用该对象的 destroy() 方法做好回收内存前的准备，辟如关闭后台线程。

和 init() 方法类似，destroy() 方法也只会被调用一次。

注意：Servlet 对象一旦创建就会驻留在内存中一直等待客户端的访问，直到服务器关闭或项目被移除出容器时，Servlet 对象才会被销毁。

Servlet的继承体系

可看到HttpSetvlet，这个类里面包含了更为丰富的请求方式，最常用就是我们的doPost 和 doGet了接下来使用一下我们的doGet 和 doPost

创建一个新的servlet 命名为HelloHttpServlet

public class HelloHttpServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("doGet ......");
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("doPost .......");
    }
}

添加新的xml配置

<servlet>
    <servlet-name>HelloHttpServlet</servlet-name>
    <servlet-class>com.niu.servlet.HelloHttpServlet</servlet-class>
</servlet>

<servlet-mapping>
    <servlet-name>HelloHttpServlet</servlet-name>
    <url-pattern>/helloHttpServlet</url-pattern>
</servlet-mapping>

可以看到doGet方法被调用了，由于doPost需要做一个模拟的表单，这里就不做了，在效果上是一样的。

ServletConfig

servlet 容器使用的 servlet 配置对象，该对象在初始化期间将信息传递给 servlet。

可以看到servlet是一个接口，它里面有四个抽象方法

方法名	作用
String getServletName()	获取servlet的名称
ServletContext getServletContext()	获取Servlet的上下文
String getInitParameter(String var1)	获取到初始化参数的Value值
Enumeration '<'String '>' getInitParameterNames()	获取到参数值的名称，返回的是一个集合

接下来就看看这四个方法

创建一个 ServletConfigServlet 实现 Servlet接口，考虑到篇幅原因只写主要的测试方法

public class ServletConfigServlet implements Servlet {
    @Override
    public void init(ServletConfig servletConfig) throws ServletException {
        /*获取到Servlet的上下文*/
        ServletContext servletContext = servletConfig.getServletContext();
        System.out.println(servletContext);
        /*获取Servlet的名称*/
        String servletName = servletConfig.getServletName();
        System.out.println(servletName);
        /*获取初始化参数的名称，他是一组集合*/
        Enumeration<String> initParameterNames = servletConfig.getInitParameterNames();
        while(initParameterNames.hasMoreElements()) {
            String element = initParameterNames.nextElement();
            System.out.println(element);
        }
        /*获取到参数的值*/
        String niuxiaoniu = servletConfig.getInitParameter("username");
        System.out.println(niuxiaoniu);
    }

    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        System.out.println("service 被调用了 ......");
    }
}

配置映射文件

<!--ServletConfigServlet-->
<servlet>
    <servlet-name>ServletConfigServlet</servlet-name>
    <servlet-class>com.niu.servlet.ServletConfigServlet</servlet-class>

    <!--init-param 初始化对象-->
    <init-param>
        <!--参数名-->
        <param-name>username</param-name>
        <!--参数值-->
        <param-value>123456</param-value>
    </init-param>
</servlet>

<servlet-mapping>
    <servlet-name>ServletConfigServlet</servlet-name>
    <url-pattern>/servletConfigServlet</url-pattern>
</servlet-mapping>

启动测试：

访问：

ServletContext

每个 Java 虚拟机的每个“Web 应用程序”都有一个上下文，也就是说不管是在哪一个Servlet里面，获取到的对象都是同一个，服务器启动的时候，会为托管的每一个web应用程序，创建一个ServletContext对象，当从服务器移除托管或者是关闭服务器时，ServletContext将会被销毁。它主要有以下几方面作用：

1、全局配置参数

2、web工程中的资源

3、Servlet间共享数据域对象

接下来就来看看ServletContext应该如何使用

获取全局配置参数

首先创建一个新的ServletContextServlet

public class ServletContextServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("执行了doGet......");
        Enumeration<String> initParameterNames = getServletContext().getInitParameterNames();
        while(initParameterNames.hasMoreElements()){
            String initParameterName = initParameterNames.nextElement();
            String initParameterValue = getServletContext().getInitParameter(initParameterName);
            System.out.println(initParameterName+":"+initParameterValue);
        }
    }
}

配置映射文件

<!--ServletContextServlet-->
<context-param>
    <param-name>username</param-name>
    <param-value>zhangsan</param-value>
</context-param>
<context-param>
    <param-name>password</param-name>
    <param-value>123456</param-value>
</context-param>

<servlet>
    <servlet-name>ServletContextServlet</servlet-name>
    <servlet-class>com.niu.servlet.ServletContextServlet</servlet-class>
</servlet>

<servlet-mapping>
    <servlet-name>ServletContextServlet</servlet-name>
    <url-pattern>/servletContextServlet</url-pattern>
</servlet-mapping>

获取web工程中的资源

添加资源文件

在以上文件中添加如下的代码：

/*获取全局的配置文件*/
String realPath = getServletContext().getRealPath("niuxiaoniu.txt");
System.out.println("获取到的绝对路径："+realPath);
InputStream resourceAsStream = getServletContext().getResourceAsStream("niuxiaoniu.txt");
System.out.println(resourceAsStream);

执行测试

Servlet间共享数据域对象

创建一个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 {

        Integer count = (Integer)getServletContext().getAttribute("count");

        if (count == null) {
            getServletContext().setAttribute("count", 1);
        } else {
            getServletContext().setAttribute("count", count + 1);
        }
    }
}

配置映射：

<!--LoginServlet-->
<servlet>
    <servlet-name>LoginServlet</servlet-name>
    <servlet-class>com.niu.servlet.LoginServlet</servlet-class>
</servlet>

<servlet-mapping>
    <servlet-name>LoginServlet</servlet-name>
    <url-pattern>/loginServlet</url-pattern>
</servlet-mapping>

在原来的ServletContextServlet中添加如下代码：

// 查看当前网站登录次数，这个数据是保存在ServletContext中的
Integer count = (Integer) getServletContext().getAttribute("count");
// 判断是否登录过，如果没有登录过，提示未登录，如果已经登录过，显示登录次数
if (count == null) {
    resp.getWriter().write("no login!");
} else {
    resp.getWriter().write("count:" + count);
}

启动测试：

这是没有访问LoginServlet的时候

接下来访问LoginServlet 然后再去访问ServletContextServlet

可以看到这个值已经传过来了

HttpServletRequest类

HttpServletRequest 类有什么作用？

每次只要有请求进入 Tomcat 服务器，Tomcat 服务器就会把请求过来的 HTTP 协议信息解析好封装到 Request 对象中。然后传递到 service 方法（doGet 和 doPost）中给我们使用。我们可以通过 HttpServletRequest 对象，获取到所有请求的信息。

体验HttpServletRequest

首先修改原始index.jsp页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>$Title$</title>
  </head>
  <body>
    <form action="httpServletRequestServlet" method="post">
      账户：<input type="text" name="username"><br>
      密码：<input type="text" name="password"><br>
      <input type="submit" value="注册">
    </form>
  </body>
</html>

然后创建一个HttpServletRequestServlet的类继承 HttpServlet

public class HttpServletRequestServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        super.doGet(req, resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        /*1、获取到请求头的名称*/
        Enumeration<String> headerNames = req.getHeaderNames();
        while(headerNames.hasMoreElements()){
            String headerName = headerNames.nextElement();
            String headerValue = req.getHeader(headerName);
            System.out.println(headerName + ":" + headerValue);
        }
        System.out.println("=========================");
        /*2、获取到请求的参数*/
        String username = req.getParameter("username");
        String password = req.getParameter("password");
        System.out.println("=========================");

        /*3、以Map集合的形式获取客户端传递过来的参数信息*/
        Map<String, String[]> parameterMap = req.getParameterMap();
        Set<String> names = parameterMap.keySet();
        for (String name : names) {
            String[] value = parameterMap.get(name);
            System.out.println(name + ":" + Arrays.toString(value));
        }
        System.out.println("=========================");

        /*4、请求的上下文路径*/
        String contextPath = req.getContextPath();
        System.out.println("contextPath:" + contextPath);
        System.out.println("=========================");
        /*5、获取到浏览器所有的Cookies*/
        Cookie[] cookies = req.getCookies();
        System.out.println("cookies:" + Arrays.toString(cookies));
        System.out.println("=========================");
        /*6、请求路径*/
        String requestURI = req.getRequestURI();
        System.out.println("requestURI:" + requestURI);
    }
}

配置请求映射

<!--HttpServletRequestServlet-->
    <servlet>
        <servlet-name>HttpServletRequestServlet</servlet-name>
        <servlet-class>com.niu.servlet.HttpServletRequestServlet</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>HttpServletRequestServlet</servlet-name>
        <url-pattern>/httpServletRequestServlet</url-pattern>
    </servlet-mapping>

启动测试：

解决中文请求乱码问题

如果是Post请求

// 这行设置一定要写在getParameter之前。
req.setCharacterEncoding("UTF-8");

如果是Get请求

// 先用原来的编码解码再用UTF—8重新编码。
String newUsername = new String(username.getBytes("ISO-8859-1"), "UTF-8");

HttpServletResponse类

HttpServletResponse类的作用？

该接口接口以提供特定于 HTTP 的发送响应功能。例如，该接口拥有访问 HTTP 头和 cookie 的方法，将一些信息相应给客户端。

体验HttpServletResponse

创建一个新的servlet，并且命名为HttpServletResponseServlet

public class HttpServletResponseServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.getWriter().write("<h1>Hello HttpServletResponse ...</h1>");
        super.doGet(req, resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        super.doPost(req, resp);
    }
}

配置请求映射

<!--HttpServletResponseServlet-->
<servlet>
    <servlet-name>HttpServletResponseServlet</servlet-name>
    <servlet-class>com.niu.servlet.HttpServletResponseServlet</servlet-class>
</servlet>

<servlet-mapping>
    <servlet-name>HttpServletResponseServlet</servlet-name>
    <url-pattern>/httpServletResponseServlet</url-pattern>
</servlet-mapping>

启动测试：

请求响应乱码问题

如果说页面上输出中文会有乱码问题

resp.getWriter().write("<h1>Hello 你好啊 ...</h1>");

启动测试：

解决方案：

//方式1 
//设置服务器端的编码
response.setCharacterEncoding("utf-8"); 
//设置浏览器页面使用那种字符集进行解码 
response.setHeader("Content-Type","text/html;charset=UTF-8");

//方式2 
//同时设置服务器的编码和浏览器的编码 
//在获取流对象之前调用
response.setContentType("text/html;charset=UTF-8");

在这里采用了方案2

请求转发和重定向

请求转发

请求重定向

Cookie

创建一个 cookie，cookie 是 servlet 发送到 Web 浏览器的少量信息，这些信息由浏览器保存，然后发送回服务器。cookie 的值可以唯一地标识客户端，因此 cookie 常用于会话管理。

servlet 通过使用 HttpServletResponse 的 addCookie 方法将 cookie 发送到浏览器，该方法将字段添加到 HTTP 响应头，以便一次一个地将 cookie 发送到浏览器。浏览器应该支持每台 Web 服务器有 20 个 cookie，总共有 300 个 cookie，并且可能将每个 cookie 的大小限定为 4 KB。

Cookie初体验

创建一个CookieServelt

public class CookieServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        Cookie cookie = new Cookie("cookieKey","cookieValue");
        resp.addCookie(cookie);
    }
}

配置请求映射

<servlet>
    <servlet-name>CookieServlet</servlet-name>
    <servlet-class>com.niu.servlet.CookieServlet</servlet-class>
</servlet>

<servlet-mapping>
    <servlet-name>CookieServlet</servlet-name>
    <url-pattern>/cookieServlet</url-pattern>
</servlet-mapping>

启动测试：

可以看到这个Cookie就被存在了浏览器端了。我们还可以设置Cookie的会话有效时间、Cookie大小等等

Session

由于Cookie会保存在客户端上，所以有安全隐患问题。还有一个问题，Cookie的大小与个数有限制，为了解决这个问题，于是就有了Session，Session是基于Cookie的一种会话机制。Cookie是服务器返回一小份数据给客户端，并且存放在客户端上。Session是数据存放在服务器端。

Session 初体验

创建一个新的Servlet 并命名为 SessionServlet

public class SessionServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        /*获取一个Session*/
        HttpSession session = req.getSession();
        System.out.println(session);
        System.out.println("------------------------------");
        /*1、获取SessionId*/
        String sessionId = session.getId();
        System.out.println(sessionId);
        System.out.println("------------------------------");
        /*2、存值*/
        session.setAttribute("sessionKey","sessionValue");

        /*3、取值*/
        Object sessionKey = session.getAttribute("sessionKey");
        System.out.println(sessionKey);
        System.out.println("-------------------------------");
        /*4、删除一个值*/
        session.removeAttribute("sessionKey");

        /*5、设置session的存活时间,单位秒*/
        session.setMaxInactiveInterval(30*60);
    }
}

配置映射

<!--SessionServlet-->
<servlet>
    <servlet-name>SessionServlet</servlet-name>
    <servlet-class>com.niu.servlet.SessionServlet</servlet-class>
</servlet>

<servlet-mapping>
    <servlet-name>SessionServlet</servlet-name>
    <url-pattern>/sessionServlet</url-pattern>
</servlet-mapping>

启动测试：

过滤器 Filter

Filter是什么？

Filter是过滤器，就是对客户端发出来的请求进行过滤。浏览器发出请求，然后服务器派servlet处理。在中间就可以过滤，其实过滤器起到的是拦截的作用。使用过滤器可以对一些敏感词汇进行过滤、统一设置编码、实现自动登录等功能。

Filter初体验

创建FilterServlet类实现 Filter接口，重写init()、doFilter()、destroy()方法

public class FilterServlet implements Filter {
    /*初始化方法*/
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("Init Filter ~~~");
    }

    /*doFilter里面做一些过滤操作*/
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        /*放行*/
        filterChain.doFilter(servletRequest, servletResponse);
    }
    /*销毁方法*/
    @Override
    public void destroy() {
        System.out.println("destory Filter ~~~");
    }
}

配置过滤器的映射

<!--FilterServlet-->
<filter>
    <filter-name>FilterServlet</filter-name>
    <filter-class>com.niu.servlet.FilterServlet</filter-class>
</filter>

<filter-mapping>
    <filter-name>FilterServlet</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

创建一个Filter的应用程序FilterApplicationServlet

public class FilterApplicationServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("FilterApplicationServlet doGet =~~~ ");
    }
}

配置映射

<!--FilterApplicationServlet-->
<servlet>
    <servlet-name>FilterApplicationServlet</servlet-name>
    <servlet-class>com.niu.servlet.FilterApplicationServlet</servlet-class>
</servlet>

<servlet-mapping>
    <servlet-name>FilterApplicationServlet</servlet-name>
    <url-pattern>/filterApplicationServlet</url-pattern>
</servlet-mapping>

执行测试：

多个Filter过滤器的执行顺序

接下来创建第二个过滤器FilterServletTwo

public class FilterServletTwo implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("初始化第二个过滤器~~~");
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("第二个过滤器放行执行之前 ~~~");
        filterChain.doFilter(servletRequest,servletResponse);
        System.out.println("第二个过滤器放行执行之后 ~~~");
    }

    @Override
    public void destroy() {
        System.out.println("销毁第二个过滤器~~~~");
    }
}

配置映射

<!--FilterServletTwo-->
<filter>
    <filter-name>FilterServletTwo</filter-name>
    <filter-class>com.niu.servlet.FilterServletTwo</filter-class>
</filter>

<filter-mapping>
    <filter-name>FilterServletTwo</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

运行测试

通过以上的执行结果可以得到过滤器的一个执行流程

过滤器的执行的顺序跟他在web.xml中的配置顺序有关，那个配置在前面哪一个就先执

init()、doFilter()、destroy() 调用的时机

init()

在应用程序启动的时候，会根据web.xml文件将每一个过滤器注册在内存中。当容器创建Filter对象时，会调用init方法。init方法在整个生命周期中，只会被调用一次。Web容器在调用整个方法的时候，会传递一个包含了Filter配置信息和运行环境信息的 FilterConfig 对象。：

可以看到程序在启动完成以后Filter就被初始化完成了

doFilter()

当从前端的请求过来以后，会在doFilter里面做一些处理的操作，其中的ServletRequest和servletResponse 代表者请求过来的对象FilterChain 代表过滤器链调用他的doFilter() 方法可以进行对过滤器进行放行

destroy()

在整个Servlet容器销毁的时候会调用destroy方法

Filter的请求拦截规则配置

全路径匹配：/a
前半段匹配：/a/b/c/*
扩展名匹配：*.action

Filter拦截类型

在web.xml文件中，每一个<filter-mapping>元素都可以配置一个Filter所拦截的资源。在<filter-mapping>元素中有一个特殊的子元素<dispatcher>,该元素用于指定过滤器所拦截的资源被Servlet容器调用的方式。具体如下：

REQUEST(默认)

当用户直接访问Servlet，Web容器会调用过滤器。如果目标资源是通过RequestDispatcher 的 include 或 forward 方法访问时，那么该过滤器将不会被调用。
INCLUDE

如果目标资源是通过RequestDispatcher 的 include方法访问时，那么该过滤器将被调用
FORWARD

如果目标资源是通过RequestDispatcher 的 forward方法访问时，那么该过滤器将被调用
ERROR

如果目标资源是通过声明式异常处理机制调用时，那么该过滤器将被调用。

监听器 Listener

什么是监听器？

监听器，顾名思义，就是负责监听，他们要监听的对象分别是request、session、servletContext对象

监听器的作用

负责监控某一个数据域的内容变化

在Servlet中有那些监听器

在Servlet中一共有八大监听器分别是：

1、ServletRequestListener监听器

2、ServletRequestAttributeListener监听器

3、HttpSessionListener监听器

4、HttpSessionAttributeListener监听器

5、ServletContextListener监听器

6、ServletContextAttributeListener监听器

7、HttpSessionBindingListener监听器

8、HttpSessionActivationListener监听器

ServletRequestListener监听器

创建一个ServletRequestListenerServlet监听器

public class ServletRequestListenerServlet implements ServletRequestListener {

    @Override
    public void requestDestroyed(ServletRequestEvent servletRequestEvent) {
        System.out.println("对象被销毁");
    }

    @Override
    public void requestInitialized(ServletRequestEvent servletRequestEvent) {
        System.out.println("servletRequestEvent ==>" + servletRequestEvent);
        /*获取到请求的对象*/
        System.out.println("servletRequestEvent.getServletRequest()" + servletRequestEvent.getServletRequest());
        /*获取请求的上下文*/
        System.out.println("servletRequestEvent.getServletContext()" + servletRequestEvent.getServletContext());
        System.out.println("对象被初始化");
    }
}

配置监听器

<!--ServletRequestListenerServlet 注册监听器-->
<listener>
    <listener-class>com.niu.servlet.ServletRequestListenerServlet</listener-class>
</listener>

启动测试;

可以看到监听器的执行是在过滤器的前面的，当一个目标方法执行完成以后这个对象也就销毁了。

Servlet技术

环境搭建

首先创建一个web工程

配置tomcat

servlet技术

什么是servlet？

第一个Servlet程序

Servlet的生命周期

Servlet的继承体系

ServletConfig

ServletContext

HttpServletRequest类

体验HttpServletRequest

解决中文请求乱码问题

HttpServletResponse类

体验HttpServletResponse

请求响应乱码问题

请求转发和重定向

请求转发

请求重定向

Cookie

Cookie初体验

Session

Session 初体验

过滤器 Filter

Filter是什么？

Filter初体验

多个Filter过滤器的执行顺序

init()、doFilter()、destroy() 调用的时机

Filter的请求拦截规则配置

Filter拦截类型

监听器 Listener

什么是监听器？

监听器的作用

在Servlet中有那些监听器

ServletRequestListener监听器

ServletRequestAttributeListener监听器

HttpSessionListener监听器

HttpSessionAttributeListener监听器

ServletContextListener监听器

ServletContextAttributeListener监听器

HttpSessionBindingListener监听器

HttpSessionActivationListener监听器