Servlet介绍与使用

发表于 2023-11-24 更新于 2023-11-28 分类于 Java ， JavaWeb

JavaWeb关键技术Servlet的介绍和使用

MavenWeb项目创建以及插件的使用参考下面的链接：

Maven Web项目结构

开发中的项目

project-name //项目名称
├── src //主目录
│   ├── main
│   │   ├── java
│   │   │   └── java代码
│   │   ├── resources
│   │   │   └── 配置文件等资源文件
│   │   └── webapp //web项目特有目录
|	|		├── html //html文件目录（可自定义）
│   │       ├── WEB-INF //web项目核心目录（必须叫这个名称）
│   │       │   ├── web.xml //web项目配置文件
│   │       │   └── 其他配置文件
│   │       └── 其他 Web 资源（HTML、JSP、CSS、JS 等）
│   └── test
│       ├── java
│       │   └── 测试源代码文件
│       ├── resources
│       │   └── 测试配置文件等资源文件
│       └── webapp
│           └── 测试使用的 Web 资源
└── pom.xml

开发完成部署的Web项目

webapps
└── project-name //项目访问路径（虚拟目录）
    ├── html // html文件目录（课自定义）
    ├── WEB-INF //web项目核心目录（必须叫这个名称）
    │   ├── classes //java字节码文件夹
    │   ├── lib
    │   │   └── 依赖库 Jar 包
    │   ├── web.xml //web项目配置文件
    │   └── 其他配置文件
    └── 其他 Web 资源（HTML、JSP、CSS、JS 等）

1. Servlet简介

Servlet是JavaWeb最核心的内容之一，是Java EE中一种用于处理Web请求和响应的服务器端组件，可以理解为在服务器上运行的Java程序。由Servlet容器（如Tomcat）进行管理和调用。
当客户端（通常是Web浏览器）发送HTTP请求到Servlet容器（如Tomcat）时，Servlet容器会根据请求的URL找到对应的Servlet，并将请求转发给该Servlet。Servlet可以从请求中读取参数、头信息等数据，执行业务逻辑（如访问数据库或其他资源），生成响应并将其发送回客户端。
使用Servlet就可以实现，根据不同的登录用户在页面上动态显示不同内容。
Servlet是一个接口，需要定义Servlet类实现Servlet接口，并由web服务器运行Servlet。

2. 快速入门

创建Web项目web-demo，导入Servlet依赖坐标

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.1.0</version>
    <!--
      此处为什么需要添加该标签?
      provided指的是在编译和测试过程中有效,最后生成的war包时不会加入
       因为Tomcat的lib目录中已经有servlet-api这个jar包，如果在生成war包的时候生效就会和Tomcat中的jar包冲突，导致报错
    -->
    <scope>provided</scope>
</dependency>

定义一个类，实现Servlet接口，并重写接口中的所有方法：

package com.itheima.web;

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

@WebServlet("/demo1")
public class ServletDemo implements Servlet {
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws Exception {
        System.out.println("servlet hello world~");
    }

    public void init(ServletConfig servletConfig) throws Exception {

    }

    public ServletConfig getServletConfig() {
        return null;
    }

    public String getServletInfo() {
        return null;
    }

    public void destory() {

    }
}

1. 配置：在类上使用@WebServlet注解，配置该Servlet访问路径
  1
  @WebServlet("/demo1")
1. 启动：启动Tomcat，浏览器中输入以下URL地址访问该Servlet，URL中的web-demo是本web项目名
  1
  http://localhost:8080/web-demo/demo1
1. 访问后，会在控制台会打印servlet hello world~ 说明servlet程序已经成功运行。

至此，本Servlet入门案例已成功。

3. 执行流程

Servlet程序已经能正常运行，但是我们需要思考个问题: 我们并没有创建ServletDemo1类的对象，也没有调用对象中的service方法，为什么在控制台就打印了servlet hello world~这句话呢?

为解决上面的问题，需要了解Servlet的执行流程：

