Servlet源码

布满荆棘的人生 2024-02-18 15:10 44阅读 0赞

**顶级接口:Servlet:**

package javax.servlet;  
  
  
import java.io.IOException;  
  
  
  
  
public interface Servlet \{  
  
  
  
public void init(ServletConfig config) throws ServletException;  
  
public ServletConfig getServletConfig();  
  
public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException;  
  
public String getServletInfo();  
  
public void destroy();  
\}

**GenericServlet抽象类:**

package javax.servlet;  
  
  
import java.io.IOException;  
import java.util.Enumeration;  
  
  
public abstract class GenericServlet implements Servlet, ServletConfig,  
java.io.Serializable \{  
  
  
private static final long serialVersionUID = 1L;  
  
  
private transient ServletConfig config;  
  
@Override  
public void init(ServletConfig config) throws ServletException \{  
this.config = config;  
this.init();  
\}  
  
public void init() throws ServletException \{  
// NOOP by default  
\}  
  
@Override  
public abstract void service(ServletRequest req, ServletResponse res) throws ServletException, IOException;  
  
@Override  
public ServletConfig getServletConfig() \{  
return config;  
\}  
  
@Override  
public String getServletInfo() \{  
return "";  
\}  
  
@Override  
public void destroy() \{  
// NOOP by default  
\}  
  
  
public GenericServlet() \{  
// NOOP  
\}  
@Override  
public String getInitParameter(String name) \{  
return getServletConfig().getInitParameter(name);  
\}  
@Override  
public Enumeration<String> getInitParameterNames() \{  
return getServletConfig().getInitParameterNames();  
\}  
public void log(String msg) \{  
getServletContext().log(getServletName() + ": " + msg);  
\}  
public void log(String message, Throwable t) \{  
getServletContext().log(getServletName() + ": " + message, t);  
\}  
@Override  
public String getServletName() \{  
return config.getServletName();  
\}  
@Override  
public ServletContext getServletContext() \{  
return getServletConfig().getServletContext();  
\}  
\}

**HttpServlet:**

