Servlet开发案例以及Servlet的细节

刺骨的言语ヽ痛彻心扉 2023-01-08 05:22 142阅读 0赞

> 详细介绍了Java Servlet的概念以及开发方式和细节。

**Servlet学习的基础：[网络基础][Link 1]，[Java Web][]。**

**在此前的文章中，我们为Servlet的出现进行了大量的铺垫，对于一些基本概念不再赘述，现在我们正式学习Servlet， Servlet是运行在实现了Java Servlet规范的服务器端一个小程序，是JavaWeb的三大组件之一（JavaWeb的三大组件：Servlet、Listener-监听器、Filter-过滤器），它属于动态资源，能够动态的根据请求的信息返回不同的响应。**

**另外，Servlet的学习还是我们深入学习Spring MVC框架的基础！**

### 文章目录 ###

*  1 Servlet接口的概述
 *  2 Servlet的生命周期和请求处理逻辑
 *  3 Servlet的开发
 *   *  3.1 简单的Servlet实现
     *  3.2 继承GenericServlet
     *  3.3 继承HttpServlet
     *   *  3.3.1 HttpServlet的设计
 *  4 Servlet的细节
 *   *  4.1 Servlet与单例
     *  4.2 多个映射路径
     *  4.3 映射路径通配符
     *   *  4.3.1 JspServlet
     *  4.4 默认Servlet
     *  4.5 Servlet初始化时机
 *  5 ServletConfig
 *   *  5.1 初始化参数
 *  6 总结

# 1 Servlet接口的概述 #

javax.serlvet.Servlet接口是Servlet规范中最顶级的接口。此接口定义了初始化 servlet、为请求提供服务以及从服务器中删除 servlet 的方法。这些方法称为Servlet的生命周期方法，它们按照一定顺序调用。

除了生命周期方法外，此接口还提供了 getServletConfig 方法(Servlet可以使用该方法可以获取自身配置信息) 和 getservetinfo方法 (允许serverlet返回有关自身的基本信息，如作者，版本和版权)。

实现servlet接口必须实现下面的5个API方法：

public interface Servlet {
        
    
        /**
         * servlet 容器在实例化servlet后调用init 方法一次进行初始化。只有完成该方法（不抛出异常），然后servlet才能接收任何请求。
         *
         * @param config 包含 servlet 的配置和初始化参数的 ServletConfig 对象。
         */
        public void init(ServletConfig config) throws ServletException;
    
    
        /**
         * 返回一个ServletConfig对象,该对象包含此servlet的初始化和启动参数，返回的ServletConfig对象是传递给init方法的参数对象。
         * 此接口的实现负责存储ServletConfig对象，以便此方法可以返回它，实现此接口的 GenericServlet 类已经执行了此操作。
         *
         * @return 辅助初始化servlet的ServletConfig对象。
         */
        public ServletConfig getServletConfig();
    
    
        /**
         * 由 servlet容器（Web 服务器）调用，以允许servlet处理和响应请求。只有在servlet的 init()方法成功完成后，才能调用此方法。
         *
         * @param req 包含客户端请求的 ServletRequest 对象
         * @param res 包含 servlet 响应的 ServletResponse 对象
         */
        public void service(ServletRequest req, ServletResponse res)
                throws ServletException, IOException;
    
    
        /**
         * 返回有关 servlet 的信息，如作者、版本和版权。
         * 此方法返回的字符串为纯文本，而不是任何类型的标记（如 HTML、XML等）语言。
         *
         * @return 返回有关 servlet 的信息字符串
         */
    
        public String getServletInfo();
    
    
        /**
         * 由 servlet（Web 服务器）容器调用，以指示 servlet 正在停用。
         * 当服务器正常关闭时会调用此方法，使servlet有机会清理正在保留的任何资源(例如, 内存、文件句柄、线程)
         * 在 servlet 容器调用此方法后，它将不会再在此 servlet 上调用service方法。
         */
        public void destroy();
    }

