Servlet源码分析【转】

 

Servlet API的核心就是javax.servlet.Servlet接口，所有的Servlet 类（抽象的或者自己写的）都必须实现这个接口。在Servlet接口中定义了5个方法，其中有3个方法是由Servlet 容器在Servlet的生命周期的不同阶段来调用的特定方法。

 

先看javax.servlet.servlet接口源码：

 

 

Java代码 复制代码
  1. package javax.servlet;   //Tomcat源码版本：6.0.20   
  2. import java.io.IOException;   
  3.   
  4. public interface Servlet {      
  5.   
  6.   
  7. //负责初始化Servlet对象。容器一旦创建好Servlet对象后，就调用此方法来初始化Servlet对象     
  8.    public void init(ServletConfig config) throws ServletException;       
  9.   
  10.     
  11.   
  12.  //方法负责响应客户的请求,提供服务。当容器接收到客户端要求访问特定的servlet请求时，就会调用Servlet的service方法     
  13.     public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException;       
  14.      
  15.        
  16.   /*  
  17.     Destroy()方法负责释放Servlet 对象占用的资源，当servlet对象结束生命周期时，servlet容器调用此方法来销毁servlet对象.  
  18.   **/  
  19.     public void destroy();   
  20.        
  21.        
  22.     /*  
  23.     说明：Init(),service(),destroy() 这三个方法是Servlet生命周期中的最重要的三个方法。  
  24.     **/      
  25.        
  26.        
  27.     /*  
  28.     返回一个字符串，在该字符串中包含servlet的创建者，版本和版权等信息  
  29.     **/  
  30.     public String getServletInfo();     
  31.        
  32.     /*  
  33.    GetServletConfig: 返回一个ServletConfig对象，该对象中包含了Servlet初始化参数信息   
  34.    **/       
  35.     public ServletConfig getServletConfig();     
  36. }  

 

 

  GenericServlet抽象类实现了Servlet接口，它只是通用的实现，与任何网络应用层协议无关。
同时，HttpServlet这个抽象类继承了GenericServlet抽象类，在Http协议上提供了通用的实现。

 

 

查看GenericSerlvet抽象类源码：

 

