提供了编程的基础技术教程

zl程序教程

您现在的位置是：首页 >  其他

当前栏目

Servlet简介与Servlet和HttpServlet运行的流程 ***

流程Servlet 运行 简介
2023-09-27 14:21:52 时间
1.Servlet 
    [1] Servlet简介
        > Server + let
        > 意为：运行在服务器端的小程序。
        > Servlet实际上就是一个接口。
            - 狭义上的Servlet，指的就是Servlet接口
            - 广义上的我们认为凡是实现Servlet接口的类，我们都称他是一个Servlet *****
        > Servlet的作用：
            1.接收用户发送的请求
            2.调用其他的java程序来处理请求
            3.根据处理结果，返回给用户一个页面
 
        > Servlet的HelloWorld
            1.创建一个类并实现Servlet接口
            2.在web.xml文件中对Servlet进行配置
                <servlet>
                    <servlet-name>别名</servlet-name>
                    <servlet-class>全类名</servlet-class>
                </servlet>
                <servlet-mapping>
                    <servlet-name>别名</servlet-name>
                    <url-pattern>需要servlet处理的请求地址</url-pattern>
                </servlet-mapping>
 
        > Servlet的三个名字：
            <servlet-name>
                - Servlet的别名，程序员通过别名对Servlet进行配置
            <servlet-class>
                - Servlet的全类名，服务器通过全类名来创建Servlet的实例
            <url-pattern>
                - Servlet映射的请求地址，用户通过该地址访问Servlet
 
    [2] Servlet的生命周期
        > Servlet的生命周期，指Servlet的对象从被创建到被销毁的过程。
        > Servlet的生命周期方法：
            1.构造器：
                - Servlet第一次处理请求时，会调用构造器，来创建Servlet实例。
                - 只会调用一次，Servlet是单例模式，他是以多线程的方式调用service()方法.
                - Servlet不是线程安全，所以尽量不要再service()方法中操作全局变量。
 
            2.init()方法：
                - 构造器调用之后马上被调用，用来初始化Servlet，只会调用一次。
 
            3.service()方法：
                - Servlet每次处理请求时都会调用service()方法，用来处理请求，会调用多次。
 
            4.destroy()方法：
                - Servlet对象销毁前(WEB项目卸载时)调用，用来做一些收尾工作，释放资源。
 
    [3] 相关接口
        ①ServletConfig
            代表：当前Servlet的配置信息，每一个Servlet都有其唯一对应的ServletConfig。
                <servlet>
                    <servlet-name>AServlet</servlet-name>
                    <servlet-class>com.atguigu.servlet.AServlet</servlet-class>
                    <init-param>
                        <param-name>user</param-name>
                        <param-value>root</param-value>
                    </init-param>
                    <init-param>
                        <param-name>password</param-name>
                        <param-value>123123</param-value>
                    </init-param>
                </servlet>
 
            获取：由Tomcat服务器创建，最终作为参数传递到init()方法中，我们可以在init()方法直接使用。
                    当我们通过继承HttpServlet创建Servlet时，由于父类已经实现ServletConfig接口，
                        所以我们可以在Servlet中直接调用ServletConfig的方法。
 
            功能：
                【1】 获取Servlet的别名
                【2】 获取当前Servlet的初始化参数。
                        <init-param>
                            <param-name>user</param-name>
                            <param-value>root</param-value>
                        </init-param>
                        <init-param>
                            <param-name>password</param-name>
                            <param-value>123123</param-value>
                        </init-param>
                【3】 获取当前WEB应用的ServletContext对象。
 
        ②ServletContext
            代表：当前的WEB应用，一个WEB应用对应一个唯一的ServletContext对象，
                  ServletContext对象在项目启动时创建，在项目卸载时销毁。
 
            获取：通过ServletConfig的getServletContext()方法获取。
 
            功能：
                【1】 可以获取整个WEB应用的初始化参数
                    <context-param>
                        <param-name>phone</param-name>
                        <param-value>1388888888</param-value>
                    </context-param>
                【2】 可以获取资源的真实路径（物理路径），主要在文件的上传和下载时使用。
                【3】 可以作为一个域对象在不同的web资源之间共享数据。（下回分解）
 
    [4] GenericServlet
        - 通用Servlet的父类
        - 相比Servlet接口GenericServlet更加简单一些，但是我们最终实际上使用的HttpServlet
 
    [5] HttpServlet
        - HttpServlet继承了GenericServlet，而GenericServlet实现Servlet接口
        - 所以我们可以同构继承HttpServlet来创建一个Servlet。
        - HttpServlet重写service()方法：
            1.在该方法中先将ServletRequest和ServletResponse
                强转为了HttpServletRequest和HttpServletResponse。
            2.然调用重载的service()方法，并将刚刚强转得到对象传递到重载的方法中。
        - 重载service(HttpServletRequest request , HttpServletResponse response)
            1.在方法中获取请求的方式（get或post）
            2.在根据不同的请求方式去调用不同的方法：
                如果是GET请求，则调用doGet(HttpServletRequest request , HttpServletResponse response)
                如果是post请求，则调用doPost(HttpServletRequest request , HttpServletResponse response)
        - 结论：
            当通过继承HttpServlet来创建一个Servlet时，我们只需要根据要处理的请求的类型，来重写不同的方法。
                处理get请求，则重写doGet()
                处理post请求，则重写doPost()
 
 
 
    [6] HttpServletRequest 
        代表：浏览器发送给服务器的请求报文。
        获取：该对象由Tomcat服务器创建，最终作为参数传递到doGet或doPost方法中，我们可以在这两个方法中直接使用。
        功能：
            【1】获取用户发送的请求参数
                request.getParameter("username");
            【2】获取项目的名字(用来设置绝对路径)
                request.getContextPath();
            【3】作为一个域对象，在不同的WEB资源之间共享数据。
            【4】请求的转发
                request.getRequestDispatcher("target.html").forward(request, response);
 
 
    [7] HttpServletResponse
        代表：服务器发送给浏览器的响应报文。
        获取：该对象由Tomcat服务器创建，最终作为参数传递到doGet或doPost方法中，我们可以在这两个方法中直接使用。
        功能：
            【1】响应给浏览器一个网页或者是网页片段(设置的是响应报文的响应体)
                response.getWriter("");
            【2】请求的重定向
                response.sendRedirect("target.html");
 
    转发和重定向：（掌握）
 
                            转发                重定向
        请求的次数：          1                      2
        发生的位置            服务器内部            浏览器
        浏览器地址栏        不改变                改变
        浏览器的感知        不知道                知道   
 
 
    [8] 字符编码
        > 当用户通过表单向Servlet发送中文请求参数时，Servlet获取到内容会产生乱码，
            当Servlet向浏览器响应中文内容时，也会产生乱码。
        > 浏览器和服务器之间通信时，中文内容时不能直接发送的，需要对中文进行编码。
        > 编码：
            - 将字符转换为二进制码的过程叫编码。
        > 解码：
            - 将二进制码转换为普通字符的过程叫解码。
        > 编码和解码所采用的规则我们称为字符集。
 
        > 产生乱码问题的根本原因：
            编码和解码所采用的字符集不同。
 
        > 解决方法：
            统一编码和解码的字符集为UTF-8。
 
        > 常见字符集：
            1.ASCII
            2.ISO8859-1
            3.GBK
            4.GB2312
            5.UTF-8
 
        > 请求编码
            - 请求是浏览器发送给服务器的。
            - 浏览器 --> 服务器
            - 浏览器 编码
                > 浏览器的会自动使用网页的字符集对参数进行编码
                  UTF-8的张三：%E5%BC%A0%E4%B8%89
                  GBK的张三：%D5%C5%C8%FD
 
                > 所以我们只需要统一网页的字符集为UTF-8即可。
 
            - 服务器 解码
                post请求
                    > request解码时默认字符集时iso8859-1，但是iso压根就不支持中文
                    > post请求在servlet中解码，所以我们只需要指定request的字符集即可。
                    > 我们可以通过如下方法，来设置request的字符集：
                        request.setCharacterEncoding("utf-8");
                    > 注意：
                        该方法要在request.getParameter()第一次调用之前调用
 
                get请求
                    > get请求是通过url地址传递请求参数，url中的请求参数将会被Tomcat服务器自动解码。
                    > Tomcat的默认编码是iso8859-1，但是iso压根就不支持中文，所以必然乱码。
                    > 只需要修改Tomcat的解码的默认字符集，修改配置文件server.xml
                    > 在server.xml的Connector标签中（改端口号的那个标签）添加如下属性：
                        URIEncoding="utf-8"
                    > 修改完配置文件以后，get请求的编码就不用再处理的，但是post请求还是老样子。
 
        > 响应编码
            - 响应是服务器发送给浏览器
            - 服务器 --> 浏览器
            - 服务器 编码
                > 指定服务器的编码字符集为UTF-8。
                > 指定response的字符集
                    response.setCharacterEncoding("utf-8");
                > 虽然我们已经指定了response的字符集为utf-8，但是浏览器并不是用utf-8解码。
                    浏览器默认使用gb2312解码的，所以依然乱码，只不过没有那么乱。
 
            - 浏览器 解码
                > 浏览器的解码字符集可以通过浏览器来设置（不靠谱）
                > 我们可以通过服务器来告诉浏览器，我们的内容的编码格式为utf-8
                > 我们可以通过一个响应头来告诉浏览器，内容的编码格式：
                    Content-Type:text/html;charset=utf-8
                > 通过response的方法，来设置响应头：
                    response.setHeader("Content-Type", "text/html;charset=utf-8");
 
            解决方案：
                1.设置响应头
                    response.setHeader("Content-Type", "text/html;charset=utf-8");
                2.设置response的编码格式
                    response.setCharacterEncoding("utf-8");
 
                > 当我们设置Content-Type这个响应头时，服务器会自动使用响应头中的字符集为内容编码。
 
                > 最终方案：
                    response.setContentType("text/html;charset=utf-8");
 
        总结：
            post请求：
                - 在request.getParameter()方法第一次调用之前，调用如下代码：
                    request.setCharacterEncoding("utf-8");
            get请求：
                - 修改server.xml配置文件
                - <Connector URIEncoding="utf-8" connectionTimeout="20000" port="8080" protocol="HTTP/1.1" redirectPort="8443"/>
 
            响应：
                - 设置一个Content-Type响应头
                    response.setContentType("text/html;charset=utf-8");
 
 
 
 
    [9] 路径问题
        > URI和URL
            - URL是URI的一种实现，也是URI最常见的实现方式。
            - URI有两种实现方式URL和URN，URN用的很少
            - 我们说URL和URI实际上可以理解为一个意思
 
        > URL地址的格式
            http://主机名:端口号/项目名/资源路径/资源名
 
        ①相对路径和绝对路径
            > 相对路径
            - 之前我们使用的路径全都是相对路径：
                - 所谓的相对路径指相对于当前资源所在路径：
                    http://主机名:端口号/项目名/资源路径/
            - 由于转发的出现，相对路径会经常发生变化，容易出现错误的链接
                所以在开发中我们一般不使用相对路径，而是使用绝对路径。
 
            > 绝对路径
            - 绝对路径使用/开头   
            - 由浏览器解析的绝对路径中的/代表的是服务器的根目录：
                http://主机名:端口号/
                注意：需要加上项目名
 
            - 由服务器解析的绝对路径中的/代表的项目的根目录：
                http://主机名:端口号/项目名/
                注意：不要加项目名
 
            - 转发的路径由服务器解析，设置绝对路径时不需要加项目名
            - 重定向的路径由浏览器解析，设置绝对路径时需要加上项目名
 
 
        ②常见的路径：
            url-pattern：
            转发的路径：
                - url-pattern和转发中的路径都是由服务器解析的，
                    根目录是项目的根目录：
                        http://主机名:端口号/项目名/
                - 所以这两个路径不需要加项目名
 
            重定向的路径：
            页面中的路径：
                - 重定向和页面中的路径（HTML标签中的路径），由浏览器解析的，
                    根目录是服务器的根目录：
                        http://主机名:端口号/
                - 所以这个两个路径必须加上项目名
  