上面的方法实际上还是很好理解的，这些Servlet实例和方法都是由Servlet容器（Web服务器）调用的，因此我们的项目不需要任何main方法，也不需要创建任何Servlet实例。

在Servlet接口中出现了三个相关类：

1.  ServletConfig，作为Servlet的配置对象；
2.  ServletRequest ，代表请求封装的对象；
3.  ServletResponse，代表响应封装的对象；

这三个对象也都不需要我们创建，由是Servlet容器（比如tomcat服务器）创建，并且由Web服务器在运行时传递进来，我们可以直接在方法中使用，后面会一一介绍！

# 2 Servlet的生命周期和请求处理逻辑 #

1.  Web服务器接收到HTTP请求，将请求转发给servlet容器，servlet容器中根据请求路径查找对应的Servlet；
2.  如果servlet实例还未创建，那么创建一个servlet实例，随后servlet容器调用servlet的init()方法对servlet进行初始化（该方法只会在servlet第一次被载入时调用）。被创建的servlet实例会被保留在容器的中，当后续有同样的请求到来时可以直接处理，不再需要重新创建和初始化。
3.  servlet容器将会解析到来的HTTP请求，创建一个Request对象，并且创建一个Response响应对象，调用该servlet实例的service方法将这两个对象作为参数传递进来，以期待service方法中的业务逻辑处理HTTP请求，因此service方法就是我们要重点开发的方法。
4.  我们业务逻辑会将要返回的结果封装到Servlet容器提供的Response对象中，service方法执行完毕之后，Web服务器会将Response对象中保存的动态生成的结果返回给客户端浏览器。
5.  如果Servlet实例被销毁，那么将会由Servlet容器执行destory方法，通常都是在服务器关闭时Servlet才会销毁，destory方法可以进行资源的释放！

# 3 Servlet的开发 #

我们开发Servlet时，需要对Servlet进行实现。一般来说，实现方式有三种：

1.  直接实现javax.servlet.Servlet接口。
2.  继承 javax.servlet.GenericServlet抽象类。
3.  继承javax.servlet.http.HttpServlet抽象类。

## 3.1 简单的Servlet实现 ##

我们通过Servlet接口来简单的实现一下Servlet。

我们新建一个java Web项目：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzc2NzAxNQ_size_16_color_FFFFFF_t_70_pic_center]

maven依赖如下，采用tomcat插件：

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.example</groupId>
        <artifactId>servlet-01</artifactId>
        <version>1.0-SNAPSHOT</version>
        <name>servlet-01</name>
        <packaging>war</packaging>
    
        <properties>
            <maven.compiler.target>1.8</maven.compiler.target>
            <maven.compiler.source>1.8</maven.compiler.source>
            <junit.version>5.7.0</junit.version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>javax.servlet-api</artifactId>
                <version>4.0.1</version>
                <scope>provided</scope>
            </dependency>
        </dependencies>
    
        <build>
            <finalName>Servlet</finalName>
            <pluginManagement>
                <plugins>
                    <plugin>
                        <groupId>org.apache.tomcat.maven</groupId>
                        <artifactId>tomcat7-maven-plugin</artifactId>
                        <version>2.2</version>
                    </plugin>
                    <plugin>
                        <artifactId>maven-compiler-plugin</artifactId>
                        <version>3.8.0</version>
                    </plugin>
                </plugins>
            </pluginManagement>
            <plugins>
                
                <plugin>
                    <groupId>org.apache.tomcat.maven</groupId>
                    <artifactId>tomcat7-maven-plugin</artifactId>
                    <configuration>
                        
                        <port>8080</port>
                        
                        <path>/servlet-01</path>
                        
                        <uriEncoding>UTF-8</uriEncoding>
                    </configuration>
                </plugin>
                
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <configuration>
                        <source>1.8</source>
                        <target>1.8</target>
                        <encoding>utf-8</encoding>
                    </configuration>
                </plugin>
    
            </plugins>
        </build>
    </project>

开发第一个自己的Servlet：

