仿照Retrofit写出自己的网络请求框架

Retrofit

Retrofit是Square出品的Android Http请求框架,官网给出的介绍是Type-safe HTTP client for Android and Java by Square, Inc.,简单来说其实是对okhttp扩展，更加方便的构造REST风格的HTTP客户端，我们再使用时可以看出其主要特点是接口类和注解类的创建和使用。

API定义：

public interface GitHubService {
  @GET("users/{user}/repos")
  Call<List<Repo>> listRepos(@Path("user") String user);
}

使用：

Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("https://api.github.com/")
    .build();

GitHubService service = retrofit.create(GitHubService.class);

Call<List<Repo>> repos = service.listRepos("octocat");

简析

Retrofit可以这么简洁的原因是使用了java的动态代理技术。
动态代理技术是整个java技术中最重要的一个技术，它是学习java框架的基础。
详细介绍可以参考：https://www.cnblogs.com/xdp-gacl/p/3971367.html

开始实现

首先，我们确定最终实现的效果：

public interface User{
    /**
     * 企业基本信息更新接口
     *
     * @param member_id
     * @param company_id
     * @param context_data
     * @return
     */
    @ACT("UCD0507")
    Call<ResponseSimple> updateCompanyData(
            @KEY("user_id") @NonNull String member_id,
            @KEY("company_id") @NonNull String company_id,
            @KEY(value = "context_data", type = KeyType.JSONOArray) @NonNull JSONArray context_data
    );
}

API.create(User.class).updateCompanyData("user_id","company_id",context_data).enqueue(new ResponseCallback<ResponseSimple>(this) {
                        @Override
                        public void onResponseSuccess(Response<ResponseSimple> response) {
                            if (response.isSuccessful()){
                                CustomToast.showShort("提交成功");
                            }else {
                                CustomToast.showShort(response.message());
                            }
                        }

                        @Override
                        public void onResponseError(Response<ResponseSimple> response, String error) {
                            CustomToast.showShort(error);
                        }
                    });

context_data是一個jsonArray的對象，大家也可以自定義其他的對象與輸出格式，这里就不一一实现了。这也是自定义Retrofit的好处之一,可以随心所欲的控制api的协议与调用。
@ACT代表的是接口的协议编号，这里可能不太符合rest风格，限于接口协议，我们仅参考Retrofit的使用与实现，并不完全按照Retrofit来。@KEY为参数的键。

关键代码

@ACT的实现

@Documented
@Target(METHOD)
@Retention(RUNTIME)
public @interface ACT {
    public String value() default "";
}

@KEY的实现

@Documented
@Target(PARAMETER)
@Retention(RUNTIME)
public @interface KEY {
    public String value() default "";
    public KeyType type() default KeyType.String;
}

//此处代表参数类型，可自定义为需要输入值的类型，方便按对应的规则解析
public enum KeyType {
    JSONObject,
    JSONOArray,
    JSONObjectString,
    JSONArrayString,
    Object,
    ObjectList,
    String
}

开始实现User接口，并解析@ACT和@KEY注解

public final class API<T>{

    /**
     * 实现接口的定义
     * @param interfaceClass
     * @param <T>
     * @return 
     */
    public static <T> T create(Class<T> interfaceClass) {
        return (T) Proxy.newProxyInstance(interfaceClass.getClassLoader(), new Class[]{interfaceClass}, (proxy, method, args) -> {
            final String act = method.getAnnotation(ACT.class).value();//获取方法所包含的注解项
            final Type returnType = method.getGenericReturnType();//获取返回值类型
            ParameterizedType parameterizedType = (ParameterizedType) returnType;
            final Type type = parameterizedType.getActualTypeArguments()[0];
            return new API(act, method, args, type);
        });
    }

    private final OkHttpClient okHttpClient=new OkHttpClient();
    private final String uri="接口地址";
    /**
     * api协议编号
     */
    private final String act;
    /**
     * 【反射调用】协议的方法
     */
    private final Method method;
    /**
     * 【反射调用】协议的参数
     */
    private final Object[] args;
    private final Type type;
    private static final MediaType REQUEST_MEDIA_TYPE = MediaType.parse("application/x-www-form-urlencoded");

    private API(String act,Method method, Object[] args, Type type) {
        this.act = act;
        this.method = method;
        this.args = args;
        this.type = type;
    }

    /**
     * 解析请求参数
     * @return
     */
    private okhttp3.Call createCall() {
        JSONObject rootJson = new JSONObject();
        JSONObject dataJson = new JSONObject();
        Annotation[][] annotationsList = method.getParameterAnnotations();
        try {
            for (int i = 0; i < args.length; i++) {
                Annotation[] annotations = annotationsList[i];//获取参数注解
                for (Annotation annotation : annotations) {
                    if (annotation instanceof KEY) {//找到注解KEY并进行处理
                        KEY key = (KEY) annotation;
                        if (args[i] == null) {
                        } else {//含有类型值，判断后找到相应的处理方案进行加工
                            if (args[i] instanceof JSONObject
                                    || args[i] instanceof JSONArray) {
                                dataJson.put(key.value(), args[i]);
                            } else if (key.type() == KeyType.JSONObject) {
                                dataJson.put(key.value(), args[i]);
                            } else if (key.type() == KeyType.JSONOArray) {
                                dataJson.put(key.value(), args[i]);
                            } else if (key.type() == KeyType.JSONArrayString) {
                                dataJson.put(key.value(), new JSONArray(args[i] + ""));
                            } else if (key.type() == KeyType.JSONObjectString) {
                                dataJson.put(key.value(), new JSONObject(args[i] + ""));
                            } else if (key.type() == KeyType.String) {
                                dataJson.put(key.value(), args[i] + "");
                            } else if (key.type() == KeyType.Object) {
                                dataJson.put(key.value(), new JSONObject(new Gson().toJson(args[i])));
                            } else if (key.type() == KeyType.ObjectList) {
                                dataJson.put(key.value(), new JSONArray(new Gson().toJson(args[i])));
                            }
                        }
                        break;
                    }
                }
            }
            String signString = HEXUtil.str2HexStr(Base64Util.encode(SecretUtil.encrypt("[自定义的协议加密]".getBytes())));
            rootJson.put("act", act)
                    .put("sign", signString)
                    .put("data", dataJson);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return okHttpClient.newCall(new Request.Builder()
                .url(uri)
                .post(RequestBody.create(REQUEST_MEDIA_TYPE, rootJson.toString()))
                .build());
    }


    @Override
    public void enqueue(Callback<T> callback) {
        createCall().enqueue(new okhttp3.Callback() {
            @Override
            public void onFailure(okhttp3.Call call, IOException e) {
                if (callback != null) {
                    callback.onFailure(e);
                }
            }

            @Override
            public void onResponse(okhttp3.Call call, okhttp3.Response response) throws IOException {
                if (callback != null) {
                    callback.onResponse(convert(response));
                }
            }
        });
    }

    /**
     * 解析返回值
     * @param response
     * @return
     */
    private T convert(okhttp3.Response response){
        return null;
    }

}