Java代码 复制代码
  1. package javax.servlet;   
  2.   
  3. import java.io.IOException;   
  4. import java.util.Enumeration;   
  5.   
  6. //抽象类GenericServlet实现了Servlet接口的同时，也实现了ServletConfig接口和Serializable这两个接口    
  7. public abstract class GenericServlet    
  8.     implements Servlet, ServletConfig, java.io.Serializable   
  9. {   
  10.     //私有变量，保存 init()传入的ServletConfig对象的引用   
  11.     private transient ServletConfig config;   
  12.        
  13.     //无参的构造方法   
  14.     public GenericServlet() { }   
  15.        
  16.   
  17.     /*  
  18.     ------------------------------------  
  19.     以下方法实现了servlet接口中的5个方法  
  20.     实现Servlet接口方法开始  
  21.     ------------------------------------  
  22.     */       
  23.        
  24.        
  25.     /*  
  26.     实现接口Servlet中的带参数的init(ServletConfig Config)方法，将传递的ServletConfig对象的引用保存到私有成员变量中，  
  27.     使得GenericServlet对象和一个ServletConfig对象关联.  
  28.     同时它也调用了自身的不带参数的init()方法  
  29.     **/  
  30.        
  31.     public void init(ServletConfig config) throws ServletException {   
  32.       this.config = config;   
  33.       this.init();   //调用了无参的 init()方法   
  34.     }   
  35.   
  36.     //无参的init()方法   
  37.     public void init() throws ServletException {   
  38.   
  39.     }   
  40.        
  41.        
  42.     //空实现了destroy方法   
  43.     public void destroy() { }       
  44.            
  45.         
  46.     //实现了接口中的getServletConfig方法，返回ServletConfig对象   
  47.     public ServletConfig getServletConfig()    
  48.     {   
  49.        return config;   
  50.     }       
  51.   
  52.     //该方法实现接口<Servlet>中的ServletInfo，默认返回空字符串   
  53.     public String getServletInfo() {   
  54.        return "";   
  55.     }   
  56.        
  57.        
  58.     //唯一没有实现的抽象方法service()，仅仅在此声明。交由子类去实现具体的应用    
  59.    //在后来的HttpServlet抽象类中，针对当前基于Http协议的Web开发，HttpServlet抽象类具体实现了这个方法   
  60.    //若有其他的协议，直接继承本类后实现相关协议即可，具有很强的扩展性   
  61.          
  62.     public abstract void service(ServletRequest req, ServletResponse res)   
  63.  throws ServletException, IOException;   
  64.        
  65.     /*  
  66.     ------------------------------------  
  67.     实现Servlet接口方法结束  
  68.     ------------------------------------  
  69.     */  
  70.        
  71.        
  72.        
  73.        
  74.        
  75.        
  76.   
  77.   /*  
  78.   ---------------------------------------------  
  79.    *以下四个方法实现了接口ServletConfig中的方法  
  80.    实现ServletConfig接口开始  
  81.   ---------------------------------------------  
  82.    */  
  83.     
  84.   //该方法实现了接口<ServletConfig>中的getServletContext方法，用于返回servleConfig对象中所包含的servletContext方法   
  85.     public ServletContext getServletContext() {   
  86.        return getServletConfig().getServletContext();   
  87.     }   
  88.        
  89.     //获取初始化参数   
  90.     public String getInitParameter(String name) {   
  91.      return getServletConfig().getInitParameter(name);   
  92.     }   
  93.        
  94.     //实现了接口<ServletConfig>中的方法，用于返回在web.xml文件中为servlet所配置的全部的初始化参数的值   
  95.     public Enumeration getInitParameterNames() {   
  96.        return getServletConfig().getInitParameterNames();   
  97.       
  98.    //获取在web.xml文件中注册的当前的这个servlet名称。没有在web.xml 中注册的servlet，该方法直接放回该servlet的类名。   
  99.    //法实现了接口<ServleConfig>中的getServletName方法     
  100.     public String getServletName() {   
  101.         return config.getServletName();   
  102.     }   
  103.        
  104.    /*  
  105.   ---------------------------------------------  
  106.    实现ServletConfig接口结束  
  107.   ---------------------------------------------  
  108.  */    
  109.            
  110.   
  111.     public void log(String msg) {   
  112.        getServletContext().log(getServletName() + ": "+ msg);   
  113.     }     
  114.       
  115.       
  116.     public void log(String message, Throwable t) {   
  117.        getServletContext().log(getServletName() + ": " + message, t);   
  118.     }   
  119. }  

 

 


HttpServlet是继承了GenericServlet抽象类的一个抽象类，但是他的里面并没有任何抽象方法，这就是说他并不会强迫我们去做什么。我们只是按需选择，重写HttpServlet中的的部分方法就可以了。


下面是抽象类HttpServlet的源码：

 

 

Java代码 复制代码
  1. package javax.servlet.http;   
  2. .....  //节约篇幅，省略导入包   
  3.   
  4. public abstract class HttpServlet extends GenericServlet   
  5.     implements java.io.Serializable    
  6. {   
  7.   
  8.     private static final String METHOD_GET = "GET";   
  9.     private static final String METHOD_POST = "POST";   
  10.     ......   
  11.       
  12.        
  13.     /**  
  14.      * Does nothing, because this is an abstract class.  
  15.      * 抽象类HttpServlet有一个构造函数，但是空的，什么都没有  
  16.      */  
  17.     public HttpServlet() { }   
  18.        
  19.   
  20.        
  21.     /*分别执行doGet,doPost,doOpitions,doHead,doPut,doTrace方法  
  22.     在请求响应服务方法service()中，根据请求类型，分贝调用这些doXXXX方法  
  23.     所以自己写的Servlet只需要根据请求类型覆盖响应的doXXX方法即可。  
  24.     */  
  25.        
  26.     //doXXXX方法开始   
  27.     protected void doGet(HttpServletRequest req, HttpServletResponse resp)   
  28.         throws ServletException, IOException   
  29.     {   
  30.         String protocol = req.getProtocol();   
  31.         String msg = lStrings.getString("http.method_get_not_supported");   
  32.         if (protocol.endsWith("1.1")) {   
  33.             resp.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, msg);   
  34.         } else {   
  35.             resp.sendError(HttpServletResponse.SC_BAD_REQUEST, msg);   
  36.         }   
  37.     }   
  38.        
  39.   
  40.     protected void doHead(HttpServletRequest req, HttpServletResponse resp)   
  41.         throws ServletException, IOException   
  42.     {   
  43.         .......   
  44.     }     
  45.     protected void doPost(HttpServletRequest req, HttpServletResponse resp)   
  46.         throws ServletException, IOException   
  47.     {   
  48.         String protocol = req.getProtocol();   
  49.         String msg = lStrings.getString("http.method_post_not_supported");   
  50.         if (protocol.endsWith("1.1")) {   
  51.             resp.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, msg);   
  52.         } else {   
  53.             resp.sendError(HttpServletResponse.SC_BAD_REQUEST, msg);   
  54.         }   
  55.     }      
  56.     protected void doPut(HttpServletRequest req, HttpServletResponse resp)   
  57.         throws ServletException, IOException  {   
  58.         //todo   
  59.     }      
  60.        
  61.            
  62.     protected void doOptions(HttpServletRequest req, HttpServletResponse resp)   
  63.         throws ServletException, IOException {   
  64.        //todo   
  65.     }   
  66.            
  67.     protected void doTrace(HttpServletRequest req, HttpServletResponse resp)    
  68.         throws ServletException, IOException   {          
  69.       //todo   
  70.     }      
  71.     
  72.     protected void doDelete(HttpServletRequest req,   
  73.                             HttpServletResponse resp)   
  74.         throws ServletException, IOException   {   
  75.         //todo   
  76.     }      
  77.     //doXXXX方法结束   
  78.        
  79.        
  80.   
  81.     //重载的service(args0,args1)方法   
  82.     protected void service(HttpServletRequest req, HttpServletResponse resp)   
  83.         throws ServletException, IOException   
  84.     {   
  85.         String method = req.getMethod();   
  86.   
  87.         if (method.equals(METHOD_GET)) {   
  88.             long lastModified = getLastModified(req);   
  89.             if (lastModified == -1) {   
  90.                 // servlet doesn't support if-modified-since, no reason   
  91.                 // to go through further expensive logic   
  92.                 doGet(req, resp);   
  93.             } else {   
  94.                 long ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);   
  95.                 if (ifModifiedSince < (lastModified / 1000 * 1000)) {   
  96.                     // If the servlet mod time is later, call doGet()   
  97.                     // Round down to the nearest second for a proper compare   
  98.                     // A ifModifiedSince of -1 will always be less   
  99.                     maybeSetLastModified(resp, lastModified);   
  100.                     doGet(req, resp);   
  101.                 } else {   
  102.                     resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);   
  103.                 }   
  104.             }   
  105.   
  106.         } else if (method.equals(METHOD_HEAD)) {   
  107.             long lastModified = getLastModified(req);   
  108.             maybeSetLastModified(resp, lastModified);   
  109.             doHead(req, resp);   
  110.   
  111.         } else if (method.equals(METHOD_POST)) {   
  112.             doPost(req, resp);   
  113.                
  114.         } else if (method.equals(METHOD_PUT)) {   
  115.             doPut(req, resp);           
  116.                
  117.         } else if (method.equals(METHOD_DELETE)) {   
  118.             doDelete(req, resp);   
  119.                
  120.         } else if (method.equals(METHOD_OPTIONS)) {   
  121.             doOptions(req,resp);   
  122.                
  123.         } else if (method.equals(METHOD_TRACE)) {   
  124.             doTrace(req,resp);   
  125.                
  126.         } else {   
  127.             //   
  128.             // Note that this means NO servlet supports whatever   
  129.             // method was requested, anywhere on this server.   
  130.             //   
  131.   
  132.             String errMsg = lStrings.getString("http.method_not_implemented");   
  133.             Object[] errArgs = new Object[1];   
  134.             errArgs[0] = method;   
  135.             errMsg = MessageFormat.format(errMsg, errArgs);   
  136.                
  137.             resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);   
  138.         }   
  139.     }   
  140.       
  141.        
  142.    //实现父类的service(ServletRequest req,ServletResponse res)方法   
  143.    //通过参数的向下转型，然后调用重载的service(HttpservletRequest,HttpServletResponse)方法   
  144.   
  145.     public void service(ServletRequest req, ServletResponse res)   
  146.         throws ServletException, IOException   
  147.     {   
  148.         HttpServletRequest        request;   
  149.         HttpServletResponse        response;   
  150.            
  151.         try {   
  152.             request = (HttpServletRequest) req;  //向下转型   
  153.             response = (HttpServletResponse) res; //参数向下转型   
  154.         } catch (ClassCastException e) {   
  155.             throw new ServletException("non-HTTP request or response");   
  156.         }   
  157.         service(request, response);  //调用重载的service()方法   
  158.     }   
  159.       
  160.     ......//其他方法   
  161. }  

 

 