@WebServlet("/first-servlet")
    public class FirstServlet implements Servlet {
        
        @Override
        public void init(ServletConfig servletConfig) {
        
            System.out.println("---------------");
            System.out.println("servletConfig: " + servletConfig);
            System.out.println("init");
        }
    
        @Override
        public ServletConfig getServletConfig() {
        
            System.out.println("---------------");
            System.out.println("getServletConfig");
            return null;
        }
    
        /**
         * 我们主要开发的方法
         *
         * @param servletRequest  请求对象
         * @param servletResponse 响应对象
         */
        @Override
        public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws IOException {
        
            //获取请求的数据
            String message = servletRequest.getParameter("xx");
            //封装响应数据
            servletResponse.setContentType("text/html");
    
            // Hello
            PrintWriter out = servletResponse.getWriter();
            out.println("<html><body>");
            out.println("<h1>" + message + "</h1>");
            out.println("</body></html>");
        }
    
        @Override
        public String getServletInfo() {
        
            System.out.println("getServletInfo");
            return null;
        }
    
        @Override
        public void destroy() {
        
            System.out.println("destroy");
        }
    }

想要成功运行servlet还要进行servlet的路径配置。这里，我们使用servlet 3.0开始提供的@WebServlet("/first-servlet")注解来配置servlet的路径。当然也可以使用web.xml来配置，但是这比较麻烦！这里的路径必须使用“/”开头，并且相对的是当前应用根目录。

如果是配置web.xml，那么可以这样配置：

将项目部署在tomcat服务器后，在浏览器中输入http://localhost:8080/servlet-01/first-servlet，这时候服务器就会先找到servlet-01工程下的web.xml，然后寻找这一次请求的映射路径/first-servlet，根据映射/first-servlet找到注释1，然后找到同级servlet的映射内部名称注释2，在根据映射的内部名称找到servlet的内部名称注释3，最后找到同级的servlet的具体类名注释4，然后服务器再根据反射执行定义了Servlt的类的方法，开始servlet的生命周期……

启动tomcat插件，访问http://localhost:8080/servlet-01/first-servlet?xx=11，可以发现servlet被初始化的信息：

![在这里插入图片描述][20210119103240580.png_pic_center]

在页面中能够看到传递的参数：

![在这里插入图片描述][20210119103259219.png_pic_center]

跟换请求参数，响应的参数也在改变：

![在这里插入图片描述][2021011910331679.png_pic_center]

**这就是基于servlet的动态Web应用。** 同时我们发现控制台并没有输出servlet被初始化的信息，这说明servlet只会被初始化一次。

需要注意的是，基于tomcat插件的Web应用在直接关闭时不会输出destory的信息，使用本地tomcat测试即可看到销毁的信息：

![在这里插入图片描述][20210119103340898.png_pic_center]

## 3.2 继承GenericServlet ##

java.servlet.GenericServlet类类使编写servlet变得更容易。它提供实现了Servlet接口和来自ServletConfig接口的方法（除了service方法）。GenericServlet类也实现了log()方法，这是一个在ServletContext接口中定义的方法，同时具有自己的init()和log()方法。

由于GenericServlet是一个抽象类，所以要扩展这个类，你必须实现这个类的所有抽象方法。但是相比于实现Servlet接口需要实现所有方法，继承该类只需要实现一个service即可，并且，Servlet接口的其他方法（比如初始化或者销毁方法）在实际开发中基本上是用不到的，因此继承GenericServlet更加方便。

Generic意为“通用的”，自己编写的servlet直接扩展GenericServlet类比实现Servlet接口更加方便。

如下是一个继承了GenericServlet的Servlet实现：

@WebServlet("/generic-servlet")
    public class MyGenericServlet extends GenericServlet {
        
    
        @Override
        public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
        
            //获取请求的数据
            String message = req.getParameter("xx");
            //封装响应数据
            res.setContentType("text/html");
    
            // Hello
            PrintWriter out = res.getWriter();
            out.println("<html><body>");
            out.println("<h1>" + message + "</h1>");
            out.println("</body></html>");
        }
    }

