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;
}
}