值得一说的是，很多介绍servlet的书中，讲解servlet第一个实例时候，都习惯去覆盖HttpServlet的service(HttpServletRequest request,HttpServletResponse response)方法来演示servlet.

 

当然，直接覆盖sevice()方法，作为演示，可以达到目的。 因为servlet首先响应的就是调用service()方法，直接在此方法中覆盖没问题。但在实际的开发中，我们只是根据请求的类型，覆盖响应的doXXX方法即可。最常见的是doGet和doPost方法。

 

从HtttpServlet的源码中关于service() 方法的实现，可以看出，它最终也是根据请求类型来调用的各个doxxx 方法来完成响应的。如果自己写的servlet覆盖了service()方法，若没对相应的请求做处理，则系统无法调用相关的doxxx方法来完成提交的请求任务。

 

---------------------------------------------------------------------/////////////////////////////////////////////////////////////////////////

在javax.servlet.Servlet接口中，定义了针对Servlet生命周期最重要的三个方法，按照顺序，依次是init(),Serveice()和destroy()这三个方法.
.

Servlet初始化阶段，包括执行如下四个步骤：
1. servlet容器(如tomcat)加载servlet类，读入其.class类文件到内存
2. servlet容器开始针对这个servlet,创建ServletConfig对象
3. servlet容器创建servlet对象
4. servlet容器调用servlet对象的init(ServletConfig config)方法，在这个init方法中，建立了sevlet对象和servletConfig对象的关联，执行了如下的代码：

 

 

 