浏览器发出http://localhost:8080/web-demo/demo1请求，从请求中可以解析出三部分内容，分别是localhost:8080、web-demo、demo1
- 根据localhost:8080可以找到要访问的Tomcat Web服务器
- 根据web-demo可以找到部署在Tomcat服务器上的web-demo项目
- 根据demo1可以找到要访问的是项目中的哪个Servlet类，根据@WebServlet后面的值进行匹配
找到ServletDemo1这个类后，Tomcat Web服务器就会自动为ServletDemo1这个类创建一个对象，然后自动调用对象中的service方法
- ServletDemo1实现了Servlet接口，所以类中必然会重写service方法供Tomcat Web服务器进行调用
- service方法中有ServletRequest和ServletResponse两个参数，ServletRequest封装的是请求数据，ServletResponse封装的是响应数据。

小结

问题一：Servlet对象由谁创建？Servlet方法由谁调用？

Servlet由web服务器创建，Servlet方法由web服务器调用

问题二：服务器怎么知道Servlet中一定有service方法?

因为我们自定义的Servlet,必须实现Servlet接口并复写其方法，而Servlet接口中有service方法

4. 生命周期

由上面可知，Servlet对象由Tomcat Web服务器帮我们创建。

再来思考一个问题: Tomcat什么时候创建的Servlet对象?

要想回答上述问题，需要了解Servlet的生命周期。

生命周期: 对象的生命周期指一个对象从被创建到被销毁的整个过程。

Servlet运行在Servlet容器(web服务器，即Tomcat)中，其生命周期由容器来管理，分为4个阶段：

加载和实例化：默认情况下，当Servlet第一次被访问时，由容器创建Servlet对象

默认情况，Servlet对象会在第一次访问时被Servlet容器（即Tomcat）创建，但是如果创建Servlet比较耗时的话，那么第一个访问的人等待的时间就比较长，用户的体验就比较差，那么我们能不能把Servlet的创建放到服务器启动的时候来创建，具体如何来配置?

@WebServlet(urlPatterns = "/demo1",loadOnStartup = 1)
loadOnstartup的取值有两类情况
	（1）负整数:第一次访问时创建Servlet对象
	（2）0或正整数:服务器启动时创建Servlet对象，数字越小优先级越高

初始化：在Servlet实例化（即创建对象）之后，Servlet容器（即Tomcat）将调用Servlet的init()方法初始化这个对象，完成一些如加载配置文件、创建连接等初始化的工作。该方法只调用一次
请求处理：每次请求Servlet时，Servlet容器都会调用Servlet的**service()**方法对请求进行处理
服务终止：当需要释放内存或者容器关闭时，容器就会调用Servlet实例的**destroy()**方法完成资源的释放。在destroy()方法调用之后，容器会释放这个Servlet实例，该实例随后会被Java的垃圾收集器所回收

通过以下案例演示上述的生命周期：

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

/**
 * Servlet生命周期方法
 */
@WebServlet(urlPatterns = "/demo2", loadOnStartup = 1)
public class ServletDemo2 implements Servlet {

    /**
     * 初始化方法
     * 1.调用时机：默认情况下，Servlet被第一次访问时，调用
     * * loadOnStartup: 默认为-1，修改为0或者正整数，则会在服务器启动的时候，调用
     * 2.调用次数: 1次
     * 
     * @param config
     * @throws ServletException
     */
    public void init(ServletConfig config) throws ServletException {
        System.out.println("init...");
    }

    /**
     * 提供服务
     * 1.调用时机:每一次Servlet被访问时，调用
     * 2.调用次数: 多次
     * 
     * @param req
     * @param res
     * @throws ServletException
     * @throws IOException
     */
    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
        System.out.println("servlet hello world~");
    }

    /**
     * 销毁方法
     * 1.调用时机：内存释放或者服务器关闭的时候，Servlet对象会被销毁，调用
     * 2.调用次数: 1次
     */
    public void destroy() {
        System.out.println("destroy...");
    }

    public ServletConfig getServletConfig() {
        return null;
    }

    public String getServletInfo() {
        return null;
    }

}

小结

1、Servlet对象在什么时候被创建？

默认是第一次访问的时候被创建的，可以使用@WebServlet(urlPatterns = “/demo2”, loadOnStartup = 1)的loadOnStartup修改成在服务器启动时创建。

2、 Servlet生命周期中涉及到的三个方法，这三个方法是什么?什么时候被调用?调用几次?

涉及到三个方法，分别是init()、service()、destroy()

init方法在Servlet对象被创建的时候执行，只执行1次

