Servlet的源码分析

<dependencies>
	<!-- servlet开发规范 -->
		<!-- https://mvnrepository.com/artifact/javax.servlet/servlet-api -->
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>servlet-api</artifactId>
			<version>2.5</version>
			<scope>provided</scope>
		</dependency>
	</dependencies>

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();
}

public interface ServletConfig {

//用于获取Servlet 名,web.xml 中定义的servlet-name
String getServletName();


//获取Servlet 上下文对象(非常重要)
ServletContext getServletContext();


//获取init-param 中的配置参数
String getInitParameter(String var1);


//获取配置的所有init-param 名字集合
Enumeration<String> getInitParameterNames();
}

/**
	 *ServletConfig 获取的是局部变量的方法
	 */
	@Override
	public void init(ServletConfig config) throws ServletException {
		String value1 = config.getInitParameter("key1");
		
	}

	/**
	 *ServletConfig 获取的是局部变量的方法
	 *getServletContext 获取的是全局的变量
	 */
	@Override
	public void init(ServletConfig config) throws ServletException {
		String value1 = config.getInitParameter("key1");
		String value= config.getServletContext().getInitParameter("key");
	}

// 抽象类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 对象的引用保存到私有成员变量中，
使得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);
}
}

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)
throws ServletException, IOException{
.......
}


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)
throws ServletException, IOException {
//todo
}
protected void doOptions(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
//todo
}
protected void doTrace(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
//todo
}
protected void doDelete(HttpServletRequest req,
HttpServletResponse resp)
throws ServletException, IOException {
//todo
}


//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()方法
}
......//其他方法
}

public class TestOverride {
    public static void main(String[] args) {
        Vehicle v1 = new Vehicle();
        Vehicle v2 = new Horse();
        Vehicle v3 = new Plane();
        v1.run();
        v2.run();
        v3.run();
        v2.stop();
        v3.stop();
    }
}
 
class Vehicle { // 交通工具类
    public void run() {
        System.out.println("跑....");
    }
    public void stop() {
        System.out.println("停止不动");
    }
}
class Horse extends Vehicle { // 马也是交通工具
    public void run() { // 重写父类方法
        System.out.println("四蹄翻飞，嘚嘚嘚...");
    }
}
 
class Plane extends Vehicle {
    public void run() { // 重写父类方法
        System.out.println("天上飞！");
    }
    public void stop() {
        System.out.println("空中不能停，坠毁了！");
    }
}