启动tomcat插件，访问http://localhost:8080/servlet-01/generic-servlet?xx=generic，结果如下，完全没问题：

![在这里插入图片描述][20210119103434519.png_pic_center]

## 3.3 继承HttpServlet ##

**实际上GenericServlet作为一个通用的Servlet实现，只提供了基本的功能，在某些情况下仍然不方便，比如我们的Web应用基本上都是基于HTTP协议的请求，因此非常有必要创造一个专门针对HTTP协议的Servlet，比如处理各种请求，获取请求头信息等等。**

Java已经为我们提供了这样的一个Servlet实现，那就是javax.servlet.http.HttpServlet。HTTP的请求方式包括DELETE、GET、OPTIONS、POST、PUT和TRACE，在HttpServlet类中分别提供了相应的服务方法,它们是doDelete()、doGet()、doOptions()、doPost()、doPut()和doTrace()。

HttpServlet继承了GenericServlet，而GenericServlet实现Servlet接口。所以可以继承HttpServlet来创建一个专门针对http请求的Servlet。

**当通过继承HttpServlet来创建一个Servlet时，我们只需要根据要处理的请求的类型，来重写不同的方法就可以了，处理get请求，则重写doGet()，处理post请求，则重写doPost()，无需实现其他方法，开发Servlet时更加简单！**

@WebServlet("/http-servlet")
    public class MyHttpServlet extends HttpServlet {
        
    
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
            //获取请求的数据
            String message = req.getParameter("xx");
            //封装响应数据
            resp.setContentType("text/html");
            // Hello
            PrintWriter out = resp.getWriter();
            out.println("<html><body>");
            out.println("<h1>" + message + "</h1>");
            out.println("</body></html>");
        }
    }

启动tomcat插件，访问http://localhost:8080/servlet-01/http-servlet?xx= http-servlet，结果如下，完全没问题：

![在这里插入图片描述][20210119103541843.png_pic_center]

### 3.3.1 HttpServlet的设计 ###

**HttpServlet类中提供了service(HttpServletRequest,HttpServletResponse)方法，这个方法是HttpServlet自己的方法，不是从Servlet继承来的。**

在HttpServlet重写自父类的service(ServletRequest,ServletResponse)方法中会把ServletRequest和ServletResponse强转成HttpServletRequest和HttpServletResponse，然后调用service(HttpServletRequest,HttpServletResponse)方法，这说明子类可以去覆盖service(HttpServletRequest,HttpServletResponse)方法即可，这就不用自己去强转请求和响应对象了。

public abstract class HttpServlet extends GenericServlet {
        
    //重写的service方法
        @Override
        public void service(ServletRequest req, ServletResponse res)
            throws ServletException, IOException {
        
            HttpServletRequest  request;
            HttpServletResponse response;
            try {
        
                request = (HttpServletRequest) req;
                response = (HttpServletResponse) res;
            } catch (ClassCastException e) {
        
                throw new ServletException("non-HTTP request or response");
            }
           //以上部分是对两个对象的装强制转型
           //下面是调用自身的service方法
            service(request, response);
    }
        //自身的service方法，在该方法中会判断http请求的的方式，并且会选择调用对应的方法如get请求调用doGet方法，post请求调用doPost方法。
    protected void service(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        
            ……
    }
    }

其实子类也不用去覆盖service(HttpServletRequest,HttpServletResponse)方法，因为HttpServlet还要做另一步简化操作。在HttpServlet的service(HttpServletRequest,HttpServletResponse)方法中会去判断当前请求是GET还是POST，如果是GET请求，那么会去调用本类的doGet()方法，如果是POST请求会去调用doPost()方法，这说明我们在子类中只需要去覆盖doGet()或doPost()方法即可。

**实际上这里采用了模版方法模式，service方法定义了请求处理的算法骨架，具体的处理方法则由子类实现。**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzc2NzAxNQ_size_16_color_FFFFFF_t_70_pic_center 1]

**通过这些细可以发现，HttpServlet的目的是让我们在进行基于HTTP请求的Web开发时更加简单，让开开发者把更多的精力放在业务逻辑上去，而不是放在网络请求的解析上。**

