Java tutorial
package cn.wochu.wh.net; import android.os.Handler; import android.os.Looper; import android.widget.ImageView; import com.google.gson.Gson; import com.google.gson.internal.$Gson$Types; import com.squareup.okhttp.Call; import com.squareup.okhttp.Callback; import com.squareup.okhttp.FormEncodingBuilder; import com.squareup.okhttp.Headers; import com.squareup.okhttp.MediaType; import com.squareup.okhttp.MultipartBuilder; import com.squareup.okhttp.OkHttpClient; import com.squareup.okhttp.Request; import com.squareup.okhttp.RequestBody; import com.squareup.okhttp.Response; import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; import java.net.CookieManager; import java.net.CookiePolicy; import java.net.FileNameMap; import java.net.URLConnection; import java.util.HashMap; import java.util.Map; import java.util.Set; /** * Copyright 2016 DoubleDa * <p/> * 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 * <p/> * http://www.apache.org/licenses/LICENSE-2.0 * <p/> * 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. */ public class OkHttpClientManager { private static OkHttpClientManager mInstance; private OkHttpClient mOkHttpClient; private Handler mDelivery; private Gson mGson; private static final String TAG = "OkHttpClientManager"; private OkHttpClientManager() { mOkHttpClient = new OkHttpClient(); //cookie enabled mOkHttpClient.setCookieHandler(new CookieManager(null, CookiePolicy.ACCEPT_ORIGINAL_SERVER)); mDelivery = new Handler(Looper.getMainLooper()); mGson = new Gson(); } public static OkHttpClientManager getInstance() { if (mInstance == null) { synchronized (OkHttpClientManager.class) { if (mInstance == null) { mInstance = new OkHttpClientManager(); } } } return mInstance; } /** * ?Get * * @param url * @return Response */ private Response _getAsyn(String url) throws IOException { final Request request = new Request.Builder().url(url).build(); Call call = mOkHttpClient.newCall(request); Response execute = call.execute(); return execute; } /** * ?Get * * @param url * @return */ private String _getAsString(String url) throws IOException { Response execute = _getAsyn(url); return execute.body().string(); } /** * get * * @param url * @param callback */ private void _getAsyn(String url, final ResultCallback callback) { final Request request = new Request.Builder().url(url).build(); deliveryResult(callback, request); } /** * ?Post * * @param url * @param params post? * @return */ private Response _post(String url, Param... params) throws IOException { Request request = buildPostRequest(url, params); Response response = mOkHttpClient.newCall(request).execute(); return response; } /** * ?Post * * @param url * @param params post? * @return */ private String _postAsString(String url, Param... params) throws IOException { Response response = _post(url, params); return response.body().string(); } /** * post * * @param url * @param callback * @param params */ private void _postAsyn(String url, final ResultCallback callback, Param... params) { Request request = buildPostRequest(url, params); deliveryResult(callback, request); } private void _postAsyn(String url, final ResultCallback callback, String params) { Request request = buildPostRequest(url, params); deliveryResult(callback, request); } /** * post * * @param url * @param callback * @param params */ private void _postAsyn(String url, final ResultCallback callback, Map<String, String> params) { Param[] paramsArr = map2Params(params); Request request = buildPostRequest(url, paramsArr, params.toString()); deliveryResult(callback, request); } /** * ?post * * @param params * @return */ private Response _post(String url, File[] files, String[] fileKeys, Param... params) throws IOException { Request request = buildMultipartFormRequest(url, files, fileKeys, params); return mOkHttpClient.newCall(request).execute(); } private Response _post(String url, File file, String fileKey) throws IOException { Request request = buildMultipartFormRequest(url, new File[] { file }, new String[] { fileKey }, null); return mOkHttpClient.newCall(request).execute(); } private Response _post(String url, File file, String fileKey, Param... params) throws IOException { Request request = buildMultipartFormRequest(url, new File[] { file }, new String[] { fileKey }, params); return mOkHttpClient.newCall(request).execute(); } /** * post * * @param url * @param callback * @param files * @param fileKeys * @throws IOException */ private void _postAsyn(String url, ResultCallback callback, File[] files, String[] fileKeys, Param... params) throws IOException { Request request = buildMultipartFormRequest(url, files, fileKeys, params); deliveryResult(callback, request); } /** * post??? * * @param url * @param callback * @param file * @param fileKey * @throws IOException */ private void _postAsyn(String url, ResultCallback callback, File file, String fileKey) throws IOException { Request request = buildMultipartFormRequest(url, new File[] { file }, new String[] { fileKey }, null); deliveryResult(callback, request); } /** * post??form? * * @param url * @param callback * @param file * @param fileKey * @param params * @throws IOException */ private void _postAsyn(String url, ResultCallback callback, File file, String fileKey, Param... params) throws IOException { Request request = buildMultipartFormRequest(url, new File[] { file }, new String[] { fileKey }, params); deliveryResult(callback, request); } /** * * * @param url * @param destFileDir * @param callback */ private void _downloadAsyn(final String url, final String destFileDir, final ResultCallback callback) { final Request request = new Request.Builder().url(url).build(); final Call call = mOkHttpClient.newCall(request); call.enqueue(new Callback() { @Override public void onFailure(final Request request, final IOException e) { sendFailedStringCallback(request, e, callback); } @Override public void onResponse(Response response) { InputStream is = null; byte[] buf = new byte[2048]; int len = 0; FileOutputStream fos = null; try { is = response.body().byteStream(); File file = new File(destFileDir, getFileName(url)); fos = new FileOutputStream(file); while ((len = is.read(buf)) != -1) { fos.write(buf, 0, len); } fos.flush(); //??? sendSuccessResultCallback(file.getAbsolutePath(), callback); } catch (IOException e) { sendFailedStringCallback(response.request(), e, callback); } finally { try { if (is != null) is.close(); } catch (IOException e) { } try { if (fos != null) fos.close(); } catch (IOException e) { } } } }); } private String getFileName(String path) { int separatorIndex = path.lastIndexOf("/"); return (separatorIndex < 0) ? path : path.substring(separatorIndex + 1, path.length()); } private void setErrorResId(final ImageView view, final int errorResId) { mDelivery.post(new Runnable() { @Override public void run() { view.setImageResource(errorResId); } }); } //************************* public static Response getAsyn(String url) throws IOException { return getInstance()._getAsyn(url); } public static String getAsString(String url) throws IOException { return getInstance()._getAsString(url); } public static <T> void getAsyn(String url, ResultCallback<T> callback) { getInstance()._getAsyn(url, callback); } public static Response post(String url, Param... params) throws IOException { return getInstance()._post(url, params); } public static String postAsString(String url, Param... params) throws IOException { return getInstance()._postAsString(url, params); } public static void postAsyn(String url, final ResultCallback callback, Param... params) { getInstance()._postAsyn(url, callback, params); } public static void postAsyn(String url, final ResultCallback callback, String params) { getInstance()._postAsyn(url, callback, params); } public static void postAsyn(String url, final ResultCallback callback, Map<String, String> params) { getInstance()._postAsyn(url, callback, params); } public static Response post(String url, File[] files, String[] fileKeys, Param... params) throws IOException { return getInstance()._post(url, files, fileKeys, params); } public static Response post(String url, File file, String fileKey) throws IOException { return getInstance()._post(url, file, fileKey); } public static Response post(String url, File file, String fileKey, Param... params) throws IOException { return getInstance()._post(url, file, fileKey, params); } public static void postAsyn(String url, ResultCallback callback, File[] files, String[] fileKeys, Param... params) throws IOException { getInstance()._postAsyn(url, callback, files, fileKeys, params); } public static void postAsyn(String url, ResultCallback callback, File file, String fileKey) throws IOException { getInstance()._postAsyn(url, callback, file, fileKey); } public static void postAsyn(String url, ResultCallback callback, File file, String fileKey, Param... params) throws IOException { getInstance()._postAsyn(url, callback, file, fileKey, params); } public static void downloadAsyn(String url, String destDir, ResultCallback callback) { getInstance()._downloadAsyn(url, destDir, callback); } //**************************** private Request buildMultipartFormRequest(String url, File[] files, String[] fileKeys, Param[] params) { params = validateParam(params); MultipartBuilder builder = new MultipartBuilder().type(MultipartBuilder.FORM); for (Param param : params) { builder.addPart(Headers.of("Content-Disposition", "form-data; name=\"" + param.key + "\""), RequestBody.create(null, param.value)); } if (files != null) { RequestBody fileBody = null; for (int i = 0; i < files.length; i++) { File file = files[i]; String fileName = file.getName(); fileBody = RequestBody.create(MediaType.parse(guessMimeType(fileName)), file); //TODO ???contentType builder.addPart( Headers.of("Content-Disposition", "form-data; name=\"" + fileKeys[i] + "\"; filename=\"" + fileName + "\""), fileBody); } } RequestBody requestBody = builder.build(); return new Request.Builder().url(url).post(requestBody).build(); } private String guessMimeType(String path) { FileNameMap fileNameMap = URLConnection.getFileNameMap(); String contentTypeFor = fileNameMap.getContentTypeFor(path); if (contentTypeFor == null) { contentTypeFor = "application/octet-stream"; } return contentTypeFor; } private Param[] validateParam(Param[] params) { if (params == null) return new Param[0]; else return params; } private Param[] map2Params(Map<String, String> params) { if (params == null) return new Param[0]; int size = params.size(); Param[] res = new Param[size]; Set<Map.Entry<String, String>> entries = params.entrySet(); int i = 0; for (Map.Entry<String, String> entry : entries) { res[i++] = new Param(entry.getKey(), entry.getValue()); } return res; } private static final String SESSION_KEY = "Set-Cookie"; private static final String mSessionKey = "JSESSIONID"; private Map<String, String> mSessions = new HashMap<String, String>(); private void deliveryResult(final ResultCallback callback, Request request) { callback.onBefore(request); mOkHttpClient.newCall(request).enqueue(new Callback() { @Override public void onFailure(final Request request, final IOException e) { //sendFailedStringCallback(request, e, callback); callback.onError(request, e); callback.onAfter(); } @Override public void onResponse(final Response response) { try { final String string = response.body().string(); if (callback.mType == String.class) { sendSuccessResultCallback(string, callback); } else { Object o = mGson.fromJson(string, callback.mType); sendSuccessResultCallback(o, callback); } } catch (IOException e) { sendFailedStringCallback(response.request(), e, callback); } catch (com.google.gson.JsonParseException e)//Json? { sendFailedStringCallback(response.request(), e, callback); } } }); } private void sendFailedStringCallback(final Request request, final Exception e, final ResultCallback callback) { mDelivery.post(new Runnable() { @Override public void run() { if (callback != null) callback.onError(request, e); callback.onAfter(); } }); } private void sendSuccessResultCallback(final Object object, final ResultCallback callback) { mDelivery.post(new Runnable() { @Override public void run() { if (callback != null) { callback.onResponse(object); callback.onAfter(); } } }); } @SuppressWarnings("static-access") private Request buildPostRequest(String url, Param[] params) { if (params == null) { params = new Param[0]; } FormEncodingBuilder builder = new FormEncodingBuilder(); for (Param param : params) { builder.add(param.key, param.value); } RequestBody requestBody = builder.build().create(MediaType.parse("application/json; charset=utf-8"), "json"); return new Request.Builder().url(url).post(requestBody).build(); } private Request buildPostRequest(String url, String params) { FormEncodingBuilder builder = new FormEncodingBuilder(); RequestBody requestBody = builder.build().create(MediaType.parse("application/json; charset=utf-8"), params); return new Request.Builder().url(url).post(requestBody).build(); } private Request buildPostRequest(String url, Param[] params, String content) { if (params == null) { params = new Param[0]; } FormEncodingBuilder builder = new FormEncodingBuilder(); for (Param param : params) { builder.add(param.key, param.value); } RequestBody requestBody = builder.build().create(MediaType.parse("application/json; charset=utf-8"), content); return new Request.Builder().url(url).post(requestBody).build(); } public static abstract class ResultCallback<T> { Type mType; public ResultCallback() { mType = getSuperclassTypeParameter(getClass()); } static Type getSuperclassTypeParameter(Class<?> subclass) { Type superclass = subclass.getGenericSuperclass(); if (superclass instanceof Class) { throw new RuntimeException("Missing type parameter."); } ParameterizedType parameterized = (ParameterizedType) superclass; return $Gson$Types.canonicalize(parameterized.getActualTypeArguments()[0]); } public void onBefore(Request request) { } ;// public void onAfter() { } ;//? public abstract void onError(Request request, Exception e); public abstract void onResponse(T response); } public static class Param { public Param() { } public Param(String key, String value) { this.key = key; this.value = value; } String key; String value; } }