service方法在Servlet被访问的时候调用，每访问1次就调用1次

destroy方法在Servlet对象被销毁的时候调用，只执行1次

5. 方法介绍

Servlet中总共有5个方法，我们已经介绍过其中的三个，剩下的两个方法作用分别是什么？

我们先来回顾下前面讲的三个方法，分别是:

初始化方法，在Servlet创建时创建，只执行一次
1
void init(ServletConfig config)
提供服务方法，每次Servlet被访问，都会调用该方法
1
void servive(ServletRequest req, ServletResponse res)
销毁方法，当Servlet被销毁时，调用该方法。在内存释放或服务器关闭时销毁Servlet
1
void destory()

剩下的两个方法是：getServletInfo() 和 getServletConfig()

getServletInfo()和getServletConfig()这两个方法使用的不是很多，了解即可

获取Servlet信息

String getServletInfo()

//该方法用来返回Servlet的相关信息，没有什么太大的用处，一般我们返回一个空字符串即可
public String getServletInfo() {
    return "";
}

获取ServletConfig对象

1	ServletConfig getServletConfig()

ServletConfig对象，在init方法的参数中有，而Tomcat Web服务器在创建Servlet对象的时候会调用init方法，必定会传入一个ServletConfig对象，我们只需要将服务器传过来的ServletConfig进行返回即可。具体如何操作?

/**
 * Servlet中ServletConfig获取
 */
@WebServlet(urlPatterns = "/demo3", loadOnStartup = 1)
public class ServletDemo2 implements Servlet {
    private ServletConfig servletconfig;
    /**
     * 初始化方法
     * 1.调用时机：默认情况下，Servlet被第一次访问时，调用
     * * loadOnStartup: 默认为-1，修改为0或者正整数，则会在服务器启动的时候，调用
     * 2.调用次数: 1次
     * 
     * @param config
     * @throws ServletException
     */
    public void init(ServletConfig config) throws ServletException {
        this.servletconfig = config;
        System.out.println("init...");
    }

    public ServletConfig getServletConfig() {
        return servletconfig;
    }

    ...其余方法不变，省略
}

6. 体系结构

通过上面的学习，我们知道要想编写一个Servlet就必须要实现Servlet接口，重写接口中的5个方法，虽然已经能完成要求，但是编写起来还是比较麻烦的，因为我们更关注的其实只有service方法，那有没有更简单方式来创建Servlet呢?

要想解决上面的问题，我们需要先对Servlet的体系结构进行下了解:

 Servlet 		------> Servlet体系根接口
	↑
	|
GenericServlet  ------> Servlet抽象实现类
	↑
	|
HttpServlet 	------> 对HTTP协议封装的Servlet实现类

因为我们将来开发B/S架构的web项目，都是针对HTTP协议，所以我们自定义Servlet,会通过继承HttpServlet

具体的编写格式如下:

@WebServlet("/demo4")
public class ServletDemo4 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //TODO GET 请求方式处理逻辑
        System.out.println("get...");
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //TODO Post 请求方式处理逻辑
        System.out.println("post...");
    }
}

要想发送一个GET请求，请求该Servlet，只需要通过浏览器发送http://localhost:8080/web-demo/demo4,就能看到doGet方法被执行了
要想发送一个POST请求，请求该Servlet，单单通过浏览器是无法实现的，这个时候就需要编写一个form表单来发送请求，在webapp下创建一个a.html页面，内容如下:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <form action="/web-demo/demo4" method="post">
        <input name="username"/><input type="submit"/>
    </form>
</body>
</html>

启动测试，在网页中输入URLhttp://localhost:8080/tomcat-demo/a.html打开网页，输入信息点击提交。即可看到doPost方法被执行了。

Servlet的简化编写就介绍完了，接着需要思考两个问题:

HttpServlet中为什么要根据请求方式的不同，调用不同的方法?
如何调用?

针对问题一，我们需要回顾之前的知识点前端发送GET和POST请求的时候，参数的位置不一致，GET请求参数在请求行中，POST请求参数在请求体中，为了能处理不同的请求方式，我们得在service方法中进行判断，然后写不同的业务处理，这样能实现，但是每个Servlet类中都将有相似的代码，针对这个问题，有什么可以优化的策略么?

