Servlet生命周期

最新推荐文章于 2024-03-23 17:58:51 发布

清世

最新推荐文章于 2024-03-23 17:58:51 发布

阅读量753

点赞数

文章标签： java

原文链接：https://blog.csdn.net/qq_15958689/article/details/87006564?utm_medium=distribute.pc_relevant.none-task-blog-baidujs-1

版权

Servlet运行在Servlet容器中，其生命周期由容器来管理。Servlet的生命周期通过javax.servlet.Servlet接口中的init()、service()和destroy()方法来表示

Servlet的生命周期包含了下面4个阶段：

1.加载和实例化

2.初始化

3.请求处理

4.服务终止

Web服务器在与客户端交互时Servlet的工作过程是:

1. 在客户端对web服务器发出请求

2. web服务器接收到请求后将其发送给Servlet

3. Servlet容器为此产生一个实例对象并调用ServletAPI中相应的方法来对客户端HTTP请求进行处理,然后将处理的响应结果返回给WEB服务器.

4. web服务器将从Servlet实例对象中收到的响应结构发送回客户端.

servlet的生命周期：

1.加载和实例化

　　Servlet容器负责加载和实例化Servlet。当Servlet容器启动时，或者在容器检测到需要这个Servlet来响应第一个请求时，创建Servlet实例。当Servlet容器

启动后，它必须要知道所需的Servlet类在什么位置，Servlet容器可以从本地文件系统、远程文件系统或者其他的网络服务中通过类加载器加载Servlet类，

成功加载后，容器创建Servlet的实例。因为容器是通过Java的反射API来创建Servlet实例，调用的是Servlet的默认构造方法（即不带参数的构造方法），所

以我们在编写Servlet类的时候，不应该提供带参数的构造方法。

2.初始化

　　在Servlet实例化之后，容器将调用Servlet的init()方法初始化这个对象。初始化的目的是为了让Servlet对象在处理客户端请求前完成一些初始化的工作，

如建立数据库的连接，获取配置信息等。对于每一个Servlet实例，init()方法只被调用一次。在初始化期间，Servlet实例可以使用容器为它准备的

ServletConfig对象从Web应用程序的配置信息（在web.xml中配置）中获取初始化的参数信息。在初始化期间，如果发生错误，Servlet实例可以抛出

ServletException异常或者UnavailableException异常来通知容器。ServletException异常用于指明一般的初始化失败，例如没有找到初始化参数；而

UnavailableException异常用于通知容器该Servlet实例不可用。例如，数据库服务器没有启动，数据库连接无法建立，Servlet就可以抛出

UnavailableException异常向容器指出它暂时或永久不可用。

I.如何配置Servlet的初始化参数？

在web.xml中该Servlet的定义标记中，比如：

    <servlet>
         <servlet-name>TimeServlet</servlet-name>
         <servlet-class>com.allanlxf.servlet.basic.TimeServlet</servlet-class>
        <init-param>
            <param-name>user</param-name>
            <param-value>username</param-value>
       </init-param>
       <init-param>
           <param-name>blog</param-name>
           <param-value>http://。。。</param-value>
       </init-param>
    </servlet>

配置了两个初始化参数user和blog它们的值分别为username和http://。。。，这样以后要修改用户名和博客的地址不需要修改Servlet代码，只需修改配置文件即可。

II.如何读取Servlet的初始化参数？

ServletConfig中定义了如下的方法用来读取初始化参数的信息：

public String getInitParameter(String name)

参数：初始化参数的名称。
返回：初始化参数的值，如果没有配置，返回null。

III.init(ServletConfig)方法执行次数

在Servlet的生命周期中，该方法执行一次。

IV.init(ServletConfig)方法与线程

该方法执行在单线程的环境下，因此开发者不用考虑线程安全的问题。

V.init(ServletConfig)方法与异常

该方法在执行过程中可以抛出ServletException来通知Web服务器Servlet实例初始化失败。一旦ServletException抛出，Web服务器不会将客户端请求交给该Servlet实例来处理，而是报告初始化失败异常信息给客户端，该Servlet实例将被从内存中销毁。如果在来新的请求，Web服务器会创建新的Servlet实例，并执行新实例的初始化操作

3.请求处理

　　Servlet容器调用Servlet的service()方法对请求进行处理。要注意的是，在service()方法调用之前，init()方法必须成功执行。在service()方法中，

Servlet实例通过ServletRequest对象得到客户端的相关信息和请求信息，在对请求进行处理后，调用ServletResponse对象的方法设置响应信息。在service

()方法执行期间，如果发生错误，Servlet实例可以抛出ServletException异常或者UnavailableException异常。如果UnavailableException异常指示了该实

例永久不可用，Servlet容器将调用实例的destroy()方法，释放该实例。此后对该实例的任何请求，都将收到容器发送的HTTP 404（请求的资源不可用）响应

。如果UnavailableException异常指示了该实例暂时不可用，那么在暂时不可用的时间段内，对该实例的任何请求，都将收到容器发送的HTTP 503（服务器暂

时忙，不能处理请求）响应。

I. service()方法的职责

