HttpProxy网络请求代理

版权声明：本文为延成原创文章，转载请标明出处

		//Application可以随意切换网络框架
//        HttpProxy.init(VolleyHelper.getInstance(this));
        HttpProxy.init(OkHttpHelper.getInstance(this));

/**
 * @author Mr.release
 * @Describe
 */
public class HttpProxy implements IRequestManager {

    private static IRequestManager iRequestManager;
    private static HttpProxy _instance;

    private HttpProxy() {
    }

    public static HttpProxy obtain() {
        synchronized (HttpProxy.class) {
            if (_instance == null) {
                _instance = new HttpProxy();
            }
        }
        return _instance;
    }

    public static void init(IRequestManager manager) {
        iRequestManager = manager;

    }

    @Override
    public void get(String url, ICallBack callBack) {
        iRequestManager.get(url, callBack);
    }

    @Override
    public void get(String url, Map<String, String> heads, ICallBack callBack) {
        iRequestManager.get(url, heads, callBack);
    }

    @Override
    public void post(String url, ICallBack callBack) {
        iRequestManager.post(url, callBack);
    }

    @Override
    public void post(String url, Map<String, String> heads, Map<String, String> params, ICallBack callBack) {
        iRequestManager.post(url, heads, params, callBack);
    }
}

public class OkHttpHelper implements IRequestManager {

    public static final String TAG = "OkHttpHelper";

    private static OkHttpHelper mOkHttpHelper;

    private static OkHttpClient client;
    private Handler mHandler;

    private OkHttpHelper(Context context) {
        File sdcache = context.getExternalCacheDir();
        int cacheSize = 10 * 1024 * 1024;//设置缓存大小
        OkHttpClient.Builder builder = new OkHttpClient.Builder()
                .connectTimeout(15, TimeUnit.SECONDS)
                .writeTimeout(20, TimeUnit.SECONDS)
                .readTimeout(20, TimeUnit.SECONDS)
                .cache(new Cache(sdcache.getAbsoluteFile(), cacheSize));//设置缓存的路径

        builder.sslSocketFactory(createSSLSocketFactory());
        builder.hostnameVerifier(new HostnameVerifier() {
            @Override
            public boolean verify(String hostname, SSLSession session) {
                return true;
            }
        });

        client = builder.build();
        mHandler = new Handler();

    }

    public static OkHttpHelper getInstance(Context context) {

        if (mOkHttpHelper == null) {
            synchronized (OkHttpHelper.class) {
                if (mOkHttpHelper == null) {
                    mOkHttpHelper = new OkHttpHelper(context);
                }
            }
        }
        return mOkHttpHelper;
    }

    @Override
    public void get(String url, ICallBack callBack) {
        if (TextUtils.isEmpty(url)) {
            return;
        }

        Request request = new Request.Builder()
                .url(url)
                .build();

        client.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                sendFailCallback(callBack, e.toString());
            }

            @Override
            public void onResponse(Call call, final Response response) throws IOException {
                LogUtils.i(TAG, "onResponse: " + Thread.currentThread());
                boolean isSuccessful = response.isSuccessful();
                sendSuccessCallback(callBack, isSuccessful, response);
            }
        });
    }

    @Override
    public void get(String url, Map<String, String> heads, ICallBack callBack) {

        if (TextUtils.isEmpty(url)) {
            return;
        }

        Headers headers = appendHeaders(heads);
        Request request = new Request.Builder()
                .headers(headers)
                .url(url)
                .build();

        client.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                sendFailCallback(callBack, e.toString());
            }

            @Override
            public void onResponse(Call call, final Response response) throws IOException {
                boolean isSuccessful = response.isSuccessful();
                sendSuccessCallback(callBack, isSuccessful, response);
            }
        });
    }

    @Override
    public void post(String url, ICallBack callBack) {
        if (TextUtils.isEmpty(url)) {
            return;
        }

        Request request = new Request.Builder()
                .url(url)
                .build();

        client.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                sendFailCallback(callBack, e.toString());
            }

            @Override
            public void onResponse(Call call, final Response response) throws IOException {

                boolean isSuccessful = response.isSuccessful();
                sendSuccessCallback(callBack, isSuccessful, response);
            }
        });
    }

    @Override
    public void post(String url, Map<String, String> heads, Map<String, String> params, ICallBack callBack) {

        if (TextUtils.isEmpty(url)) {
            return;
        }

        Headers headers = appendHeaders(heads);
        RequestBody requestBody = appendBody(params);

        Request request = new Request.Builder()
                .headers(headers)
                .post(requestBody)
                .url(url)
                .build();

        client.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                sendFailCallback(callBack, e.toString());
            }

            @Override
            public void onResponse(Call call, final Response response) throws IOException {

                boolean isSuccessful = response.isSuccessful();
                sendSuccessCallback(callBack, isSuccessful, response);
            }
        });
    }

    private Headers appendHeaders(Map<String, String> headers) {
        Headers.Builder headerBuilder = new Headers.Builder();
        if (headers == null || headers.isEmpty())
            return headerBuilder.build();

        for (String key : headers.keySet()) {
            headerBuilder.add(key, headers.get(key));
        }
        return headerBuilder.build();
    }

    private RequestBody appendBody(Map<String, String> params) {
        FormBody.Builder body = new FormBody.Builder();
        if (params == null || params.isEmpty()) {
            return body.build();
        }
        for (Map.Entry<String, String> entry : params.entrySet()) {
            body.add(entry.getKey(), entry.getValue().toString());
        }
        return body.build();
    }


    private void sendSuccessCallback(final ICallBack callback, final boolean isSuccess, final Response response) {

        try {
            String responseString = response.body().string();
            mHandler.post(new Runnable() {
                @Override
                public void run() {
                    if (isSuccess == true) {
                        callback.onSuccess(responseString);
                    } else
                        callback.onFailure(response.message().toString());
                }
            });
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private void sendFailCallback(final ICallBack callback, String throwable) {
        mHandler.post(new Runnable() {
            @Override
            public void run() {
                callback.onFailure(throwable);
            }
        });
    }

    public SSLSocketFactory createSSLSocketFactory() {
        SSLSocketFactory ssfFactory = null;
        try {
            SSLContext sc = SSLContext.getInstance("TLS");
            sc.init(null, new TrustManager[]{new TrustAllCerts()}, new SecureRandom());
            ssfFactory = sc.getSocketFactory();
        } catch (Exception e) {
        }
        return ssfFactory;
    }

    /**
     * 用于信任所有证书
     */
    class TrustAllCerts implements X509TrustManager {
        @Override
        public void checkClientTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
        }

        @Override
        public void checkServerTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {

        }

        @Override
        public X509Certificate[] getAcceptedIssuers() {
            return new X509Certificate[0];
        }
    }
}

