httpServlet，GenericServlet，Servlet源码分析-白红宇

强烈建议你试试无所不能的chatGPT，快点击我

httpServlet，GenericServlet，Servlet源码分析

阅读量：5754 次

发布时间：2019-06-18

本文共 39940 字，大约阅读时间需要 133 分钟。

httpServlet源码:

[java]

/*

* Licensed to the Apache Software Foundation (ASF) under one or more

* contributor license agreements. See the NOTICE file distributed with

* this work for additional information regarding copyright ownership.

* The ASF licenses this file to You under the Apache License, Version 2.0

* (the "License"); you may not use this file except in compliance with

* the License. You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

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;

/**

* Provides an abstract class to be subclassed to create

* an HTTP servlet suitable for a Web site. A subclass of

* <code>HttpServlet</code> must override at least

* one method, usually one of these:

*

* <ul>

* <li> <code>doGet</code>, if the servlet supports HTTP GET requests

* <li> <code>doPost</code>, for HTTP POST requests

* <li> <code>doPut</code>, for HTTP PUT requests

* <li> <code>doDelete</code>, for HTTP DELETE requests

* <li> <code>init</code> and <code>destroy</code>,

* to manage resources that are held for the life of the servlet

* <li> <code>getServletInfo</code>, which the servlet uses to

* provide information about itself

* </ul>

*

* <p>There's almost no reason to override the <code>service</code>

* method. <code>service</code> handles standard HTTP

* requests by dispatching them to the handler methods

* for each HTTP request type (the <code>do</code><i>Method</i>

* methods listed above).

*

* <p>Likewise, there's almost no reason to override the

* <code>doOptions</code> and <code>doTrace</code> methods.

*

* <p>Servlets typically run on multithreaded servers,

* so be aware that a servlet must handle concurrent

* requests and be careful to synchronize access to shared resources.

* Shared resources include in-memory data such as

* instance or class variables and external objects

* such as files, database connections, and network

* connections.

* See the

* <a href="http://java.sun.com/Series/Tutorial/java/threads/multithreaded.html">

* Java Tutorial on Multithreaded Programming</a> for more

* information on handling multiple threads in a Java program.

*/

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 final ResourceBundle lStrings =

ResourceBundle.getBundle(LSTRING_FILE);

/**

* Does nothing, because this is an abstract class.

*/

public HttpServlet() {

// NOOP

}

/**

* Called by the server (via the <code>service</code> method) to

* allow a servlet to handle a GET request.

*

* <p>Overriding this method to support a GET request also

* automatically supports an HTTP HEAD request. A HEAD

* request is a GET request that returns no body in the

* response, only the request header fields.

*

* <p>When overriding this method, read the request data,

* write the response headers, get the response's writer or

* output stream object, and finally, write the response data.

* It's best to include content type and encoding. When using

* a <code>PrintWriter</code> object to return the response,

* set the content type before accessing the

* <code>PrintWriter</code> object.

*

* <p>The servlet container must write the headers before

* committing the response, because in HTTP the headers must be sent

* before the response body.

*

* <p>Where possible, set the Content-Length header (with the

* {@link javax.servlet.ServletResponse#setContentLength} method),

* to allow the servlet container to use a persistent connection

* to return its response to the client, improving performance.

* The content length is automatically set if the entire response fits

* inside the response buffer.

*

* <p>When using HTTP 1.1 chunked encoding (which means that the response

* has a Transfer-Encoding header), do not set the Content-Length header.

*

* <p>The GET method should be safe, that is, without

* any side effects for which users are held responsible.

* For example, most form queries have no side effects.

* If a client request is intended to change stored data,

* the request should use some other HTTP method.

*

* <p>The GET method should also be idempotent, meaning

* that it can be safely repeated. Sometimes making a

* method safe also makes it idempotent. For example,

* repeating queries is both safe and idempotent, but

* buying a product online or modifying data is neither

* safe nor idempotent.

*

* <p>If the request is incorrectly formatted, <code>doGet</code>

* returns an HTTP "Bad Request" message.

*

* @param req an {@link HttpServletRequest} object that

* contains the request the client has made

* of the servlet

*

* @param resp an {@link HttpServletResponse} object that

* contains the response the servlet sends

* to the client

*

* @exception IOException if an input or output error is

* detected when the servlet handles

* the GET request

*

* @exception ServletException if the request for the GET

* could not be handled

*

* @see javax.servlet.ServletResponse#setContentType

*/

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

}

}