[10]运行的流程

1、浏览器发送请求到HttpSevr类调用HttpServ的service（servletRequest, servletReponse）方法

2、由于没有找到这个方法，去调用父类（HttpServlet） 的同名方法。

3、父类的service方法将ServletRequest req请求转换成HttpServletRequest请求，再去调用service(request, response) 方法。

将ServletRequest req请求转换成HttpServletRequest请求再调用service(request, response) 方法源码如下：

　　

 

 

[11]HttpServlet

 

 

怎样才能实现一个servlet，方法有3种：

1、实现servlet接口

2、继承GenericServlet（实现service 方法 ）

3、继承HttpServlet类（重写doGet，doPost方法就行）

 

servlet 接口源代码

public abstract interface Servlet  
{  
  public abstract void init(ServletConfig paramServletConfig)  
    throws ServletException;  
  public abstract ServletConfig getServletConfig();  
  public abstract void service(ServletRequest paramServletRequest, ServletResponse paramServletResponse)  
    throws ServletException, IOException;  
  public abstract String getServletInfo();  
  public abstract void destroy();  
}

GenericServlet源代码

package javax.servlet;  
import java.io.IOException;  
import java.io.Serializable;  
import java.util.Enumeration;  
import java.util.ResourceBundle;  
public abstract class GenericServlet  
  implements Servlet, ServletConfig, Serializable  
{  
  private static final String LSTRING_FILE = "javax.servlet.LocalStrings";  
  private static ResourceBundle lStrings = ResourceBundle.getBundle("javax.servlet.LocalStrings");  
  private transient ServletConfig config;  
  public void destroy()  
  {  
  }  
  public String getInitParameter(String name)  
  {  
    ServletConfig sc = getServletConfig();  
    if (sc == null) {  
      throw new IllegalStateException(lStrings.getString("err.servlet_config_not_initialized"));  
    }  
    return sc.getInitParameter(name);  
  }  
  public Enumeration getInitParameterNames()  
  {  
    ServletConfig sc = getServletConfig();  
    if (sc == null) {  
      throw new IllegalStateException(lStrings.getString("err.servlet_config_not_initialized"));  
    }  
    return sc.getInitParameterNames();  
  }  
  public ServletConfig getServletConfig()  
  {  
    return this.config;  
  }  
  public ServletContext getServletContext()  
  {  
    ServletConfig sc = getServletConfig();  
    if (sc == null) {  
      throw new IllegalStateException(lStrings.getString("err.servlet_config_not_initialized"));  
    }  
    return sc.getServletContext();  
  }  
  public String getServletInfo()  
  {  
    return "";  
  }  
  public void init(ServletConfig config)  
    throws ServletException  
  {  
    this.config = config;  
    init();  
  }  
  public void init()  
    throws ServletException  
  {  
  }  
  public void log(String msg)  
  {  
    getServletContext().log(getServletName() + ": " + msg);  
  }  
  public void log(String message, Throwable t)  
  {  
    getServletContext().log(getServletName() + ": " + message, t);  
  }  
  public abstract void service(ServletRequest paramServletRequest, ServletResponse paramServletResponse)  
    throws ServletException, IOException;  
  public String getServletName()  
  {  
    ServletConfig sc = getServletConfig();  
    if (sc == null) {  
      throw new IllegalStateException(lStrings.getString("err.servlet_config_not_initialized"));  
    }  
    return sc.getServletName();  
  }  
}