/**
 * @author Mr.release
 * @create 2019/3/22
 * @Describe
 */
public class VolleyHelper implements IRequestManager {

    private static final String TAG = VolleyHelper.class.getSimpleName();
    RequestQueue requestQueue;
    private static VolleyHelper _instance;

    private VolleyHelper(Context context) {
        requestQueue = Volley.newRequestQueue(context);
    }

    public static VolleyHelper getInstance(Context context) {
        if (_instance == null) {
            synchronized (VolleyHelper.class) {
                if (_instance == null) {
                    _instance = new VolleyHelper(context);
                }
            }
        }
        return _instance;
    }

    @Override
    public void get(String url, ICallBack callBack) {

        if (TextUtils.isEmpty(url)) {
            return;
        }

        StringRequest request = new StringRequest(Request.Method.GET, url,
                s -> callBack.onSuccess(s),
                volleyError -> callBack.onFailure(volleyError.toString())) {
        };
        requestQueue.add(request);
    }

    @Override
    public void get(String url, Map<String, String> heads, ICallBack callBack) {

        if (TextUtils.isEmpty(url)) {
            return;
        }

        StringRequest request = new StringRequest(Request.Method.GET, url,
                s -> callBack.onSuccess(s),
                volleyError -> callBack.onFailure(volleyError.toString())) {

            @Override
            public Map<String, String> getHeaders() throws AuthFailureError {
                return heads;
            }
        };
        requestQueue.add(request);
    }

    @Override
    public void post(String url, ICallBack callBack) {
        if (TextUtils.isEmpty(url)) {
            return;
        }
        StringRequest request = new StringRequest(Request.Method.POST, url,
                s -> callBack.onSuccess(s),
                volleyError -> callBack.onFailure(volleyError.toString())) {
        };
        requestQueue.add(request);
    }

    @Override
    public void post(String url, Map<String, String> heads, Map<String, String> params, ICallBack callBack) {
        if (TextUtils.isEmpty(url)) {
            return;
        }

        StringRequest request = new StringRequest(Request.Method.POST, url,
                s -> callBack.onSuccess(s),
                volleyError -> callBack.onFailure(volleyError.toString())) {
            @Override
            protected Map<String, String> getParams() throws AuthFailureError {
                return params;
            }

            @Override
            public Map<String, String> getHeaders() throws AuthFailureError {
                return heads;
            }
        };
        requestQueue.add(request);
    }
}

/**
 * @author Mr.release
 * @create 2019/4/23
 * @Describe
 */
public abstract class HttpCallback<Result> implements ICallBack {

    @Override
    public void onSuccess(String response) {

        Class<?> cls = analysisClazzInfo(this);

        Result result = (Result) JSON.parseObject(response, cls);
        onSuccess(result);
    }

    public abstract void onSuccess(Result result);

    public static Class<?> analysisClazzInfo(Object object) {
        Type genType = object.getClass().getGenericSuperclass();
        Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
        return (Class<?>) params[0];
    }
}

/**
 * @author Mr.release
 * @create 2019/3/29
 * @Describe
 */
public interface  ICallBack {
    void onFailure(String throwable);
    void onSuccess(String response);
}

/**
 * @author Mr.release
 * @create 2019/4/23
 * @Describe
 */
public interface IRequestManager {

    void get(String url, ICallBack callBack);

    void get(String url, Map<String, String> heads, ICallBack callBack);

    void post(String url, ICallBack callBack);

    void post(String url, Map<String, String> heads, Map<String, String> params, ICallBack callBack);
}

/**
 * @author Mr.release
 * @create 2019/3/22
 * @Describe
 */
public interface URL {
    String BASE_URL="http://api.tianapi.com/";
    String news = BASE_URL + "it?key=4a0090627cf07a50def18da875165740&num=20";
}