/**

* Returns the time the <code>HttpServletRequest</code>

* object was last modified,

* in milliseconds since midnight January 1, 1970 GMT.

* If the time is unknown, this method returns a negative

* number (the default).

*

* <p>Servlets that support HTTP GET requests and can quickly determine

* their last modification time should override this method.

* This makes browser and proxy caches work more effectively,

* reducing the load on server and network resources.

*

* @param req the <code>HttpServletRequest</code>

* object that is sent to the servlet

*

* @return a <code>long</code> integer specifying

* the time the <code>HttpServletRequest</code>

* object was last modified, in milliseconds

* since midnight, January 1, 1970 GMT, or

* -1 if the time is not known

*/

protected long getLastModified(HttpServletRequest req) {

return -1;

}

/**

* <p>Receives an HTTP HEAD request from the protected

* <code>service</code> method and handles the

* request.

* The client sends a HEAD request when it wants

* to see only the headers of a response, such as

* Content-Type or Content-Length. The HTTP HEAD

* method counts the output bytes in the response

* to set the Content-Length header accurately.

*

* <p>If you override this method, you can avoid computing

* the response body and just set the response headers

* directly to improve performance. Make sure that the

* <code>doHead</code> method you write is both safe

* and idempotent (that is, protects itself from being

* called multiple times for one HTTP HEAD request).

*

* <p>If the HTTP HEAD request is incorrectly formatted,

* <code>doHead</code> returns an HTTP "Bad Request"

* message.

*

* @param req the request object that is passed to the servlet

*

* @param resp the response object that the servlet

* uses to return the headers to the client

*

* @exception IOException if an input or output error occurs

*

* @exception ServletException if the request for the HEAD

* could not be handled

*/

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

}

}

/**

* Called by the server (via the <code>service</code> method)

* to allow a servlet to handle a POST request.

*

* The HTTP POST method allows the client to send

* data of unlimited length to the Web server a single time

* and is useful when posting information such as

* credit card numbers.

*

* <p>When overriding this method, read the request data,

* write the response headers, get the response's writer or output

* stream object, and finally, write the response data. It's best

* to include content type and encoding. When using a

* <code>PrintWriter</code> object to return the response, set the

* content type before accessing the <code>PrintWriter</code> object.

*

* <p>The servlet container must write the headers before committing the

* response, because in HTTP the headers must be sent before the

* response body.

*

* <p>Where possible, set the Content-Length header (with the

* {@link javax.servlet.ServletResponse#setContentLength} method),

* to allow the servlet container to use a persistent connection

* to return its response to the client, improving performance.

* The content length is automatically set if the entire response fits

* inside the response buffer.

*

* <p>When using HTTP 1.1 chunked encoding (which means that the response

* has a Transfer-Encoding header), do not set the Content-Length header.

*

* <p>This method does not need to be either safe or idempotent.

* Operations requested through POST can have side effects for

* which the user can be held accountable, for example,

* updating stored data or buying items online.

*

* <p>If the HTTP POST request is incorrectly formatted,

* <code>doPost</code> returns an HTTP "Bad Request" message.

*

*

* @param req an {@link HttpServletRequest} object that

* contains the request the client has made

* of the servlet

*

* @param resp an {@link HttpServletResponse} object that

* contains the response the servlet sends

* to the client

*

* @exception IOException if an input or output error is

* detected when the servlet handles

* the request

*

* @exception ServletException if the request for the POST

* could not be handled

*

* @see javax.servlet.ServletOutputStream

* @see javax.servlet.ServletResponse#setContentType

*/

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

}

}

