一个基于http协议的访问网络的封装类
转一个基于http协议的访问网络的封装类，使用时只需调用
public static synchronized byte[] connect(String url, byte[] data,String method, String contentType, long lowRange, long highRange, boolean disableProxy, boolean detached)
这个函数就可以了．
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
/**
* NetConnection.java
*
* This code is protected under the Apache 2.0 license as mentioned in
* the accompanying license.txt file. The license.txt file MUST be located
* within the same folder as this NetConnection.java source file.
*
* The license file may also be viewed online by
* visiting http://www.apache.org/licenses/
*/
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import javax.microedition.io.Connector;
import javax.microedition.io.HttpConnection;
/**
* This class provides robust network connectivity and exception handling
* over an unreliable MIDP HttpConnection.
*
* In addition the caller may perform a combination of any of the below
* functions.
*
* - Proxy-server thwarting
* - HTTP range requests
* - Thread-separated connections
*
* @author Jason Fuerstenberg (http://www.jay-f.jp)
* @version 2004/03/15
*/
public final class NetConnection implements Runnable {
/*
* This class is implemented as a singleton since only
* a single active connection is allowed.
*/
private static NetConnection singleton = new NetConnection();
/*
* The underlying HttpConnection which is managed by this class.
*/
private static HttpConnection httpConn;
/*
* To support multi-threaded network connections a series of
* pass-through members are used/shared across the class' threads.
*/
/*
* The requested URL.
*
* This member serves a second purpose which is to prevent a caller
* from directly calling the run() method which is public to adhere to
* the Runnable interface.
*/
private static String url;
// The HTTP method used to make the connection.
private static String method;
// The posted data if any.
private static byte[] data;
// The content type (if the method is POST)
private static String contentType;
// The lower bound of the requested range.
private static long lowRange;
// The higher bound of the requested range.
private static long highRange;
/*
* The flag to indicate that the request should attempt to thwart
* any proxy servers by appending a timestamp to the request.
*/
private static boolean disableProxy;
/*
* The flag to indicate that the connection should occur in a separate
* thread.
*/
private static boolean detached;
// The response's byte array.
private static byte[] response;
/*
* In the event of an exception occuring in the run() method during
* synchronous or asynchronous execution the exception needs to be
* communicated up the main application thread's call stack. This static
* member will be a reference for any exception that may have occured
* and will be thrown after run() returns.
*
*/
private static Exception exceptionPipe;
/*
* The private constructor to enforce the singleton pattern
* which this class implements.
*/
private NetConnection() {
// singleton
}
/**
* Connects to a target URL.
*
* @param url The target URL
* @param data The data to post (if any)
* @param method HttpConnection.GET or HttpConnection.POST
* @param contentType The content-type of the posted data (if any)
* @param lowRange The byte offset within the requested resource from
* which the response will begin.
* @param highRange The last byte the response will return or 0
* if requesting the entire resource.
* @param disableProxy Attempts to prevent a given server from
* offering a cached proxy version of the
* requested resource.
* @param detached Causes the connection to occur in a thread separate
* from the calling thread. This call will block until
* the connection has ended.
* @return A byte array containing the response from the server.
* @throws IOException If a network error occured.
*/
public static synchronized byte[] connect(String url, byte[] data,
String method, String contentType, long lowRange, long highRange,
boolean disableProxy, boolean detached) throws Exception {
/*
* Set all the pass-through members here.
*/
exceptionPipe = null;
NetConnection.url = url;
NetConnection.data = data;
NetConnection.method = method;
NetConnection.contentType = contentType;
NetConnection.lowRange = lowRange;
NetConnection.highRange = highRange;
NetConnection.disableProxy = disableProxy;
NetConnection.detached = detached;
// Preemptively try to disconnect from a previous connection!
NetConnection.severConnection();
if (detached) {
/*
* The caller has specified that the connection should occur
* in a separate, detached thread.
*/
Thread t = new Thread(singleton);
t.start();
/*
* Enforce a wait here to provide the illusion of synchronous
* execution despite having the connection in another thread.
*/
singleton.forceWait();
} else {
/*
* Call run() directly without creating a thread to launch it.
*/
singleton.run();
}
/*
* Reset the URL to null to prevent direct
* calling of the run() method.
*/
NetConnection.url = null;
if (exceptionPipe != null) {
/*
* During the course of the connection an exception occured
* and was communicated here by the exceptionPipe member.
* Throw it from this location.
*/
throw exceptionPipe;
}
// successful connection, return response!
return response;
}
/**
* Performs the actual connection logic.
* The connection may occur in a separate thread from that of the caller.
*
* @throws IllegalStateException if called directly by any class
* other than this one.
*/
public void run() {
if (url == null) {
/*
* The URL is used as a means to ascertain whether or not the
* caller of this method was the connect() method. Since it is
* null the caller is directly calling run() so throw an exception.
*/
throw new IllegalStateException("Cannot invoke this method!");
}
DataOutputStream dos = null;
DataInputStream dis = null;
StringBuffer buffer = null;
/*
* IMPLEMENTATION NOTE:
*
* From this section on, a series of try/catch/finally statements
* is used to ensure the proper flow of the connection under a
* wide variety of circumstances. This seemingly verbose logic
* is important for the proper exception handling and object
* reclamation required to make subsequent connections
* possible in the future.
*
* In addition, the catching of exception is not too particular
* regarding the type of exception being thrown for a few reasons...
*
* 1. The handling of each exception type is identical
* 2. Implementations may vary in which exceptions they throw
*
* In the interest of stability it is highly recommended to
* leave this as is, even if it goes against orthodox practices.
*/
try {
int permissions = 0;
// Setup the permissions
if (HttpConnection.GET.equals(method)) {
permissions = Connector.READ;
} else if (HttpConnection.POST.equals(method)) {
permissions = Connector.READ_WRITE;
}
if (disableProxy) {
/*
* To thwart the a given server's proxy cache
* the logic will attach a query parameter to the
* end of the URL with a millisecond timestamp which
* will hopefully force the server to see this request as one
* which has never previously occured for this client
* and therefore entitled to a fresh copy of the requested
* resource.
*/
boolean hasQueryParams = false;
char[] ca = url.toCharArray();
for (int loop = 0; loop < url.length(); loop++) {
if (ca[loop] == '?') {
hasQueryParams = true;
break;
}
}
StringBuffer noProxyUrl = new StringBuffer();
noProxyUrl.append(url);
if (hasQueryParams) {
noProxyUrl.append("&");
} else {
noProxyUrl.append("?");
}
noProxyUrl.append("no-proxy=");
noProxyUrl.append(System.currentTimeMillis()); // timestamp
/*
* Reset the URL to include the "no-proxy" query
* parameter.
*/
url = noProxyUrl.toString();
}
// Open the connection and set the request method.
httpConn = (HttpConnection) Connector.open(url, permissions, true);
httpConn.setRequestMethod(method);
//if (HttpConnection.GET.equals(method)) {
if (permissions == Connector.READ) {
// GET request
if (lowRange > -1 && lowRange < highRange) {
/*
* The caller is requesting a specific range within
* the resource.
*
* The logic will insert the appropriate HTTP header to
* implement the request.
*/
StringBuffer range = new StringBuffer();
range.append("bytes=");
range.append(lowRange);
range.append("-");
range.append(highRange);
httpConn.setRequestProperty("Range", range.toString());
}
} else if (permissions == Connector.READ_WRITE) {
// POST request
httpConn.setRequestProperty("Content-Type", contentType);
dos = httpConn.openDataOutputStream();
dos.write(data);
}
} catch (Exception e) {
/*
* An exception occured either during the opening of the connection
* or during the POSTing of data. In either case the logic cannot
* continue and will quit here.
*/
exceptionPipe = e;
if (detached) {
forceNotify();
}
return;
} finally {
try {
try {
if (dos != null) {
// Close the DataOutputStream.
dos.close();
}
} catch (Exception e) {
// Failure to close the DataOutputStream!
if (exceptionPipe == null) {
exceptionPipe = e;
if (detached) {
forceNotify();
}
return;
}
} finally {
// Force the dereferencing of the DataOutputStream.
dos = null;
}
// Get the response code.
int responseCode = httpConn.getResponseCode();
if (responseCode != HttpConnection.HTTP_OK
&& responseCode != HttpConnection.HTTP_PARTIAL) {
/*
* The response code does not match HTTP_OK (200)
* or HTTP_PARTIAL (206). The logic cannot proceed to
* treat the response as one holding the requested
* resource and therefore will report the response code
* via an exception to the caller.
*/
if (exceptionPipe == null) {
StringBuffer errorCode = new StringBuffer();
errorCode.append("Response code from server: ");
errorCode.append(responseCode);
errorCode.append("/nMessage: [");
errorCode.append(httpConn.getResponseMessage());
errorCode.append("]");
exceptionPipe = new IOException(errorCode.toString());
if (detached) {
forceNotify();
}
return;
}
}
dis = httpConn.openDataInputStream();
/*
* Cycle through all the bytes provided
* in the response and append them to a
* StringBuffer for later use.
*/
int ch;
buffer = new StringBuffer();
while ((ch = dis.read()) != -1) {
buffer.append((char) ch);
}
/*
* Convert the StringBuffer to an array using
* the ISO-8859-1 encoding to preserve the byte
* encoding of the characters.
*/
response = buffer.toString().getBytes("ISO8859_1");
if (detached) {
forceNotify();
}
/*
* All OK, now returning.
*/
return;
} catch (Exception e) {
/*
* An exception occured either during the usage of the
* connection object (such as a NullPointerException) or during
* the reading of the data. In either case the logic cannot
* continue.
*/
if (exceptionPipe == null) {
exceptionPipe = e;
if (detached) {
forceNotify();
}
return;
}
} finally {
try {
if (dis != null) {
// Close the DataInputStream.
dis.close();
}
} catch (Exception e) {
// Failure to close the DataInputStream!
if (exceptionPipe == null) {
exceptionPipe = e;
if (detached) {
forceNotify();
}
return;
}
} finally {
// force the dereferencing of the DataInputStream.
dis = null;
}
try {
if (httpConn != null) {
// Close the HttpConnection.
httpConn.close();
/*
* Only dereference the HttpConnection if the
* closing actually succeeded!
*/
httpConn = null;
}
} catch (Exception e) {
// Failure in closing the HttpConnection!
if (exceptionPipe == null) {
exceptionPipe = e;
if (detached) {
forceNotify();
}
return;
}
}
}
}
}
/*
* Provides the synchronized context against the singleton's instance
* for the wait() method call to properly execute. Not all implementations
* of the JVM support the concept of synchronized contexts other than
* that of an entire method. As such the inner call to wait must be
* embedded in this synchronized method.
*/
private synchronized void forceWait() {
try {
wait();
} catch (InterruptedException ie) {
// Ignore this exception
ie = null;
}
}
/*
* Provides the synchronized context against the singleton's instance
* for the notify() method call to properly execute. Not all
* implementations of the JVM support the concept of synchronized
* contexts other than that of an entire method. As such the inner
* call to notify must be embedded in this synchronized method.
*/
private synchronized void forceNotify() {
notify();
}
/*
* Severs an ongoing connection.
*/
private static void severConnection() {
try {
if (httpConn == null) {
/*
* No connection is in progress so simply return
* to the caller.
*/
return;
}
// Close the connection.
httpConn.close();
} catch (Exception e) {
/*
* If the handset's implementation of the HttpConnection
* interface is solid it will not be possible for
* an exception to occur.
*/
e = null;
} finally {
// Force the dereferencing of the connection.
httpConn = null;
}
}
}