httpconnection.java

用于移动设备上的java虚拟机源代码

 *                 int actual = 0;
 *                 int bytesread = 0 ;
 *                 byte[] data = new byte[len];
 *                 while ((bytesread != len) && (actual != -1)) {
 *                    actual = is.read(data, bytesread, len - bytesread);
 *                    bytesread += actual;
 *                 }
 *                process(data);
 *            } else {
 *                int ch;
 *                while ((ch = is.read()) != -1) {
 *                    process((byte)ch);
 *                }
 *            }
 *        } catch (ClassCastException e) {
 *            throw new IllegalArgumentException("Not an HTTP URL");
 *        } finally {
 *            if (is != null)
 *                is.close();
 *            if (os != null)
 *                os.close();
 *            if (c != null)
 *                c.close();
 *        }
 *    }
 * </pre>
 * <hr>
 * <p>
 * <STRONG>Simplified Stream Methods on Connector</STRONG>
 * <p>
 * Please note the following: The
 * <code>Connector</code> class defines the following
 * convenience methods for retrieving an input or output stream directly
 * for a specified URL:
 *
 * <UL>
 * <LI> <CODE> InputStream openInputStream(String url) </CODE>
 * <LI> <CODE> DataInputStream openDataInputStream(String url) </CODE>
 * <LI> <CODE> OutputStream openOutputStream(String url) </CODE>
 * <LI> <CODE> DataOutputStream openDataOutputStream(String url) </CODE>
 * </UL>
 *
 * Please be aware that using these methods implies certain restrictions.
 * You will not get a reference to the actual connection, but rather just
 * references to the input or output stream of the connection. Not having
 * a reference to the connection means that you will not be able to manipulate
 * or query the connection directly. This in turn means that you will not
 * be able to call any of the following methods:
 *
 * <UL>
 * <LI> <CODE> getRequestMethod() </CODE>
 * <LI> <CODE> setRequestMethod() </CODE>
 * <LI> <CODE> getRequestProperty() </CODE>
 * <LI> <CODE> setRequestProperty() </CODE>
 * <LI> <CODE> getLength() </CODE>
 * <LI> <CODE> getType() </CODE>
 * <LI> <CODE> getEncoding() </CODE>
 * <LI> <CODE> getHeaderField() </CODE>
 * <LI> <CODE> getResponseCode() </CODE>
 * <LI> <CODE> getResponseMessage() </CODE>
 * <LI> <CODE> getHeaderFieldInt</CODE>
 * <LI> <CODE> getHeaderFieldDate</CODE>
 * <LI> <CODE> getExpiration</CODE>
 * <LI> <CODE> getDate</CODE>
 * <LI> <CODE> getLastModified</CODE>
 * <LI> <CODE> getHeaderField</CODE>
 * <LI> <CODE> getHeaderFieldKey</CODE>
 * </UL>
 * @since MIDP 1.0
 */

public interface HttpConnection extends ContentConnection {
    /** HTTP Head method. */
    public final static String HEAD = "HEAD";
    /** HTTP Get method. */
    public final static String GET = "GET";
    /** HTTP Post method. */
    public final static String POST = "POST";

    /** 2XX: generally "OK" */
    /** 200: The request has succeeded. */
    public static final int HTTP_OK = 200;

    /**
     * 201: The request has been fulfilled and resulted in a new
     * resource being created.
     */
    public static final int HTTP_CREATED = 201;

    /**
     * 202: The request has been accepted for processing, but the processing
     * has not been completed.
     */
    public static final int HTTP_ACCEPTED = 202;

    /**
     * 203: The returned meta-information in the entity-header is not the
     *  definitive set as available from the origin server.
     */
    public static final int HTTP_NOT_AUTHORITATIVE = 203;

    /**
     * 204:  The server has fulfilled the request but does not need to
     * return an entity-body, and might want to return updated
     * meta-information.
     */
    public static final int HTTP_NO_CONTENT = 204;

    /**
     * 205: The server has fulfilled the request and the user agent SHOULD reset
     *	the document view which caused the request to be sent.
     */
    public static final int HTTP_RESET = 205;

    /**
     *  206: The server has fulfilled the partial GET request for the resource.
     */
    public static final int HTTP_PARTIAL = 206;

    /** 3XX: relocation/redirect */

    /**
     * 300: The requested resource corresponds to any one of a set of
     *   representations, each with its own specific location, and agent-
     *   driven negotiation information is being provided so that
     *   the user (or user agent) can select a preferred representation and
     *   redirect its request to that location.
     */
    public static final int HTTP_MULT_CHOICE = 300;

    /**
     * 301:  The requested resource has been assigned a new permanent URI and
     *   any future references to this resource SHOULD use one of the returned
     *   URIs.
     */
    public static final int HTTP_MOVED_PERM = 301;

