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

只是简单的封装，还有很多问题

首先在build.gradle 中添加引用

dependencies {
    ···
     api 'com.squareup.okhttp3:okhttp:4.9.0'
     api 'com.google.code.gson:gson:2.8.6'
}

创建EngineCallback接口

public interface EngineCallback {
    /**
     * 请求错误
     *
     * @param e e
     */
    void onError(Exception e);

    /**
     * 请求成功
     *
     * @param result s
     */
    void onSuccess(String result);

    /**
     * 默认的callback
     */
    EngineCallback ENGINE_CALLBACK = new EngineCallback() {
        @Override
        public void onError(Exception e) {

        }

        @Override
        public void onSuccess(String result) {

        }
    };
}

创建引擎规范接口IHttpEngine

public interface IHttpEngine {
    /**
     * get请求
     *
     * @param context  c
     * @param url      s
     * @param params   m
     * @param callback c
     */
    void get(Context context, String url, Map<String, Object> params, EngineCallback callback);

    /**
     * post请求
     *
     * @param context  c
     * @param url      s
     * @param params   m
     * @param callback c
     */
    void post(Context context, String url, Map<String, Object> params, EngineCallback callback);

    /**
     * 下载文件
     */

    /**
     * 上传文件
     */

    /**
     * https添加证书
     */
}

创建默认引擎OkHttpEngine，实现规范接口

public class OkHttpEngine implements IHttpEngine {
    private static final OkHttpClient M_OK_HTTP_CLIENT = new OkHttpClient();

    @Override
    public void get(Context context, String url, Map<String, Object> params, EngineCallback callback) {
        final String jointUrl = HttpUtils.joinParams(url, params);
        Log.e("Get请求路径: ", jointUrl);
        Request request = new Request.Builder()
                .url(url)
                .get()
                .tag(context)
                .build();
        M_OK_HTTP_CLIENT.newCall(request).enqueue(
                new Callback() {
                    @Override
                    public void onFailure(@NotNull Call call, @NotNull IOException e) {
                        callback.onError(e);
                    }

                    @Override
                    public void onResponse(@NotNull Call call, @NotNull Response response) throws IOException {
                        String result = Objects.requireNonNull(response.body()).string();
                        Log.e("Get返回结果: ", result);
                        Looper.prepare();
                        callback.onSuccess(result);
                        Looper.loop();
                    }
                }
        );
    }

    @Override
    public void post(Context context, String url, Map<String, Object> params, EngineCallback callback) {
        final String jointUrl = HttpUtils.joinParams(url, params);
        Log.e("Post请求路径: ", jointUrl);
        RequestBody requestBody = appendBody(params);
        Request request = new Request.Builder()
                .url(url)
                .tag(context)
                .post(requestBody)
                .build();
        M_OK_HTTP_CLIENT.newCall(request).enqueue(
                new Callback() {
                    @Override
                    public void onFailure(@NotNull Call call, @NotNull IOException e) {
                        callback.onError(e);
                    }

                    @Override
                    public void onResponse(@NotNull Call call, @NotNull Response response) throws IOException {
                        String result = Objects.requireNonNull(response.body()).string();
                        Log.e("Post返回结果: ", result);
                        Looper.prepare();
                        callback.onSuccess(result);
                        Looper.loop();
                    }
                }
        );
    }

    /**
     * 组装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(file, MediaType.parse(guessMimeType(file.getAbsolutePath()))));
                } else if (value instanceof List) {
                    try {
                        List<File> fileList = (List<File>) value;
                        for (int i = 0; i < fileList.size(); i++) {
                            //获取文件
                            File file = fileList.get(i);
                            builder.addFormDataPart(key + i, file.getName(), RequestBody
                                    .create(file, MediaType.parse(guessMimeType(file.getAbsolutePath()))));
                        }
                    } 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;
    }
}

创建HttpUtils类

public class HttpUtils {

    private String mUrl;
    private int mType = GET_TYPE;
    private static final int POST_TYPE = 0x0011;
    private static final int GET_TYPE = 0x0012;
    private final Map<String, Object> mParams;
    private final Context mContext;

    private HttpUtils(Context context) {
        mContext = context;
        mParams = new ArrayMap<>();
    }

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

    /**
     * 请求地址
     */
    public HttpUtils url(String url) {
        mUrl = url;
        return this;
    }

    /**
     * 请求方式
     */
    public HttpUtils post() {
        mType = POST_TYPE;
        return this;
    }

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

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

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

    /**
     * 添加回调
     */
    public void execute(EngineCallback callback) {
        if (callback == null) {
            callback = EngineCallback.ENGINE_CALLBACK;
        }
        //判断执行方法
        if (mType == POST_TYPE) {
            post(mUrl, mParams, callback);
        }
        if (mType == GET_TYPE) {
            get(mUrl, mParams, callback);
        }
    }

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

    /**
     * 默认OkHttpEngine
     */
    private static IHttpEngine mIHttpEngine = new OkHttpEngine();

    /**
     * 在application中初始化引擎
     *
     * @param iHttpEngine h
     */
    public static void init(IHttpEngine iHttpEngine) {
        mIHttpEngine = iHttpEngine;
    }

    /**
     * 每次可以自带引擎
     *
     * @param iHttpEngine h
     */
    public HttpUtils exchangeEngine(IHttpEngine iHttpEngine) {
        mIHttpEngine = iHttpEngine;
        return this;
    }

    private void get(String url, Map<String, Object> params, EngineCallback callback) {
        mIHttpEngine.get(mContext, url, params, callback);
    }

    private void post(String url, Map<String, Object> params, EngineCallback callback) {
        mIHttpEngine.post(mContext, url, params, callback);
    }

    /**
     * 拼接参数
     */
    public static String joinParams(String url, Map<String, Object> params) {
        if (params == null || params.size() <= 0) {
            return url;
        }
        StringBuilder stringBuilder = new StringBuilder(url);
        if (!url.contains("?")) {
            stringBuilder.append("?");
        } else {
            if (!url.endsWith("?")) {
                stringBuilder.append("&");
            }
        }
        for (Map.Entry<String, Object> entry : params.entrySet()) {
            stringBuilder.append(entry.getKey()).append("=").append(entry.getValue()).append("&");
        }
        stringBuilder.deleteCharAt(stringBuilder.length() - 1);
        return stringBuilder.toString();
    }
	
    /**
     * 解析一个类上面的class信息
     */
    public static Class<?> analysisClazzInfo(Object object) {
        Type getType = object.getClass().getGenericSuperclass();
        Type[] params = ((ParameterizedType) getType).getActualTypeArguments();
        return (Class<?>) params[0];
    }
}

创建带业务的抽象HttpCallback类

把公用参数添加到params中去

public abstract class HttpCallback<T> implements EngineCallback {
    @Override
    public void onPreExecute(Context context, Map<String, Object> params) {
        //添加公用参数，与项目的业务逻辑有关
        params.put("app_name","joke_essay");
        params.put("app_name2","joke_essay");
        params.put("app_name3","joke_essay");
        onPreExecute();
    }

    /**
     * 开始执行
     */
    public void onPreExecute() {
    }

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

    /**
     * 返回可直接操作的对象
     * @param result t
     */
    public abstract void onSuccess(T result);
}

使用方法

HttpUtils.with(this).url(url).get().execute(new EngineCallback() {
    @Override
    public void onError(Exception e) {
    }

    @Override
    public void onSuccess(String result) {
    }
});