/**

* Called by the server (via the <code>service</code> method)

* to allow a servlet to handle a PUT request.

*

* The PUT operation allows a client to

* place a file on the server and is similar to

* sending a file by FTP.

*

* <p>When overriding this method, leave intact

* any content headers sent with the request (including

* Content-Length, Content-Type, Content-Transfer-Encoding,

* Content-Encoding, Content-Base, Content-Language, Content-Location,

* Content-MD5, and Content-Range). If your method cannot

* handle a content header, it must issue an error message

* (HTTP 501 - Not Implemented) and discard the request.

* For more information on HTTP 1.1, see RFC 2616

* <a href="http://www.ietf.org/rfc/rfc2616.txt"></a>.

*

* <p>This method does not need to be either safe or idempotent.

* Operations that <code>doPut</code> performs can have side

* effects for which the user can be held accountable. When using

* this method, it may be useful to save a copy of the

* affected URL in temporary storage.

*

* <p>If the HTTP PUT request is incorrectly formatted,

* <code>doPut</code> returns an HTTP "Bad Request" message.

*

* @param req the {@link HttpServletRequest} object that

* contains the request the client made of

* the servlet

*

* @param resp the {@link HttpServletResponse} object that

* contains the response the servlet returns

* to the client

*

* @exception IOException if an input or output error occurs

* while the servlet is handling the

* PUT request

*

* @exception ServletException if the request for the PUT

* cannot be handled

*/

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

}

}

/**

* Called by the server (via the <code>service</code> method)

* to allow a servlet to handle a DELETE request.

*

* The DELETE operation allows a client to remove a document

* or Web page from the server.

*

* <p>This method does not need to be either safe

* or idempotent. Operations requested through

* DELETE can have side effects for which users

* can be held accountable. When using

* this method, it may be useful to save a copy of the

* affected URL in temporary storage.

*

* <p>If the HTTP DELETE request is incorrectly formatted,

* <code>doDelete</code> returns an HTTP "Bad Request"

* message.

*

* @param req the {@link HttpServletRequest} object that

* contains the request the client made of

* the servlet

*

*

* @param resp the {@link HttpServletResponse} object that

* contains the response the servlet returns

* to the client

*

* @exception IOException if an input or output error occurs

* while the servlet is handling the

* DELETE request

*

* @exception ServletException if the request for the

* DELETE cannot be handled

*/

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;

}

/**

* Called by the server (via the <code>service</code> method)

* to allow a servlet to handle a OPTIONS request.

*

* The OPTIONS request determines which HTTP methods

* the server supports and

* returns an appropriate header. For example, if a servlet

* overrides <code>doGet</code>, this method returns the

* following header:

*

* <p><code>Allow: GET, HEAD, TRACE, OPTIONS</code>

*

* <p>There's no need to override this method unless the

* servlet implements new HTTP methods, beyond those

* implemented by HTTP 1.1.

*

* @param req the {@link HttpServletRequest} object that

* contains the request the client made of

* the servlet

*

* @param resp the {@link HttpServletResponse} object that

* contains the response the servlet returns

* to the client

*

* @exception IOException if an input or output error occurs

* while the servlet is handling the

* OPTIONS request

*

* @exception ServletException if the request for the

* OPTIONS cannot be handled

*/

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

}

/**

* Called by the server (via the <code>service</code> method)

* to allow a servlet to handle a TRACE request.

*

* A TRACE returns the headers sent with the TRACE

* request to the client, so that they can be used in

* debugging. There's no need to override this method.

*

* @param req the {@link HttpServletRequest} object that

* contains the request the client made of

* the servlet

*

* @param resp the {@link HttpServletResponse} object that

* contains the response the servlet returns

* to the client

*

* @exception IOException if an input or output error occurs

* while the servlet is handling the

* TRACE request

*

* @exception ServletException if the request for the

* TRACE cannot be handled

*/

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;

}