package javax.servlet.http;  
  
  
import java.io.IOException;  
import java.io.OutputStreamWriter;  
import java.io.PrintWriter;  
import java.io.UnsupportedEncodingException;  
import java.lang.reflect.Method;  
import java.text.MessageFormat;  
import java.util.Enumeration;  
import java.util.ResourceBundle;  
import javax.servlet.DispatcherType;  
import javax.servlet.GenericServlet;  
import javax.servlet.ServletException;  
import javax.servlet.ServletOutputStream;  
import javax.servlet.ServletRequest;  
import javax.servlet.ServletResponse;  
  
  
public abstract class HttpServlet extends GenericServlet \{  
  
  
private static final long serialVersionUID = 1L;  
private static final String METHOD\_DELETE = "DELETE";  
private static final String METHOD\_HEAD = "HEAD";  
private static final String METHOD\_GET = "GET";  
private static final String METHOD\_OPTIONS = "OPTIONS";  
private static final String METHOD\_POST = "POST";  
private static final String METHOD\_PUT = "PUT";  
private static final String METHOD\_TRACE = "TRACE";  
private static final String HEADER\_IFMODSINCE = "If-Modified-Since";  
private static final String HEADER\_LASTMOD = "Last-Modified";  
private static final String LSTRING\_FILE =  
"javax.servlet.http.LocalStrings";  
private static ResourceBundle lStrings =  
ResourceBundle.getBundle(LSTRING\_FILE);  
  
public HttpServlet() \{  
// NOOP  
\}  
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 long getLastModified(HttpServletRequest req) \{  
return -1;  
\}  
protected void doHead(HttpServletRequest req, HttpServletResponse resp)  
throws ServletException, IOException \{  
  
  
if (DispatcherType.INCLUDE.equals(req.getDispatcherType())) \{  
doGet(req, resp);  
\} else \{  
NoBodyResponse response = new NoBodyResponse(resp);  
doGet(req, response);  
response.setContentLength();  
\}  
\}  
protected void doPost(HttpServletRequest req, HttpServletResponse resp)  
throws ServletException, IOException \{  
  
  
String protocol = req.getProtocol();  
String msg = lStrings.getString("http.method\_post\_not\_supported");  
if (protocol.endsWith("1.1")) \{  
resp.sendError(HttpServletResponse.SC\_METHOD\_NOT\_ALLOWED, msg);  
\} else \{  
resp.sendError(HttpServletResponse.SC\_BAD\_REQUEST, msg);  
\}  
\}  
protected void doPut(HttpServletRequest req, HttpServletResponse resp)  
throws ServletException, IOException \{  
  
  
String protocol = req.getProtocol();  
String msg = lStrings.getString("http.method\_put\_not\_supported");  
if (protocol.endsWith("1.1")) \{  
resp.sendError(HttpServletResponse.SC\_METHOD\_NOT\_ALLOWED, msg);  
\} else \{  
resp.sendError(HttpServletResponse.SC\_BAD\_REQUEST, msg);  
\}  
\}  
protected void doDelete(HttpServletRequest req,  
HttpServletResponse resp)  
throws ServletException, IOException \{  
  
  
String protocol = req.getProtocol();  
String msg = lStrings.getString("http.method\_delete\_not\_supported");  
if (protocol.endsWith("1.1")) \{  
resp.sendError(HttpServletResponse.SC\_METHOD\_NOT\_ALLOWED, msg);  
\} else \{  
resp.sendError(HttpServletResponse.SC\_BAD\_REQUEST, msg);  
\}  
\}  
private static Method\[\] getAllDeclaredMethods(Class<?> c) \{  
  
  
if (c.equals(javax.servlet.http.HttpServlet.class)) \{  
return null;  
\}  
Method\[\] parentMethods = getAllDeclaredMethods(c.getSuperclass());  
Method\[\] thisMethods = c.getDeclaredMethods();  
  
  
if ((parentMethods != null) && (parentMethods.length > 0)) \{  
Method\[\] allMethods =  
new Method\[parentMethods.length + thisMethods.length\];  
System.arraycopy(parentMethods, 0, allMethods, 0,  
parentMethods.length);  
System.arraycopy(thisMethods, 0, allMethods, parentMethods.length,  
thisMethods.length);  
  
  
thisMethods = allMethods;  
\}  
  
  
return thisMethods;  
\}  
protected void doOptions(HttpServletRequest req,  
HttpServletResponse resp)  
throws ServletException, IOException \{  
  
  
Method\[\] methods = getAllDeclaredMethods(this.getClass());  
  
  
boolean ALLOW\_GET = false;  
boolean ALLOW\_HEAD = false;  
boolean ALLOW\_POST = false;  
boolean ALLOW\_PUT = false;  
boolean ALLOW\_DELETE = false;  
boolean ALLOW\_TRACE = true;  
boolean ALLOW\_OPTIONS = true;  
for (int i=0; i<methods.length; i++) \{  
Method m = methods\[i\];  
  
  
if (m.getName().equals("doGet")) \{  
ALLOW\_GET = true;  
ALLOW\_HEAD = true;  
\}  
if (m.getName().equals("doPost"))  
ALLOW\_POST = true;  
if (m.getName().equals("doPut"))  
ALLOW\_PUT = true;  
if (m.getName().equals("doDelete"))  
ALLOW\_DELETE = true;  
\}  
  
  
String allow = null;  
if (ALLOW\_GET)  
allow=METHOD\_GET;  
if (ALLOW\_HEAD)  
if (allow==null) allow=METHOD\_HEAD;  
else allow += ", " + METHOD\_HEAD;  
if (ALLOW\_POST)  
if (allow==null) allow=METHOD\_POST;  
else allow += ", " + METHOD\_POST;  
if (ALLOW\_PUT)  
if (allow==null) allow=METHOD\_PUT;  
else allow += ", " + METHOD\_PUT;  
if (ALLOW\_DELETE)  
if (allow==null) allow=METHOD\_DELETE;  
else allow += ", " + METHOD\_DELETE;  
if (ALLOW\_TRACE)  
if (allow==null) allow=METHOD\_TRACE;  
else allow += ", " + METHOD\_TRACE;  
if (ALLOW\_OPTIONS)  
if (allow==null) allow=METHOD\_OPTIONS;  
else allow += ", " + METHOD\_OPTIONS;  
  
  
resp.setHeader("Allow", allow);  
\}  
protected void doTrace(HttpServletRequest req, HttpServletResponse resp)  
throws ServletException, IOException  
\{  
int responseLength;  
  
  
String CRLF = "\\r\\n";  
StringBuilder buffer = new StringBuilder("TRACE ").append(req.getRequestURI())  
.append(" ").append(req.getProtocol());  
  
  
Enumeration<String> reqHeaderEnum = req.getHeaderNames();  
  
  
while( reqHeaderEnum.hasMoreElements() ) \{  
String headerName = reqHeaderEnum.nextElement();  
buffer.append(CRLF).append(headerName).append(": ")  
.append(req.getHeader(headerName));  
\}  
buffer.append(CRLF);  
  
  
responseLength = buffer.length();  
  
  
resp.setContentType("message/http");  
resp.setContentLength(responseLength);  
ServletOutputStream out = resp.getOutputStream();  
out.print(buffer.toString());  
out.close();  
return;  
\}  
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) \{  
doGet(req, resp);  
\} else \{  
long ifModifiedSince;  
try \{  
ifModifiedSince = req.getDateHeader(HEADER\_IFMODSINCE);  
\} catch (IllegalArgumentException iae) \{  
ifModifiedSince = -1;  
\}  
if (ifModifiedSince < (lastModified / 1000 \* 1000)) \{  
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 \{  
  
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);  
\}  
\}  
private void maybeSetLastModified(HttpServletResponse resp,  
long lastModified) \{  
if (resp.containsHeader(HEADER\_LASTMOD))  
return;  
if (lastModified >= 0)  
resp.setDateHeader(HEADER\_LASTMOD, lastModified);  
\}  
@Override  
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);  
\}  
\}  
class NoBodyResponse extends HttpServletResponseWrapper \{  
private NoBodyOutputStream noBody;  
private PrintWriter writer;  
private boolean didSetContentLength;  
  
  
  
NoBodyResponse(HttpServletResponse r) \{  
super(r);  
noBody = new NoBodyOutputStream();  
\}  
void setContentLength() \{  
if (!didSetContentLength) \{  
if (writer != null) \{  
writer.flush();  
\}  
super.setContentLength(noBody.getContentLength());  
\}  
\}  
@Override  
public void setContentLength(int len) \{  
super.setContentLength(len);  
didSetContentLength = true;  
\}  
@Override  
public void setHeader(String name, String value) \{  
super.setHeader(name, value);  
checkHeader(name);  
\}  
@Override  
public void addHeader(String name, String value) \{  
super.addHeader(name, value);  
checkHeader(name);  
\}  
@Override  
public void setIntHeader(String name, int value) \{  
super.setIntHeader(name, value);  
checkHeader(name);  
\}  
@Override  
public void addIntHeader(String name, int value) \{  
super.addIntHeader(name, value);  
checkHeader(name);  
\}  
private void checkHeader(String name) \{  
if ("content-length".equalsIgnoreCase(name)) \{  
didSetContentLength = true;  
\}  
\}  
@Override  
public ServletOutputStream getOutputStream() throws IOException \{  
return noBody;  
\}  
@Override  
public PrintWriter getWriter() throws UnsupportedEncodingException \{  
  
  
if (writer == null) \{  
OutputStreamWriter w;  
  
  
w = new OutputStreamWriter(noBody, getCharacterEncoding());  
writer = new PrintWriter(w);  
\}  
return writer;  
\}  
\}  
class NoBodyOutputStream extends ServletOutputStream \{  
  
  
private static final String LSTRING\_FILE =  
"javax.servlet.http.LocalStrings";  
private static ResourceBundle lStrings =  
ResourceBundle.getBundle(LSTRING\_FILE);  
  
  
private int contentLength = 0;  
NoBodyOutputStream() \{  
  
\}  
int getContentLength() \{  
return contentLength;  
\}  
@Override  
public void write(int b) \{  
contentLength++;  
\}  
@Override  
public void write(byte buf\[\], int offset, int len) throws IOException \{  
if (buf == null) \{  
throw new NullPointerException(  
lStrings.getString("err.io.nullArray"));  
\}  
  
  
if (offset < 0 || len < 0 || offset+len > buf.length) \{  
String msg = lStrings.getString("err.io.indexOutOfBounds");  
Object\[\] msgArgs = new Object\[3\];  
msgArgs\[0\] = Integer.valueOf(offset);  
msgArgs\[1\] = Integer.valueOf(len);  
msgArgs\[2\] = Integer.valueOf(buf.length);  
msg = MessageFormat.format(msg, msgArgs);  
throw new IndexOutOfBoundsException(msg);  
\}  
contentLength += len;  
\}  
\}