Java代码 复制代码
  1. public void init(ServletConfig config) throws ServletException    
  2. {      
  3.   this.config = config;  //将容器创建的servletConfig 对象传入，并使用私有成员变量引用该servletConfig对象      
  4.   this.init();       
  5. }  

 

 

 

通过以上的初始化步骤建立了servlet对象和sevletConfig对象的关联，而servletConfig对象又和当前容器创建的ServleContext对象获得关联.

 

运行时阶段：
当容器接受到访问特定的servlet请求时，针对这个请求，创建对应的ServletRequest对象和ServletResponse对象，并调用servlet的service()方法，service()根据从ServletRequest对象中获得客户的请求信息
并将调用相应的doxxx方法等进行响应，再通过ServletResponse对象生成响应结果，然后发送给客户端，最后销毁创建的ServletRequest 和ServletResponse

 

 

销毁阶段：
只有当web应用被终止时，servlet才会被销毁。servlet容器现调用web应用中所有的Servlet对象的destroy()方法，然后再销毁这些servlet对象，此外，容器还销毁了针对各个servlet所创建的相关联的serveltConfig对象

以下程序代码演示了Servlet对象的生命周期：

 

 

Java代码 复制代码
  1. /*  
  2.  * 本程序代码演示了Servlet周期中init()、serveic()、destroy() 三个方法的调用的情况  
  3.  * Author: Laurence Luo   
  4.  * Date; 2009-10-21   
  5.  *   
  6.  *   
  7.  */  
  8.   
  9. package com.longweir;   
  10.   
  11.   
  12. import javax.servlet.*;   
  13. import javax.servlet.http.*;   
  14. import java.io.*;   
  15.   
  16. public class LifeServlet extends HttpServlet   
  17.  {     
  18.    private int initvar=0;   
  19.     private int servicevar=0;   
  20.     private int destroyvar=0;   
  21.     private String name;   
  22.   
  23.     //覆盖父类的销毁方法，加入销毁的计数器   
  24.   public void destroy()    
  25.   {   
  26.         destroyvar++;   
  27.         System.out.println(name+">destroy()被销毁了"+destroyvar+"次");   
  28.   }   
  29.   
  30.     
  31.     //覆盖父类的init(ServletConfig config)方法 加入计数   
  32.   /*  public void init(ServletConfig config) throws ServletException   
  33.   {  
  34.     super.init(config);  //调用父类的带参数的init方法  
  35.     name=config.getServletName();  
  36.     initvar++;  
  37.     System.out.println(name+">init():Servlet 被初始化了"+initvar+"次");   
  38.     
  39.   }*/  
  40.     
  41.     
  42.  /* 根据分析GenericServlet的源码，其init(ServletConfig config)方法最终还是会调用了不带参数的init()方法，  
  43.   * 所以也可以在自己编写的的servlet中覆盖不带参数的init()方法来加入统计计数  
  44. */  
  45.      
  46.   public void init()  //覆盖父类的不带参数的初始化方法   
  47.   {   
  48.   initvar++;   
  49.   //name=getServleConfig.getServletNmae();   
  50.   name=getServletName();  //直接返回   
  51.   System.out.println(name+"init(): servlet被初始化了了 "+initvar+"次");   
  52.   }   
  53.  */   
  54.     
  55.     
  56.  public void service(HttpServletRequest request,HttpServletResponse response) throws ServletException,IOException    
  57.  {   
  58.   servicevar++;  //请求服务计数器自增   
  59.   System.out.println(name+">service():servlet共响应了"+servicevar+"请求");   
  60.      
  61.   String content1="初始化次数: "+initvar;   
  62.   String content2="销毁次数： "+destroyvar;   
  63.   String content3="请求服务次数 "+servicevar;   
  64.   response.setContentType("text/html;charset=GBK");   
  65.   PrintWriter out=response.getWriter();   
  66.   out.print("<html><head><title>LifeServlet</title></head>");   
  67.   out.print("<body>");   
  68.   out.print("<h1>"+content1+"</h1><br>");   
  69.   out.print("<h1>"+content2+"</h1><br>");   
  70.   out.print("<h1>"+content3+"</h1><br>");   
  71.   out.print("</body>");   
  72.   out.print("</head>");   
  73.   out.close();   
  74.  }   
  75.     
  76.   
  77. }  