/**

* Receives standard HTTP requests from the public

* <code>service</code> method and dispatches

* them to the <code>do</code><i>Method</i> methods defined in

* this class. This method is an HTTP-specific version of the

* {@link javax.servlet.Servlet#service} method. There's no

* need to override this method.

*

* @param req the {@link HttpServletRequest} object that

* contains the request the client made of

* the servlet

*

* @param resp the {@link HttpServletResponse} object that

* contains the response the servlet returns

* to the client

*

* @exception IOException if an input or output error occurs

* while the servlet is handling the

* HTTP request

*

* @exception ServletException if the HTTP request

* cannot be handled

*

* @see javax.servlet.Servlet#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;

try {

ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);

} catch (IllegalArgumentException iae) {

// Invalid date header - proceed as if none was set

ifModifiedSince = -1;

}

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

}

}

/*

* Sets the Last-Modified entity header field, if it has not

* already been set and if the value is meaningful. Called before

* doGet, to ensure that headers are set before response data is

* written. A subclass might have set this header already, so we

* check.

*/

private void maybeSetLastModified(HttpServletResponse resp,

long lastModified) {

if (resp.containsHeader(HEADER_LASTMOD))

return;

if (lastModified >= 0)

resp.setDateHeader(HEADER_LASTMOD, lastModified);

}

/**

* Dispatches client requests to the protected

* <code>service</code> method. There's no need to

* override this method.

*

* @param req the {@link HttpServletRequest} object that

* contains the request the client made of

* the servlet

*

* @param res the {@link HttpServletResponse} object that

* contains the response the servlet returns

* to the client

*

* @exception IOException if an input or output error occurs

* while the servlet is handling the

* HTTP request

*

* @exception ServletException if the HTTP request cannot

* be handled

*

* @see javax.servlet.Servlet#service

*/

@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);

}

}

/*

* A response wrapper for use in (dumb) "HEAD" support.

* This just swallows that body, counting the bytes in order to set

* the content length appropriately. All other methods delegate to the

* wrapped HTTP Servlet Response object.

*/

// file private

class NoBodyResponse extends HttpServletResponseWrapper {

private final NoBodyOutputStream noBody;

private PrintWriter writer;

private boolean didSetContentLength;

// file private

NoBodyResponse(HttpServletResponse r) {

super(r);

noBody = new NoBodyOutputStream();

}

// file private

void setContentLength() {

if (!didSetContentLength) {

if (writer != null) {

writer.flush();

}

super.setContentLength(noBody.getContentLength());

}

}

// SERVLET RESPONSE interface methods

@Override

public void setContentLength(int len) {

super.setContentLength(len);

didSetContentLength = true;

}

@Override

public void setContentLengthLong(long len) {

super.setContentLengthLong(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;

}

}

/*

* Servlet output stream that gobbles up all its data.

*/

// file private

class NoBodyOutputStream extends ServletOutputStream {

private static final String LSTRING_FILE =

"javax.servlet.http.LocalStrings";

private static final ResourceBundle lStrings =

ResourceBundle.getBundle(LSTRING_FILE);

private int contentLength = 0;

// file private

NoBodyOutputStream() {

// NOOP

}

// file private

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;

}

@Override

public boolean isReady() {

// TODO SERVLET 3.1

return false;

}

@Override

public void setWriteListener(javax.servlet.WriteListener listener) {

// TODO SERVLET 3.1

}

}

GenericServlet源码:

[java]

