Java tutorial
/** * Copyright (c) 2012-2013. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.wisedu.scc.love.widget.http; import android.content.Context; import android.text.TextUtils; import android.util.Log; import com.google.gson.Gson; import com.loopj.android.http.AsyncHttpClient; import com.loopj.android.http.AsyncHttpRequest; import com.loopj.android.http.AsyncHttpResponseHandler; import com.loopj.android.http.RequestHandle; import com.loopj.android.http.RequestParams; import com.loopj.android.http.ResponseHandlerInterface; import com.wisedu.scc.love.utils.ReflectUtil; import org.apache.http.Header; import org.apache.http.HttpEntity; import org.apache.http.client.HttpClient; import org.apache.http.client.methods.HttpEntityEnclosingRequestBase; import org.apache.http.client.methods.HttpGet; import org.apache.http.client.methods.HttpPost; import org.apache.http.client.methods.HttpUriRequest; import org.apache.http.impl.client.DefaultHttpClient; import org.apache.http.protocol.HttpContext; import java.lang.reflect.Field; import java.lang.reflect.Method; import java.util.HashMap; import java.util.Iterator; import java.util.Map; public class HttpManager extends AsyncHttpClient { private static final String TAG = "HttpManager"; private HttpConfig mHttpConfig; private static Field CLIENT_HEADER_FIELD; private static Method PARAMS_TO_ENTITY; private static Method ADD_ENTITY_TO_REQUEST_ENTITY; private static HashMap<String, HttpManager> mHttpMap = new HashMap<String, HttpManager>(); private HttpManager(HttpConfig config) { super(); CLIENT_HEADER_FIELD = ReflectUtil.getField(getClass(), "clientHeaderMap"); CLIENT_HEADER_FIELD.setAccessible(true); PARAMS_TO_ENTITY = ReflectUtil.getMethod(getClass(), "paramsToEntity", RequestParams.class, ResponseHandlerInterface.class); PARAMS_TO_ENTITY.setAccessible(true); ADD_ENTITY_TO_REQUEST_ENTITY = ReflectUtil.getMethod(getClass(), "addEntityToRequestBase", HttpEntityEnclosingRequestBase.class, HttpEntity.class); ADD_ENTITY_TO_REQUEST_ENTITY.setAccessible(true); this.mHttpConfig = config; final Map<String, String> headMap = config.getHeadMap(); if (headMap != null) { getHeaders().putAll(headMap); } } public static HttpManager create() { Log.i(TAG, "HttpManager create."); HttpConfig config = new HttpConfig(); config.setPrefix(HttpConfig.DEFAULT); return create(config); } public static HttpManager create(String prefix) { Log.i(TAG, "HttpManager create prefix = " + prefix); HttpConfig config = new HttpConfig(); config.setPrefix(prefix); return create(config); } public static HttpManager create(HttpConfig config) { return config != null ? getInstance(config) : create(); } private synchronized static HttpManager getInstance(HttpConfig config) { HttpManager http = null; synchronized (mHttpMap) { Log.i(TAG, "HttpManager getInstance prefix = " + config.getPrefix()); http = mHttpMap.get(config.getPrefix()); if (http == null) { http = new HttpManager(config); mHttpMap.put(config.getPrefix(), http); } } return http; } public static void shutdown() { synchronized (mHttpMap) { mHttpMap.clear(); } } public HttpConfig getHttpConfig() { return mHttpConfig; } public String generateUrl(String url) { return this.mHttpConfig.getUrl(url); } public Object getSync(String url) { return getSync(url, null); } public Object getSync(String url, RequestParams params) { HttpUriRequest request = new HttpGet( getUrlWithQueryString(isUrlEncodingEnabled(), generateUrl(url), params)); return sendSyncRequest(getHttpClient(), getHttpContext(), request, null); } public Object getSync(String url, Header[] headers, RequestParams params) { HttpUriRequest request = new HttpGet( getUrlWithQueryString(isUrlEncodingEnabled(), generateUrl(url), params)); if (headers != null) request.setHeaders(headers); return sendSyncRequest(getHttpClient(), getHttpContext(), request, null); } public String postSync(String url) { return postSync(url, null); } public String postSync(String url, RequestParams params) { return postSync(url, invokeParamsToEntity(params, new DefaultHttpResponseHandler()), null); } public String postSync(String url, HttpEntity entity, String contentType) { return sendSyncRequest(getHttpClient(), getHttpContext(), invokeAddEntityToRequestBase(new HttpPost(generateUrl(url)), entity), contentType); } public String postSync(String url, Header[] headers, RequestParams params, String contentType) { HttpEntityEnclosingRequestBase request = new HttpPost(generateUrl(url)); if (params != null) request.setEntity(invokeParamsToEntity(params, new DefaultHttpResponseHandler())); if (headers != null) request.setHeaders(headers); return sendSyncRequest(getHttpClient(), getHttpContext(), request, contentType); } protected String sendSyncRequest(HttpClient client, HttpContext httpContext, HttpUriRequest uriRequest, String contentType) { if (contentType != null) { uriRequest.addHeader("Content-Type", contentType); } return new SyncRequestHandler((DefaultHttpClient) client, httpContext, AsyncHttpResponseHandler.DEFAULT_CHARSET).sendRequest(uriRequest); } // thrift post json interface public void postScc(String url, ResponseHandlerInterface responseHandler, Map<String, Object> pararms) { RequestParams params = new RequestParams(); if (pararms != null) { Iterator<Map.Entry<String, Object>> iter = pararms.entrySet().iterator(); while (iter.hasNext()) { Map.Entry<String, Object> entry = (Map.Entry<String, Object>) iter.next(); final String key = entry.getKey(); final Object val = entry.getValue(); if (val instanceof String || val instanceof Integer || val instanceof Long || val instanceof Short) { params.put(key, String.valueOf(val)); } else { params.put(key, GsonProvider.getInstance().toJson(val)); } } } post(url, params, responseHandler); } // another thrift post json interface public void postScc(String url, ResponseHandlerInterface responseHandler, Object... objects) { RequestParams params = new RequestParams(); if (objects != null && objects.length != 0) { StringBuilder sb = new StringBuilder(); for (Object object : objects) { if (object instanceof String || object instanceof Integer || object instanceof Long || object instanceof Short) { sb.append(object); } else { sb.append(GsonProvider.getInstance().toJson(object)); } sb.append(","); } params.put("_p", sb.toString()); } post(url, params, responseHandler); } public String postServiceSync(String url, Map<String, Object> pararms) { RequestParams params = new RequestParams(); if (pararms != null && pararms.entrySet() != null) { Iterator<Map.Entry<String, Object>> iter = pararms.entrySet().iterator(); while (iter.hasNext()) { Map.Entry<String, Object> entry = (Map.Entry<String, Object>) iter.next(); final String key = entry.getKey(); final Object val = entry.getValue(); if (val instanceof String || val instanceof Integer || val instanceof Long || val instanceof Short) { params.put(key, String.valueOf(val)); } else { params.put(key, new Gson().toJson(val)); } } } return postSync(url, params); } public String postServiceSync(String url, Object... objects) { RequestParams params = new RequestParams(); if (objects != null && objects.length != 0) { StringBuilder sb = new StringBuilder(); for (Object object : objects) { if (object instanceof String || object instanceof Integer || object instanceof Long || object instanceof Short) { sb.append(object); } else { sb.append(GsonProvider.getInstance().toJson(object)); } sb.append(","); } params.put("_p", sb.toString()); } return postSync(url, params); } @SuppressWarnings("unchecked") public Map<String, String> getHeaders() { try { return (Map<String, String>) CLIENT_HEADER_FIELD.get(this); } catch (IllegalAccessException e) { throw new RuntimeException(e); } } public HttpEntity invokeParamsToEntity(RequestParams params, ResponseHandlerInterface responseHandler) { try { return (HttpEntity) PARAMS_TO_ENTITY.invoke(this, params, responseHandler); } catch (Exception e) { throw new RuntimeException(e); } } public HttpEntityEnclosingRequestBase invokeAddEntityToRequestBase(HttpEntityEnclosingRequestBase requestBase, HttpEntity entity) { try { return (HttpEntityEnclosingRequestBase) ADD_ENTITY_TO_REQUEST_ENTITY.invoke(this, requestBase, entity); } catch (Exception e) { throw new RuntimeException(e); } } /** * check the header * * @param header * the name of the header * @return make sure to has the header */ public boolean hasHeader(String header) { return getHeaders().containsKey(header); } /** * get the header * * @param header * the name of the header * @return the contents of the header */ public String getHeader(String header) { return getHeaders().get(header); } /** * put some headers * * @param headers */ public void addHeadMap(HashMap<String, String> headers) { getHeaders().putAll(headers); } @Override public RequestHandle head(Context context, String url, RequestParams params, ResponseHandlerInterface responseHandler) { return super.head(context, generateUrl(url), params, responseHandler); } @Override public RequestHandle head(Context context, String url, Header[] headers, RequestParams params, ResponseHandlerInterface responseHandler) { return super.head(context, generateUrl(url), headers, params, responseHandler); } @Override public RequestHandle get(Context context, String url, RequestParams params, ResponseHandlerInterface responseHandler) { return super.get(context, generateUrl(url), params, responseHandler); } @Override public RequestHandle get(Context context, String url, Header[] headers, RequestParams params, ResponseHandlerInterface responseHandler) { return super.get(context, generateUrl(url), headers, params, responseHandler); } @Override public RequestHandle post(Context context, String url, HttpEntity entity, String contentType, ResponseHandlerInterface responseHandler) { return super.post(context, generateUrl(url), entity, contentType, responseHandler); } @Override public RequestHandle post(Context context, String url, Header[] headers, RequestParams params, String contentType, ResponseHandlerInterface responseHandler) { return super.post(context, generateUrl(url), headers, params, contentType, responseHandler); } @Override public RequestHandle post(Context context, String url, Header[] headers, HttpEntity entity, String contentType, ResponseHandlerInterface responseHandler) { return super.post(context, generateUrl(url), headers, entity, contentType, responseHandler); } @Override public RequestHandle put(Context context, String url, HttpEntity entity, String contentType, ResponseHandlerInterface responseHandler) { return super.put(context, generateUrl(url), entity, contentType, responseHandler); } @Override public RequestHandle put(Context context, String url, Header[] headers, HttpEntity entity, String contentType, ResponseHandlerInterface responseHandler) { return super.put(context, generateUrl(url), headers, entity, contentType, responseHandler); } @Override public RequestHandle delete(Context context, String url, ResponseHandlerInterface responseHandler) { return super.delete(context, generateUrl(url), responseHandler); } @Override public RequestHandle delete(Context context, String url, Header[] headers, ResponseHandlerInterface responseHandler) { return super.delete(context, generateUrl(url), headers, responseHandler); } @Override public RequestHandle delete(Context context, String url, Header[] headers, RequestParams params, ResponseHandlerInterface responseHandler) { return super.delete(context, generateUrl(url), headers, params, responseHandler); } /** * Instantiate a new asynchronous HTTP request for the passed parameters. * * @param client * HttpClient to be used for request, can differ in single * requests * @param contentType * MIME body type, for POST and PUT requests, may be null * @param context * Context of Android application, to hold the reference of * request * @param httpContext * HttpContext in which the request will be executed * @param responseHandler * ResponseHandler or its subclass to put the response into * @param uriRequest * instance of HttpUriRequest, which means it must be of * HttpDelete, HttpPost, HttpGet, HttpPut, etc. * @return AsyncHttpRequest ready to be dispatched */ @Override protected AsyncHttpRequest newAsyncHttpRequest(DefaultHttpClient client, HttpContext httpContext, HttpUriRequest uriRequest, String contentType, ResponseHandlerInterface responseHandler, Context context) { return new AutoHttpRequest(client, httpContext, uriRequest, responseHandler, getHttpConfig()); } /** * make a config for AsyncHttpClient * * @author DONG Shengdong * */ public static class HttpConfig { public static final String DEFAULT = "DEFAULT"; /** * can be url prefix */ private String prefix; private Map<String, String> headMap; private RequestInterpator requestInterpator; private ErrorCodeHandler errorCodeHandler; public String getPrefix() { return prefix; } public void setPrefix(String prefix) { this.prefix = prefix; } public Map<String, String> getHeadMap() { return headMap; } public void setHeadMap(Map<String, String> headMap) { this.headMap = headMap; } public RequestInterpator getRequestInterpator() { return requestInterpator; } public void setRequestInterpator(RequestInterpator requestInterpator) { this.requestInterpator = requestInterpator; } public ErrorCodeHandler getErrorCodeHandler() { return errorCodeHandler; } public void setErrorCodeHandler(ErrorCodeHandler errorCodeHandler) { this.errorCodeHandler = errorCodeHandler; } public String getUrl(String url) { Log.v(TAG, "getUrl url = " + url); if (TextUtils.isEmpty(prefix) || DEFAULT.equals(url)) { return url; } if (url.startsWith("http")) { return url; } else { return prefix + url; } } } }