Android 封装okhttp3网络请求

本次封装针对get和post

依赖

 implementation 'com.squareup.okhttp3:okhttp:3.8.0'
 implementation 'com.squareup.okio:okio:3.0.0-alpha.6'
 implementation 'com.google.code.gson:gson:2.8.5'

权限

<uses-permission android:name="android.permission.INTERNET" />

准备工作：

RequestEntity

public class RequestEntity implements Serializable {

    private static final String REQUEST_SUFFIX = "Request";

    public String getUrlName() {
        String clsName = this.getClass().getSimpleName();
        if (clsName.endsWith(REQUEST_SUFFIX)) {
            String action = clsName.substring(0, clsName.length() - 7);
            return action.substring(0, 1).toLowerCase()+ action.substring(1);
        } else {
            return clsName.substring(0, 1).toLowerCase()+ clsName.substring(1);
        }
    }
}

ResponseEntity

public class ResponseEntity implements Serializable {
    /**
     * 响应码
     */
    private int code;
    /**
     * 提示消息
     */
    private String msg;

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }
}

FilterGson

public class FilterGson extends MyGson {

    /**
     * 过滤字段
     */
    private static String[] filterFields = {};

    public FilterGson() {
        super(filter());
    }

    private static Gson filter() {
        return new GsonBuilder().addSerializationExclusionStrategy(new ExclusionStrategy() {
            @Override
            public boolean shouldSkipField(FieldAttributes f) {
                for (String exclude : filterFields) {
                    if (exclude.equals(f.getName())) {
                        return true;
                    }
                }
                return false;
            }

            @Override
            public boolean shouldSkipClass(Class<?> clazz) {
                return false;
            }
        }).create();
    }
}

HttpCode

public class HttpCode {
    public static final int CODE_200 = 200;

    public static final int CODE_9999 = 9999;

    public static final String CODE_9999_MSG = "网络或系统异常";
}

JsonParse

public class JsonParse {

    private Object responseBodyResult;

    public Object getResponseBodyResult() {
        return responseBodyResult;
    }