package com.itheima.web;

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


@WebServlet("/demo5")
public class ServletDemo5 implements Servlet {

    public void init(ServletConfig config) throws ServletException {

    }

    public ServletConfig getServletConfig() {
        return null;
    }

    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
        //如何调用?
        //获取请求方式，根据不同的请求方式进行不同的业务处理
        HttpServletRequest request = (HttpServletRequest)req;
       //1. 获取请求方式
        String method = request.getMethod();
        //2. 判断
        if("GET".equals(method)){
            // get方式的处理逻辑
        }else if("POST".equals(method)){
            // post方式的处理逻辑
        }
    }

    public String getServletInfo() {
        return null;
    }

    public void destroy() {

    }
}

要解决上述问题，我们可以对Servlet接口进行继承封装，来简化代码开发。

package com.itheima.web;

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

public class MyHttpServlet implements Servlet {
    public void init(ServletConfig config) throws ServletException {

    }

    public ServletConfig getServletConfig() {
        return null;
    }

    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
        HttpServletRequest request = (HttpServletRequest)req;
        //1. 获取请求方式
        String method = request.getMethod();
        //2. 判断
        if("GET".equals(method)){
            // get方式的处理逻辑
            doGet(req,res);
        }else if("POST".equals(method)){
            // post方式的处理逻辑
            doPost(req,res);
        }
    }

    protected void doPost(ServletRequest req, ServletResponse res) {
    }

    protected void doGet(ServletRequest req, ServletResponse res) {
    }

    public String getServletInfo() {
        return null;
    }

    public void destroy() {

    }
}

有了MyHttpServlet这个类，以后我们再编写Servlet类的时候，只需要继承MyHttpServlet，重写父类中的doGet和doPost方法，就可以用来处理GET和POST请求的业务逻辑。接下来，可以把ServletDemo5代码进行改造

@WebServlet("/demo5")
public class ServletDemo5 extends MyHttpServlet {

    @Override
    protected void doGet(ServletRequest req, ServletResponse res) {
        System.out.println("get...");
    }

    @Override
    protected void doPost(ServletRequest req, ServletResponse res) {
        System.out.println("post...");
    }
}

将来页面发送的是GET请求，则会进入到doGet方法中进行执行，如果是POST请求，则进入到doPost方法。这样代码在编写的时候就相对来说更加简单快捷。

类似MyHttpServlet这样的类Servlet中已经为我们提供好了，就是HttpServlet,翻开源码，大家可以搜索service()方法，你会发现HttpServlet做的事更多，不仅可以处理GET和POST还可以处理其他五种请求方式。

