pocketcommunityclient/app/src/main/java/com/community/pocket/util/HttpUtil.java

package com.community.pocket.util;

import android.content.Context;
import android.os.Looper;

import androidx.annotation.NonNull;
import androidx.appcompat.app.AlertDialog;

import com.community.pocket.BuildConfig;
import com.community.pocket.R;

import org.jetbrains.annotations.NotNull;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.FormBody;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;

public class HttpUtil {

    private static final Map<String, HttpRequest> map = new HashMap<>();

    public static void getRequest(Method method, Callback callback) {
        getRequest(method, callback, null);
    }

    public static void getRequest(Method method, Callback callback, FormBody formBody) {
        //1.创建OkHttpClient对象
        OkHttpClient okHttpClient = new OkHttpClient();
        //2.创建Request对象，设置一个url地址（百度地址）,设置请求方式。
        Request.Builder builder = new Request.Builder();
        if (method == Method.GET && formBody != null) {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < formBody.size(); i++) {
                sb.append("&").append(formBody.name(i)).append("=").append(formBody.value(i));
            }
            builder = builder.url(BuildConfig.API_HOST + getUrl() + "?" + sb.substring(1)).method(method.name(), null);
        } else {
            builder = builder.url(BuildConfig.API_HOST + getUrl()).method(method.name(), formBody);
        }
        //3.创建一个call对象,参数就是Request请求对象
        Call call = okHttpClient.newCall(builder.build());
        //4.请求加入调度，重写回调方法
        call.enqueue(callback);
    }

    //检查服务端连接
    public static void checkServer(final Context context) {
        //1.创建OkHttpClient对象
        OkHttpClient okHttpClient = new OkHttpClient();
        //2.创建Request对象，设置一个url地址（百度地址）,设置请求方式。
        Request.Builder builder = new Request.Builder().url(BuildConfig.API_HOST);
        //3.创建一个call对象,参数就是Request请求对象
        Call call = okHttpClient.newCall(builder.build());
        //4.请求加入调度，重写回调方法
        call.enqueue(new Callback() {
            @Override
            public void onFailure(@NotNull Call call, @NotNull IOException e) {
                if (BuildConfig.DEBUG) {
                    Looper.prepare();
                    new AlertDialog.Builder(context)
                            .setMessage(context.getString(R.string.check_server_fail, BuildConfig.API_HOST)).show();
                    Looper.loop();
                }
            }

            @Override
            public void onResponse(@NotNull Call call, @NotNull Response response) {

            }
        });
    }

    public enum Method {
        GET,
        POST
    }


    /**
     * 获取调用
     */
    @NonNull
    private static String getUrl() {
        HttpRequest httpRequest = null;

        StackTraceElement[] stack = Thread.currentThread().getStackTrace();
        String className = null;
        String methodName = null;
        for (int index = 1; index < stack.length; index++) {
            if (HttpUtil.class.getName().equals(stack[index - 1].getClassName()) && !HttpUtil.class.getName().equals(stack[index].getClassName())) {
                className = stack[index].getClassName();
                methodName = stack[index].getMethodName();
                break;
            }
        }
        RuntimeException runtimeException = new RuntimeException("未知异常！！！");
        if (className != null) {

            try {

                if (!map.containsKey(className + methodName)) {

                    Class c = Class.forName(className);
                    java.lang.reflect.Method[] methods = c.getMethods();
                    List<java.lang.reflect.Method> matchMethod = new ArrayList<>();

                    for (java.lang.reflect.Method m : methods) {
                        if (methodName.equals(m.getName()) && m.getAnnotation(HttpRequest.class) != null) {
                            matchMethod.add(m);
                        }
                    }
                    if (matchMethod.size() == 1) {
                        httpRequest = matchMethod.get(0).getAnnotation(HttpRequest.class);
                        map.put(matchMethod.get(0).getName(), httpRequest);
                    } else if (matchMethod.size() > 1) {
                        runtimeException = new RuntimeException(c.getName() + "包含多个方法名为：" + methodName + "的方法！！！");
                    } else {
                        runtimeException = new RuntimeException("类：" + c.getName() + "方法：" + methodName + "缺少注解" + HttpRequest.class + "，无法调用" + HttpUtil.class);
                    }
                } else {
                    httpRequest = map.get(className + methodName);
                }
                if (httpRequest != null) {
                    return httpRequest.value();
                }
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (RuntimeException e) {
                e.printStackTrace();
            }
        }
        throw runtimeException;
    }

}