己用Okhttp工具类

1、请求工具类

import android.os.Handler;
import android.os.Looper;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;

import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.FormBody;
import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;
import okhttp3.logging.HttpLoggingInterceptor;

/**
 * 网络请求工厂类
 */
public class OkHttpFactory {
    private static OkHttpFactory mInstance;
    private OkHttpClient mOkHttpClient;
    private Handler mDelivery;
    private static final MediaType JSON = MediaType.parse("application/json; charset=utf-8");

    public OkHttpFactory(OkHttpClient okHttpClient) {
        if (okHttpClient == null) {
            mOkHttpClient = new OkHttpClient();
        } else {
            mOkHttpClient = okHttpClient;
        }
        if (mDelivery == null)
            mDelivery = new Handler(Looper.getMainLooper());
    }

   void goInitClient(){ //初始化示范
        OkHttpClient.Builder builder = new OkHttpClient.Builder();
        HttpLoggingInterceptor loggingInterceptor = new HttpLoggingInterceptor();
        builder.addInterceptor(loggingInterceptor);
        builder.readTimeout(60000L, TimeUnit.MILLISECONDS);
        builder.writeTimeout(60000L, TimeUnit.MILLISECONDS);
        builder.connectTimeout(60000L, TimeUnit.MILLISECONDS);
        HttpsUtils.SSLParams sslParams = HttpsUtils.getSslSocketFactory();
        builder.sslSocketFactory(sslParams.sSLSocketFactory, sslParams.trustManager);
        builder.hostnameVerifier(HttpsUtils.UnSafeHostnameVerifier);
       OkHttpClient okHttpClient = builder.build();
    }


    // 推荐在AppLocation中初始化
    public static OkHttpFactory initClient(OkHttpClient okHttpClient) {
        if (mInstance == null) {
            synchronized (OkHttpFactory.class) {
                if (mInstance == null) {
                    mInstance = new OkHttpFactory(okHttpClient);
                }
            }
        }
        return mInstance;
    }

    public static OkHttpFactory getInstance() {
        return initClient(null);
    }

    /**
     * 同步的Get请求
     *
     * @param url
     * @return Response
     */
    private Response getSync(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
     * @param callback
     */
    public Call get(String url, final ResultCallback callback , Object tag) {
        final Request request = new Request.Builder()
                .url(url)
                .tag(tag)
                .build();
       return deliveryResult(callback, request);
    }

    /**
     * 同步的Post请求
     *
     * @param url
     * @param params post的参数
     * @return
     */
    private Response postSync(String url, Map<String, String> params , Object tag) throws IOException {
        Request request = buildPostRequest(url, params ,tag);
        Response response = mOkHttpClient.newCall(request).execute();
        return response;
    }

    /**
     * 异步的post请求
     *
     * @param url
     * @param callback
     * @param params
     */
    public Call post(String url, final ResultCallback callback, Object tag, Map<String, String> params) {
        Request request = buildPostRequest(url, params , tag);
       return deliveryResult(callback, request);
    }

    /**
     *
     * @param url            地址
     * @param jsonParams     参数
     * @param herder         herder
     * @param tag            用于区分是谁调用的标志
     * @param resultCallback 回调
     * @return Call 用于特殊情况下调用cancel方法取消请求
     */
    public Call postJson(String url, String jsonParams, HashMap<String, String> herder, String tag, ResultCallback resultCallback) {
        RequestBody requestBody = RequestBody.create(JSON, jsonParams);
        Request.Builder builder = new Request.Builder().post(requestBody).url(url).tag(tag);

        if (herder != null && !herder.isEmpty()) {
            for (Map.Entry<String, String> entry : herder.entrySet()) {
                builder.addHeader(entry.getKey(), entry.getValue());
            }
        }
        Request request = builder.build();
        return deliveryResult(resultCallback, request);
    }

    private Request buildPostRequest(String url, Map<String, String> params,Object tag) {
        FormBody.Builder builder = new FormBody.Builder();
        if (params != null && !params.isEmpty()) {
            for (Map.Entry<String, String> entry : params.entrySet()) {
                builder.add(entry.getKey(), entry.getValue());
            }
        }
        RequestBody requestBody = builder.build();
        return new Request.Builder()
                .url(url)
                .post(requestBody)
                .tag(tag)
                .build();
    }


    private Call deliveryResult(final ResultCallback callback, Request request) {
        Call call = mOkHttpClient.newCall(request);
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                sendFailedStringCallback(call.request(), e, callback , call.request().tag());
            }

            @Override
            public void onResponse(Call call, Response response) {
                try {
                    final String string = response.body().string();
                    sendSuccessResultCallback(string, callback, response.request().tag());
                } catch (IOException e) {
                    sendFailedStringCallback(response.request(), e, callback, response.request().tag());
                }
            }
        });
        return call;
    }

    private void sendFailedStringCallback(final Request request, final Exception e, final ResultCallback callback, final Object tag) {
        mDelivery.post(new Runnable() {
            @Override
            public void run() {
                if (callback != null)
                    callback.onFailure(request, e, tag);
            }
        });
    }

    private void sendSuccessResultCallback(final Object object, final ResultCallback callback, final Object tag) {
        mDelivery.post(new Runnable() {
            @Override
            public void run() {
                if (callback != null) {
                    callback.onResponse(object, tag);
                }
            }
        });
    }

    public void cancelTag(Object tag)
    {
        for (Call call : mOkHttpClient.dispatcher().queuedCalls())
        {
            if (tag.equals(call.request().tag()))
            {
                call.cancel();
            }
        }
        for (Call call : mOkHttpClient.dispatcher().runningCalls())
        {
            if (tag.equals(call.request().tag()))
            {
                call.cancel();
            }
        }
    }

    public void cancelTag()
    {
        mOkHttpClient.dispatcher().cancelAll();
    }

}