之前提到servlet 生命周期中的三个阶段，第一个阶段中servlet容器会执行init方法来初始化一个servlet.
init方法和destroy这两个方法在servlet生命周期中之执行一次。servlet容器（或者说是servlet引擎)创建了servlet实例对象后立即调用该init方法。
Init方法是在servlet对象被创建后，再由servlet容器调用的方法，其执行位于构造方法之后，在执行init方法时，会传递一个serveltConfig对象。
所以，如果要在初始代码中用到servletConfig对象，则这些初始操作只能在init方法中编写，不能在构造方法中编写.

 

 

Java代码 复制代码
  1. GenericServlet中关于init方法的示意源码：   
  2.   
  3. public void init(ServletConfig config) throws ServletException   
  4. {   
  5.     this.config=config;   
  6.     ......   
  7.         
  8. }  

 

 

 

如果在要在自己编写的servlet类中增加一些额外的初始化功能，则必须覆盖GenricServlet类的init(ServletConfig config)方法，如果覆盖后，父类的init(ServletConfig config)方法就不会被调用。GenericServlet类中有些方法依赖init方法执行的结果，例如

 

Java代码 复制代码
  1. getServletName()方法：   
  2.   
  3. public ServletContext getServeltContext()   
  4. {   
  5.  return config.getServletContext;   
  6. }  

 

 

 

这里的config对象的引用就来自Init(ServletConfig config)执行的结果.

所以如果子类需要覆盖了父类的init(ServletConfig config)方法，则首先要调用父类的init(ServletConfig config)方法，也就是先加入 super.init(config) 语句来先执行父类的方法.否则，会产生空指针异常 java.lang.NullPointerException ，因为config对象的引用为空。

 

为了避免这样的情况的产生，GenericServlet的设计人员 在GenericServlet中又定义了一个无参数的init()空方法. 且在init(servletConfig config)方法最后也调用了这个无参的空方法

 

Java代码 复制代码
  1. public void init(ServletConfig config) throws ServletException   
  2. {   
  3.     this.config=config;   
  4.     init();        
  5. }  

 

 

 

所以，我们只需覆盖这个无参的init方法加入自己的初始代码即可，而无需覆盖带参数的父类的init方法.
如果有多个重载的init方法，对以servlet而言，servlet容器始终就之调用servlet接口中的那个方法：init(ServletConfig config) (当然也会执行已经覆盖的无参的init()方法)，其他的覆盖的init方法不会执行。