/*

* Licensed to the Apache Software Foundation (ASF) under one or more

* contributor license agreements. See the NOTICE file distributed with

* this work for additional information regarding copyright ownership.

* The ASF licenses this file to You under the Apache License, Version 2.0

* (the "License"); you may not use this file except in compliance with

* the License. You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

package javax.servlet;

import java.io.IOException;

import java.util.Enumeration;

/**

* Defines a generic, protocol-independent servlet. To write an HTTP servlet for

* use on the Web, extend {@link javax.servlet.http.HttpServlet} instead.

* <p>

* <code>GenericServlet</code> implements the <code>Servlet</code> and

* <code>ServletConfig</code> interfaces. <code>GenericServlet</code> may be

* directly extended by a servlet, although it's more common to extend a

* protocol-specific subclass such as <code>HttpServlet</code>.

* <p>

* <code>GenericServlet</code> makes writing servlets easier. It provides simple

* versions of the lifecycle methods <code>init</code> and <code>destroy</code>

* and of the methods in the <code>ServletConfig</code> interface.

* <code>GenericServlet</code> also implements the <code>log</code> method,

* declared in the <code>ServletContext</code> interface.

* <p>

* To write a generic servlet, you need only override the abstract

* <code>service</code> method.

*/

public abstract class GenericServlet implements Servlet, ServletConfig,

java.io.Serializable {

private static final long serialVersionUID = 1L;

private transient ServletConfig config;

/**

* Does nothing. All of the servlet initialization is done by one of the

* <code>init</code> methods.

*/

public GenericServlet() {

// NOOP

}

/**

* Called by the servlet container to indicate to a servlet that the servlet

* is being taken out of service. See {@link Servlet#destroy}.

*/

@Override

public void destroy() {

// NOOP by default

}

/**

* Returns a <code>String</code> containing the value of the named

* initialization parameter, or <code>null</code> if the parameter does not

* exist. See {@link ServletConfig#getInitParameter}.

* <p>

* This method is supplied for convenience. It gets the value of the named

* parameter from the servlet's <code>ServletConfig</code> object.

*

* @param name

* a <code>String</code> specifying the name of the

* initialization parameter

* @return String a <code>String</code> containing the value of the

* initialization parameter

*/

@Override

public String getInitParameter(String name) {

return getServletConfig().getInitParameter(name);

}

/**

* Returns the names of the servlet's initialization parameters as an

* <code>Enumeration</code> of <code>String</code> objects, or an empty

* <code>Enumeration</code> if the servlet has no initialization parameters.

* See {@link ServletConfig#getInitParameterNames}.

* <p>

* This method is supplied for convenience. It gets the parameter names from

* the servlet's <code>ServletConfig</code> object.

*

* @return Enumeration an enumeration of <code>String</code> objects

* containing the names of the servlet's initialization parameters

*/

@Override

public Enumeration<String> getInitParameterNames() {

return getServletConfig().getInitParameterNames();

}

/**

* Returns this servlet's {@link ServletConfig} object.

*

* @return ServletConfig the <code>ServletConfig</code> object that

* initialized this servlet

*/

@Override

public ServletConfig getServletConfig() {

return config;

}

/**

* Returns a reference to the {@link ServletContext} in which this servlet

* is running. See {@link ServletConfig#getServletContext}.

* <p>

* This method is supplied for convenience. It gets the context from the

* servlet's <code>ServletConfig</code> object.

*

* @return ServletContext the <code>ServletContext</code> object passed to

* this servlet by the <code>init</code> method

*/

@Override

public ServletContext getServletContext() {

return getServletConfig().getServletContext();

}

/**

* Returns information about the servlet, such as author, version, and

* copyright. By default, this method returns an empty string. Override this

* method to have it return a meaningful value. See

* {@link Servlet#getServletInfo}.

*

* @return String information about this servlet, by default an empty string

*/

@Override

public String getServletInfo() {

return "";

}

/**

* Called by the servlet container to indicate to a servlet that the servlet

* is being placed into service. See {@link Servlet#init}.

* <p>

* This implementation stores the {@link ServletConfig} object it receives

* from the servlet container for later use. When overriding this form of

* the method, call <code>super.init(config)</code>.

*

* @param config

* the <code>ServletConfig</code> object that contains

* configuration information for this servlet

* @exception ServletException

* if an exception occurs that interrupts the servlet's

* normal operation

* @see UnavailableException

*/

@Override

public void init(ServletConfig config) throws ServletException {

this.config = config;

this.init();

}

/**

* A convenience method which can be overridden so that there's no need to

* call <code>super.init(config)</code>.

* <p>

* Instead of overriding {@link #init(ServletConfig)}, simply override this

* method and it will be called by

* <code>GenericServlet.init(ServletConfig config)</code>. The

* <code>ServletConfig</code> object can still be retrieved via

* {@link #getServletConfig}.

*

* @exception ServletException

* if an exception occurs that interrupts the servlet's

* normal operation

*/

public void init() throws ServletException {

// NOOP by default

}

/**

* Writes the specified message to a servlet log file, prepended by the

* servlet's name. See {@link ServletContext#log(String)}.

*

* @param msg

* a <code>String</code> specifying the message to be written to

* the log file

*/

public void log(String msg) {

getServletContext().log(getServletName() + ": " + msg);

}

/**

* Writes an explanatory message and a stack trace for a given

* <code>Throwable</code> exception to the servlet log file, prepended by

* the servlet's name. See {@link ServletContext#log(String, Throwable)}.

*

* @param message

* a <code>String</code> that describes the error or exception

* @param t

* the <code>java.lang.Throwable</code> error or exception

*/

public void log(String message, Throwable t) {

getServletContext().log(getServletName() + ": " + message, t);

}

/**

* Called by the servlet container to allow the servlet to respond to a

* request. See {@link Servlet#service}.

* <p>

* This method is declared abstract so subclasses, such as

* <code>HttpServlet</code>, must override it.

*

* @param req

* the <code>ServletRequest</code> object that contains the

* client's request

* @param res

* the <code>ServletResponse</code> object that will contain the

* servlet's response

* @exception ServletException

* if an exception occurs that interferes with the servlet's

* normal operation occurred

* @exception IOException

* if an input or output exception occurs

*/

@Override

public abstract void service(ServletRequest req, ServletResponse res)

throws ServletException, IOException;

/**

* Returns the name of this servlet instance. See

* {@link ServletConfig#getServletName}.

*

* @return the name of this servlet instance

*/

@Override

public String getServletName() {

return config.getServletName();

}

}

