android网络访问,以及上传文件

这个是用第三方库做的文件上传。稳定性还不错。然后使用简单。我进一步简化了。更简单使用。

使用的包是httpmime-4.1.2.jar(http://download.csdn.net/detail/u012565107/7005475)。

加上我改写的HttpClientImp(主要部分是当年看师兄代码写的。顺便在此感谢一下大神师兄。跑题了。。。。)

先看看怎么使用HttpClientImp吧

//这是单例模式 所以不要去new 一个
HttpClientImp httpClientImp = HttpClientImp.INSTANCE;

List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>();
nameValuePairs.add(new BasicNameValuePair("data",189));
//根据自己需求 可以post,get等请求。 Session 填上null就行了。
//得到的jsonStr就是 http访问返回的字符串。然后把jsonStr哪去按自己需求处理
String jsonStr = httpClientImp.postForString("url_api", null, nameValuePairs);

文件上传也有接口,使用方式:

HttpClientImp httpClientImp = HttpClientImp.INSTANCE;
			
File file = new File("/sdcard/test.png");
if(file.exists() && file.isFile()){

	Map<String, String> param = new HashMap<String, String>();
	param.put("data","myContent");
	
	Map<String, File> fileMap = new HashMap<String, File>();
	fileMap.put("fileData", file);
	
	//非文件的参数 用Map<String, String>的键值对传进去 就是param
	//文件参数 也用Map<String, File>的键值对传递进去 fileMap。
	String jsonStr= httpClientImp.postForString(URLConstant.REPLY_SEND, param, fileMap);
}

好了上面就是怎么用的。HttpClientImp的源码:

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.ParseException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpRequestBase;
import org.apache.http.client.params.HttpClientParams;
import org.apache.http.client.utils.URLEncodedUtils;
import org.apache.http.conn.ClientConnectionManager;
import org.apache.http.conn.params.ConnManagerParams;
import org.apache.http.conn.params.ConnPerRoute;
import org.apache.http.conn.routing.HttpRoute;
import org.apache.http.conn.scheme.PlainSocketFactory;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.conn.scheme.SocketFactory;
import org.apache.http.entity.mime.MultipartEntity;
import org.apache.http.entity.mime.content.FileBody;
import org.apache.http.entity.mime.content.StringBody;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;

import android.text.TextUtils;

public class HttpClientImp {

	private static final String TAG = "HttpClient";
	
	private static final int MAX_CONNECTIONS_PER_ROUTE = 8;
	private static final int MAX_CONNECTION = 16;
	
	public static final String COOKIE = "Cookie";
	public static final String SESSIONID = "JSESSIONID=";
	public static final int TIMEOUT = 300000;
	
	private static final String DEFAULT_CLIENT_VERSION = "com.znisea.linju";
	private static final String CLIENT_VERSION_HEADER = "User-Agent";
	private final HttpClient mHttpClient;
	private final String mClientVersion;

	/**
	 * singleton
	 */
	public static HttpClientImp INSTANCE = new HttpClientImp();

	private HttpClientImp() {
		mHttpClient = createHttpClient();
		mClientVersion = DEFAULT_CLIENT_VERSION;
	}

	/**
	 * execute a HttpPost
	 * 
	 * @param url
	 *            not null
	 * @param sessionId
	 *            allow null
	 * @param list
	 * @return String
	 */
	public String postForString(String url, String sessionId,
			List<NameValuePair> list) throws Exception {
		HttpPost httpPost = createHttpPost(url, sessionId, list);

		HttpResponse response = executeHttpRequest(httpPost);

		switch (response.getStatusLine().getStatusCode()) {
		case 200:
			try {
				return EntityUtils.toString(response.getEntity());
			} catch (ParseException e) {
				throw new Exception(e.getMessage());
			}

		case 401:
			response.getEntity().consumeContent();
			throw new Exception(response.getStatusLine().toString());

		case 404:
			response.getEntity().consumeContent();
			throw new Exception(response.getStatusLine().toString());

		default:
			response.getEntity().consumeContent();
			throw new Exception(response.getStatusLine().toString());
		}
	}

	/**
	 * execute a HttpPost
	 * 
	 * @param url
	 *            not null
	 * @param sessionId
	 *            allow null
	 * @param
	 * @return String
	 */
	public String postForString(String url, String sessionId,
			NameValuePair nameValuePair) throws Exception {
		List<NameValuePair> list = new ArrayList<NameValuePair>();
		list.add(nameValuePair);
		return postForString(url, sessionId, list);
	}

	/**
	 * execute a HttpPost
	 * 
	 * @param url
	 *            not null
	 * @param sessionId
	 *            allow null
	 * @param
	 * @return InputStream
	 */
	public InputStream postForStream(String url, String sessionId,
			List<NameValuePair> list) throws Exception {
		HttpPost httpPost = createHttpPost(url, sessionId, list);
		HttpResponse response = executeHttpRequest(httpPost);
		switch (response.getStatusLine().getStatusCode()) {
		case 200:
			try {
				return response.getEntity().getContent();
			} catch (ParseException e) {
				throw new Exception(e.getMessage());
			}

		case 401:
			response.getEntity().consumeContent();
			throw new Exception(response.getStatusLine().toString());

		case 404:
			response.getEntity().consumeContent();
			throw new Exception(response.getStatusLine().toString());

		default:
			response.getEntity().consumeContent();
			throw new Exception(response.getStatusLine().toString());
		}
	}

	/**
	 * execute a HttpPost
	 * 
	 * @param url
	 *            not null
	 * @param sessionId
	 *            allow null
	 * @param
	 * @return InputStream
	 */
	public InputStream postForStream(String url, String sessionId,
			NameValuePair nameValuePair) throws Exception {
		List<NameValuePair> list = new ArrayList<NameValuePair>();
		list.add(nameValuePair);
		return postForStream(url, sessionId, list);
	}
	
	public String postForString(String url,Map<String, String> params,
			Map<String, File> files) throws Exception{
			HttpPost post = new HttpPost(url);
			post.addHeader(CLIENT_VERSION_HEADER, mClientVersion);
			MultipartEntity entity = new MultipartEntity();
			for (Map.Entry<String, String> entry : params.entrySet()) {
			 entity.addPart(entry.getKey(), new StringBody(entry.getValue(), Charset.forName("UTF-8")));
//			 System.out.println(entry.getKey() +"   "+entry.getValue());
			}
			
			if(files != null){
			 for (Map.Entry<String, File> file : files.entrySet()) {
//				 entity.addPart(file.getKey(),new FileBody(file.getValue()));
				 entity.addPart(file.getKey(),new FileBody(file.getValue()));
//				 System.out.println(file.getKey());
			 }
			}
			post.setEntity(entity);
			HttpResponse response = mHttpClient.execute(post);
			return EntityUtils.toString(response.getEntity());
	}
	
	/**
	 * execute a HttpGet
	 * 
	 * @param url
	 *            not null
	 * @param sessionId
	 *            allow null
	 * @return String
	 * @throws Exception
	 */
	public String getForString(String url, String sessionId) throws Exception {
		HttpGet httpGet = createHttpGet(url, sessionId);

		HttpResponse response = executeHttpRequest(httpGet);

		switch (response.getStatusLine().getStatusCode()) {
		case 200:
			try {
				return EntityUtils.toString(response.getEntity());
			} catch (ParseException e) {
				throw new Exception(e.getMessage());
			}

		case 401:
			response.getEntity().consumeContent();
			throw new Exception(response.getStatusLine().toString());

		case 404:
			response.getEntity().consumeContent();
			throw new Exception(response.getStatusLine().toString());

		default:
			response.getEntity().consumeContent();
			throw new Exception(response.getStatusLine().toString());
		}
	}
	
	public String getForString(String url, String sessionId,
			NameValuePair nameValuePair) throws Exception {
		List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>();
		nameValuePairs.add(nameValuePair);
		return getForString(url, sessionId, nameValuePairs);
	}
	
	public String getForString(String url, String sessionId,
			List<NameValuePair> nameValuePairs) throws Exception {
		HttpGet httpGet = createHttpGet(url, sessionId, nameValuePairs);

		HttpResponse response = executeHttpRequest(httpGet);
		
		switch (response.getStatusLine().getStatusCode()) {
		case 200:
			try {
				return EntityUtils.toString(response.getEntity());
			} catch (ParseException e) {
				throw new Exception(e.getMessage());
			}

		case 401:
			response.getEntity().consumeContent();
			throw new Exception(response.getStatusLine().toString());

		case 404:
			response.getEntity().consumeContent();
			throw new Exception(response.getStatusLine().toString());

		default:
			response.getEntity().consumeContent();
			throw new Exception(response.getStatusLine().toString());
		}
	}

	/**
	 * execute a HttpGet
	 * 
	 * @param url
	 *            not null
	 * @param sessionId
	 *            allow null
	 * @return String
	 * @throws Exception
	 */
	public InputStream getForStream(String url, String sessionId)
			throws Exception {
		HttpGet httpGet = createHttpGet(url, sessionId);

		HttpResponse response = executeHttpRequest(httpGet);

		switch (response.getStatusLine().getStatusCode()) {
		case 200:
			try {
				return response.getEntity().getContent();
			} catch (ParseException e) {
				throw new Exception(e.getMessage());
			}

		case 401:
			response.getEntity().consumeContent();
			throw new Exception(response.getStatusLine().toString());

		case 404:
			response.getEntity().consumeContent();
			throw new Exception(response.getStatusLine().toString());

		default:
			response.getEntity().consumeContent();
			throw new Exception(response.getStatusLine().toString());
		}
	}

	/**
	 * execute a HttpGet
	 * 
	 * @param url
	 * @param nameValuePairs
	 * @return
	 * @throws Exception
	 */
	public InputStream getForStream(String url, String sessionId,
			List<NameValuePair> nameValuePairs) throws Exception {
		HttpGet httpGet = createHttpGet(url, sessionId, nameValuePairs);

		HttpResponse response = executeHttpRequest(httpGet);

		switch (response.getStatusLine().getStatusCode()) {
		case 200:
			try {
				return response.getEntity().getContent();
			} catch (ParseException e) {
				throw new Exception(e.getMessage());
			}

		case 401:
			response.getEntity().consumeContent();
			throw new Exception(response.getStatusLine().toString());

		case 404:
			response.getEntity().consumeContent();
			throw new Exception(response.getStatusLine().toString());

		default:
			response.getEntity().consumeContent();
			throw new Exception(response.getStatusLine().toString());
		}
	}

	/**
	 * execute() an httpRequest catching exceptions and returning null instead.
	 * 
	 * @param httpRequest
	 * @return
	 * @throws IOException
	 */
	public HttpResponse executeHttpRequest(HttpRequestBase httpRequest)
			throws IOException {
		try {
			mHttpClient.getConnectionManager().closeExpiredConnections();
			return mHttpClient.execute(httpRequest);
		} catch (IOException e) {
			httpRequest.abort();
			throw e;
		}
	}

	/**
	 * create HttpGet
	 */
	public HttpGet createHttpGet(String url, String sessionId) {
		HttpGet httpGet = new HttpGet(url);
		httpGet.addHeader(CLIENT_VERSION_HEADER, mClientVersion);
		if (!TextUtils.isEmpty(sessionId)) {
			httpGet.addHeader(COOKIE, SESSIONID + sessionId);
		}
		return httpGet;
	}

	/**
	 * create HttpGet
	 */
	public HttpGet createHttpGet(String url, String sessionId,
			List<NameValuePair> nameValuePairs) {
		String query = URLEncodedUtils.format(nameValuePairs, HTTP.UTF_8);
		HttpGet httpGet = new HttpGet(url + "?" + query);
		httpGet.addHeader(CLIENT_VERSION_HEADER, mClientVersion);
		if (!TextUtils.isEmpty(sessionId)) {
			httpGet.addHeader(COOKIE, SESSIONID + sessionId);
		}
		return httpGet;
	}

	/**
	 * create HttpPost
	 */
	public HttpPost createHttpPost(String url, String sessionId,
			List<NameValuePair> list) {
		HttpPost httpPost = new HttpPost(url);
		httpPost.addHeader(CLIENT_VERSION_HEADER, mClientVersion);
		if (!TextUtils.isEmpty(sessionId)) {
			httpPost.addHeader(COOKIE, SESSIONID + sessionId);
		}
		try {
			httpPost.setEntity(new UrlEncodedFormEntity(list, HTTP.UTF_8));
		} catch (UnsupportedEncodingException e1) {
			throw new IllegalArgumentException(
					"Unable to encode http parameters.");
		}
		return httpPost;
	}

	/**
	 * Create a thread-safe client. This client does not do redirecting, to
	 * allow us to capture correct "error" codes.
	 * 
	 * @return HttpClient
	 */
	public final DefaultHttpClient createHttpClient() {
		// Sets up the http part of the service.
		final SchemeRegistry supportedSchemes = new SchemeRegistry();

		// Register the "http" protocol scheme, it is required
		// by the default operator to look up socket factories.
		final SocketFactory sf = PlainSocketFactory.getSocketFactory();
		supportedSchemes.register(new Scheme("http", sf, 80));

		// Set some client http client parameter defaults.
		final HttpParams httpParams = createHttpParams();
		HttpClientParams.setRedirecting(httpParams, false);

		final ClientConnectionManager ccm = new ThreadSafeClientConnManager(
				httpParams, supportedSchemes);
		return new DefaultHttpClient(ccm, httpParams);
	}

	/**
	 * Create the default HTTP protocol parameters.
	 */
	private static final HttpParams createHttpParams() {
		final HttpParams params = new BasicHttpParams();

		// Turn off stale checking. Our connections break all the time anyway,
		// and it's not worth it to pay the penalty of checking every time.
		HttpConnectionParams.setStaleCheckingEnabled(params, false);
		HttpConnectionParams.setConnectionTimeout(params, TIMEOUT);
		HttpConnectionParams.setSoTimeout(params, TIMEOUT);
		HttpConnectionParams.setSocketBufferSize(params, 8192);
		
		ConnManagerParams.setTimeout(params, TIMEOUT);
		ConnManagerParams.setMaxTotalConnections(params, MAX_CONNECTION);
		ConnManagerParams.setMaxConnectionsPerRoute(params, CONN_PER_ROUTE);
		
		return params;
	}
	
	/** The default maximum number of connections allowed per host */
    private static final ConnPerRoute CONN_PER_ROUTE = new ConnPerRoute() {
        
        public int getMaxForRoute(HttpRoute route) {
            return MAX_CONNECTIONS_PER_ROUTE;
        }
        
    };

}



你可能感兴趣的:(http,android,网络,fileupload)