分析 2中关于servlet生命周期的那个例子程序中的一个代码：

 

 

Java代码 复制代码
  1. //覆盖父类的init(ServletConfig config)方法 加入计数   
  2.  public void init(ServletConfig config) throws ServletException    
  3.  {   
  4.   super.init(config);  //调用父类的init方法   
  5.      
  6.   name=config.getServletName();   
  7.   initvar++;   
  8.   System.out.println(name+">init():Servlet 被初始化了"+initvar+"次");    
  9.      
  10.  }   
  11.     
  12.     
  13.  /* 父类的带参数的init(ServletConfig config)方法最终还是会调用了不带参数的init()方法，  
  14.   * 所以也可以在自己的servlet中覆盖不带参数的init()方法来加入自己的统计参数代码  
  15.   */    
  16.   public void init()  //覆盖父类的不带参数的初始化方法   
  17.   {   
  18.      
  19.   //name=getServleConfig.getServletNmae(); //因为已经实现了servletConfig接口，则直接调用其方法即可   
  20.   name=getServletName();  //直接返回   
  21.   initvar++;   
  22.   System.out.println(name+"init(): servlet被初始化了了 "+initvar+"次");   
  23.   }  

 

观察GenericServlet源码中关于service()方法的实现:

 

Java代码 复制代码
  1. //实现父类的service(ServletRequest req,ServletResponse res)方法      
  2.  //通过参数的向下转型，然后调用重载的service(HttpservletRequest,HttpServletResponse)方法      
  3.      
  4.     public void service(ServletRequest req, ServletResponse res)      
  5.         throws ServletException, IOException      
  6.     {      
  7.         HttpServletRequest        request;      
  8.         HttpServletResponse        response;      
  9.               
  10.         try {      
  11.             request = (HttpServletRequest) req;  //向下转型      
  12.             response = (HttpServletResponse) res; //向下转型      
  13.         } catch (ClassCastException e) {      
  14.             throw new ServletException("non-HTTP request or response");      
  15.         }      
  16.         service(request, response);  //调用重载的service(HttpServelertRequest,HttpServletResponse)方法      
  17.     }     
  18.        
  19.        
  20.     //重载的service(HttpServletRequest req, HttpServletResponse resp)方法      
  21.     protected void service(HttpServletRequest req, HttpServletResponse resp)      
  22.         throws ServletException, IOException      
  23.     {      
  24.         String method = req.getMethod();      
  25.      
  26.         if (method.equals(METHOD_GET)) {      
  27.             long lastModified = getLastModified(req);      
  28.             if (lastModified == -1) {      
  29.                 // servlet doesn't support if-modified-since, no reason      
  30.                 // to go through further expensive logic      
  31.                 doGet(req, resp);      
  32.             } else {      
  33.                 long ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);      
  34.                 if (ifModifiedSince < (lastModified / 1000 * 1000)) {      
  35.                     // If the servlet mod time is later, call doGet()      
  36.                     // Round down to the nearest second for a proper compare      
  37.                     // A ifModifiedSince of -1 will always be less      
  38.                     maybeSetLastModified(resp, lastModified);      
  39.                     doGet(req, resp);      
  40.                 } else {      
  41.                     resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);      
  42.                 }      
  43.             }      
  44.      
  45.         } else if (method.equals(METHOD_HEAD)) {      
  46.             long lastModified = getLastModified(req);      
  47.             maybeSetLastModified(resp, lastModified);      
  48.             doHead(req, resp);      
  49.      
  50.         } else if (method.equals(METHOD_POST)) {      
  51.             doPost(req, resp);      
  52.                   
  53.         } else if (method.equals(METHOD_PUT)) {      
  54.             doPut(req, resp);              
  55.                   
  56.         } else if (method.equals(METHOD_DELETE)) {      
  57.             doDelete(req, resp);      
  58.                   
  59.         } else if (method.equals(METHOD_OPTIONS)) {      
  60.             doOptions(req,resp);      
  61.                   
  62.         } else if (method.equals(METHOD_TRACE)) {      
  63.             doTrace(req,resp);      
  64.                   
  65.         } else {      
  66.             //      
  67.             // Note that this means NO servlet supports whatever      
  68.             // method was requested, anywhere on this server.      
  69.             //      
  70.      
  71.             String errMsg = lStrings.getString("http.method_not_implemented");      
  72.             Object[] errArgs = new Object[1];      
  73.             errArgs[0] = method;      
  74.             errMsg = MessageFormat.format(errMsg, errArgs);      
  75.                   
  76.             resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);      
  77.         }      
  78.     }  

 

  

