Servlet簡介與Servlet和HttpServlet運行的流程 ***

本文轉載自查看原文 2018-08-01 11:45 1513 JAVA WEB & 微服務

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-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-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/

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 Servlet簡介與Servlet和HttpServlet運行的流程 servlet(一)：從Sevlet到HttpServlet Servlet快速入門及運行流程 Servlet——使用HttpServlet的Form表單 servlet、genericservlet、httpservlet之間的區別 servlet、genericservlet、httpservlet之間的區別 Servlet，GenericServlet和HttpServlet的繼承關系 Servlet 簡介新建一個servlet類，繼承HttpServlet，但是無法導入HttpServlet包 Java Servlet 技術簡介