    /**
     * 请求体转请求json字符串
     *
     * @param requestEntity 请求对象
     * @return params字符串
     */
    public String toGetJson(RequestEntity requestEntity) {
        StringBuilder params = new StringBuilder("?");
        try {
            Class cls = requestEntity.getClass();
            Field[] fields = cls.getDeclaredFields();
            for (Field field : fields) {
                params.append(field.getName());
                params.append("=");
                params.append(field.get(requestEntity));
                params.append("&");
            }

        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return params.substring(0, params.length() - 1);
    }

    public String toPostJson(RequestEntity requestEntity) {
        return new FilterGson().toJson(requestEntity);
    }

    public void parseJson(String json, Type type) {
        try {
            JSONObject jsonObject = new JSONObject(json);

            String jsonBody = jsonObject.get("data").toString();
            if (NetConstant.NULL.equals(jsonBody) || NetConstant.NULL_SLASH.equals(jsonBody)) {
                try {
                    jsonBody = "{}";
                    responseBodyResult = new FilterGson().fromJson(jsonBody, type);
                } catch (Exception e) {
                    jsonBody = "[]";
                    responseBodyResult = new FilterGson().fromJson(jsonBody, type);
                }
            }else {
                responseBodyResult = new FilterGson().fromJson(jsonBody, type);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

MyGson

public class MyGson {

    private Gson gson;

    public MyGson() {
        this.gson = new Gson();
    }

    public MyGson(Gson gson) {
        this.gson = gson;
    }

    public <T> T fromJson(String json, Type typeOfT) {
        try {
            return gson.fromJson(json, typeOfT);
        } catch (JsonSyntaxException e) {
            e.printStackTrace();
            return null;
        }
    }

    public String toJson(Object src) {
        return gson.toJson(src);
    }
}

NetConstant

public class NetConstant {
    public static final String NULL = "null";
    public static final String NULL_SLASH = "\"null\"";
}

HttpManager

public class HttpManager {

    public static void init(String ip, String post) {
        baseIp = ip;
        basePort = post;
    }

    private static String baseIp;
    private static String basePort;

    private static String getRequestUrl(String action) {
        String baseUrl = "http://%s:%s/offline/%s/";
        return String.format(baseUrl, baseIp, basePort, action);
    }

    public static void getAsyn(String url, OkHttpManager.BaseCallback callback) {
        OkHttpManager.getInstance().getAsyn(url, callback);
    }

    public static void getAsyn(RequestEntity requestEntity, OkHttpManager.BaseCallback callback) {
        OkHttpManager.getInstance().getAsyn(getRequestUrl(requestEntity.getUrlName()) + new JsonParse().toGetJson(requestEntity), callback);
    }

    public static void postAsyn(RequestEntity requestEntity, OkHttpManager.BaseCallback callback) {
        OkHttpManager.getInstance().postAsyn(getRequestUrl(requestEntity.getUrlName()), new JsonParse().toPostJson(requestEntity), callback);
    }
}

OkHttpManager

public class OkHttpManager {

    private final Handler mHandler;
    private final OkHttpClient okHttpClient;

    private OkHttpManager() {
        okHttpClient = new OkHttpClient();
        mHandler = new Handler(Looper.getMainLooper());
    }

    public static OkHttpManager getInstance() {
        return OkHttpHolder.okHttpManager;
    }

    private static class OkHttpHolder {
        private static OkHttpManager okHttpManager = new OkHttpManager();
    }

    /**
     * get请求
     *
     * @param url      地址
     * @param callback 回调
     */
    public void getAsyn(String url, final BaseCallback callback) {
        final Request request = new Request.Builder()
                .url(url)
                .get()
                .build();
        send(request, callback);
    }

    /**
     * post请求
     *
     * @param url         地址
     * @param requestBody 参数
     * @param callback    回调
     */
    public void postAsyn(String url, String requestBody, final BaseCallback callback) {
        MediaType mediaType = MediaType.parse("application/json; charset=utf-8");
        Request request = new Request.Builder()
                .url(url)
                .post(RequestBody.create(mediaType, requestBody))
                .build();
        send(request, callback);
    }

    /**
     * 发送服务器
     *
     * @param request  内容
     * @param callback 回调
     */
    private void send(Request request, final BaseCallback callback) {
        Call call = okHttpClient.newCall(request);
        call.enqueue(new Callback() {
            @Override
            public void onFailure(@NonNull Call call, @NonNull IOException e) {
                sendFailCallback(callback, call.toString());
            }

            @Override
            public void onResponse(@NonNull Call call, @NonNull Response response) throws IOException {
                if (HttpCode.CODE_200 == response.code()) {
                    JsonParse jsonParse = new JsonParse();
                    jsonParse.parseJson(response.body().string(), callback.mType);
                    sendSuccessCallBack(callback, jsonParse.getResponseBodyResult());
                } else {
                    sendFailCallback(callback, HttpCode.CODE_9999_MSG);
                }
            }
        });
    }

    /**
     * UI线程中执行操作成功回调
     *
     * @param callback     回调类
     * @param responseBody 服务器响应的body
     */
    private void sendSuccessCallBack(final BaseCallback callback, final Object responseBody) {
        mHandler.post(new Runnable() {
            @Override
            public void run() {
                if (null != callback) {
                    callback.onSuccess(responseBody);
                }
            }
        });
    }

    /**
     * UI线程中执行操作失败回调
     *
     * @param callback 回调类
     * @param msg      错误信息
     */
    private void sendFailCallback(final BaseCallback callback, final String msg) {
        mHandler.post(new Runnable() {
            @Override
            public void run() {
                if (null != callback) {
                    callback.onFailure(msg);
                }
            }
        });
    }


    public static abstract class BaseCallback<T> {

        Type mType;

        public BaseCallback() {
            mType = getSuperclassTypeParameter(getClass());
        }

        static Type getSuperclassTypeParameter(Class<?> subclass) {
            Type superclass = subclass.getGenericSuperclass();
            if (superclass instanceof Class) {
                throw new RuntimeException("Enter generics in BaseResultCallback");
            }
            ParameterizedType parameterized = (ParameterizedType) superclass;
            return parameterized.getActualTypeArguments()[0];
        }

        public abstract void onFailure(String message);

        public abstract void onSuccess(T result);
    }
}

调用与Android 封装HttpURLConnection网络请求一致。