在抽象类中GenericServlet中service()是一个抽象方法,但在HttpServlet中对这个方法进行了实现。
servlet接口中定义的service()方法中的两个参数分别是servletRequest 和 ServletResponse 这两个类型。当前的http请求，如果需要在这个service()方法内部使用http消息特有的功能，也就是要调用HttpServletRequest 和HttpServletResponse来中定义的方法时，需要将请求和响应对象进行一个类型的转换，所以,在GenericServlet中，使用了两个方法来共同完成这个工作。


实现父类GenericServlet中的service(ServltRequest req,ServeltResponse res)抽象方法
   

Java代码 复制代码
  1. public void service(ServletRequest req, ServletResponse res)      
  2.        throws ServletException, IOException      
  3.    {      
  4.        HttpServletRequest        request;      
  5.        HttpServletResponse        response;      
  6.              
  7.        try {      
  8.            request = (HttpServletRequest) req;  //向下转型      
  9.            response = (HttpServletResponse) res; //向下转型      
  10.        } catch (ClassCastException e) {      
  11.            throw new ServletException("non-HTTP request or response");      
  12.        }      
  13.        service(request, response);  //这里是调用重载的service(HttpServelertRequest,HttpServletResponse)方法      
  14.    }    

     
   

 service(HttpServelertRequest,HttpServletResponse)方法： 
 
  //重载的service(HttpServletRequest req, HttpServletResponse resp)方法 ，注意参数类型
    
   

Java代码 复制代码
  1. protected void service(HttpServletRequest req, HttpServletResponse resp)      
  2.        throws ServletException, IOException      
  3.    {      
  4.        String method = req.getMethod();      
  5.     
  6.        if (method.equals(METHOD_GET)) {      
  7.            long lastModified = getLastModified(req);      
  8.            if (lastModified == -1) {      
  9.                // servlet doesn't support if-modified-since, no reason      
  10.                // to go through further expensive logic      
  11.                doGet(req, resp);      
  12.            } else {      
  13.                long ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);      
  14.                if (ifModifiedSince < (lastModified / 1000 * 1000)) {      
  15.                    // If the servlet mod time is later, call doGet()      
  16.                    // Round down to the nearest second for a proper compare      
  17.                    // A ifModifiedSince of -1 will always be less      
  18.                    maybeSetLastModified(resp, lastModified);      
  19.                    doGet(req, resp);      
  20.                } else {      
  21.                    resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);      
  22.                }      
  23.            }      
  24.     
  25.        } else if (method.equals(METHOD_HEAD)) {      
  26.            long lastModified = getLastModified(req);      
  27.            maybeSetLastModified(resp, lastModified);      
  28.            doHead(req, resp);      
  29.     
  30.        } else if (method.equals(METHOD_POST)) {      
  31.            doPost(req, resp);      
  32.                  
  33.        } else if (method.equals(METHOD_PUT)) {      
  34.            doPut(req, resp);              
  35.                  
  36.        } else if (method.equals(METHOD_DELETE)) {      
  37.            doDelete(req, resp);      
  38.                  
  39.        } else if (method.equals(METHOD_OPTIONS)) {      
  40.            doOptions(req,resp);      
  41.                  
  42.        } else if (method.equals(METHOD_TRACE)) {      
  43.            doTrace(req,resp);      
  44.                  
  45.        } else {      
  46.            //      
  47.            // Note that this means NO servlet supports whatever      
  48.            // method was requested, anywhere on this server.      
  49.            //      
  50.     
  51.            String errMsg = lStrings.getString("http.method_not_implemented");      
  52.            Object[] errArgs = new Object[1];      
  53.            errArgs[0] = method;      
  54.            errMsg = MessageFormat.format(errMsg, errArgs);      
  55.                  
  56.            resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);      
  57.        }      
  58.    }      
  59.      
http://jzinfo.javaeye.com/blog/502779
posted @ 2011-03-04 16:43  kelin1314  阅读(1663)  评论(1)  编辑  收藏  举报