Servlet源码:

[java]

/*

* Licensed to the Apache Software Foundation (ASF) under one or more

* contributor license agreements. See the NOTICE file distributed with

* this work for additional information regarding copyright ownership.

* The ASF licenses this file to You under the Apache License, Version 2.0

* (the "License"); you may not use this file except in compliance with

* the License. You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

package javax.servlet;

import java.io.IOException;

/**

* Defines methods that all servlets must implement.

*

* <p>

* A servlet is a small Java program that runs within a Web server. Servlets

* receive and respond to requests from Web clients, usually across HTTP, the

* HyperText Transfer Protocol.

*

* <p>

* To implement this interface, you can write a generic servlet that extends

* <code>javax.servlet.GenericServlet</code> or an HTTP servlet that extends

* <code>javax.servlet.http.HttpServlet</code>.

*

* <p>

* This interface defines methods to initialize a servlet, to service requests,

* and to remove a servlet from the server. These are known as life-cycle

* methods and are called in the following sequence:

* <ol>

* <li>The servlet is constructed, then initialized with the <code>init</code>

* method.

* <li>Any calls from clients to the <code>service</code> method are handled.

* <li>The servlet is taken out of service, then destroyed with the

* <code>destroy</code> method, then garbage collected and finalized.

* </ol>

*

* <p>

* In addition to the life-cycle methods, this interface provides the

* <code>getServletConfig</code> method, which the servlet can use to get any

* startup information, and the <code>getServletInfo</code> method, which allows

* the servlet to return basic information about itself, such as author,

* version, and copyright.

*

* @see GenericServlet

* @see javax.servlet.http.HttpServlet

*/

