链式调用打造第三方的网络引擎

首先IHttpEnigne

public interface IHttpEngine {
    //get方法
     void get(Context context, String url, Map<String,Object> params, EngineCallBack callBack);
    //post方法
    void post(Context context,String url, Map<String,Object> params,EngineCallBack callBack);
    //下载文件

    //上传文件

    //https证书
}

HttpUtils

public class HttpUtils {
    //链式调用    要什么  传什么
    //url
    private String mUrl;
    //请求方式
    private int mType = GET_TYPE;
    private static final int POST_TYPE = 0x0011;
    private static final int GET_TYPE = 0x0010;

    private Context mContext;
    private Map<String, Object> mParams;

    //不允许外部去调用
    private HttpUtils(Context context) {
        this.mContext = context;
        mParams = new HashMap<>();
    }

    public static HttpUtils with(Context context) {
        return new HttpUtils(context);
    }

    //url
    public HttpUtils url(String url) {
        this.mUrl = url;
        return this;
    }

    //get请求
    public HttpUtils get() {
        mType = GET_TYPE;
        return this;
    }

    //post
    public HttpUtils post() {
        mType = GET_TYPE;
        return this;
    }

    //添加参数
    public HttpUtils addParams(String key, String value) {
        mParams.put(key, value);
        return this;
    }

    public HttpUtils addParams(Map<String, Object> params) {
        mParams.putAll(params);
        return this;
    }

    //回调方法
    public void execture(EngineCallBack callBack) {
        if (callBack == null) {
            callBack = EngineCallBack.DEFAULT_CALL_BACK;
        }
        if (mType == GET_TYPE) {
            get(mUrl, mParams, callBack);
        }
        if (mType == POST_TYPE) {
            post(mUrl, mParams, callBack);
        }
    }

    public void execture() {
        execture(null);
    }

    //默认是OkHttp引擎
    private static IHttpEngine mHttpEngine = new OkHttpEngine();

    public HttpUtils() {
    }

    //Application中调用
    public static void init(IHttpEngine httpEngine) {
        mHttpEngine = httpEngine;
    }

    /**
     * 切换引擎
     */
    public HttpUtils exchangeEngine(IHttpEngine httpEngine) {
        mHttpEngine = httpEngine;
        return this;
    }


    private void get(String url, Map<String, Object> params, EngineCallBack callBack) {
        mHttpEngine.get(mContext, url, params, callBack);
    }


    private void post(String url, Map<String, Object> params, EngineCallBack callBack) {
        mHttpEngine.post(mContext, url, params, callBack);
    }

    /**
     * 拼接参数
     */
    public static String jointParams(String url, Map<String, Object> params) {
        if (params == null || params.size() <= 0) {
            return url;
        }
        StringBuffer stringBuffer = new StringBuffer(url);
        if (!url.contains("?")) {
            stringBuffer.append("?");
        } else {
            if (!url.endsWith("?")) {
                stringBuffer.append("&");
            }
        }
        for (Map.Entry<String, Object> entry : params.entrySet()) {
            stringBuffer.append(entry.getKey() + "=" + entry.getValue() + "&");
        }
        stringBuffer.deleteCharAt(stringBuffer.length() - 1);
        return stringBuffer.toString();
    }

    /**
     * 反射获取泛型参数
     */
    public static Class<?> analysisClazzInfo(Object object) {
        Type genType = object.getClass().getGenericSuperclass();//获得带有泛型的父类
        Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
        return (Class<?>) params[0];
    }


}

EngineCallBack

public interface EngineCallBack {
    //错误
    public void onError(Exception e);

    //成功    data{"",""} 成功 失败 data ""
    public void onSuccess(String result);

    //方法执行前回调方法
    public void onPreExceture(Context context, Map<String, Object> params);

    //默认回调接口
    public EngineCallBack DEFAULT_CALL_BACK = new EngineCallBack() {
        @Override
        public void onError(Exception e) {

        }

        @Override
        public void onSuccess(String result) {

        }

        @Override
        public void onPreExceture(Context context, Map<String, Object> params) {

        }
    };
}

OKHttpEngine

public class OkHttpEngine implements IHttpEngine {
    private OkHttpClient mOkHttpClient = new OkHttpClient();