service()方法为Servlet的核心方法，客户端的业务逻辑应该在该方法内执行，典型的服务方法的开发流程为：

解析客户端请求-〉执行业务逻辑-〉输出响应页面到客户端

II.service()方法与线程

为了提高效率，Servlet规范要求一个Servlet实例必须能够同时服务于多个客户端请求，即service()方法运行在多线程的环境下，Servlet开发者必须保证该方法的线程安全性。

III.service()方法与异常

service()方法在执行的过程中可以抛出ServletException和IOException。其中ServletException可以在处理客户端请求的过程中抛出，比如请求的资源不可用、数据库不可用等。一旦该异常抛出，容器必须回收请求对象，并报告客户端该异常信息。IOException表示输入输出的错误，编程者不必关心该异常，直接由容器报告给客户端即可。

编程注意事项说明：

1) 当Server Thread线程执行Servlet实例的init()方法时，所有的Client Service Thread线程都不能执行该实例的service()方法，更没有线程能够执行该实例的destroy()方法，因此Servlet的init()方法是工作在单线程的环境下，开发者不必考虑任何线程安全的问题。

2) 当服务器接收到来自客户端的多个请求时，服务器会在单独的Client Service Thread线程中执行Servlet实例的service()方法服务于每个客户端。此时会有多个线程同时执行同一个Servlet实例的service()方法，因此必须考虑线程安全的问题。

3) 请大家注意，虽然service()方法运行在多线程的环境下，并不一定要同步该方法。而是要看这个方法在执行过程中访问的资源类型及对资源的访问方式。分析如下：

i. 如果service()方法没有访问Servlet的成员变量也没有访问全局的资源比如静态变量、文件、数据库连接等，而是只使用了当前线程自己的资源，比如非指向全局资源的临时变量、request和response对象等。该方法本身就是线程安全的，不必进行任何的同步控制。

ii. 如果service()方法访问了Servlet的成员变量，但是对该变量的操作是只读操作，该方法本身就是线程安全的，不必进行任何的同步控制。

iii. 如果service()方法访问了Servlet的成员变量，并且对该变量的操作既有读又有写，通常需要加上同步控制语句。

iv. 如果service()方法访问了全局的静态变量，如果同一时刻系统中也可能有其它线程访问该静态变量，如果既有读也有写的操作，通常需要加上同步控制语句。

v. 如果service()方法访问了全局的资源，比如文件、数据库连接等，通常需要加上同步控制语句。

4.服务终止

　　当容器检测到一个Servlet实例应该从服务中被移除的时候，容器就会调用实例的destroy()方法，以便让该实例可以释放它所使用的资源，保存数据到持久存

储设备中。当需要释放内存或者容器关闭时，容器就会调用Servlet实例的destroy()方法。在destroy()方法调用之后，容器会释放这个Servlet实例，该实例

随后会被Java的垃圾收集器所回收。如果再次需要这个Servlet处理请求，Servlet容器会创建一个新的Servlet实例。

　　在整个Servlet的生命周期过程中，创建Servlet实例、调用实例的init()和destroy()方法都只进行一次，当初始化完成后，Servlet容器会将该实例保存在内存中，通过调用它的service()方法，为接收到的请求服务。

5.异步Servlet

再Servlet3.0中开始支持异步处理方式。

Servlet 3.0 之前，一个普通 Servlet 的主要工作流程大致如下：
（1）首先，Servlet 接收到请求之后，可能需要对请求携带的数据进行一些预处理；
（2）接着，调用业务接口的某些方法，以完成业务处理；
（3）最后，根据处理的结果提交响应，Servlet 线程结束。
其中第二步的业务处理通常是最耗时的，这主要体现在数据库操作，以及其它的跨网络调用等，在此过程中，Servlet 线程一直处于阻塞状态，直到业务方法执行完毕。

在处理业务的过程中，Servlet 资源一直被占用而得不到释放，对于并发较大的应用，这有可能造成性能的瓶颈。对此，在以前通常是采用私有解决方案来提前结束 Servlet 线程，并及时释放资源。

Servlet 3.0 针对这个问题做了开创性的工作，现在通过使用 Servlet 3.0 的异步处理支持，之前的 Servlet 处理流程可以调整为如下的过程：
首先，Servlet 接收到请求之后，可能首先需要对请求携带的数据进行一些预处理；
接着，Servlet 线程将请求转交给一个异步线程来执行业务处理，线程本身返回至容器，此时 Servlet 还没有生成响应数据，异步线程处理完业务以后，可以直接生成响应数据（异步线程拥有 ServletRequest 和 ServletResponse 对象的引用），或者将请求继续转发给其它 Servlet。

如此一来， Servlet 线程不再是一直处于阻塞状态以等待业务逻辑的处理，而是启动异步线程之后可以立即返回。

开启功能：