    /**
     * 302: The requested resource resides temporarily under a
     *   different URI. (<strong>Note:</strong> the name of this
     *   status code
     *   reflects the earlier publication of RFC2068, which
     *   was changed in RFC2616 from "moved temporalily" to
     *   "found". The semantics were not changed. The <code>Location</code>
     *   header indicates where the application should resend
     *   the request.)
     */
    public static final int HTTP_MOVED_TEMP = 302;

    /**
     * 303: The response to the request can be found under a different URI and
     *   SHOULD be retrieved using a GET method on that resource.
     */
    public static final int HTTP_SEE_OTHER = 303;

    /**
     * 304: If the client has performed a conditional GET request and access is
     *   allowed, but the document has not been modified, the server SHOULD
     *   respond with this status code.
     */
    public static final int HTTP_NOT_MODIFIED = 304;

    /**
     * 305: The requested resource MUST be accessed through the proxy given by
     *	the Location field.
     */
    public static final int HTTP_USE_PROXY = 305;

    /**
     * 307: The requested resource resides temporarily under a different
     *   URI.
     */
    public static final int HTTP_TEMP_REDIRECT = 307;

    /** 4XX: client error */
    /**
     * 400: The request could not be understood by the server due to malformed
     *   syntax.
     */
    public static final int HTTP_BAD_REQUEST = 400;

    /**
     * 401: The request requires user authentication. The response MUST
     *   include a WWW-Authenticate header field  containing a challenge
     *   applicable to the requested resource.
     */
    public static final int HTTP_UNAUTHORIZED = 401;

    /** 402: This code is reserved for future use. */
    public static final int HTTP_PAYMENT_REQUIRED = 402;

    /**
     * 403:  The server understood the request, but is refusing to fulfill it.
     *   Authorization will not help and the request SHOULD NOT be repeated.
     */
    public static final int HTTP_FORBIDDEN = 403;

    /**
     * 404: The server has not found anything matching the Request-URI. No
     *   indication is given of whether the condition is temporary or
     *   permanent.
     */
    public static final int HTTP_NOT_FOUND = 404;

    /**
     * 405: The method specified in the Request-Line is not allowed for the
     *	resource identified by the Request-URI.
     */
    public static final int HTTP_BAD_METHOD = 405;

    /**
     * 406: The resource identified by the request is only capable of generating
     *   response entities which have content characteristics not acceptable
     *   according to the accept headers sent in the request.
     */
    public static final int HTTP_NOT_ACCEPTABLE = 406;

    /**
     * 407: This code is similar to 401 (Unauthorized), but indicates that the
     *	client must first authenticate itself with the proxy.
     */
    public static final int HTTP_PROXY_AUTH = 407;

    /**
     * 408: The client did not produce a request within the time that the server
     *   was prepared to wait. The client MAY repeat the request without
     *   modifications at any later time.
     */
    public static final int HTTP_CLIENT_TIMEOUT = 408;

    /**
     * 409: The request could not be completed due to a conflict with
     * the current state of the resource.
     */
    public static final int HTTP_CONFLICT = 409;

    /**
     * 410: The requested resource is no longer available at the server and no
     *	forwarding address is known.
     */
    public static final int HTTP_GONE = 410;

    /**
     * 411: The server refuses to accept the request without a defined Content-
     *	Length.
     */
    public static final int HTTP_LENGTH_REQUIRED = 411;

    /**
     * 412: The precondition given in one or more of the request-header fields
     *	evaluated to false when it was tested on the server.
     */
    public static final int HTTP_PRECON_FAILED = 412;

    /**
     * 413: The server is refusing to process a request because the request
     *	entity is larger than the server is willing or able to process.
     */
    public static final int HTTP_ENTITY_TOO_LARGE = 413;

    /**
     * 414: The server is refusing to service the request because the
     * Request-URI is longer than the server is willing to interpret.
     */
    public static final int HTTP_REQ_TOO_LONG = 414;

    /**
     * 415: The server is refusing to service the request because the entity of
     *   the request is in a format not supported by the requested resource
     *   for the requested method.
     */
    public static final int HTTP_UNSUPPORTED_TYPE = 415;

    /**
     * 416: A server SHOULD return a response with this status code if a request
     *   included a Range request-header field , and none of
     *   the range-specifier values in this field overlap the current extent
     *   of the selected resource, and the request did not include an If-Range
     *   request-header field.
     */
    public static final int HTTP_UNSUPPORTED_RANGE = 416;

    /**
     * 417: The expectation given in an Expect request-header field
     *   could not be met by this server, or, if the server is a proxy,
     *   the server has unambiguous evidence that the request could not be met
     *   by the next-hop server.
     */
    public static final int HTTP_EXPECT_FAILED = 417;

    /** 5XX: server error */
    /**