    @Override
    public void get(Context context, String url, Map<String, Object> params, final EngineCallBack callBack) {
        url = HttpUtils.jointParams(url, params);
        Log.e("Get请求路径：", url);
        Request.Builder requestBuilder = new Request.Builder().url(url).tag(context);
        //可以省略，默认是GET请求
        Request request = requestBuilder.build();
        mOkHttpClient.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                callBack.onError(e);
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                String resultJson = response.body().string();
                callBack.onSuccess(resultJson);
                Log.e("Get返回结果：", resultJson);
            }
        });
    }

    @Override
    public void post(Context context, String url, Map<String, Object> params, final EngineCallBack callBack) {
        final String jointUrl = HttpUtils.jointParams(url,params);  //打印
        Log.e("Post请求路径：",jointUrl);
        RequestBody requestBody = appendBody(params);
        Request request = new Request.Builder()
                .url(url)
                .tag(context)
                .post(requestBody)
                .build();

        mOkHttpClient.newCall(request).enqueue(
                new Callback() {
                    @Override
                    public void onFailure(okhttp3.Call call, IOException e) {
                        callBack.onError(e);
                    }

                    @Override
                    public void onResponse(okhttp3.Call call, Response response) throws IOException {
                        // 这个 两个回掉方法都不是在主线程中
                        String result = response.body().string();
                        Log.e("Post返回结果：",jointUrl);
                        callBack.onSuccess(result);
                    }
                }
        );

    }
    /**
     * 组装post请求参数body
     */
    protected RequestBody appendBody(Map<String,Object> params){
        MultipartBody.Builder builder = new MultipartBody.Builder()
                .setType(MultipartBody.FORM);
        addParams(builder, params);
        return builder.build();
    }

    // 添加参数
    private void addParams(MultipartBody.Builder builder, Map<String, Object> params) {
        if (params != null && !params.isEmpty()) {
            for (String key : params.keySet()) {
                builder.addFormDataPart(key, params.get(key) + "");
                Object value = params.get(key);
                if (value instanceof File) {
                    // 处理文件 --> Object File
                    File file = (File) value;
                    builder.addFormDataPart(key, file.getName(), RequestBody
                            .create(MediaType.parse(guessMimeType(file
                                    .getAbsolutePath())), file));
                } else if (value instanceof List) {
                    // 代表提交的是 List集合
                    try {
                        List<File> listFiles = (List<File>) value;
                        for (int i = 0; i < listFiles.size(); i++) {
                            // 获取文件
                            File file = listFiles.get(i);
                            builder.addFormDataPart(key + i, file.getName(), RequestBody
                                    .create(MediaType.parse(guessMimeType(file
                                            .getAbsolutePath())), file));
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                } else {
                    builder.addFormDataPart(key, value + "");
                }
            }
        }
    }

    /**
     * 猜测文件类型
     */
    private String guessMimeType(String path) {
        FileNameMap fileNameMap = URLConnection.getFileNameMap();
        String contentTypeFor = fileNameMap.getContentTypeFor(path);
        if (contentTypeFor == null) {
            contentTypeFor = "application/octet-stream";
        }
        return contentTypeFor;
    }



}

1.请求网络的时候会有很多相同的参数，这时候我们可以在方法执行前添加相同的参数
2.回掉每次都要用 Json转换 但是不能够直接用泛型，因为当我们调用成功的时候后台会传json数据，但是当失败的时候又有可能传的是字符串

HttpCallBack

public abstract class HttpCallBack<T> implements EngineCallBack {


    @Override
    public void onPreExceture(Context context, Map<String, Object> params) {
        // 大大方方的添加公用参数  与项目业务逻辑有关
        // 项目名称  context
        params.put("app_name","joke_essay");
        params.put("version_name","5.7.0");
        params.put("ac","wifi");
        params.put("device_id","30036118478");
        params.put("device_brand","Xiaomi");
        params.put("update_version_code","5701");
        params.put("manifest_version_code","570");
        params.put("longitude","113.000366");
        params.put("latitude","28.171377");
        params.put("device_platform","android");

        onPreExecute();
    }

    protected  void onPreExecute(){

    }

    @Override
    public void onSuccess(String result) {
        Gson gson=new Gson();
        T objectResult= (T) gson.fromJson(result, HttpUtils.analysisClazzInfo(this));
        onSuccess(objectResult);
    }

    public abstract void onSuccess(T result);
}

使用

 HttpUtils.with(this).url("http://is.snssdk.com/2/essay/discovery/v3/")
                .addParams("iid", "6152551759")
                .addParams("aid", "7")
                .exchangeEngine(new OkHttpEngine())
                .execture(new HttpCallBack<DiscoverListResult> (){
                    @Override
                    public void onError(Exception e) {

                    }

                    @Override
                    public void onSuccess(DiscoverListResult result) {
                        Log.e("TAG", "name --> "+result.getData().getCategories().getName());
                    }

                    @Override
                    public void onPreExecute() {
                        super.onPreExecute();
                        //进度条等
                    }
                });