异步处理特性可以应用于 Servlet 和过滤器两种组件，由于异步处理的工作模式和普通工作模式在实现上有着本质的区别，因此默认情况下，Servlet 和过滤器并没有开启异步处理特性，如果希望使用该特性，则必须按照如下的方式启用：
1、对于使用传统的部署描述文件 (web.xml) 配置 Servlet 和过滤器的情况，Servlet 3.0 为和标签增加了子标签，该标签的默认取值为 false，要启用异步处理支持，则将其设为 true 即可。以 Servlet 为例，其配置方式如下所示：


 
 
   
   
    
    
   
   
   
   
    
    
     
     <servlet> 
    
    
   
   

   
   
    
    
   
   
   
   
    
        
     
     <servlet-name>DemoServlet
     
     </servlet-name> 
    
    
   
   

   
   
    
    
   
   
   
   
    
        
     
     <servlet-class>footmark.servlet.Demo Servlet
     
     </servlet-class> 
    
    
   
   

   
   
    
    
   
   
   
   
    
        
     
     <async-supported>true
     
     </async-supported> 
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     </servlet>

2、对于使用 Servlet 3.0 提供的 @WebServlet 和 @WebFilter 进行 Servlet 或过滤器配置的情况，这两个注解都提供了 asyncSupported 属性，默认该属性的取值为 false，要启用异步处理支持，只需将该属性设置为 true 即可。以 @WebFilter 为例，其配置方式如下所示：


 
 
   
   
    
    
   
   
   
   
    
    
     
     @WebFilter(urlPatterns = 
     
     "/demo",asyncSupported = 
     
     true) 
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     public 
     
     class DemoFilter implements Filter{...}

一个简单的模拟异步处理的 Servlet 示例如下：


 
 
   
   
    
    
   
   
   
   
    
    
     
     @WebServlet(urlPatterns = 
     
     "/demo", asyncSupported = 
     
     true)
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     public 
     
     class 
     
     AsyncDemoServlet 
     
     extends 
     
     HttpServlet {
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         @
     
     Override
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         public void doGet(HttpServletRequest req, HttpServletResponse resp)
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         throws IOException, ServletException {
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             resp.setContentType(
     
     "text/html;charset=UTF-8");
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             PrintWriter 
     
     out = resp.getWriter();
    
    
   
   

   
   
    
    
   
   
   
   
    
            
     
     out.println(
     
     "进入Servlet的时间：" + 
     
     new Date() + 
     
     ".");
    
    
   
   

   
   
    
    
   
   
   
   
    
            
     
     out.flush();
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
            
     
     //在子线程中执行业务调用，并由其负责输出响应，主线程退出
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             AsyncContext ctx = req.startAsync();
    
    
   
   

   
   
    
    
   
   
   
   
    
            
     
     new Thread(
     
     new Executor(ctx)).start();
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
            
     
     out.println(
     
     "结束Servlet的时间：" + 
     
     new Date() + 
     
     ".");
    
    
   
   

   
   
    
    
   
   
   
   
    
            
     
     out.flush();
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         }
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     }
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     public 
     
     class 
     
     Executor 
     
     implements 
     
     Runnable {
    
    
   
   

   
   
    
    
   
   
   
   
    
        
     
     private AsyncContext ctx = 
     
     null;
    
    
   
   

   
   
    
    
   
   
   
   
    
        
     
     public Executor(AsyncContext ctx){
    
    
   
   

   
   
    
    
   
   
   
   
    
            
     
     this.ctx = ctx;
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         }
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
        
     
     public void run(){
    
    
   
   

   
   
    
    
   
   
   
   
    
            
     
     try {
    
    
   
   

   
   
    
    
   
   
   
   
    
                
     
     //等待十秒钟，以模拟业务方法的执行
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
                 Thread.sleep(
     
     10000);
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
                 PrintWriter 
     
     out = ctx.getResponse().getWriter();
    
    
   
   

   
   
    
    
   
   
   
   
    
                
     
     out.println(
     
     "业务处理完毕的时间：" + 
     
     new Date() + 
     
     ".");
    
    
   
   

   
   
    
    
   
   
   
   
    
                
     
     out.flush();
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
                 ctx.complete();
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             } 
     
     catch (Exception e) {
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
                 e.printStackTrace();
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             }
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         }
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     }

Servlet 3.0 还为异步处理提供了一个监听器，使用

AsyncListener 接口表示。它可以监控如下四种事件：
1. 异步线程开始时，调用 AsyncListener 的 onStartAsync(AsyncEvent event) 方法；
2. 异步线程出错时，调用 AsyncListener 的 onError(AsyncEvent event) 方法；
3. 异步线程执行超时，则调用 AsyncListener 的 onTimeout(AsyncEvent event) 方法；
4. 异步执行完毕时，调用 AsyncListener 的 onComplete(AsyncEvent event) 方法；

要注册一个AsyncListener，只需将准备好的 AsyncListener 对象传递给 AsyncContext 对象的 addListener() 方法即可，如下所示：


 
 
   
   
    
    
   
   
   
   
    
    
     
     AsyncContext ctx = req.startAsync(); 
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     ctx.addListener(
     
     new AsyncListener() { 
    
    
   
   

   
   
    
    
   
   
   
   
    
        
     
     public void onComplete(AsyncEvent asyncEvent) throws IOException { 
    
    
   
   

   
   
    
    
   
   
   
   
    
            
     
     // 做一些清理工作或者其他
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         } 
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         ... 
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     });