Servlet源码分析【转】
2015-09-17 16:43
417 查看
有点长,看完需要耐心.
Servlet API的核心就是javax.servlet.Servlet接口，所有的Servlet 类（抽象的或者自己写的）都必须实现这个接口。在Servlet接口中定义了5个方法，其中有3个方法是由Servlet 容器在Servlet的生命周期的不同阶段来调用的特定方法。
先看javax.servlet.servlet接口源码：
Java代码
package javax.servlet; //Tomcat源码版本：6.0.20
import java.io.IOException;
public interface Servlet {
//负责初始化Servlet对象。容器一旦创建好Servlet对象后，就调用此方法来初始化Servlet对象
public void init(ServletConfig config) throws ServletException;
//方法负责响应客户的请求,提供服务。当容器接收到客户端要求访问特定的servlet请求时，就会调用Servlet的service方法
public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException;
//Destroy()方法负责释放Servlet 对象占用的资源，当servlet对象结束生命周期时，servlet容器调用此方法来销毁servlet对象.
public void destroy();
// 说明：Init(),service(),destroy() 这三个方法是Servlet生命周期中的最重要的三个方法。
// 返回一个字符串，在该字符串中包含servlet的创建者，版本和版权等信息
public String getServletInfo();
// GetServletConfig: 返回一个ServletConfig对象，该对象中包含了Servlet初始化参数信息
public ServletConfig getServletConfig();
}
GenericServlet抽象类实现了Servlet接口，它只是通用的实现，与任何网络应用层协议无关。
同时，HttpServlet这个抽象类继承了GenericServlet抽象类，在Http协议上提供了通用的实现
查看GenericSerlvet抽象类源码：
Java代码
//抽象类GenericServlet实现了Servlet接口的同时，也实现了ServletConfig接口和Serializable这两个接口
public abstract class GenericServlet
implements Servlet, ServletConfig, java.io.Serializable {
//私有变量，保存 init()传入的ServletConfig对象的引用
private transient ServletConfig config;
//无参的构造方法
public GenericServlet() { }
------------------------------------
以下方法实现了servlet接口中的5个方法
实现Servlet接口方法开始
------------------------------------
// 实现接口Servlet中的带参数的init(ServletConfig Config)方法，将传递的ServletConfig对象的引用保存到私有成员变量中， 通过含参的init方法实现组合注入 然后通过无参的init方法初始化
使得GenericServlet对象和一个ServletConfig对象关联.
同时它也调用了自身的不带参数的init()方法
public void init(ServletConfig config) throws ServletException {
this.config = config;
this.init(); //调用了无参的 init()方法
}
//无参的init()方法
public void init() throws ServletException {}
//空实现了destroy方法
public void destroy() { }
//实现了接口中的getServletConfig方法，返回ServletConfig对象
public ServletConfig getServletConfig()
{ return config; }
//该方法实现接口<Servlet>中的ServletInfo，默认返回空字符串
public String getServletInfo() {
return ""; }
//唯一没有实现的抽象方法service()，仅仅在此声明。交由子类去实现具体的应用
//在后来的HttpServlet抽象类中，针对当前基于Http协议的Web开发，HttpServlet抽象类具体实现了这个方法
//若有其他的协议，直接继承本类后实现相关协议即可，具有很强的扩展性
public abstract void service(ServletRequest req, ServletResponse res)
throws ServletException, IOException;
------------------------------------
实现Servlet接口方法结束
------------------------------------
---------------------------------------------
*以下四个方法实现了接口ServletConfig中的方法
实现ServletConfig接口开始
---------------------------------------------
*/
//该方法实现了接口<ServletConfig>中的getServletContext方法，用于返回servleConfig对象中所包含的servletContext方法
public ServletContext getServletContext() {
return getServletConfig().getServletContext();
}
//获取初始化参数
public String getInitParameter(String name) {
return getServletConfig().getInitParameter(name);
}
//实现了接口<ServletConfig>中的方法，用于返回在web.xml文件中为servlet所配置的全部的初始化参数的值
public Enumeration getInitParameterNames() {
return getServletConfig().getInitParameterNames();
//获取在web.xml文件中注册的当前的这个servlet名称。没有在web.xml 中注册的servlet，该方法直接放回该servlet的类名。
//法实现了接口<ServleConfig>中的getServletName方法
public String getServletName() {
return config.getServletName();
}
---------------------------------------------
实现ServletConfig接口结束
---------------------------------------------
public void log(String msg) {
getServletContext().log(getServletName() + ": "+ msg);
}
public void log(String message, Throwable t) {
getServletContext().log(getServletName() + ": " + message, t);
}
}
HttpServlet是继承了GenericServlet抽象类的一个抽象类，但是他的里面并没有任何抽象方法，这就是说他并不会强迫我们去做什么。我们只是按需选择，重写HttpServlet中的的部分方法就可以了。
下面是抽象类HttpServlet的源码：
Java代码
public abstract class HttpServlet extends GenericServlet
implements java.io.Serializable
{
private static final String METHOD_GET = "GET";
private static final String METHOD_POST = "POST";
......
* Does nothing, because this is an abstract class.
* 抽象类HttpServlet有一个构造函数，但是空的，什么都没有
public HttpServlet() { }
/*分别执行doGet,doPost,doOpitions,doHead,doPut,doTrace方法
在请求响应服务方法service()中，根据请求类型，分贝调用这些doXXXX方法
所以自己写的Servlet只需要根据请求类型覆盖响应的doXXX方法即可。
*/
//doXXXX方法开始
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(HttpServletResponse.SC_METHOD_NOT_ALLOWED, msg);
} else {
resp.sendError(HttpServletResponse.SC_BAD_REQUEST, msg);
}
}
protected void doHead(HttpServletRequest req, HttpServletResponse resp)
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(HttpServletResponse.SC_METHOD_NOT_ALLOWED, msg);
} else {
resp.sendError(HttpServletResponse.SC_BAD_REQUEST, msg);
}
}
protected void doPut(HttpServletRequest req, HttpServletResponse resp)
protected void doOptions(HttpServletRequest req, HttpServletResponse resp)
protected void doTrace(HttpServletRequest req, HttpServletResponse resp)
protected void doDelete(HttpServletRequest req, HttpServletResponse resp)
//doXXXX方法结束
//重载的service(args0,args1)方法
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);
}
}
//实现父类的service(ServletRequest req,ServletResponse res)方法
//通过参数的向下转型，然后调用重载的service(HttpservletRequest,HttpServletResponse)方法
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); //调用重载的service()方法
}
......//其他方法
}
值得一说的是，很多介绍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代码
public void init(ServletConfig config) throws ServletException
{
this.config = config; //将容器创建的servletConfig 对象传入，并使用私有成员变量引用该servletConfig对象
this.init();
}
通过以上的初始化步骤建立了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代码
/*
* 本程序代码演示了Servlet周期中init()、serveic()、destroy() 三个方法的调用的情况
* Author: Laurence Luo
* Date; 2009-10-21
package com.longweir;
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
public class LifeServlet extends HttpServlet
{
private int initvar=0;
private int servicevar=0;
private int destroyvar=0;
private String name;
//覆盖父类的销毁方法，加入销毁的计数器
public void destroy()
{
destroyvar++;
System.out.println(name+">destroy()被销毁了"+destroyvar+"次");
}
//覆盖父类的init(ServletConfig config)方法 加入计数
/* public void init(ServletConfig config) throws ServletException
{
super.init(config); //调用父类的带参数的init方法
name=config.getServletName();
initvar++;
System.out.println(name+">init():Servlet 被初始化了"+initvar+"次");
}*/
/* 根据分析GenericServlet的源码，其init(ServletConfig config)方法最终还是会调用了不带参数的init()方法，
* 所以也可以在自己编写的的servlet中覆盖不带参数的init()方法来加入统计计数
*/
public void init() //覆盖父类的不带参数的初始化方法
{
initvar++;
//name=getServleConfig.getServletNmae();
name=getServletName(); //直接返回
System.out.println(name+"init(): servlet被初始化了了 "+initvar+"次");
}
*/
public void service(HttpServletRequest request,HttpServletResponse response) throws ServletException,IOException
{
servicevar++; //请求服务计数器自增
System.out.println(name+">service():servlet共响应了"+servicevar+"请求");
String content1="初始化次数: "+initvar;
String content2="销毁次数： "+destroyvar;
String content3="请求服务次数 "+servicevar;
response.setContentType("text/html;charset=GBK");
PrintWriter out=response.getWriter();
out.print("<html><head><title>LifeServlet</title></head>");
out.print("<body>");
out.print("<h1>"+content1+"</h1><br>");
out.print("<h1>"+content2+"</h1><br>");
out.print("<h1>"+content3+"</h1><br>");
out.print("</body>");
out.print("</head>");
out.close();
}
}
之前提到servlet 生命周期中的三个阶段，第一个阶段中servlet容器会执行init方法来初始化一个servlet.
init方法和destroy这两个方法在servlet生命周期中之执行一次。servlet容器（或者说是servlet引擎)创建了servlet实例对象后立即调用该init方法。
Init方法是在servlet对象被创建后，再由servlet容器调用的方法，其执行位于构造方法之后，在执行init方法时，会传递一个serveltConfig对象。
所以，如果要在初始代码中用到servletConfig对象，则这些初始操作只能在init方法中编写，不能在构造方法中编写.
Java代码
GenericServlet中关于init方法的示意源码：
public void init(ServletConfig config) throws ServletException
{
this.config=config;
......
}
如果在要在自己编写的servlet类中增加一些额外的初始化功能，则必须覆盖GenricServlet类的init(ServletConfig config)方法，如果覆盖后，父类的init(ServletConfig config)方法就不会被调用。GenericServlet类中有些方法依赖init方法执行的结果，例如
Java代码
getServletName()方法：
public ServletContext getServeltContext()
{
return config.getServletContext;
}
这里的config对象的引用就来自Init(ServletConfig config)执行的结果.
所以如果子类需要覆盖父类的init(ServletConfig config)方法，则首先要调用父类的init(ServletConfig config)方法，也就是先加入 super.init(config) 语句来先执行父类的方法.否则，会产生空指针异常 java.lang.NullPointerException ，因为config对象的引用为空。
为了避免这样的情况的产生，GenericServlet的设计人员 在GenericServlet中又定义了一个无参数的init()空方法. 且在init(servletConfig config)方法最后也调用了这个无参的空方法
Java代码
public void init(ServletConfig config) throws ServletException
{
this.config=config;
init();
}
所以，我们只需覆盖这个无参的init方法加入自己的初始代码即可，而无需覆盖带参数的父类的init方法.
如果有多个重载的init方法，对以servlet而言，servlet容器始终就之调用servlet接口中的那个方法：init(ServletConfig config) (当然也会执行已经覆盖的无参的init()方法)，其他的覆盖的init方法不会执行。
分析 2中关于servlet生命周期的那个例子程序中的一个代码：
Java代码
//覆盖父类的init(ServletConfig config)方法 加入计数
public void init(ServletConfig config) throws ServletException
{
super.init(config); //调用父类的init方法
name=config.getServletName();
initvar++;
System.out.println(name+">init():Servlet 被初始化了"+initvar+"次");
}
/* 父类的带参数的init(ServletConfig config)方法最终还是会调用了不带参数的init()方法，
* 所以也可以在自己的servlet中覆盖不带参数的init()方法来加入自己的统计参数代码
*/
public void init() //覆盖父类的不带参数的初始化方法
{
//name=getServleConfig.getServletNmae(); //因为已经实现了servletConfig接口，则直接调用其方法即可
name=getServletName(); //直接返回
initvar++;
System.out.println(name+"init(): servlet被初始化了了 "+initvar+"次");
}
观察GenericServlet源码中关于service()方法的实现:
Java代码
//实现父类的service(ServletRequest req,ServletResponse res)方法
//通过参数的向下转型，然后调用重载的service(HttpservletRequest,HttpServletResponse)方法
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); //调用重载的service(HttpServelertRequest,HttpServletResponse)方法
}
//重载的service(HttpServletRequest req, HttpServletResponse resp)方法
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);
}
}
在抽象类中GenericServlet中service()是一个抽象方法,但在HttpServlet中对这个方法进行了实现。
servlet接口中定义的service()方法中的两个参数分别是servletRequest 和 ServletResponse 这两个类型。当前的http请求，如果需要在这个service()方法内部使用http消息特有的功能，也就是要调用HttpServletRequest 和HttpServletResponse来中定义的方法时，需要将请求和响应对象进行一个类型的转换，所以,在GenericServlet中，使用了两个方法来共同完成这个工作。
实现父类GenericServlet中的service(ServltRequest req,ServeltResponse res)抽象方法
Java代码
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); //这里是调用重载的service(HttpServelertRequest,HttpServletResponse)方法
}
service(HttpServelertRequest,HttpServletResponse)方法：
//重载的service(HttpServletRequest req, HttpServletResponse resp)方法 ，注意参数类型
Java代码
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 API的核心就是javax.servlet.Servlet接口，所有的Servlet 类（抽象的或者自己写的）都必须实现这个接口。在Servlet接口中定义了5个方法，其中有3个方法是由Servlet 容器在Servlet的生命周期的不同阶段来调用的特定方法。
先看javax.servlet.servlet接口源码：
Java代码
package javax.servlet; //Tomcat源码版本：6.0.20
import java.io.IOException;
public interface Servlet {
//负责初始化Servlet对象。容器一旦创建好Servlet对象后，就调用此方法来初始化Servlet对象
public void init(ServletConfig config) throws ServletException;
//方法负责响应客户的请求,提供服务。当容器接收到客户端要求访问特定的servlet请求时，就会调用Servlet的service方法
public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException;
//Destroy()方法负责释放Servlet 对象占用的资源，当servlet对象结束生命周期时，servlet容器调用此方法来销毁servlet对象.
public void destroy();
// 说明：Init(),service(),destroy() 这三个方法是Servlet生命周期中的最重要的三个方法。
// 返回一个字符串，在该字符串中包含servlet的创建者，版本和版权等信息
public String getServletInfo();
// GetServletConfig: 返回一个ServletConfig对象，该对象中包含了Servlet初始化参数信息
public ServletConfig getServletConfig();
}
GenericServlet抽象类实现了Servlet接口，它只是通用的实现，与任何网络应用层协议无关。
同时，HttpServlet这个抽象类继承了GenericServlet抽象类，在Http协议上提供了通用的实现
查看GenericSerlvet抽象类源码：
Java代码
//抽象类GenericServlet实现了Servlet接口的同时，也实现了ServletConfig接口和Serializable这两个接口
public abstract class GenericServlet
implements Servlet, ServletConfig, java.io.Serializable {
//私有变量，保存 init()传入的ServletConfig对象的引用
private transient ServletConfig config;
//无参的构造方法
public GenericServlet() { }
------------------------------------
以下方法实现了servlet接口中的5个方法
实现Servlet接口方法开始
------------------------------------
// 实现接口Servlet中的带参数的init(ServletConfig Config)方法，将传递的ServletConfig对象的引用保存到私有成员变量中， 通过含参的init方法实现组合注入 然后通过无参的init方法初始化
使得GenericServlet对象和一个ServletConfig对象关联.
同时它也调用了自身的不带参数的init()方法
public void init(ServletConfig config) throws ServletException {
this.config = config;
this.init(); //调用了无参的 init()方法
}
//无参的init()方法
public void init() throws ServletException {}
//空实现了destroy方法
public void destroy() { }
//实现了接口中的getServletConfig方法，返回ServletConfig对象
public ServletConfig getServletConfig()
{ return config; }
//该方法实现接口<Servlet>中的ServletInfo，默认返回空字符串
public String getServletInfo() {
return ""; }
//唯一没有实现的抽象方法service()，仅仅在此声明。交由子类去实现具体的应用
//在后来的HttpServlet抽象类中，针对当前基于Http协议的Web开发，HttpServlet抽象类具体实现了这个方法
//若有其他的协议，直接继承本类后实现相关协议即可，具有很强的扩展性
public abstract void service(ServletRequest req, ServletResponse res)
throws ServletException, IOException;
------------------------------------
实现Servlet接口方法结束
------------------------------------
---------------------------------------------
*以下四个方法实现了接口ServletConfig中的方法
实现ServletConfig接口开始
---------------------------------------------
*/
//该方法实现了接口<ServletConfig>中的getServletContext方法，用于返回servleConfig对象中所包含的servletContext方法
public ServletContext getServletContext() {
return getServletConfig().getServletContext();
}
//获取初始化参数
public String getInitParameter(String name) {
return getServletConfig().getInitParameter(name);
}
//实现了接口<ServletConfig>中的方法，用于返回在web.xml文件中为servlet所配置的全部的初始化参数的值
public Enumeration getInitParameterNames() {
return getServletConfig().getInitParameterNames();
//获取在web.xml文件中注册的当前的这个servlet名称。没有在web.xml 中注册的servlet，该方法直接放回该servlet的类名。
//法实现了接口<ServleConfig>中的getServletName方法
public String getServletName() {
return config.getServletName();
}
---------------------------------------------
实现ServletConfig接口结束
---------------------------------------------
public void log(String msg) {
getServletContext().log(getServletName() + ": "+ msg);
}
public void log(String message, Throwable t) {
getServletContext().log(getServletName() + ": " + message, t);
}
}
HttpServlet是继承了GenericServlet抽象类的一个抽象类，但是他的里面并没有任何抽象方法，这就是说他并不会强迫我们去做什么。我们只是按需选择，重写HttpServlet中的的部分方法就可以了。
下面是抽象类HttpServlet的源码：
Java代码
public abstract class HttpServlet extends GenericServlet
implements java.io.Serializable
{
private static final String METHOD_GET = "GET";
private static final String METHOD_POST = "POST";
......
* Does nothing, because this is an abstract class.
* 抽象类HttpServlet有一个构造函数，但是空的，什么都没有
public HttpServlet() { }
/*分别执行doGet,doPost,doOpitions,doHead,doPut,doTrace方法
在请求响应服务方法service()中，根据请求类型，分贝调用这些doXXXX方法
所以自己写的Servlet只需要根据请求类型覆盖响应的doXXX方法即可。
*/
//doXXXX方法开始
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(HttpServletResponse.SC_METHOD_NOT_ALLOWED, msg);
} else {
resp.sendError(HttpServletResponse.SC_BAD_REQUEST, msg);
}
}
protected void doHead(HttpServletRequest req, HttpServletResponse resp)
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(HttpServletResponse.SC_METHOD_NOT_ALLOWED, msg);
} else {
resp.sendError(HttpServletResponse.SC_BAD_REQUEST, msg);
}
}
protected void doPut(HttpServletRequest req, HttpServletResponse resp)
protected void doOptions(HttpServletRequest req, HttpServletResponse resp)
protected void doTrace(HttpServletRequest req, HttpServletResponse resp)
protected void doDelete(HttpServletRequest req, HttpServletResponse resp)
//doXXXX方法结束
//重载的service(args0,args1)方法
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);
}
}
//实现父类的service(ServletRequest req,ServletResponse res)方法
//通过参数的向下转型，然后调用重载的service(HttpservletRequest,HttpServletResponse)方法
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); //调用重载的service()方法
}
......//其他方法
}
值得一说的是，很多介绍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代码
public void init(ServletConfig config) throws ServletException
{
this.config = config; //将容器创建的servletConfig 对象传入，并使用私有成员变量引用该servletConfig对象
this.init();
}
通过以上的初始化步骤建立了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代码
/*
* 本程序代码演示了Servlet周期中init()、serveic()、destroy() 三个方法的调用的情况
* Author: Laurence Luo
* Date; 2009-10-21
package com.longweir;
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
public class LifeServlet extends HttpServlet
{
private int initvar=0;
private int servicevar=0;
private int destroyvar=0;
private String name;
//覆盖父类的销毁方法，加入销毁的计数器
public void destroy()
{
destroyvar++;
System.out.println(name+">destroy()被销毁了"+destroyvar+"次");
}
//覆盖父类的init(ServletConfig config)方法 加入计数
/* public void init(ServletConfig config) throws ServletException
{
super.init(config); //调用父类的带参数的init方法
name=config.getServletName();
initvar++;
System.out.println(name+">init():Servlet 被初始化了"+initvar+"次");
}*/
/* 根据分析GenericServlet的源码，其init(ServletConfig config)方法最终还是会调用了不带参数的init()方法，
* 所以也可以在自己编写的的servlet中覆盖不带参数的init()方法来加入统计计数
*/
public void init() //覆盖父类的不带参数的初始化方法
{
initvar++;
//name=getServleConfig.getServletNmae();
name=getServletName(); //直接返回
System.out.println(name+"init(): servlet被初始化了了 "+initvar+"次");
}
*/
public void service(HttpServletRequest request,HttpServletResponse response) throws ServletException,IOException
{
servicevar++; //请求服务计数器自增
System.out.println(name+">service():servlet共响应了"+servicevar+"请求");
String content1="初始化次数: "+initvar;
String content2="销毁次数： "+destroyvar;
String content3="请求服务次数 "+servicevar;
response.setContentType("text/html;charset=GBK");
PrintWriter out=response.getWriter();
out.print("<html><head><title>LifeServlet</title></head>");
out.print("<body>");
out.print("<h1>"+content1+"</h1><br>");
out.print("<h1>"+content2+"</h1><br>");
out.print("<h1>"+content3+"</h1><br>");
out.print("</body>");
out.print("</head>");
out.close();
}
}
之前提到servlet 生命周期中的三个阶段，第一个阶段中servlet容器会执行init方法来初始化一个servlet.
init方法和destroy这两个方法在servlet生命周期中之执行一次。servlet容器（或者说是servlet引擎)创建了servlet实例对象后立即调用该init方法。
Init方法是在servlet对象被创建后，再由servlet容器调用的方法，其执行位于构造方法之后，在执行init方法时，会传递一个serveltConfig对象。
所以，如果要在初始代码中用到servletConfig对象，则这些初始操作只能在init方法中编写，不能在构造方法中编写.
Java代码
GenericServlet中关于init方法的示意源码：
public void init(ServletConfig config) throws ServletException
{
this.config=config;
......
}
如果在要在自己编写的servlet类中增加一些额外的初始化功能，则必须覆盖GenricServlet类的init(ServletConfig config)方法，如果覆盖后，父类的init(ServletConfig config)方法就不会被调用。GenericServlet类中有些方法依赖init方法执行的结果，例如
Java代码
getServletName()方法：
public ServletContext getServeltContext()
{
return config.getServletContext;
}
这里的config对象的引用就来自Init(ServletConfig config)执行的结果.
所以如果子类需要覆盖父类的init(ServletConfig config)方法，则首先要调用父类的init(ServletConfig config)方法，也就是先加入 super.init(config) 语句来先执行父类的方法.否则，会产生空指针异常 java.lang.NullPointerException ，因为config对象的引用为空。
为了避免这样的情况的产生，GenericServlet的设计人员 在GenericServlet中又定义了一个无参数的init()空方法. 且在init(servletConfig config)方法最后也调用了这个无参的空方法
Java代码
public void init(ServletConfig config) throws ServletException
{
this.config=config;
init();
}
所以，我们只需覆盖这个无参的init方法加入自己的初始代码即可，而无需覆盖带参数的父类的init方法.
如果有多个重载的init方法，对以servlet而言，servlet容器始终就之调用servlet接口中的那个方法：init(ServletConfig config) (当然也会执行已经覆盖的无参的init()方法)，其他的覆盖的init方法不会执行。
分析 2中关于servlet生命周期的那个例子程序中的一个代码：
Java代码
//覆盖父类的init(ServletConfig config)方法 加入计数
public void init(ServletConfig config) throws ServletException
{
super.init(config); //调用父类的init方法
name=config.getServletName();
initvar++;
System.out.println(name+">init():Servlet 被初始化了"+initvar+"次");
}
/* 父类的带参数的init(ServletConfig config)方法最终还是会调用了不带参数的init()方法，
* 所以也可以在自己的servlet中覆盖不带参数的init()方法来加入自己的统计参数代码
*/
public void init() //覆盖父类的不带参数的初始化方法
{
//name=getServleConfig.getServletNmae(); //因为已经实现了servletConfig接口，则直接调用其方法即可
name=getServletName(); //直接返回
initvar++;
System.out.println(name+"init(): servlet被初始化了了 "+initvar+"次");
}
观察GenericServlet源码中关于service()方法的实现:
Java代码
//实现父类的service(ServletRequest req,ServletResponse res)方法
//通过参数的向下转型，然后调用重载的service(HttpservletRequest,HttpServletResponse)方法
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); //调用重载的service(HttpServelertRequest,HttpServletResponse)方法
}
//重载的service(HttpServletRequest req, HttpServletResponse resp)方法
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);
}
}
在抽象类中GenericServlet中service()是一个抽象方法,但在HttpServlet中对这个方法进行了实现。
servlet接口中定义的service()方法中的两个参数分别是servletRequest 和 ServletResponse 这两个类型。当前的http请求，如果需要在这个service()方法内部使用http消息特有的功能，也就是要调用HttpServletRequest 和HttpServletResponse来中定义的方法时，需要将请求和响应对象进行一个类型的转换，所以,在GenericServlet中，使用了两个方法来共同完成这个工作。
实现父类GenericServlet中的service(ServltRequest req,ServeltResponse res)抽象方法
Java代码
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); //这里是调用重载的service(HttpServelertRequest,HttpServletResponse)方法
}
service(HttpServelertRequest,HttpServletResponse)方法：
//重载的service(HttpServletRequest req, HttpServletResponse resp)方法 ，注意参数类型
Java代码
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);
}
}
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 虚函数的实现原理--c++虚函数表解析
- c#操作JSON
- 智能指针用法
- 【SDOI2010】【BZOJ1925】地精部落
- Android Studio 很耗内存的问题
- 五年磨一剑：Java 开源博客 Solo 1.0.0 发布了！
- Oracle锁表
- 优化的8大核心策略影响SEO关键词排名
- Kafka协议翻译
- Git分支 - 创建，切换
- Oracle笔记——DDL
- Qt5常用依赖库
- OC-继承，多态，self,super
- android gps开发必备资料
- BMFont 自定义字体 数字图片 文字图片 制作成字体
- java解惑之try catch finally
- jar包中初始化Spring环境，报错找不到applicationContext.xml
- CommonAdapter-万能的ListView.GridView的适配器
- 小甲鱼Python笔记（下）
- MVC中TextBox事件