HttpServlet源代码

package javax.servlet.http;
import java.io.IOException;
import java.io.Serializable;
import java.lang.reflect.Method;
import java.text.MessageFormat;
import java.util.Enumeration;
import java.util.ResourceBundle;
import javax.servlet.GenericServlet;
import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
public abstract class HttpServlet extends GenericServlet
  implements Serializable
{
  private static final String METHOD_DELETE = "DELETE";
  private static final String METHOD_HEAD = "HEAD";
  private static final String METHOD_GET = "GET";
  private static final String METHOD_OPTIONS = "OPTIONS";
  private static final String METHOD_POST = "POST";
  private static final String METHOD_PUT = "PUT";
  private static final String METHOD_TRACE = "TRACE";
  private static final String HEADER_IFMODSINCE = "If-Modified-Since";
  private static final String HEADER_LASTMOD = "Last-Modified";
  private static final String LSTRING_FILE = "javax.servlet.http.LocalStrings";
  private static ResourceBundle lStrings = ResourceBundle.getBundle("javax.servlet.http.LocalStrings");
  protected void doGet(HttpServletRequest req, HttpServletResponse resp)
    throws ServletException, IOException
  {
    String protocol = req.getProtocol();
    String msg = lStrings.getString("http.method_get_not_supported");
    if (protocol.endsWith("1.1"))
      resp.sendError(405, msg);
    else
      resp.sendError(400, msg);
  }
  protected long getLastModified(HttpServletRequest req)
  {
    return -1L;
  }
  protected void doHead(HttpServletRequest req, HttpServletResponse resp)
    throws ServletException, IOException
  {
    NoBodyResponse response = new NoBodyResponse(resp);
    doGet(req, response);
    response.setContentLength();
  }
  protected void doPost(HttpServletRequest req, HttpServletResponse resp)
    throws ServletException, IOException
  {
    String protocol = req.getProtocol();
    String msg = lStrings.getString("http.method_post_not_supported");
    if (protocol.endsWith("1.1"))
      resp.sendError(405, msg);
    else
      resp.sendError(400, msg);
  }
  protected void doPut(HttpServletRequest req, HttpServletResponse resp)
    throws ServletException, IOException
  {
    String protocol = req.getProtocol();
    String msg = lStrings.getString("http.method_put_not_supported");
    if (protocol.endsWith("1.1"))
      resp.sendError(405, msg);
    else
      resp.sendError(400, msg);
  }
  protected void doDelete(HttpServletRequest req, HttpServletResponse resp)
    throws ServletException, IOException
  {
    String protocol = req.getProtocol();
    String msg = lStrings.getString("http.method_delete_not_supported");
    if (protocol.endsWith("1.1"))
      resp.sendError(405, msg);
    else
      resp.sendError(400, msg);
  }
  private Method[] getAllDeclaredMethods(Class c)
  {
    if (c.equals(HttpServlet.class)) {
      return null;
    }
    Method[] parentMethods = getAllDeclaredMethods(c.getSuperclass());
    Method[] thisMethods = c.getDeclaredMethods();
    if ((parentMethods != null) && (parentMethods.length > 0)) {
      Method[] allMethods = new Method[parentMethods.length + thisMethods.length];
      System.arraycopy(parentMethods, 0, allMethods, 0, parentMethods.length);
      System.arraycopy(thisMethods, 0, allMethods, parentMethods.length, thisMethods.length);
      thisMethods = allMethods;
    }
    return thisMethods;
  }
  protected void doOptions(HttpServletRequest req, HttpServletResponse resp)
    throws ServletException, IOException
  {
    Method[] methods = getAllDeclaredMethods(getClass());
    boolean ALLOW_GET = false;
    boolean ALLOW_HEAD = false;
    boolean ALLOW_POST = false;
    boolean ALLOW_PUT = false;
    boolean ALLOW_DELETE = false;
    boolean ALLOW_TRACE = true;
    boolean ALLOW_OPTIONS = true;
    for (int i = 0; i < methods.length; ++i) {
      Method m = methods[i];
      if (m.getName().equals("doGet")) {
        ALLOW_GET = true;
        ALLOW_HEAD = true;
      }
      if (m.getName().equals("doPost"))
        ALLOW_POST = true;
      if (m.getName().equals("doPut"))
        ALLOW_PUT = true;
      if (m.getName().equals("doDelete"))
        ALLOW_DELETE = true;
    }
    String allow = null;
    if ((ALLOW_GET) && 
      (allow == null)) allow = "GET";
    if (ALLOW_HEAD)
      if (allow == null) allow = "HEAD";
      else allow = allow + ", HEAD";
    if (ALLOW_POST)
      if (allow == null) allow = "POST";
      else allow = allow + ", POST";
    if (ALLOW_PUT)
      if (allow == null) allow = "PUT";
      else allow = allow + ", PUT";
    if (ALLOW_DELETE)
      if (allow == null) allow = "DELETE";
      else allow = allow + ", DELETE";
    if (ALLOW_TRACE)
      if (allow == null) allow = "TRACE";
      else allow = allow + ", TRACE";
    if (ALLOW_OPTIONS)
      if (allow == null) allow = "OPTIONS";
      else allow = allow + ", OPTIONS";
    resp.setHeader("Allow", allow);
  }
  protected void doTrace(HttpServletRequest req, HttpServletResponse resp)
    throws ServletException, IOException
  {
    String CRLF = "/r/n";
    String responseString = "TRACE " + req.getRequestURI() + " " + req.getProtocol();
    Enumeration reqHeaderEnum = req.getHeaderNames();
    while (reqHeaderEnum.hasMoreElements()) {
      String headerName = (String)reqHeaderEnum.nextElement();
      responseString = responseString + CRLF + headerName + ": " + req.getHeader(headerName);
    }
    responseString = responseString + CRLF;
    int responseLength = responseString.length();
    resp.setContentType("message/http");
    resp.setContentLength(responseLength);
    ServletOutputStream out = resp.getOutputStream();
    out.print(responseString);
    out.close();
  }
  protected void service(HttpServletRequest req, HttpServletResponse resp)
    throws ServletException, IOException
  {
    long lastModified;
    String method = req.getMethod();
    if (method.equals("GET")) {
      lastModified = getLastModified(req);
      if (lastModified == -1L)
      {
        doGet(req, resp);
      } else {
        long ifModifiedSince = req.getDateHeader("If-Modified-Since");
        if (ifModifiedSince < lastModified / 1000L * 1000L)
        {
          maybeSetLastModified(resp, lastModified);
          doGet(req, resp);
        }
        else resp.setStatus(304);
      }
    }
    else if (method.equals("HEAD")) {
      lastModified = getLastModified(req);
      maybeSetLastModified(resp, lastModified);
      doHead(req, resp);
    }
    else if (method.equals("POST")) {
      doPost(req, resp);
    }
    else if (method.equals("PUT")) {
      doPut(req, resp);
    }
    else if (method.equals("DELETE")) {
      doDelete(req, resp);
    }
    else if (method.equals("OPTIONS")) {
      doOptions(req, resp);
    }
    else if (method.equals("TRACE")) {
      doTrace(req, resp);
    }
    else
    {
      String errMsg = lStrings.getString("http.method_not_implemented");
      Object[] errArgs = new Object[1];
      errArgs[0] = method;
      errMsg = MessageFormat.format(errMsg, errArgs);
      resp.sendError(501, errMsg);
    }
  }
  private void maybeSetLastModified(HttpServletResponse resp, long lastModified)
  {
    if (resp.containsHeader("Last-Modified"))
      return;
    if (lastModified >= 0L)
      resp.setDateHeader("Last-Modified", lastModified);
  }
  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(request, response);
  }
}

