Java-HttpServlet

/**
 *
 * 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>XXX</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.
 * @author	Various
 * @version	$Version$
 */

public abstract class HttpServlet extends GenericServlet
    implements java.io.Serializable
{
    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);
    /**
     * Does nothing, because this is an abstract class.
     */
    //抽象类构造函数
    public HttpServlet() { }
    /**
     * 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
     */
    //服务器调用，获得一个Get请求
    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 clien
     * @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
    {
    	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)
		    if (allow==null) 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";
		String responseString = "TRACE "+ req.getRequestURI()+
		    " " + req.getProtocol();
		Enumeration reqHeaderEnum = req.getHeaderNames();
		while( reqHeaderEnum.hasMoreElements() ) {
		    String headerName = (String)reqHeaderEnum.nextElement();
		    responseString += CRLF + headerName + ": " +
			req.getHeader(headerName);
		}
		responseString += CRLF;
		responseLength = responseString.length();
		resp.setContentType("message/http");
		resp.setContentLength(responseLength);
		ServletOutputStream out = resp.getOutputStream();
		out.print(responseString);
		out.close();
		return;
    }
    /**
     * Receives standard HTTP requests from the public
     * <code>service</code> method and dispatches
     * them to the <code>do</code><i>XXX</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 = 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);
		}
    }
    /*
     * 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
     */

    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 that includes no body, 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 directly
 * to the HTTP Servlet Response object used to construct this one.
 */
// file private
class NoBodyResponse implements HttpServletResponse {
    private HttpServletResponse		resp;
    private NoBodyOutputStream		noBody;
    private PrintWriter			writer;
    private boolean			didSetContentLength;
    // file private
    NoBodyResponse(HttpServletResponse r) {
		resp = r;
		noBody = new NoBodyOutputStream();
    }
    // file private
    void setContentLength() {
	if (!didSetContentLength)
	  resp.setContentLength(noBody.getContentLength());
    }
    // SERVLET RESPONSE interface methods
    public void setContentLength(int len) {
	resp.setContentLength(len);
	didSetContentLength = true;
    }
    public void setCharacterEncoding(String charset)
      { resp.setCharacterEncoding(charset); }

    public void setContentType(String type)
      { resp.setContentType(type); }

    public String getContentType()
      { return resp.getContentType(); }

    public ServletOutputStream getOutputStream() throws IOException
      { return noBody; }

    public String getCharacterEncoding()
	{ return resp.getCharacterEncoding(); }

    public PrintWriter getWriter() throws UnsupportedEncodingException
    {
	if (writer == null) {
	    OutputStreamWriter	w;

	    w = new OutputStreamWriter(noBody, getCharacterEncoding());
	    writer = new PrintWriter(w);
	}
	return writer;
    }
    public void setBufferSize(int size) throws IllegalStateException
      { resp.setBufferSize(size); }

    public int getBufferSize()
      { return resp.getBufferSize(); }

    public void reset() throws IllegalStateException
      { resp.reset(); }

      public void resetBuffer() throws IllegalStateException
      { resp.resetBuffer(); }

    public boolean isCommitted()
      { return resp.isCommitted(); }

    public void flushBuffer() throws IOException
      { resp.flushBuffer(); }

    public void setLocale(Locale loc)
      { resp.setLocale(loc); }

    public Locale getLocale()
      { return resp.getLocale(); }
    // HTTP SERVLET RESPONSE interface methods
    public void addCookie(Cookie cookie)
      { resp.addCookie(cookie); }
    public boolean containsHeader(String name)
      { return resp.containsHeader(name); }
    /** @deprecated */
    public void setStatus(int sc, String sm)
      { resp.setStatus(sc, sm); }

    public void setStatus(int sc)
      { resp.setStatus(sc); }

    public void setHeader(String name, String value)
      { resp.setHeader(name, value); }

    public void setIntHeader(String name, int value)
      { resp.setIntHeader(name, value); }

    public void setDateHeader(String name, long date)
      { resp.setDateHeader(name, date); }

    public void sendError(int sc, String msg) throws IOException
      { resp.sendError(sc, msg); }

    public void sendError(int sc) throws IOException
      { resp.sendError(sc); }

    public void sendRedirect(String location) throws IOException
      { resp.sendRedirect(location); }

    public String encodeURL(String url)
      { return resp.encodeURL(url); }

    public String encodeRedirectURL(String url)
      { return resp.encodeRedirectURL(url); }

    public void addHeader(String name, String value)
      { resp.addHeader(name, value); }

    public void addDateHeader(String name, long value)
      { resp.addDateHeader(name, value); }

    public void addIntHeader(String name, int value)
      { resp.addIntHeader(name, value); }
    /**
     * @deprecated	As of Version 2.1, replaced by
     * 			{@link HttpServletResponse#encodeURL}.
     */
    public String encodeUrl(String url)
      { return this.encodeURL(url); }
    /**
     * @deprecated	As of Version 2.1, replaced by
     *			{@link HttpServletResponse#encodeRedirectURL}.
     */
    public String encodeRedirectUrl(String url)
      { return this.encodeRedirectURL(url); }

}
/*
 * Servlet output stream that gobbles up all its data.
 */
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;
    // file private
    NoBodyOutputStream() {}
    // file private
    int getContentLength() {
	return contentLength;
    }
    public void write(int b) {
	contentLength++;
    }
    public void write(byte buf[], int offset, int len)
	throws IOException
    {
	if (len >= 0) {
	    contentLength += len;
	} else {
	    // XXX
	    // isn't this really an IllegalArgumentException?
	    String msg = lStrings.getString("err.io.negativelength");
	    throw new IOException("negative length");
	}
    }
}