protected void service(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException
    {
        String method = req.getMethod();

        if (method.equals(METHOD_GET)) {
            long lastModified = getLastModified(req);
            if (lastModified ** -1) {
                // servlet doesn't support if-modified-since, no reason
                // to go through further expensive logic
                doGet(req, resp);
            } else {
                long ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
                if (ifModifiedSince < lastModified) {
                    // If the servlet mod time is later, call doGet()
                    // Round down to the nearest second for a proper compare
                    // A ifModifiedSince of -1 will always be less
                    maybeSetLastModified(resp, lastModified);
                    doGet(req, resp);
                } else {
                    resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
                }
            }

        } else if (method.equals(METHOD_HEAD)) {
            long lastModified = getLastModified(req);
            maybeSetLastModified(resp, lastModified);
            doHead(req, resp);

        } else if (method.equals(METHOD_POST)) {
            doPost(req, resp);
            
        } else if (method.equals(METHOD_PUT)) {
            doPut(req, resp);
            
        } else if (method.equals(METHOD_DELETE)) {
            doDelete(req, resp);
            
        } else if (method.equals(METHOD_OPTIONS)) {
            doOptions(req,resp);
            
        } else if (method.equals(METHOD_TRACE)) {
            doTrace(req,resp);
            
        } else {
            //
            // Note that this means NO servlet supports whatever
            // method was requested, anywhere on this server.
            //

            String errMsg = lStrings.getString("http.method_not_implemented");
            Object[] errArgs = new Object[1];
            errArgs[0] = method;
            errMsg = MessageFormat.format(errMsg, errArgs);
            
            resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
        }
    }

既然如此，直接继承HttpServlet不就行吗，为什么还要实现MyHttpServlet ？

当然可以直接继承HttpServlet类来编写Servlet，这是常见的做法。HttpServlet类已经实现了Servlet接口，并提供了一些针对HTTP请求的便捷方法，比如doGet()、doPost()等。直接继承HttpServlet可以简化代码编写，不再需要重写service()方法来判断请求类型，而是直接重写doGet()和doPost()方法来处理相应的请求。直接继承HttpServlet的优点是简单明了，代码结构清晰，适用于简单的Servlet开发。

但是如果有一些通用的业务逻辑需要在多个Servlet中复用，或者想要遵循某种模板方法的设计模式，那么封装Servlet接口的方式可能更合适。根据具体的需求和项目情况，选择合适的方式来编写Servlet。

小结

通过这一节的学习，要掌握:

HttpServlet的使用步骤

继承HttpServlet

重写doGet和doPost方法

HttpServlet原理

获取请求方式，并根据不同的请求方式，调用不同的doXxx方法

7 urlPattern配置

Servlet类编写好后，要想被访问到，就需要配置其访问路径（urlPattern）

一个Servlet,可以配置多个urlPattern

1	@WebServlet(urlPatterns = {"/demo1","/demo2"})

package com.itheima.web;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebServlet;

/**
* urlPattern: 一个Servlet可以配置多个访问路径
*/
@WebServlet(urlPatterns = {"/demo7","/demo8"})
public class ServletDemo7 extends MyHttpServlet {

    @Override
    protected void doGet(ServletRequest req, ServletResponse res) {
        
        System.out.println("demo7 get...");
    }
    @Override
    protected void doPost(ServletRequest req, ServletResponse res) {
    }
}

在浏览器上输入http://localhost:8080/web-demo/demo7,http://localhost:8080/web-demo/demo8这两个地址都能访问到ServletDemo7的doGet方法。

urlPattern配置规则

精确匹配

配置路径：@WebServlet(urlPatterns = “/user/select”)
访问路径： localhost:8080/web-demo/user/select

/**
 * UrlPattern:
 * * 精确匹配
 */
@WebServlet(urlPatterns = "/user/select")
public class ServletDemo8 extends MyHttpServlet {

    @Override
    protected void doGet(ServletRequest req, ServletResponse res) {

        System.out.println("demo8 get...");
    }
    @Override
    protected void doPost(ServletRequest req, ServletResponse res) {
    }
}

访问路径http://localhost:8080/web-demo/user/select

目录匹配

配置路径：@WebServlet(urlPatterns = “/user/*”)
访问路径： localhost:8080/web-demo/user/aaa localhost:8080/web-demo/user/bbb

package com.itheima.web;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebServlet;

/**
 * UrlPattern:
 * * 目录匹配: /user/*
 */
@WebServlet(urlPatterns = "/user/*")
public class ServletDemo9 extends MyHttpServlet {

    @Override
    protected void doGet(ServletRequest req, ServletResponse res) {

        System.out.println("demo9 get...");
    }
    @Override
    protected void doPost(ServletRequest req, ServletResponse res) {
    }
}

访问路径http://localhost:8080/web-demo/user/任意

思考:

访问路径http://localhost:8080/web-demo/user是否能访问到demo9的doGet方法?
访问路径http://localhost:8080/web-demo/user/a/b是否能访问到demo9的doGet方法?
访问路径http://localhost:8080/web-demo/user/select是否能访问到demo9还是demo8的doGet方法?

答案是: 能、能、demo8，进而我们可以得到的结论是/user/*中的/*代表的是零或多个层级访问目录同时精确匹配优先级要高于目录匹配。

扩展名匹配

配置路径：@WebServlet("*.do")
访问路径： localhost:8080/web-demo/aaa.do localhost:8080/web-demo/bbb.do

package com.itheima.web;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebServlet;

/**
 * UrlPattern:
 * * 扩展名匹配: *.do
 */
@WebServlet(urlPatterns = "*.do")
public class ServletDemo10 extends MyHttpServlet {

    @Override
    protected void doGet(ServletRequest req, ServletResponse res) {

        System.out.println("demo10 get...");
    }
    @Override
    protected void doPost(ServletRequest req, ServletResponse res) {
    }
}

访问路径http://localhost:8080/web-demo/任意.do

注意:

如果路径配置的不是扩展名，那么在路径的前面就必须要加/否则会报错
如果路径配置的是*.do,那么在.do的前面不能加/,否则会报错*

任意匹配

配置路径：@WebServlet( “/”) @WebServlet( “/*”)
访问路径： localhost:8080/web-demo/hehe localhost:8080/web-demo/haha

  package com.itheima.web;
  
  import javax.servlet.ServletRequest;
  import javax.servlet.ServletResponse;
  import javax.servlet.annotation.WebServlet;
  
  /**
   * UrlPattern:
   * * 任意匹配： /
   */
  @WebServlet(urlPatterns = "/")
  public class ServletDemo11 extends MyHttpServlet {
  
      @Override
      protected void doGet(ServletRequest req, ServletResponse res) {
  
          System.out.println("demo11 get...");
      }
      @Override
      protected void doPost(ServletRequest req, ServletResponse res) {
      }
  }

访问路径`http://localhost:8080/demo-web/任意`

```java
package com.itheima.web;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebServlet;

/**
 * UrlPattern:
 * * 任意匹配： /*
 */
@WebServlet(urlPatterns = "/*")
public class ServletDemo12 extends MyHttpServlet {

    @Override
    protected void doGet(ServletRequest req, ServletResponse res) {

        System.out.println("demo12 get...");
    }
    @Override
    protected void doPost(ServletRequest req, ServletResponse res) {
    }
}

访问路径http://localhost:8080/demo-web/任意

注意:/和/*的区别?

当Servlet配置了/时，它将成为默认的Servlet。这意味着当其他的URL匹配不上时，请求会被路由到这个Servlet上。这样做的好处是可以在默认Servlet中处理一些全局逻辑或错误处理。但需要注意的是，如果配置了/，那么默认的静态资源处理器（如Tomcat的DefaultServlet）将被覆盖，导致静态资源无法正常访问。

当Servlet配置了/*时，它将匹配任意访问路径，包括静态资源请求。这样做可以实现对所有请求的拦截和处理。但需要注意的是，在配置了/*的情况下，静态资源的处理可能需要自行实现，或者通过其他方式（例如配置额外的Servlet或使用特定框架）来处理静态资源请求。

选择使用哪种URL模式取决于具体需求和项目结构。如果需要处理全局逻辑或错误处理，并且不涉及静态资源的特殊处理，可以选择使用/作为URL模式。如果需要对所有请求进行拦截和处理，包括静态资源请求，可以选择使用/*作为URL模式。在使用/*时，需要额外考虑静态资源的处理方式，以确保正常访问静态资源。

小结

urlPattern总共有四种配置方式，分别是精确匹配、目录匹配、扩展名匹配、任意匹配
五种配置的优先级为精确匹配 > 目录匹配> 扩展名匹配 > /* > / ,无需记，以最终运行结果为准。

8 XML配置

前面对应Servlet的配置，我们都使用的是@WebServlet,这个是Servlet从3.0版本后开始支持注解配置，3.0版本前只支持XML配置文件的配置方法。

对于XML的配置步骤有两步:

编写Servlet类

package com.itheima.web;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebServlet;

public class ServletDemo13 extends MyHttpServlet {

    @Override
    protected void doGet(ServletRequest req, ServletResponse res) {

        System.out.println("demo13 get...");
    }
    @Override
    protected void doPost(ServletRequest req, ServletResponse res) {
    }
}

在web.xml中配置该Servlet

<?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 全类名
    -->
    <servlet>
        <!-- servlet的名称，名字任意-->
        <servlet-name>demo13</servlet-name>
        <!--servlet的类全名-->
        <servlet-class>com.itheima.web.ServletDemo13</servlet-class>
    </servlet>

    <!-- 
        Servlet 访问路径
    -->
    <servlet-mapping>
        <!-- servlet的名称，要和上面的名称一致-->
        <servlet-name>demo13</servlet-name>
        <!-- servlet的访问路径-->
        <url-pattern>/demo13</url-pattern>
    </servlet-mapping>
</web-app>

这种配置方式和注解比起来，确认麻烦很多，所以建议大家使用注解来开发。但是大家要认识上面这种配置方式，因为并不是所有的项目都是基于注解开发的。