GenericServlet实现了接口：Servlet , ServletConfig

HttpServlet ：继承了GenericServlet 

 

 

咱先看下访问页面是怎样的一个流程：

 

当你访问一个servlet的时候(也可以说是访问一个jsp页面)，访问的方式有（get，post，delete），调用service（）方法处理你的请求，你可以在里面写你想要干嘛。

 

在GenericServlet中，service是一个抽象方法，也就是当你以继承GenericServlet的方式创建一个servlet时，必须实现service方法，在里面处理前端发过来的request，和response。

 

在HttpServlet中，大家可以看它的原代码，有2个service方法，一个是保护的（主要看里面的实现），一个是公有的，公有的service接收到请求时，会抛给保护的那个service，它在这只是起一个中转的作用。当前端有请求过来时，会默认找到这2个service方法，具体先找哪个我不清楚，反正最后请求都会在保护的那个service那里，在那个service中，会根据前端是哪种方式的请求，再抛给相应的处理方法，如：get则交给doGet处理。所以，在以继承GenericServlet的方式创建一个servlet时，你只要重写相应的doGet或者doPost等处理方法就行了，然后再在里面写你的代码就行了。

 

 

--------------------

还有一个就是关于servlet的生命周期，它开始于init，而且容器中一个servlet只有一个实例，多个请求过来时，是共享一个servlet的，每次请求都是调用service，它销毁与容器关闭的时候，还有人说可以调用destory来销毁一个实例，我做了实验，不行。可能是不同容器不同的处理吧，你们可以看下源代码，destory在GenericServlet中是空实现，不知道为什么。求高手解答。

 

 

测试销毁servlet的代码

public class LoginServlet extends HttpServlet {
    private Integer a = 0; // 一个servlet将会一直在容器中存在，除非它重启服务器或者强制
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        doPost(req, resp);
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        PrintWriter pw = resp.getWriter();
        pw.write("这是一个servlet");
        System.out.println(a++);
        if (a > 5) {
            
            destroy();  //如果销毁的话，下次输出a就又从0开始了，否则就是继续递增
        }
    }
}

 

http://www.cnblogs.com/libingbin/

 

相关文章