public interface Servlet {

/**

* Called by the servlet container to indicate to a servlet that the servlet

* is being placed into service.

*

* <p>

* The servlet container calls the <code>init</code> method exactly once

* after instantiating the servlet. The <code>init</code> method must

* complete successfully before the servlet can receive any requests.

*

* <p>

* The servlet container cannot place the servlet into service if the

* <code>init</code> method

* <ol>

* <li>Throws a <code>ServletException</code>

* <li>Does not return within a time period defined by the Web server

* </ol>

*

*

* @param config

* a <code>ServletConfig</code> object containing the servlet's

* configuration and initialization parameters

*

* @exception ServletException

* if an exception has occurred that interferes with the

* servlet's normal operation

*

* @see UnavailableException

* @see #getServletConfig

*/

public void init(ServletConfig config) throws ServletException;

/**

*

* Returns a {@link ServletConfig} object, which contains initialization and

* startup parameters for this servlet. The <code>ServletConfig</code>

* object returned is the one passed to the <code>init</code> method.

*

* <p>

* Implementations of this interface are responsible for storing the

* <code>ServletConfig</code> object so that this method can return it. The

* {@link GenericServlet} class, which implements this interface, already

* does this.

*

* @return the <code>ServletConfig</code> object that initializes this

* servlet

*

* @see #init

*/

public ServletConfig getServletConfig();

/**

* Called by the servlet container to allow the servlet to respond to a

* request.

*

* <p>

* This method is only called after the servlet's <code>init()</code> method

* has completed successfully.

*

* <p>

* The status code of the response always should be set for a servlet that

* throws or sends an error.

*

*

* <p>

* Servlets typically run inside multithreaded servlet containers that can

* handle multiple requests concurrently. Developers must be aware to

* synchronize access to any shared resources such as files, network

* connections, and as well as the servlet's class and instance variables.

* More information on multithreaded programming in Java is available in <a

* href

* ="http://java.sun.com/Series/Tutorial/java/threads/multithreaded.html">

* the Java tutorial on multi-threaded programming</a>.

*

*

* @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

*

* @exception ServletException

* if an exception occurs that interferes with the servlet's

* normal operation

*

* @exception IOException

* if an input or output exception occurs

*/

public void service(ServletRequest req, ServletResponse res)

throws ServletException, IOException;

/**

* Returns information about the servlet, such as author, version, and

* copyright.

*

* <p>

* The string that this method returns should be plain text and not markup

* of any kind (such as HTML, XML, etc.).

*

* @return a <code>String</code> containing servlet information

*/

public String getServletInfo();

/**

* Called by the servlet container to indicate to a servlet that the servlet

* is being taken out of service. This method is only called once all

* threads within the servlet's <code>service</code> method have exited or

* after a timeout period has passed. After the servlet container calls this

* method, it will not call the <code>service</code> method again on this

* servlet.

*

* <p>

* This method gives the servlet an opportunity to clean up any resources

* that are being held (for example, memory, file handles, threads) and make

* sure that any persistent state is synchronized with the servlet's current

* state in memory.

*/

public void destroy();

}

转载地址：http://jmjkx.baihongyu.com/

你可能感兴趣的文章

LVS+Keepalived高可用负载均衡集群架构

烂泥：kvm安装windows系统蓝屏

iPhone开发面试题--葵花宝典

EdbMails Convert EDB to PST

大话程序猿眼里的接口

struts2用了哪几种模式

replace函数结合正则表达式实现转化成驼峰与转化成连接字符串的方法

ubuntu 初学常用命令

WCF客户端与服务端通信简单入门教程

判断是否含有中文

android 资源种类及使用

Explorer程序出错

Centos7同时运行多个Tomcat

使用CocoaPods过程中的几个问题

我的友情链接

mysql数据类型---数值型---int

为eclipse安装maven插件

公司新年第一次全员大会小记

最懒的程序员

喝酒易醉，品茶养心，人生如梦，品茶悟道，何以解忧？唯有杜康！-- 愿君每日到此一游！

当前时间: 2024-12-19 22:48:54 当前IP: 18.218.47.83 联系邮箱:javaeecc@qq.com Copyright © 2020 - 2022 baihongyu.com 京ICP备2021015314号-2

强烈建议你试试无所不能的CHAT-GPT，快点击我

强烈建议你试试无所不能的CHAT-GPT，快点击我