**一系列的doXxx方法使用了`模版方法设计模式`。**

# 4 Servlet的细节 #

## 4.1 Servlet与单例 ##

**Servlet是单例的，在web容器当中，在服务器关闭之前，自始至终就是同一个Servlet。即同时并发的请求也是由同一个servlet处理的！这样的好处是能够减少对象的创建，提升性能，但是我们在开发Servlet的时候需要注意线程安全问题，尽量不要定义有状态的全局变量。**

## 4.2 多个映射路径 ##

**一个Servlet，可以绑定一个多个映射路径，通过这些映射路径发送的请求都会到达该Servlet。**

对于web.xml可以如下配置，配置多个servlet-mapping，它们的servlet-name一致，但是url-pattern不一致。

<servlet>
        
        <servlet-name>firstServlt</servlet-name>
        
        <servlet-class>com.example.servlet_01.FirstServlet</servlet-class>
    </servlet>
    
    <servlet-mapping>
        
        <servlet-name>firstServlt</servlet-name>
        
        <url-pattern>/first-servlet</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        
        <servlet-name>firstServlt</servlet-name>
        
        <url-pattern>/first-servlet2</url-pattern>
    </servlet-mapping>

或者在一个servlet-mapping中配置多个url-pattern：

<servlet-mapping>
        
        <servlet-name>firstServlt</servlet-name>
        
        <url-pattern>/first-servlet3</url-pattern>
        <url-pattern>/first-servlet4</url-pattern>
        <url-pattern>/first-servlet5</url-pattern>
    </servlet-mapping>

对于采用@WebServlet注解的方式，那就更简单了，该注解的value是一个i嗯String数组，因此我们直接传递多个路径地址的数组就行了：

@WebServlet({
        "/generic-servlet","/generic-servlet2","/generic-servlet3"})

## 4.3 映射路径通配符 ##

**Servlet映射路径可以使⽤通配符“\*”，通配符可以匹配任何的字符串：**

1.  如果路径是`/*`结尾，则表示匹配具有指定前缀路径的所有的路径（优先级最高）！如果路径为`/*`，那么它会拦截所有的请求，包括访问直接静态资源、jsp文件的请求。
2.  如果路径是`*. 扩展名`，则表示匹配已该后缀结尾的任意路径。
3.  这两种格式不能混用。

**Servlet映射路径优先级：**

1.  对于某个具体的访问路径，如果存在该路径的Servlet映射，那么该Servlet优先级最高。
2.  如果不存在，那么具有“`/*`”结尾的通配符路径的Servlet优先级最高。
3.  如果不存在，那么具有“`*.后缀名`”结尾的通配符路径的Servlet优先级最高。
4.  如果不存在，那么最后是具有“`/`”默认路径通配符的Servlet，它也被称为默认Servlet。

**如果使用了“`/*`”通配符Servlet，那么当该Servlet中存在请求include、forward、redirect到其他没有显示指定路径的资源时（比如转发到某个jsp、静态资源等），那么这个请求将会一直在这个“`/*`”通配符Servlet中循环直到抛出异常，因为转发的路径并没有在第一步匹配到具体的Servlet的映射，进而又匹配到了这个通配符Servlet本身，而这个通配符Servlet中又再一次进行了转发。**

### 4.3.1 JspServlet ###

**对于以“\*.jsp”结尾的访问路径，默认是被一个在tomcat容器的conf/web.xml配置文件中配置的JspServlet处理的，名为jsp。它的定义如下：**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzc2NzAxNQ_size_16_color_FFFFFF_t_70]

**它的映射如下：**

![在这里插入图片描述][202102010132013.png_pic_center]

如下案例，该Servlet的路径为“\*.jsp”：

@WebServlet("*.jsp")
    public class AntServlet extends HttpServlet {
        
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
            //封装响应数据
            resp.setContentType("text/html");
            // AntServlet
            PrintWriter out = resp.getWriter();
            out.println("<html><body>");
            out.println("<h1>" + "AntServlet" + "</h1>");
            out.println("</body></html>");
        }
    }

