public interface HttpConnection extends ContentConnection
The URI format with scheme http
when passed to
Connector.open
will return a
HttpConnection
.
RFC 2616
defines the scheme.
HTTP is a request-response protocol in which the parameters of
request must be set before the request is sent.
The mode
parameter of Connector.open
is not used.
The connection exists in one of three states:
setRequestMethod
setRequestProperty
The following methods cause the transition to the Connected state when the connection is in Setup state.
openInputStream
openDataInputStream
getLength
getType
getEncoding
getHeaderField
getResponseCode
getResponseMessage
getHeaderFieldInt
getHeaderFieldDate
getExpiration
getDate
getLastModified
getHeaderField
getHeaderFieldKey
The following methods may be invoked while the connection is in Setup or Connected state.
close
getRequestMethod
getRequestProperty
getURL
getProtocol
getHost
getFile
getRef
getPort
getQuery
After an output stream has been opened by the
openOutputStream
or openDataOutputStream
methods, attempts to change the request parameters via
setRequestMethod
or the setRequestProperty
are ignored. Once the request parameters have been sent,
these methods will throw an IOException
.
When an output stream is closed via the
OutputStream.close
or DataOutputStream.close
methods, the connection enters the Connected state.
The output stream is implicitly closed, if not already closed, when the
Connected state is entered and can not be used thereafter (because it is closed).
When the output stream is flushed via the
OutputStream.flush
or DataOutputStream.flush
methods, the request parameters MUST be sent along with any data
written to the stream.
close
method and the closing all of the streams that were
opened from the connection.
The HTTP 1.1 specification provides a rich set of request and response headers that allow the application to negotiate the form, format, language, and other attributes of the content retrieved. The application is responsible for selection and processing of request and response headers. Only the User-Agent header is described in detail. Any other header that is mutually agreed upon with the server may be used.
Transmission of Request and Response Headers
The implementation MUST pass all request headers supplied by the application and response headers as supplied by the network server. The ordering of request and response headers MAY be changed. While the headers may be transformed in transit, they MUST be reconstructed as equivalent headers on the device and server. Any transformations MUST be transparent to the application and origin server.
User-Agent and Accept-Language Request Headers
The User-Agent field may be used to identify the current device. As specified by [RFC2616], the field contains blank separated features where the feature contains a name and optional version number.
The application is responsible for formatting and requesting that the User-Agent field be included in HTTP requests via the setRequestProperty method in the interface javax.microedition.io.HttpConnection. It can supply any application-specific features that are appropriate, in addition to any of the profile-specific request header values listed below.
Applications are not required to be loaded onto the device using HTTP. But if they are, then the User-Agent request header should be included in requests to load an application descriptor or application JAR file onto the device. This will allow the server to provide the most appropriate application for the device.
The user-agent and accept-language fields SHOULD contain the following features as defined by system properties using java.lang.System.getProperty. If multiple values are present they will need to be reformatted into individual fields in the request header.
System Properties Used for User-Agent and Accept-Language Request Headers
System Property | Description |
---|---|
microedition.profiles | A blank (Unicode U+0020) separated list of the J2ME profiles that this device supports. For devices implementing this specification, this property MUST contain at least the string identifying the profile version. |
microedition.configuration | The Java ME configuration supported by this device. For example, "CLDC-1.1." |
microedition.locale | The name of the current locale on this device. For example, "en-US." |
The HttpConnection
supports additional settings during Connector.open
to
specify a proxy host and port, a timeout, or IP version for this connection.
Options with invalid values must result in IllegalArgumentException
to be thrown from Connector.open
.
The following connection settings are supported on all platforms.
ConnectionOption | Type | Sample Value |
---|---|---|
Proxy | String | proxy.myhost.org:80 |
Timeout | Integer | 2000 |
AccessPoint | AccessPoint | See AccessPoint.getAccessPoints |
EnableRoaming | Boolean | true or false |
IPVersion | String | ipv6 |
The ConnectionOption Proxy
is used to supply a single string containing a host or host and port.
The syntax is {host}[:{port}]
.
The value of the {host} field must be a symbolic hostname,
a literal IPv4 address or an IP-literal as specified by RFC 3986.
An IP-literal requires to surround the IPv6Address with square brackets ('[', ']'),
IPvFuture addresses from RFC 3986 are not supported.
The port is optional; if the port is present the colon must be present.
If the port is not present, the default is port 80.
If the Proxy
is provided, the rights to access the proxy
are verified via HttpProtocolPermission
.
If the Proxy
cannot be reached, a java.net.ConnectException
is raised.
The ConnectionOption Timeout
can be used to specify a timeout in milliseconds on blocking
read or write operations on this connection.
With this option set to a non-zero timeout, a read() call on the InputStream
associated with this connection will block for only this amount of time.
If the timeout expires and the timeouts
flag on connector.open
is true,
a java.io.InterruptedIOException
is thrown.
If no timeouts
flag was used or timeouts
is false
,
the read operation returns the number of bytes available and no exception is thrown.
The timeout value must be greater than or equal to 0.
A timeout value of zero is interpreted as an infinite timeout.
If a platform does not support timeouts, the Timeout
setting is silently ignored
and the read/write operations behave as if it was set to 0.
AccessPoint
is used to supply a specific AccessPoint
instance that must be used for the connection.
The connect
method of the AccessPoint will be
called to connect the AccessPoint.
If the access point is not valid or can not be connected, Connector.Open
throws a ConnectionNotFoundException
.
ConnectionOption values are validated during Connector.open
and any exceptions reported.
In the case an AccessPoint is not present in the parameters to
Connector.open, Connector.open must use one of the AccessPoints
already connected that supports the requested ConnectionOptions.
If no AccessPoint is available the implementation may initialize a
network connection and create an AccessPoint for it.
Otherwise, a ConnectionNotFoundException is thrown.
The AccessPoint for a connection is available from getAccessPoint
.
The ConnectionOption EnableRoaming
with a value of true
is used to enable making connections via a NetworkInterface that returns
true
from isRoaming
.
The value false
disables creating connections via a roaming
NetworkInterface. A ConnectionNotFoundException
is
thrown if a roaming enabled connection was requested but cannot be found.
If the ConnectionOption is not present, it is implementation specific, whether
the use of roaming connections is permitted.
The ConnectionOption IPVersion
may be used on dual stack IPv4/IPv6 platforms,
for setting the required protocol stack (IPv4 or IPv6) as well as the preferred
address family types (inet4 or inet6) for the connection. Possible values are either
"ipv4" or "ipv6".
The host name to IP address lookup mechanism also uses IPVersion
.
If an IP Address of the requested address type is not available, whether via DNS
or other hostname translation service a java.net.UnknownHostException
is thrown.
If the exception occurs in Connector.open a
ConnectionNotFoundException
is thrown with the UnknownHostException
as the cause.
In case of a conflict between the IPVersion
ConnectionOption and
a literal host address in the URL string or another ConnectionOption
Connector.Open
throws a ConnectionNotFoundException
.
If the platform or AccessPoint does not support the selected IP version,
Connector.Open
throws a ConnectionNotFoundException
.
The usage of ConnectionOption is illustrated in the following example:
ConnectionOption<String> proxy = new ConnectionOption<String>("Proxy", "proxy-us:80"); try { Connection c = Connector.open("http://www.oracle.com/index.html", proxy); } catch (IOException e) { ... }
Example using StreamConnection
Simple read of a URL using StreamConnection
.
No HTTP specific behavior is needed or used.
(Note: this example ignores all HTTP response
headers and the HTTP response code. Since a proxy or server
may have sent an error response page, an application
can not distinguish which data is retrieved in
the InputStream
.)
Connector.open
is used to open URL and a
StreamConnection
is returned.
From the StreamConnection
the
InputStream
is opened.
It is used to read every character until end of file (-1).
If an exception is thrown the connection and stream are closed.
void getViaStreamConnection(String url) throws IOException { StreamConnection c = null; InputStream s = null; try { c = (StreamConnection)Connector.open(url); s = c.openInputStream(); int ch; while ((ch = s.read()) != -1) { ... } } finally { if (s != null) s.close(); if (c != null) c.close(); } }
Example using ContentConnection
Simple read of a URL using ContentConnection
.
No HTTP specific behavior is needed or used.
Connector.open
is used to open url and
a ContentConnection
is returned.
The ContentConnection
may be able to provide the length.
If the length is available, it is used to read the data in bulk.
From the ContentConnection
the
InputStream
is opened.
It is used to read every character until end of file (-1).
If an exception is thrown the connection and stream are closed.
void getViaContentConnection(String url) throws IOException { ContentConnection c = null; DataInputStream is = null; try { c = (ContentConnection)Connector.open(url); int len = (int)c.getLength(); dis = c.openDataInputStream(); if (len > 0) { byte[] data = new byte[len]; dis.readFully(data); } else { int ch; while ((ch = dis.read()) != -1) { ... } } } finally { if (dis != null) dis.close(); if (c != null) c.close(); } }
Example using HttpConnection
Read the HTTP headers and the data using HttpConnection
.
Connector.open
is used to open url and a
HttpConnection
is returned.
The HTTP headers are read and processed.
If the length is available, it is used to read the data in bulk.
From the HttpConnection
the
InputStream
is opened.
It is used to read every character until end of file (-1).
If an exception is thrown the connection and stream are closed.
void getViaHttpConnection(String url) throws IOException {
HttpConnection c = null;
InputStream is = null;
int rc;
try {
c = (HttpConnection)Connector.open(url);
// Getting the response code will open the connection,
// send the request, and read the HTTP response headers.
// The headers are stored until requested.
rc = c.getResponseCode();
if (rc != HttpConnection.HTTP_OK) {
throw new IOException("HTTP response code: " + rc);
}
is = c.openInputStream();
// Get the ContentType
String type = c.getType();
// Get the length and process the data
int len = (int)c.getLength();
if (len > 0) {
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;
}
} else {
int ch;
while ((ch = is.read()) != -1) {
...
}
}
} catch (ClassCastException e) {
throw new IllegalArgumentException("Not an HTTP URL");
} finally {
if (is != null)
is.close();
if (c != null)
c.close();
}
}
Example using POST with HttpConnection
Post a request with some headers and content to the server and process the headers and content.
Connector.open
is used to open url and a
HttpConnection
is returned.
The request method is set to POST and request headers set.
A simple command is written and flushed.
The HTTP headers are read and processed.
If the length is available, it is used to read the data in bulk.
From the HttpConnection
the
InputStream
is opened.
It is used to read every character until end of file (-1).
If an exception is thrown the connection and stream is closed.
void postViaHttpConnection(String url) throws IOException {
HttpConnection c = null;
InputStream is = null;
OutputStream os = null;
int rc;
try {
c = (HttpConnection)Connector.open(url);
// Set the request method and headers
c.setRequestMethod(HttpConnection.POST);
c.setRequestProperty("If-Modified-Since",
"29 Oct 1999 19:43:31 GMT");
c.setRequestProperty("User-Agent",
"Profile/MIDP-2.0 Configuration/CLDC-1.0");
c.setRequestProperty("Content-Language", "en-US");
// Getting the output stream may flush the headers
os = c.openOutputStream();
os.write("LIST games\n".getBytes());
os.flush(); // Optional, getResponseCode will flush
// Getting the response code will open the connection,
// send the request, and read the HTTP response headers.
// The headers are stored until requested.
rc = c.getResponseCode();
if (rc != HttpConnection.HTTP_OK) {
throw new IOException("HTTP response code: " + rc);
}
is = c.openInputStream();
// Get the ContentType
String type = c.getType();
processType(type);
// Get the length and process the data
int len = (int)c.getLength();
if (len > 0) {
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();
}
}
Simplified Stream Methods on Connector
Please note the following: The
Connector
class defines the following
convenience methods for retrieving an input or output stream directly
for a specified URL:
InputStream openInputStream(String url)
DataInputStream openDataInputStream(String url)
OutputStream openOutputStream(String url)
DataOutputStream openDataOutputStream(String url)
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:
getRequestMethod()
setRequestMethod()
getRequestProperty()
setRequestProperty()
getLength()
getType()
getEncoding()
getHeaderField()
getResponseCode()
getResponseMessage()
getHeaderFieldInt
getHeaderFieldDate
getExpiration
getDate
getLastModified
getHeaderField
getHeaderFieldKey
Modifier and Type | Field and Description |
---|---|
static java.lang.String |
CONNECT
HTTP CONNECT method.
|
static java.lang.String |
DELETE
HTTP Delete method.
|
static java.lang.String |
GET
HTTP Get method.
|
static java.lang.String |
HEAD
HTTP Head method.
|
static int |
HTTP_ACCEPTED
202: The request has been accepted for processing, but the processing
has not been completed.
|
static int |
HTTP_BAD_GATEWAY
502: The server, while acting as a gateway or proxy, received an invalid
response from the upstream server it accessed in attempting to
fulfill the request.
|
static int |
HTTP_BAD_METHOD
405: The method specified in the Request-Line is not allowed for the
resource identified by the Request-URI.
|
static int |
HTTP_BAD_REQUEST
400: The request could not be understood by the server due to malformed
syntax.
|
static int |
HTTP_CLIENT_TIMEOUT
408: The client did not produce a request within the time that the server
was prepared to wait.
|
static int |
HTTP_CONFLICT
409: The request could not be completed due to a conflict with
the current state of the resource.
|
static int |
HTTP_CREATED
201: The request has been fulfilled and resulted in a new
resource being created.
|
static int |
HTTP_ENTITY_TOO_LARGE
413: The server is refusing to process a request because the request
entity is larger than the server is willing or able to process.
|
static int |
HTTP_EXPECT_FAILED
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.
|
static int |
HTTP_FORBIDDEN
403: The server understood the request, but is refusing to fulfill it.
|
static int |
HTTP_GATEWAY_TIMEOUT
504: The server, while acting as a gateway or proxy, did not receive a
timely response from the upstream server specified by the URI
or some other auxiliary server it needed
to access in attempting to complete the request.
|
static int |
HTTP_GONE
410: The requested resource is no longer available at the server and no
forwarding address is known.
|
static int |
HTTP_INTERNAL_ERROR
500: The server encountered an unexpected condition which prevented it
from fulfilling the request.
|
static int |
HTTP_LENGTH_REQUIRED
411: The server refuses to accept the request without a defined Content-
Length.
|
static int |
HTTP_MOVED_PERM
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.
|
static int |
HTTP_MOVED_TEMP
302: The requested resource resides temporarily under a
different URI.
|
static int |
HTTP_MULT_CHOICE
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.
|
static int |
HTTP_NO_CONTENT
204: The server has fulfilled the request but does not need to
return an entity-body, and might want to return updated
meta-information.
|
static int |
HTTP_NOT_ACCEPTABLE
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.
|
static int |
HTTP_NOT_AUTHORITATIVE
203: The returned meta-information in the entity-header is not the
definitive set as available from the origin server.
|
static int |
HTTP_NOT_FOUND
404: The server has not found anything matching the Request-URI.
|
static int |
HTTP_NOT_IMPLEMENTED
501: The server does not support the functionality required to
fulfill the request.
|
static int |
HTTP_NOT_MODIFIED
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.
|
static int |
HTTP_OK
200: The request has succeeded.
|
static int |
HTTP_PARTIAL
206: The server has fulfilled the partial GET request for the resource.
|
static int |
HTTP_PAYMENT_REQUIRED
402: This code is reserved for future use.
|
static int |
HTTP_PRECON_FAILED
412: The precondition given in one or more of the request-header fields
evaluated to false when it was tested on the server.
|
static int |
HTTP_PROXY_AUTH
407: This code is similar to 401 (Unauthorized), but indicates that the
client must first authenticate itself with the proxy.
|
static int |
HTTP_REQ_TOO_LONG
414: The server is refusing to service the request because the
Request-URI is longer than the server is willing to interpret.
|
static int |
HTTP_RESET
205: The server has fulfilled the request and the user agent SHOULD reset
the document view which caused the request to be sent.
|
static int |
HTTP_SEE_OTHER
303: The response to the request can be found under a different URI and
SHOULD be retrieved using a GET method on that resource.
|
static int |
HTTP_TEMP_REDIRECT
307: The requested resource resides temporarily under a different
URI.
|
static int |
HTTP_UNAUTHORIZED
401: The request requires user authentication.
|
static int |
HTTP_UNAVAILABLE
503: The server is currently unable to handle the request due to a
temporary overloading or maintenance of the server.
|
static int |
HTTP_UNSUPPORTED_RANGE
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.
|
static int |
HTTP_UNSUPPORTED_TYPE
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.
|
static int |
HTTP_USE_PROXY
305: The requested resource MUST be accessed through the proxy given by
the Location field.
|
static int |
HTTP_VERSION
505: The server does not support, or refuses to support, the HTTP
protocol version that was used in the request message.
|
static java.lang.String |
OPTIONS
HTTP Options method.
|
static java.lang.String |
POST
HTTP Post method.
|
static java.lang.String |
PUT
HTTP Put method.
|
static java.lang.String |
TRACE
HTTP Trace method.
|
Modifier and Type | Method and Description |
---|---|
AccessPoint |
getAccessPoint()
Gets the AccessPoint for this connection.
|
long |
getDate()
Returns the value of the
date header field. |
long |
getExpiration()
Returns the value of the
expires header field. |
java.lang.String |
getFile()
Returns the file portion of the URL of this
HttpConnection . |
java.lang.String |
getHeaderField(int n)
Gets a header field value by index.
|
java.lang.String |
getHeaderField(java.lang.String name)
Returns the value of the named header field.
|
long |
getHeaderFieldDate(java.lang.String name,
long def)
Returns the value of the named field parsed as date.
|
int |
getHeaderFieldInt(java.lang.String name,
int def)
Returns the value of the named field parsed as a number.
|
java.lang.String |
getHeaderFieldKey(int n)
Gets a header field key by index.
|
java.lang.String |
getHost()
Returns the host information of the URL of
this
HttpConnection . |
long |
getLastModified()
Returns the value of the
last-modified header field. |
int |
getPort()
Returns the network port number of the URL for this
HttpConnection . |
java.lang.String |
getProtocol()
Returns the protocol name of the URL of this
HttpConnection . |
java.lang.String |
getQuery()
Returns the query portion of the URL of this
HttpConnection . |
java.lang.String |
getRef()
Returns the ref portion of the URL of this
HttpConnection . |
java.lang.String |
getRequestMethod()
Get the current request method.
|
java.lang.String |
getRequestProperty(java.lang.String key)
Returns the value of the named general request property for this
connection.
|
int |
getResponseCode()
Returns the HTTP response status code.
|
java.lang.String |
getResponseMessage()
Gets the HTTP response message, if any, returned along with the
response code from a server.
|
java.lang.String |
getURL()
Return a string representation of the URL for this connection.
|
void |
setRequestMethod(java.lang.String method)
Set the method for the URL request, one of:
GET
POST
HEAD
PUT
DELETE
OPTIONS
TRACE
CONNECT
extension-method (as defined in RFC2616)
are legal, subject to protocol restrictions.
|
void |
setRequestProperty(java.lang.String key,
java.lang.String value)
Sets the general request property.
|
getEncoding, getLength, getType
openDataInputStream, openInputStream
openDataOutputStream, openOutputStream
close
static final java.lang.String CONNECT
static final java.lang.String DELETE
static final java.lang.String GET
static final java.lang.String HEAD
static final int HTTP_ACCEPTED
static final int HTTP_BAD_GATEWAY
static final int HTTP_BAD_METHOD
static final int HTTP_BAD_REQUEST
static final int HTTP_CLIENT_TIMEOUT
static final int HTTP_CONFLICT
static final int HTTP_CREATED
static final int HTTP_ENTITY_TOO_LARGE
static final int HTTP_EXPECT_FAILED
static final int HTTP_FORBIDDEN
static final int HTTP_GATEWAY_TIMEOUT
static final int HTTP_GONE
static final int HTTP_INTERNAL_ERROR
static final int HTTP_LENGTH_REQUIRED
static final int HTTP_MOVED_PERM
static final int HTTP_MOVED_TEMP
Location
header indicates where the application should resend
the request.)static final int HTTP_MULT_CHOICE
static final int HTTP_NO_CONTENT
static final int HTTP_NOT_ACCEPTABLE
static final int HTTP_NOT_AUTHORITATIVE
static final int HTTP_NOT_FOUND
static final int HTTP_NOT_IMPLEMENTED
static final int HTTP_NOT_MODIFIED
static final int HTTP_OK
static final int HTTP_PARTIAL
static final int HTTP_PAYMENT_REQUIRED
static final int HTTP_PRECON_FAILED
static final int HTTP_PROXY_AUTH
static final int HTTP_REQ_TOO_LONG
static final int HTTP_RESET
static final int HTTP_SEE_OTHER
static final int HTTP_TEMP_REDIRECT
static final int HTTP_UNAUTHORIZED
static final int HTTP_UNAVAILABLE
static final int HTTP_UNSUPPORTED_RANGE
static final int HTTP_UNSUPPORTED_TYPE
static final int HTTP_USE_PROXY
static final int HTTP_VERSION
static final java.lang.String OPTIONS
static final java.lang.String POST
static final java.lang.String PUT
static final java.lang.String TRACE
AccessPoint getAccessPoint()
long getDate() throws java.io.IOException
date
header field.0
if not known. The value returned is the
number of milliseconds since January 1, 1970 GMT.java.io.IOException
- if an error occurred connecting to the server.long getExpiration() throws java.io.IOException
expires
header field.java.io.IOException
- if an error occurred connecting to the server.java.lang.String getFile()
HttpConnection
.HttpConnection
.
null
is returned if there is no file.java.lang.String getHeaderField(int n) throws java.io.IOException
n
- the index of the header fieldnull
if the array index is out of range.
An empty String is returned if the field does not have a value.java.io.IOException
- if an error occurred connecting to the server.java.lang.String getHeaderField(java.lang.String name) throws java.io.IOException
name
- of a header field.null
if there is no such field in the header.java.io.IOException
- if an error occurred connecting to the server.java.lang.NullPointerException
- if name
is null
long getHeaderFieldDate(java.lang.String name, long def) throws java.io.IOException
This form of getHeaderField
exists because some
connection types (e.g., http-ng
) have pre-parsed
headers. Classes for that connection type can override this method
and short-circuit the parsing.
name
- the name of the header field.def
- a default value.def
argument is returned if the field is
missing or malformed.java.io.IOException
- if an error occurred connecting to the server.java.lang.NullPointerException
- if name
is null
int getHeaderFieldInt(java.lang.String name, int def) throws java.io.IOException
This form of getHeaderField
exists because some
connection types (e.g., http-ng
) have pre-parsed
headers. Classes for that connection type can override this method
and short-circuit the parsing.
name
- the name of the header field.def
- the default value.def
value is returned if the field is
missing or malformed.java.io.IOException
- if an error occurred connecting to the server.java.lang.NullPointerException
- if name
is null
java.lang.String getHeaderFieldKey(int n) throws java.io.IOException
n
- the index of the header fieldnull
if the array index is out of range.java.io.IOException
- if an error occurred connecting to the server.java.lang.String getHost()
HttpConnection
.
For IPV6, the string MUST be formatted as in a URL according to
RFC 2732 ipv6reference
so it contains the '[' and ']'.
For example, the host name or IP address such as oracle.com
or
10.43.22.22
or [3ffe:2aa:100:7031::1]
. In this form
it can be used to construct a URL.HttpConnection
.long getLastModified() throws java.io.IOException
last-modified
header field.
The result is the number of milliseconds since January 1, 1970 GMT.HttpConnection
was last modified, or
0 if not known.java.io.IOException
- if an error occurred connecting to the server.int getPort()
HttpConnection
.HttpConnection
.
The default HTTP port number (80) is returned if there was
no port number in the string passed to Connector.open
.java.lang.String getProtocol()
HttpConnection
. e.g., http or httpsHttpConnection
.java.lang.String getQuery()
HttpConnection
.
RFC2396 defines the query component as the text after the first
question-mark (?) character in the URL.HttpConnection
.
null
is returned if there is no value.java.lang.String getRef()
HttpConnection
.
RFC2396 specifies the optional fragment identifier as the
the text after the crosshatch (#) character in the URL.
This information may be used by the user agent as additional
reference information after the resource is successfully retrieved.
The format and interpretation of the fragment identifier is dependent
on the media type[RFC2046] of the retrieved information.HttpConnection
.
null
is returned if there is no value.java.lang.String getRequestMethod()
setRequestMethod(java.lang.String)
java.lang.String getRequestProperty(java.lang.String key)
key
- the keyword by which the request property is
known (e.g., "accept").null
is returned.java.lang.NullPointerException
- if key
is null
setRequestProperty(java.lang.String, java.lang.String)
int getResponseCode() throws java.io.IOException
HTTP/1.0 200 OK HTTP/1.0 401 Unauthorizedand extracts the ints 200 and 401 respectively. from the response (i.e., the response is not valid HTTP).
java.io.IOException
- if an error occurred connecting to the server.java.lang.String getResponseMessage() throws java.io.IOException
HTTP/1.0 200 OK HTTP/1.0 404 Not FoundExtracts the Strings "OK" and "Not Found" respectively. Returns null if none could be discerned from the responses (the result was not valid HTTP).
null
java.io.IOException
- if an error occurred connecting to the server.java.lang.String getURL()
void setRequestMethod(java.lang.String method) throws java.io.IOException
void setRequestProperty(java.lang.String key, java.lang.String value) throws java.io.IOException
Note: HTTP requires all request properties which can legally have multiple instances with the same key to use a comma-separated list syntax which enables multiple properties to be appended into a single property.
key
- the keyword by which the request is known
(e.g., "accept
").value
- the value associated with it.java.io.IOException
- is thrown if the connection is in the
connected state.java.lang.NullPointerException
- if key
is null
getRequestProperty(java.lang.String)
Copyright (c) 2014, Oracle and/or its affiliates. All Rights Reserved. Use of this specification is subject to license terms.