2、回调工具类

import okhttp3.Request;

public abstract class ResultCallback<T> {

    public abstract void onResponse(T response , Object tag);
    public abstract void onFailure(Request request, Exception e , Object tag);


}

3、https工具类，可选

import java.io.IOException;
import java.io.InputStream;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.KeyStore.LoadStoreParameter;
import java.security.cert.Certificate;
import java.security.cert.CertificateException;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.KeyManager;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.TrustManagerFactory;
import javax.net.ssl.X509TrustManager;

public class HttpsUtils {
    public static X509TrustManager UnSafeTrustManager = new X509TrustManager() {
        public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
        }

        public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
        }

        public X509Certificate[] getAcceptedIssuers() {
            return new X509Certificate[0];
        }
    };
    public static HostnameVerifier UnSafeHostnameVerifier = new HostnameVerifier() {
        public boolean verify(String hostname, SSLSession session) {
            return true;
        }
    };

    public HttpsUtils() {
    }

    public static HttpsUtils.SSLParams getSslSocketFactory() {
        return getSslSocketFactoryBase((X509TrustManager)null, (InputStream)null, (String)null);
    }

    public static HttpsUtils.SSLParams getSslSocketFactory(X509TrustManager trustManager) {
        return getSslSocketFactoryBase(trustManager, (InputStream)null, (String)null);
    }

    public static HttpsUtils.SSLParams getSslSocketFactory(InputStream... certificates) {
        return getSslSocketFactoryBase((X509TrustManager)null, (InputStream)null, (String)null, certificates);
    }

    public static HttpsUtils.SSLParams getSslSocketFactory(InputStream bksFile, String password, InputStream... certificates) {
        return getSslSocketFactoryBase((X509TrustManager)null, bksFile, password, certificates);
    }

    public static HttpsUtils.SSLParams getSslSocketFactory(InputStream bksFile, String password, X509TrustManager trustManager) {
        return getSslSocketFactoryBase(trustManager, bksFile, password);
    }

    private static HttpsUtils.SSLParams getSslSocketFactoryBase(X509TrustManager trustManager, InputStream bksFile, String password, InputStream... certificates) {
        HttpsUtils.SSLParams sslParams = new HttpsUtils.SSLParams();

        try {
            KeyManager[] keyManagers = prepareKeyManager(bksFile, password);
            TrustManager[] trustManagers = prepareTrustManager(certificates);
            X509TrustManager manager;
            if (trustManager != null) {
                manager = trustManager;
            } else if (trustManagers != null) {
                manager = chooseTrustManager(trustManagers);
            } else {
                manager = UnSafeTrustManager;
            }

            SSLContext sslContext = SSLContext.getInstance("TLS");
            sslContext.init(keyManagers, new TrustManager[]{manager}, (SecureRandom)null);
            sslParams.sSLSocketFactory = sslContext.getSocketFactory();
            sslParams.trustManager = manager;
            return sslParams;
        } catch (NoSuchAlgorithmException var9) {
            throw new AssertionError(var9);
        } catch (KeyManagementException var10) {
            throw new AssertionError(var10);
        }
    }

    private static KeyManager[] prepareKeyManager(InputStream bksFile, String password) {
        try {
            if (bksFile != null && password != null) {
                KeyStore clientKeyStore = KeyStore.getInstance("BKS");
                clientKeyStore.load(bksFile, password.toCharArray());
                KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
                kmf.init(clientKeyStore, password.toCharArray());
                return kmf.getKeyManagers();
            } else {
                return null;
            }
        } catch (Exception var4) {
            var4.printStackTrace();
            return null;
        }
    }

    private static TrustManager[] prepareTrustManager(InputStream... certificates) {
        if (certificates != null && certificates.length > 0) {
            try {
                CertificateFactory certificateFactory = CertificateFactory.getInstance("X.509");
                KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
                keyStore.load((LoadStoreParameter)null);
                int index = 0;
                InputStream[] var4 = certificates;
                int var5 = certificates.length;

                for(int var6 = 0; var6 < var5; ++var6) {
                    InputStream certStream = var4[var6];
                    String certificateAlias = Integer.toString(index++);
                    Certificate cert = certificateFactory.generateCertificate(certStream);
                    keyStore.setCertificateEntry(certificateAlias, cert);

                    try {
                        if (certStream != null) {
                            certStream.close();
                        }
                    } catch (IOException var11) {
                        var11.printStackTrace();
                    }
                }

                TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
                tmf.init(keyStore);
                return tmf.getTrustManagers();
            } catch (Exception var12) {
                var12.printStackTrace();
                return null;
            }
        } else {
            return null;
        }
    }

    private static X509TrustManager chooseTrustManager(TrustManager[] trustManagers) {
        TrustManager[] var1 = trustManagers;
        int var2 = trustManagers.length;

        for(int var3 = 0; var3 < var2; ++var3) {
            TrustManager trustManager = var1[var3];
            if (trustManager instanceof X509TrustManager) {
                return (X509TrustManager)trustManager;
            }
        }

        return null;
    }

    public static class SSLParams {
        public SSLSocketFactory sSLSocketFactory;
        public X509TrustManager trustManager;

        public SSLParams() {
        }
    }
}