Servlet 介紹 以及Servlet生命週期（詳細）
阿新 • • 發佈：2019-01-20
在上一篇文件裡提到了CGI和Servelt 的對比，並介紹了在JAVA編寫的應用程式Servlet在伺服器上執行主要就是解決了CGI程序處理佔資源效率高的問題。
Servlet 只是一個名詞，具體的解釋就是使用JAVA編寫的一個應用程式，在伺服器上執行，處理請求的資訊，並且將處理後的結果回發的客戶端。
對於所有的來自於客戶端的請求，這段程式即Servlet只需要建立一次例項，因此它節省了大量的記憶體。Servlet在初始化後即停駐在記憶體中，因此每次做出請求時無需重新載入。
具體來看看Tomcat容器即Servlet容器到底是如何管理Servlet的，它的生命週期到底是如何執行的，其中是如何與Tomcat容器實現互動，主要大家認真理解下面的分析，基本上理解Servlet生命週期也是沒有問題的。
[color=green][b]一．Tomcat 是如何載入Servlet的（Servlet的初始化）[/b][/color]
還是以Simon 本人配置的環境舉例
找到 [url]C:\Program Files\Apache Software Foundation\Tomcat 6.0\webapps\myapp\WEB-INF[/url]下的 web.xml
這個配置檔案實際上起到的最直接的作用就是管理Servlet. 在其中先加上兩個 <servlet>和<serlvet-mapping>
web.xml – 繼續第一次測試Servlet 的配置時的內容，複製替換即可，加的部分用紅色標識
新添的一個Servlet ServletDemo.java 也應該先編譯好，然後放到
[url]C:\Program Files\Apache Software Foundation\Tomcat 6.0\webapps\myapp\WEB-INF\classes[/url]目錄下，此時這個目錄應該有 [color=olive]ServletDemo.class [/color]和 [color=olive]MyServlet.class [/color]兩個類檔案。
[url]ServletDemo.java[/url]
[color=green][b]
二．啟動Tomcat服務[/b][/color]
[url]C:\Program Files\Apache Software Foundation\Tomcat 6.0\bin tomcat6.exe[/url]
注意紅色圈起來的部分
[u]圖片1見附件[/u]
這句話的輸出即證明了 在MyServlet中的 init方法被呼叫了一次！
MyServlet.java中的相關程式碼：
但是我在MyServlet.java 和上面新加的ServletDemo.java中都存在 init()方法，但是為什麼僅僅MyServlet.java中的方法被呼叫了呢？原因就在於在 web.xml中，指定了Tomcat一啟動就初始化的例項
這樣就通知了Tomcat在它的服務一啟動的時候，就要去載入所對應的Servlet-class MyServlet這個類，0代表級別，隨後是1.2.3.4---- 0最高。Tomcat首先把這些類載入並例項化，儲存在自己的Servlet容器池中，如果以後有請求，就直接從容器池中取出來，處理相應的請求。
要注意的是：此時並沒有來自於客戶端的請求，是先於客戶請求直接就已經載入完畢了的。
下面我們去請求 ServletDemo ,它沒有像MyServlet 那樣在客戶端請求前就被Tomcat例項化了的，它需要由請求完成例項化。
在IE瀏覽器中輸入 ：[url]http://localhost:8080/myapp/t238servlet[/url]
在頁面上看到
[u]圖片2見附件[/u]
在Tomcat 控制檯上看到: 注意紅線部分！
[u]圖片2見附件[/u]
說明了什麼？
說明了，Tomcat載入Servlet例項至少有兩種方法，一種是通過在 web.xml配置檔案中設定載入級別，另一種是通過客戶端訪問到某個具體的Servlet時，也一定會完成初始化，載入這個例項！一旦例項被載入，後面的請求，將不會再重新例項化Servlet。
再重新整理頁面：[url]http://localhost:8080/myapp/t238servlet[/url]
對應的網頁 和Tomcat
[u]圖片3見附件[/u]
ServletDemo中的doGet方法被執行一次 多輸出了一句，但是 初始化的資訊沒有再輸出，說明了 init()方法只執行了一次，也即說明了Servlet例項只被Tomcat 載入了一次！
換個頁面請求一次 [url]http://localhost:8080/myapp/servletpage[/url]相應頁面和Tomcat控制檯為：
[u]圖片4見附件[/u]
MyServlet 的doGet()方法被執行了一次。
Init()方法呢？ 答案是 MyServlet 在客戶端請求之前就已經被Tomcat載入，還記得這段程式碼嗎？
目前只能知道是這麼種情況，但是為什麼輸入不同的URL就能訪問到不同的Servlet,伺服器端如何判斷來自客戶端的請求要做什麼，要交給那個JAVA程式去處理呢？並且 ServletDemo 即第一個頁面是訪問了1次，但是MyServlet的頁面為10001次，這些都是從哪裡得到的？
繼續…..
開啟 web.xml 配置檔案 選兩段內容
因為我們部署在Tomcat上的JSP環境是 myapp 所以我們在訪問伺服器時，myapp是要寫上的，就相當於一個根目錄。
[url]http://localhost:8080/myapp/t238servlet[/url] 這是一個請求的網址。
當客戶端提交這個請求時，伺服器會對這個網址進行分析，首先會通過 myapp 定位到相應的根目錄，再通過 /t238servlet 確定要訪問的資源。
在配置檔案中
伺服器端就已經明確的告訴了程式 需要用一個名叫 servletDemo 的程式去處理這個請求。
於是….. servlet-name 就可以定位到真正的可以處理客戶端請求的類 ServletDemo.class
ServletDemo.class 在哪裡？ 就位於我們部署好的路徑中 \webapps\myapp\WEB-INF\classes
注意，真正的處理程式是 ServletDemo.class
不同的請求，伺服器通過 url-pattern 的設定，就能將請求交給相應的伺服器端Servlet程式去處理，因此看到的效果就不一樣，Tomcat控制檯中顯示的效果也就不一樣。
第二個問題？ 第一個頁面顯示的是訪問1次，而後一個頁面是10001次。原因在於 web.xml 配置檔案中
即MyServlet配置資訊中有一個引數為 initial ,值為 10000
MyServlet中的初始化方法
頁面輸出部分：
out.println("自從載入後（讀取引數化後）");
out.println("MyServlet 中的 已經被訪問過了");
out.println(count+" 次");
相信看完這些就能基本上明白這種差異了，並且發現由於
沒有這種初始化引數，自然就無法獲得這種效果了。
但是隨即在 以上程式碼中填入
Ctrl+S 儲存 web.xml 再次重新整理 [url]http://localhost:8080/myapp/t238servlet[/url]馬上就能看到
[u]圖片5見附件[/u]
從100次開始了！！！
由於 web.xml 就是Tomcat管理Servlet的環境，Tomcat不需要關閉，只要 web.xml做出改動，它的能夠識別到這種改動。
所以在上面就能夠清楚的看到 ：
ServletDemo例項資源已經釋放，MyServlet 也是如此，即都呼叫了它們的
[url] //清除資源
public void destroy() {
System.out.println("MyServlet 例項資源已經被釋放！");
}[/url]
方法。
並且重新初始化並載入 優先級別為0的 MyServlet，同時因為重新重新整理了http://localhost:8080/myapp/t238servlet 由 ServletDemo處理這個請求，自然ServletDemo先例項化，並被載入，同時因為重新制定了初始化引數，所以效果自然也變成 101次訪問！
[color=green][b]
三．再述Servlet生命週期及關鍵方法的呼叫，以及引數和內容部分的詳解。[/b][/color]Servlet的生命週期由Servlet容器控制，可以通過兩種方式建立Servlet的例項：一是通過 web.xml配置檔案首先載入某個Servlet，或者當客戶端請求時動態載入某一個Servlet.這兩種方式在前面已經提到並由具體事例證明。
首先來看Servlet ,Servlet是一個介面。位於 package javax.servlet; 包。
[color=green]第一．在這個介面中有幾個重要的抽象方法：[/color]
public void init(ServletConfig config) throws ServletException;
--- The servlet container calls the <code>init</code> method exactly once after instantiating the servlet.
---Servlet容器一旦建立Servlet例項，就會呼叫 init()方法完成此Servlet的初始化，有點類似於普通JAVA類的構造方法一樣，建立例項時就完成對這個例項的初始化，也有可以什麼都不做。
但是裡面有一個引數 ServletConfig config ，ServletConfig 其實也是一個介面，其意思是實現了ServletConfig 介面的物件作為引數進行傳遞。
ServletConfig 介面中有幾個方法：
public String getServletName(); the name of the servlet instance 返回Servlet例項的名稱
public ServletContext getServletContext(); 返回與容器互動的上下文資訊
public String getInitParameter(String name); 得到初始化引數的資訊
public Enumeration getInitParameterNames(); //列舉值 引數的資訊
簡單一點，config物件就可以理解成為我們在Tomcat容器環境下的配置檔案物件。就像我們從 web.xml中設定好初始化引數，隨後又能在 init()方法中取得一樣。
[color=green]第二．看一個很重要的方法 service( )方法[/color]
public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException;
它的任務就是在Servlet例項化之後，就可以處理客戶端發出的請求，最終向客戶端回發響應。
@param req the <code>ServletRequest</code> object that contains
the client's request
@param res the <code>ServletResponse</code> object that contains
the servlet's response
兩個引數：一個是包含有來自於客戶端請求資訊封裝後的 req —— 一個實現了ServletRequest介面的物件
一個是包含有Servlet處理客戶端請求後封裝的 res —— 一個實現了 ServletResponse 介面的響應物件
[color=green]第三． public void destroy(); 如果沒有需要處理的請求，就會釋放Servlet例項。[/color]
整個流程是：
1. 例項化Servlet . 不管是來自於客戶端請求，還是由 web.xml配置，總之Servlet容器首先要例項化Servlet,並載入到記憶體中。
2. 在例項化後，馬上呼叫Servlet的init（）方法，完成對例項的初始化。這兩個步驟和JAVA類先用 new 關鍵字建立例項，在堆區分配記憶體，並通過構造方法的完成對此例項物件初始化，修改堆區的屬性值的道理是一樣的。
3. 服務：由容器根據使用者的請求分配相應的Servlet例項去處理請求，回發響應，這個過程是由 service()方法來完成的。
4. 釋放資源 destory( );
要例項化一個Servlet，容器必須找到Servlet類，載入Servlet類並建立Servlet物件。
然後通過Servlet的 init()方法來初始化Servlet.ServletConfig 介面物件作為引數傳遞給 init()方法，該介面物件為Servlet提供對ServletContext 介面的訪問，Servlet 容器使用ServletContext介面與Servlet容器進行通訊。
如果初始化Servlet失敗，則丟擲UnavailableException或 ServletException異常，並再次嘗試對Servlet進行例項化和初始化。然後將ServletRequest和 ServletResponse介面物件作為引數傳遞給service()方法，該方法將處理請求並返回響應。
如果響應請求時引發異常，則容器通過呼叫Servlet的 destory()方法來解除安裝例項，呼叫destory()方法後，就會從記憶體中釋放Servlet例項。destory()方法給了Servlet機會來清除所持有的資源，比如記憶體，檔案處理和執行緒，以確保在記憶體中所有的持續狀態和Servlet的當前狀態是同步的。
寫到這裡，再回頭看我們的例項
此時的我們自定義的Servlet 類，並沒有實現Servlet而是實現的 HttpServlet ,且方法中也找不到service()方法，取而代之的是 doPost 和 doGet( )方法，引數型別和 service( )方法定義到有些類似，只不過一個是ServletRequest,一個是 HttpServletRequest.
這個地方就需要從類的繼承關係上來說明了。
HttpServlet 是一個抽象類繼承GenericServlet public abstract class HttpServlet extends GenericServlet
GenericServlet 也是一個抽象類，但是它實現了 abstract class GenericServlet
implements Servlet, ServletConfig 等介面 ，注意 Servlet也包括在其中。
那麼，必須GenericServlet抽象類就會實現Servlet介面中的方法，如 init( ) , destory() 等方法，包括service()方法，不過這個方法並沒有被實現。 如然後以抽象的形式存在，很明顯service方法需要靠實現了GenericServlet的類去完成。
public abstract void service(ServletRequest req, ServletResponse res)
throws ServletException, IOException;
public abstract class HttpServlet extends GenericServlet
在HttpServlet抽象類還是完成了一些具體的內容 ,比如實現GenericServlet的 service( ) 方法
不過在這個方法中，它同時完成了兩個物件的強制轉換，並將兩個物件作為引數傳給自己真正實現的service()方法。
在HttpServlet中有兩個 service 方法，上面的是第一個，實現了GenericServlet抽象類的抽象方法，第二個就是紅色文字標識的，此 service()方法的過載版本。
protected void service(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException
其名稱一樣，但引數型別不一致，完成過載的 service()方法，才是HttpServlet類的關鍵流程控制與處理的核心方法。不過，在這個service()方法中，它只做了一件事情，根據HTTP請求頭中的請求行的請求方法法來完成方法的轉移，例如是 get方法還是post方法。
如果是 get方法，就交給 HttpServlet類中的 doGet()去處理，引數照傳，如果是post方法就交給 doPost去處理。這樣一來，從最開始的只要是請求就處理到現在的請求來了，還要看看請求是什麼方法它再做出反應，於是就有各種各樣的處理方法，而所有方法的引數倒還是一致的 。
HttpServletRequest req, HttpServletResponse resp 。
當然方法可不止 get,post 還有 post,contact 等其它6種方法。
因此，看到HttpServlet中的過載的 service()方法就是這樣的：
所以到這裡應該不難理解，雖然我們提到的是Servlet生命週期中有一個重要的service方法，但是在我們自己實現的Servlet類中並沒有看見，其原因就是我們實現的是HttpServlet類，這個類中的service方法首先已經可以通過類的繼承關係一樣得到了來自於客戶端請求的請求物件，其次通過對請求方法的判斷將service方法的控制流程交給的相對於單一的方法處理，例如doGet(),doPost()。 如果我們實現了HttpServlet類，還需要繼續重寫service方法的話，那也就意味著我們仍然需要去搞定這些請求方法的判斷工作。所以，最簡單最直接的就是直接重寫 HttpServlet中的 doGet()或者doPost()方法，所有的問題就迎刃而解了。
HttpServlet 作為一個抽象類用來建立使用者自己的HTTP Servlet.HttpServlet類擴充套件了GenericServlet 類。HttpServlet類的子類必須至少重寫以下方法中的一個：doGet( ) / doPost( ) .
doGet( ): 由伺服器呼叫來處理客戶端發出的GET請求，通過GenericServlet類的service( ) 方法來呼叫此方法。重寫GET方法還支援HTTP HEAD請求，該請求返回沒有主體只有標題欄位的響應。提交響應之前，Servlet容器要編寫標題，這是因為在HTTP中必須在傳送響應主體之前傳送標題。
GET方法必須是安全的，如果客戶端請求更改儲存的資料，則必須使用其它的HTTP方法。
doPost() 處理post請求，其流程和上述差不多。
另外，應該要看看，請求頭和響應頭，即HTTP請求和響應的原理，本人會另起文章做出解釋。
轉載請註明出處 [url]http://lvp.iteye.com[/url]
Servlet 只是一個名詞，具體的解釋就是使用JAVA編寫的一個應用程式，在伺服器上執行，處理請求的資訊，並且將處理後的結果回發的客戶端。
對於所有的來自於客戶端的請求，這段程式即Servlet只需要建立一次例項，因此它節省了大量的記憶體。Servlet在初始化後即停駐在記憶體中，因此每次做出請求時無需重新載入。
具體來看看Tomcat容器即Servlet容器到底是如何管理Servlet的，它的生命週期到底是如何執行的，其中是如何與Tomcat容器實現互動，主要大家認真理解下面的分析，基本上理解Servlet生命週期也是沒有問題的。
[color=green][b]一．Tomcat 是如何載入Servlet的（Servlet的初始化）[/b][/color]
還是以Simon 本人配置的環境舉例
找到 [url]C:\Program Files\Apache Software Foundation\Tomcat 6.0\webapps\myapp\WEB-INF[/url]下的 web.xml
這個配置檔案實際上起到的最直接的作用就是管理Servlet. 在其中先加上兩個 <servlet>和<serlvet-mapping>
web.xml – 繼續第一次測試Servlet 的配置時的內容，複製替換即可，加的部分用紅色標識
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>
<display-name>My web application</display-name>
<description>
A application for test!
</description>
<servlet>
<servlet-class>ServletDemo</servlet-class>
<servlet-name>servletDemo</servlet-name>
</servlet>
<servlet>
<load-on-startup>0</load-on-startup>
<init-param>
<param-name>initial</param-name>
<param-value>10000</param-value>
</init-param>
<servlet-name>servletTest</servlet-name>
<servlet-class>MyServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>servletTest</servlet-name>
<url-pattern>/servletpage</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>servletDemo</servlet-name>
<url-pattern>/t238servlet</url-pattern>
</servlet-mapping>
</web-app>
新添的一個Servlet ServletDemo.java 也應該先編譯好，然後放到
[url]C:\Program Files\Apache Software Foundation\Tomcat 6.0\webapps\myapp\WEB-INF\classes[/url]目錄下，此時這個目錄應該有 [color=olive]ServletDemo.class [/color]和 [color=olive]MyServlet.class [/color]兩個類檔案。
[url]ServletDemo.java[/url]
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import java.util.*;
/**
*@author : Simon lv
演示Servlet的生命週期
繼承HttpServlet
ServletDemo
*/
public class ServletDemo
extends HttpServlet {
//定義好將回發客戶端頁面的MIME型別，HTML格式的網頁
private static final String CONTENT_TYPE = "text/html; charset=GBK";
//計數器
int count;
/**
* init 初始化方法第一次載入只會初始化一次一旦呼叫即說明了已經建立了ServeltDemo的例項，此後這個例項
* /將一直停留在Tomcat分配的一塊記憶體中，下次有客戶端的請求，就不用重複的例項化
* ServletConfig config 引數用來傳遞Servlet 在web.xml中的配置資訊自動封裝資訊
*/
public void init(ServletConfig config) throws ServletException {
super.init(config);
//得到配置資訊中initial引數的值
String initial = config.getInitParameter("initial");
try{
//轉化為數字即計數器
count = Integer.parseInt(initial);
}catch(NumberFormatException e){
count =0;
}
//輸出初始化資訊
System.out.println("ServletDemo中的記數器Servlet 已經初始化成功！");
}
/**
* doGet 處理
*/
public void doGet(HttpServletRequest request, HttpServletResponse response) throws
ServletException, IOException {
response.setContentType(CONTENT_TYPE);
PrintWriter out = response.getWriter();
out.println("<html>");
out.println("<head><title>LifeServletDemo</title></head>");
out.println("<body bgcolor=\"#ffffff\">");
count++;
out.println("自從載入後（讀取引數化後）");
out.println("ServletDemo 已經被訪問過了");
out.println(count+" 次");
out.println("</body>");
out.println("</html>");
out.close();
System.out.println("ServletDemo中的的doGet 方法被執行一次");
}
//doPost()方法
public void doPost(HttpServletRequest request, HttpServletResponse response) throws
ServletException, IOException {
doGet(request, response);
}
//清除資源
public void destroy() {
System.out.println("ServletDemo 例項資源已經釋放！");
}
}
[color=green][b]
二．啟動Tomcat服務[/b][/color]
[url]C:\Program Files\Apache Software Foundation\Tomcat 6.0\bin tomcat6.exe[/url]
注意紅色圈起來的部分
[u]圖片1見附件[/u]
這句話的輸出即證明了 在MyServlet中的 init方法被呼叫了一次！
MyServlet.java中的相關程式碼：
//初始化方法第一次載入只會初始化一次
public void init(ServletConfig config) throws ServletException {
super.init(config);
String initial = config.getInitParameter("initial");
try{
count = Integer.parseInt(initial);
}catch(NumberFormatException e){
count =0;
}
System.out.println("MyServlet 中的記數器Servlet 已經初始化成功！");
}
但是我在MyServlet.java 和上面新加的ServletDemo.java中都存在 init()方法，但是為什麼僅僅MyServlet.java中的方法被呼叫了呢？原因就在於在 web.xml中，指定了Tomcat一啟動就初始化的例項
<servlet>
<load-on-startup>0</load-on-startup>
<init-param>
<param-name>initial</param-name>
<param-value>10000</param-value>
</init-param>
<servlet-name>servletTest</servlet-name>
<servlet-class>MyServlet</servlet-class>
</servlet>
這樣就通知了Tomcat在它的服務一啟動的時候，就要去載入所對應的Servlet-class MyServlet這個類，0代表級別，隨後是1.2.3.4---- 0最高。Tomcat首先把這些類載入並例項化，儲存在自己的Servlet容器池中，如果以後有請求，就直接從容器池中取出來，處理相應的請求。
要注意的是：此時並沒有來自於客戶端的請求，是先於客戶請求直接就已經載入完畢了的。
下面我們去請求 ServletDemo ,它沒有像MyServlet 那樣在客戶端請求前就被Tomcat例項化了的，它需要由請求完成例項化。
在IE瀏覽器中輸入 ：[url]http://localhost:8080/myapp/t238servlet[/url]
在頁面上看到
[u]圖片2見附件[/u]
在Tomcat 控制檯上看到: 注意紅線部分！
[u]圖片2見附件[/u]
說明了什麼？
說明了，Tomcat載入Servlet例項至少有兩種方法，一種是通過在 web.xml配置檔案中設定載入級別，另一種是通過客戶端訪問到某個具體的Servlet時，也一定會完成初始化，載入這個例項！一旦例項被載入，後面的請求，將不會再重新例項化Servlet。
再重新整理頁面：[url]http://localhost:8080/myapp/t238servlet[/url]
對應的網頁 和Tomcat
[u]圖片3見附件[/u]
ServletDemo中的doGet方法被執行一次 多輸出了一句，但是 初始化的資訊沒有再輸出，說明了 init()方法只執行了一次，也即說明了Servlet例項只被Tomcat 載入了一次！
換個頁面請求一次 [url]http://localhost:8080/myapp/servletpage[/url]相應頁面和Tomcat控制檯為：
[u]圖片4見附件[/u]
MyServlet 的doGet()方法被執行了一次。
Init()方法呢？ 答案是 MyServlet 在客戶端請求之前就已經被Tomcat載入，還記得這段程式碼嗎？
<servlet>
<load-on-startup>0</load-on-startup>
<init-param>
<param-name>initial</param-name>
<param-value>10000</param-value>
</init-param>
<servlet-name>servletTest</servlet-name>
<servlet-class>MyServlet</servlet-class>
</servlet>目前只能知道是這麼種情況，但是為什麼輸入不同的URL就能訪問到不同的Servlet,伺服器端如何判斷來自客戶端的請求要做什麼，要交給那個JAVA程式去處理呢？並且 ServletDemo 即第一個頁面是訪問了1次，但是MyServlet的頁面為10001次，這些都是從哪裡得到的？
繼續…..
開啟 web.xml 配置檔案 選兩段內容
<servlet-mapping>
<servlet-name>servletDemo</servlet-name>
<url-pattern>/t238servlet</url-pattern>
</servlet-mapping>因為我們部署在Tomcat上的JSP環境是 myapp 所以我們在訪問伺服器時，myapp是要寫上的，就相當於一個根目錄。
[url]http://localhost:8080/myapp/t238servlet[/url] 這是一個請求的網址。
當客戶端提交這個請求時，伺服器會對這個網址進行分析，首先會通過 myapp 定位到相應的根目錄，再通過 /t238servlet 確定要訪問的資源。
在配置檔案中
<servlet-name>servletDemo</servlet-name>
<url-pattern>/t238servlet</url-pattern> 伺服器端就已經明確的告訴了程式 需要用一個名叫 servletDemo 的程式去處理這個請求。
於是….. servlet-name 就可以定位到真正的可以處理客戶端請求的類 ServletDemo.class
<servlet>
<servlet-class>ServletDemo</servlet-class>
<servlet-name>servletDemo</servlet-name>
</servlet>
ServletDemo.class 在哪裡？ 就位於我們部署好的路徑中 \webapps\myapp\WEB-INF\classes
注意，真正的處理程式是 ServletDemo.class
不同的請求，伺服器通過 url-pattern 的設定，就能將請求交給相應的伺服器端Servlet程式去處理，因此看到的效果就不一樣，Tomcat控制檯中顯示的效果也就不一樣。
第二個問題？ 第一個頁面顯示的是訪問1次，而後一個頁面是10001次。原因在於 web.xml 配置檔案中
<servlet>
<load-on-startup>0</load-on-startup>
<init-param>
<param-name>initial</param-name>
<param-value>10000</param-value>
</init-param>
<servlet-name>servletTest</servlet-name>
<servlet-class>MyServlet</servlet-class>
</servlet>即MyServlet配置資訊中有一個引數為 initial ,值為 10000
MyServlet中的初始化方法
//初始化方法第一次載入只會初始化一次
public void init(ServletConfig config) throws ServletException {
super.init(config);
String initial = config.getInitParameter("initial");
try{
count = Integer.parseInt(initial);
}catch(NumberFormatException e){
count =0;
}
System.out.println("MyServlet 中的記數器Servlet 已經初始化成功！");
}頁面輸出部分：
out.println("自從載入後（讀取引數化後）");
out.println("MyServlet 中的 已經被訪問過了");
out.println(count+" 次");
相信看完這些就能基本上明白這種差異了，並且發現由於
<servlet>
<servlet-class>ServletDemo</servlet-class>
<servlet-name>servletDemo</servlet-name>
</servlet>沒有這種初始化引數，自然就無法獲得這種效果了。
但是隨即在 以上程式碼中填入
<init-param>
<param-name>initial</param-name>
<param-value>100</param-value>
</init-param>Ctrl+S 儲存 web.xml 再次重新整理 [url]http://localhost:8080/myapp/t238servlet[/url]馬上就能看到
[u]圖片5見附件[/u]
從100次開始了！！！
由於 web.xml 就是Tomcat管理Servlet的環境，Tomcat不需要關閉，只要 web.xml做出改動，它的能夠識別到這種改動。
所以在上面就能夠清楚的看到 ：
ServletDemo例項資源已經釋放，MyServlet 也是如此，即都呼叫了它們的
[url] //清除資源
public void destroy() {
System.out.println("MyServlet 例項資源已經被釋放！");
}[/url]
方法。
並且重新初始化並載入 優先級別為0的 MyServlet，同時因為重新重新整理了http://localhost:8080/myapp/t238servlet 由 ServletDemo處理這個請求，自然ServletDemo先例項化，並被載入，同時因為重新制定了初始化引數，所以效果自然也變成 101次訪問！
[color=green][b]
三．再述Servlet生命週期及關鍵方法的呼叫，以及引數和內容部分的詳解。[/b][/color]Servlet的生命週期由Servlet容器控制，可以通過兩種方式建立Servlet的例項：一是通過 web.xml配置檔案首先載入某個Servlet，或者當客戶端請求時動態載入某一個Servlet.這兩種方式在前面已經提到並由具體事例證明。
首先來看Servlet ,Servlet是一個介面。位於 package javax.servlet; 包。
[color=green]第一．在這個介面中有幾個重要的抽象方法：[/color]
public void init(ServletConfig config) throws ServletException;
--- The servlet container calls the <code>init</code> method exactly once after instantiating the servlet.
---Servlet容器一旦建立Servlet例項，就會呼叫 init()方法完成此Servlet的初始化，有點類似於普通JAVA類的構造方法一樣，建立例項時就完成對這個例項的初始化，也有可以什麼都不做。
但是裡面有一個引數 ServletConfig config ，ServletConfig 其實也是一個介面，其意思是實現了ServletConfig 介面的物件作為引數進行傳遞。
ServletConfig 介面中有幾個方法：
public String getServletName(); the name of the servlet instance 返回Servlet例項的名稱
public ServletContext getServletContext(); 返回與容器互動的上下文資訊
public String getInitParameter(String name); 得到初始化引數的資訊
public Enumeration getInitParameterNames(); //列舉值 引數的資訊
簡單一點，config物件就可以理解成為我們在Tomcat容器環境下的配置檔案物件。就像我們從 web.xml中設定好初始化引數，隨後又能在 init()方法中取得一樣。
public void init(ServletConfig config) throws ServletException {
super.init(config);
String initial = config.getInitParameter("initial");
try{
count = Integer.parseInt(initial);
}catch(NumberFormatException e){
count =0;
}
System.out.println("MyServlet 中的記數器Servlet 已經初始化成功！");
}
[color=green]第二．看一個很重要的方法 service( )方法[/color]
public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException;
它的任務就是在Servlet例項化之後，就可以處理客戶端發出的請求，最終向客戶端回發響應。
@param req the <code>ServletRequest</code> object that contains
the client's request
@param res the <code>ServletResponse</code> object that contains
the servlet's response
兩個引數：一個是包含有來自於客戶端請求資訊封裝後的 req —— 一個實現了ServletRequest介面的物件
一個是包含有Servlet處理客戶端請求後封裝的 res —— 一個實現了 ServletResponse 介面的響應物件
[color=green]第三． public void destroy(); 如果沒有需要處理的請求，就會釋放Servlet例項。[/color]
整個流程是：
1. 例項化Servlet . 不管是來自於客戶端請求，還是由 web.xml配置，總之Servlet容器首先要例項化Servlet,並載入到記憶體中。
2. 在例項化後，馬上呼叫Servlet的init（）方法，完成對例項的初始化。這兩個步驟和JAVA類先用 new 關鍵字建立例項，在堆區分配記憶體，並通過構造方法的完成對此例項物件初始化，修改堆區的屬性值的道理是一樣的。
3. 服務：由容器根據使用者的請求分配相應的Servlet例項去處理請求，回發響應，這個過程是由 service()方法來完成的。
4. 釋放資源 destory( );
要例項化一個Servlet，容器必須找到Servlet類，載入Servlet類並建立Servlet物件。
然後通過Servlet的 init()方法來初始化Servlet.ServletConfig 介面物件作為引數傳遞給 init()方法，該介面物件為Servlet提供對ServletContext 介面的訪問，Servlet 容器使用ServletContext介面與Servlet容器進行通訊。
如果初始化Servlet失敗，則丟擲UnavailableException或 ServletException異常，並再次嘗試對Servlet進行例項化和初始化。然後將ServletRequest和 ServletResponse介面物件作為引數傳遞給service()方法，該方法將處理請求並返回響應。
如果響應請求時引發異常，則容器通過呼叫Servlet的 destory()方法來解除安裝例項，呼叫destory()方法後，就會從記憶體中釋放Servlet例項。destory()方法給了Servlet機會來清除所持有的資源，比如記憶體，檔案處理和執行緒，以確保在記憶體中所有的持續狀態和Servlet的當前狀態是同步的。
寫到這裡，再回頭看我們的例項
public class ServletDemo
extends HttpServlet { ……
public void doPost(HttpServletRequest request, HttpServletResponse response) throws
ServletException, IOException {
doGet(request, response);
}此時的我們自定義的Servlet 類，並沒有實現Servlet而是實現的 HttpServlet ,且方法中也找不到service()方法，取而代之的是 doPost 和 doGet( )方法，引數型別和 service( )方法定義到有些類似，只不過一個是ServletRequest,一個是 HttpServletRequest.
這個地方就需要從類的繼承關係上來說明了。
HttpServlet 是一個抽象類繼承GenericServlet public abstract class HttpServlet extends GenericServlet
GenericServlet 也是一個抽象類，但是它實現了 abstract class GenericServlet
implements Servlet, ServletConfig 等介面 ，注意 Servlet也包括在其中。
那麼，必須GenericServlet抽象類就會實現Servlet介面中的方法，如 init( ) , destory() 等方法，包括service()方法，不過這個方法並沒有被實現。 如然後以抽象的形式存在，很明顯service方法需要靠實現了GenericServlet的類去完成。
public abstract void service(ServletRequest req, ServletResponse res)
throws ServletException, IOException;
public abstract class HttpServlet extends GenericServlet
在HttpServlet抽象類還是完成了一些具體的內容 ,比如實現GenericServlet的 service( ) 方法
public void service(ServletRequest req, ServletResponse res)
throws ServletException, IOException{
}不過在這個方法中，它同時完成了兩個物件的強制轉換，並將兩個物件作為引數傳給自己真正實現的service()方法。
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);
}在HttpServlet中有兩個 service 方法，上面的是第一個，實現了GenericServlet抽象類的抽象方法，第二個就是紅色文字標識的，此 service()方法的過載版本。
protected void service(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException
其名稱一樣，但引數型別不一致，完成過載的 service()方法，才是HttpServlet類的關鍵流程控制與處理的核心方法。不過，在這個service()方法中，它只做了一件事情，根據HTTP請求頭中的請求行的請求方法法來完成方法的轉移，例如是 get方法還是post方法。
如果是 get方法，就交給 HttpServlet類中的 doGet()去處理，引數照傳，如果是post方法就交給 doPost去處理。這樣一來，從最開始的只要是請求就處理到現在的請求來了，還要看看請求是什麼方法它再做出反應，於是就有各種各樣的處理方法，而所有方法的引數倒還是一致的 。
HttpServletRequest req, HttpServletResponse resp 。
當然方法可不止 get,post 還有 post,contact 等其它6種方法。
因此，看到HttpServlet中的過載的 service()方法就是這樣的：
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 / 1000 * 1000)) {
// 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);
}
}所以到這裡應該不難理解，雖然我們提到的是Servlet生命週期中有一個重要的service方法，但是在我們自己實現的Servlet類中並沒有看見，其原因就是我們實現的是HttpServlet類，這個類中的service方法首先已經可以通過類的繼承關係一樣得到了來自於客戶端請求的請求物件，其次通過對請求方法的判斷將service方法的控制流程交給的相對於單一的方法處理，例如doGet(),doPost()。 如果我們實現了HttpServlet類，還需要繼續重寫service方法的話，那也就意味著我們仍然需要去搞定這些請求方法的判斷工作。所以，最簡單最直接的就是直接重寫 HttpServlet中的 doGet()或者doPost()方法，所有的問題就迎刃而解了。
HttpServlet 作為一個抽象類用來建立使用者自己的HTTP Servlet.HttpServlet類擴充套件了GenericServlet 類。HttpServlet類的子類必須至少重寫以下方法中的一個：doGet( ) / doPost( ) .
doGet( ): 由伺服器呼叫來處理客戶端發出的GET請求，通過GenericServlet類的service( ) 方法來呼叫此方法。重寫GET方法還支援HTTP HEAD請求，該請求返回沒有主體只有標題欄位的響應。提交響應之前，Servlet容器要編寫標題，這是因為在HTTP中必須在傳送響應主體之前傳送標題。
GET方法必須是安全的，如果客戶端請求更改儲存的資料，則必須使用其它的HTTP方法。
doPost() 處理post請求，其流程和上述差不多。
另外，應該要看看，請求頭和響應頭，即HTTP請求和響應的原理，本人會另起文章做出解釋。
轉載請註明出處 [url]http://lvp.iteye.com[/url]
相關推薦
Servlet 介紹 以及Servlet生命週期（詳細）
在上一篇文件裡提到了CGI和Servelt 的對比，並介紹了在JAVA編寫的應用程式Servlet在伺服器上執行主要就是解決了CGI程序處理佔資源效率高的問題。Servlet 只是一個名詞，具體的解釋就是使用JAVA編寫的一個應用程式，在伺服器上執行，處理請求的資訊，並且將處
Servlet的生命週期 （一）
package com.xxxx.java; import java.io.IOException; import javax.servlet.Servlet; import javax.servlet.ServletConfig; import javax.servlet.ServletExc
Servlet 和Filter的生命週期（springboot測試servlet和filter）
servlet生命週期： 通過建構函式例項化Servlet物件； 當第一次瀏覽器向伺服器傳送請求，訪問servlet； 呼叫init方法進行初始化 (servlet物件一般只有一個，會常駐記憶體) init方法只會呼叫一次； 開啟一個執行緒，去呼叫s
vue 元件與通訊與vuex與computed與生命週期（2）
二：vuex 先看官方文件 Vuex 官方文件：https://vuex.vuejs.org/zh-cn/ vuex 是一個專為vue應用程式開發的狀態管理模式。它採用集中式儲存管理應用的所有元件的狀態，並以相應的規則保證狀態以一種可預測的方式發生變化。 vuex 不同於lo
vue 元件與通訊與vuex與computed與生命週期（1）
一：元件 1：先看官方文件 什麼是元件 元件 (Component) 是 Vue.js 最強大的功能之一。元件可以擴充套件 HTML 元素，封裝可重用的程式碼。在較高層面上，元件是自定義元素，Vue.js 的編譯器為它新增特殊功能。在有些情況下，元件也可以表現為用 is 特性進行
VirtualBox設定主機與虛擬機器資料夾共享以及“安裝增強功能”（詳細）
要設定資料夾共享之前，需要確保已安裝VirtualBox的“安裝增強功能” 。 步驟1： 步驟2： 如果沒有報錯請跳過步驟2！！！如果報錯如下，請按本步驟做： 把ubuntu的光碟機彈出 然後再重複步驟1，重複完後，進入步驟3 步驟3： 輸入當前管理員的密
React 生命週期（摘抄）
/* 首先當元件第一次渲染的時候會執行哪些生命週期函式？ constructor--->componentWillMount--->render--->componentDidMount constructor: 初始化
【軟體安全設計】安全開發生命週期（SDL）
安全開發生命週期（SDL）是一個幫助開發人員構建更安全的軟體和解決安全合規要求的同時降低開發成本的軟體開發過程。 安全應用從安全設計開始，軟體的安全問題很大一部分是由於不安全的設計而引入的，微軟用多年的經驗總結出了安全開發生命週期（SDL），並提出了攻擊面最小化、STRIDE
vue元件的生命週期（轉）
vue元件的生命週期 Vue所有的生命週期鉤子自動繫結在this上下文到例項中，因此你可以訪問資料，對屬性和方法進行運算。這意味著你不能使用箭頭函式來定義一個生命週期方法。這是因為箭頭函式綁定了父上下文，因此this與你期待的Vue例項不同。 1、beforeCreate 在例項初始
Java程式設計師從笨鳥到菜鳥之（九十三）深入java虛擬機器（二）——類的生命週期（上）類的載入和連線
類載入器，顧名思義，類載入器（class loader）用來載入 Java 類到 Java 虛擬機器中。一般來說，Java 虛擬機器使用 Java 類的方式如下：Java 源程式（.java 檔案）在經過 Java 編譯器編譯之後就被轉換成 Java 位元組程式碼（.class 檔案）。類載
深入理解Activity的生命週期（必備）
目錄 前言 基本認知 總結： 總結： 完結： 前言 Activity 作為四大元件之一，是使用最為頻繁的一種元件 Activity在異常情況下的生命週期十分微妙 讓你面試的時候不只是會說onCrea
關於Vue例項的生命週期（2）
關於Vue例項的生命週期（2） 建立(create)->掛載(mount)->更新(update)->銷燬(destory) 鉤子函式觸發事件 beforeCreate 在例項初始化之後，資料觀測(data observer)
vue生命週期（記錄）
vue生命週期（建立、掛載、更新、銷燬 ） let app = new Vue({ el:"#app", data:{ name:"靈demo" }, //此階段為例項初始化之後，此時的資料觀察和事件配置都沒好準備好。 //所以資料data和掛載元素el
react 學習--元件的生命週期（三）銷燬階段
var HelloWorld = React.createClass({ render:function () { return ( <p>
Vue與React的異同—生命週期（一）
React與Vue都有lifecycle生命週期的概念，表示每個元件例項在被建立之前都要經過一系列的初始化過程。比如設定資料監聽、編譯模板、掛載例項到檢視、在資料變化時更新檢視等。 Vue生命週期 所有的生命週期鉤子自動繫結 this 上下文到
【Visual Studio 2015】安全開發生命週期（SDL）檢查
有的時候寫的程式碼明明沒有什麼問題就是編譯不過，我就覺得奇怪了。我是編譯通過的程式碼，怎麼就有問題呢？在VS2015執行，還真是有問題。看錯誤提示，是VS將這個函式的使用當做錯誤對待了！ 在以前的VS版本中，檢測並不嚴格，對於很多警告，我們程式設計師通常都是忽
從程式碼上看程式生死週期(生死迴圈，生命週期)（轉）
C語言程式的C執行時庫，C++語言程式的C++執行時庫（如上圖所示）等，這些執行時庫需要提前安裝在系統中，系統才會在分析到一個對應的程式時去啟動這個執行時庫，否則就無法執行這個程式。比如說你的系統沒有安裝C++執行時庫，而你的程式又沒有自己帶上這個庫，那麼系
ASP.NET頁面生命週期 （轉載）
# 事件或方法 功能 描述 1 Init 事件 頁面初始化 頁面生存週期中的第一個階段是初始化。當 Init 事件發生時，在 .aspx 原始檔中靜態宣告的所有控制元件都已例項化並取其預設值。應該注意的是，這時檢視狀態資訊還不可用。 2 LoadVie
IOC容器Bean的例項化方式以及其生命週期（上）
1. 三種例項化Bean的方式 a.使用類構造器例項化(預設無引數) <bean id=“personService" class="com.baidu..PersonServiceImpl"/> b.使用靜態工廠方法例項化(簡單工廠模式) <
Service的生命週期（一）
參考Android官方開發文件API22 簡介 Service是Android的四大元件之一，它是用來進行後臺操作的，它並不為使用者提供介面，所有的操作都在後臺完成，它的所有操作對使用者都是不可見的。一旦其他的元件啟動了一個Service，它會在