那么我们访问以.jsp结尾的资源，比如http://localhost:8080/servlet-01/11/222.jsp，此时就会转发到该Servlet中：

![在这里插入图片描述][20210119104225316.png_pic_center]

## 4.4 默认Servlet ##

**Java Web应用的一切请求都是在请求对应的Servlet，动态的资源就不必说了，有自己的路径，对于静态资源，比如html、css、js、图片等，虽然在请求URL中看起来是访问的静态资源的地址，但是实际上仍然是通过一个默认Servlet查找资源的，没找到就返回404。**

**和JspServlet一样，默认servlet也是在tomcat容器在conf/web.xml配置文件中帮我们配置的，名为default。它的定义如下：**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzc2NzAxNQ_size_16_color_FFFFFF_t_70_pic_center 2]

**它的映射如下：**

![在这里插入图片描述][20210201013359892.png]

**所以说，静态资源的请求，会被这个由tomcat为我们配置的DefaultServlet拦截并处理，在该Servlet中，会尝试查找请求URL路径对应的静态资源，找到了就返回该资源，找不到就返回404！**

**如果在项目中自定义了映射路径为“`/`”的Servlet，那么会覆盖容器为我们配置的DefaultServlet，转而走我们自己配置的Servlet的逻辑！**

我们在webapp下创建一个default.html：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzc2NzAxNQ_size_16_color_FFFFFF_t_70_pic_center 3]

可以通过URL直接访问http://localhost:8080/servlet-01/default.html：

![在这里插入图片描述][20210119104310315.png_pic_center]

如果我们配置了默认的Servlet：

@WebServlet("/")
    public class DefaultServlet extends HttpServlet {
        
    
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        
            //封装响应数据
            resp.setContentType("text/html");
            // Hello
            PrintWriter out = resp.getWriter();
            out.println("<html><body>");
            out.println("<h1>" + "默认Servlet" + "</h1>");
            out.println("</body></html>");
        }
    }

再次访问该静态资源，http://localhost:8080/servlet-01/default.html，发现它会自动访问我们配置的默认Servlet：

![在这里插入图片描述][20210119104345494.png_pic_center]

## 4.5 Servlet初始化时机 ##

**Servlet在默认情况下，只有当对应的请求第一次到来时才会初始化，我们也可以配置在启动服务器时立即初始化某些Servlet。这样的好处是，在第一次请求的时候不会再创建Servlet对象了，提升处理速度，缺点就是启动服务器时会更多的对象，可能会延长服务器启动时间。**

对于web.xml可以如下配置，在servlet标签中添加一个load-on-startup子标签，该标签用于指示容器是否应该在web应用程序启动的时候就加载这个Servlet（实例化并调用其init方法）。

<servlet>
        <servlet-name>firstServlt</servlet-name>
        <servlet-class>com.example.servlet_01.FirstServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>

标签中填写的是启动的优先级：

1.  它的值必须是一个整数，当值为0或者大于0时，表示容器在应用启动时就加载并初始化这个servlet。值越小，该servlet的优先级越高，应用启动时就越先加载。
2.  如果该元素的值为负数或者没有设置，则容器会当Servlet被请求时再加载。
3.  当值相同时，容器就会自己选择顺序来加载。

**对于@WebServlet注解，可以在loadOnStartup属性中配置该特性。**

# 5 ServletConfig #

**javax.servlet.ServletConfig封装了配置某个Servlet的初始化信息，这个功能将配置信息从Java文件提到了xml文件或者注解中，能够统一管理配置，更加灵活，这可以看作比较原始的将配置和代码分离的方式。**

当servlet配置了初始化参数之后，web容器在创建servlet实例对象时，会自动将这些初始化参数封装到一个ServletConfig对象中，并在调用servlet的init方法时，将ServletConfig对象传递给Servlet，进而，程序员通过Servlet对象可以得到当前servlet的初始化参数信息，并且自定义初始化逻辑。