retrofit作为http请求的接口框架而被众人熟知道，它独特且优雅的接口使用习惯被无数的程序员所认可。http://square.github.io/retrofit/
介绍
A type-safe HTTP client for Android and Java
Retrofit是一个基于AOP思想，对RestfulApi注解进行动态代理的网络框架。
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);
我们的JT框架
JTHttpClient
.create()
.setSecLevel(JtRequest.NORMAL)
.url(Urls.index_V)
.build()
.post(HomeModule.class)
.subscribe(new JtSingObserver<HomeModule>(this) {
@Override
public void onSuccess(HomeModule homeModule) {
if (homeModule.header.app_login_status == 0) {
JTApi.get().logout();
}
sHomeModule = homeModule;
mHomeModule.setValue(homeModule);
}
@Override
public void onError(Throwable e) {
sHomeModule = null;
mHomeModule.setValue(null);
UIUtil.INSTANCE.showExceptionMsg(e);
}
});
我在深思熟虑中打造的JT框架虽然简单易用性和性能上其实已经很优秀，但是经过我再一次的深思熟虑觉得依然存在着一些问题。
- 模板类代码太多
- 泛型传递太频发（两次）
- 链式的调用过程某种程度意味效率的低下（选择遗忘的太多）
Retrofit的实现过程
retrofit的主要技术细节包括：
1.接口的实例化
2.获取泛型的返回值type（数据的解析和实例化观察者需要）
3.获取Method之后通过反射获取方法注解和参数注解
我们忽略了一些AOP编程的细节，而是主要去关注一个注解方法对象（Method）的解析过程。
retrofit将Method对象解析成对应http request；将request的参数给下层的网络适配器adapter(可以认为是OkhttpAdapter），适配器调用自身execute方法，调用成功后通过线程分发器发送到对应的线程。至此，完成了retrofit对网络的完整的抽象。
retrofit_stay.png
public <T> T create(final Class<T> service) {//函数的入口，实例化接口对象
Utils.validateServiceInterface(service);//检查service合法性
if (validateEagerly) {
eagerlyValidateMethods(service);
}
//动态代理实例化对象
return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] {service},
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object... args)
throws Throwable {
// If the method is a method from Object then defer to normal invocation.
//解析method注解并交给call对象（网络执行者，默认okhttpclient）
// 触发http请求的方法。invoke会返回Call对象，调用该对象的方法即可完成网络请求
return loadMethodHandler(method).invoke(args);
}
});
}
MethodHandler loadMethodHandler(Method method) {
MethodHandler handler;
synchronized(methodHandlerCache) {//查看静态缓存区，是否有对应method可用，加快执行的速度
handler = methodHandlerCache.get(method);
if (handler == null) {
//创建MethodHandler对象，
//该对象用来管理
// requestFactory请求构造器，
// callFactory（http执行栈默认OkHttpClient），
// callAdapter回调适配器（用于线程的分发），
// responseConverter内容转换器
// 可以认为一种接口method与http请求过程的媒介
// new MethodHandler(retrofit.callFactory(), requestFactory, callAdapter,responseConverter);
handler = MethodHandler.create(this, method);
methodHandlerCache.put(method, handler);
}
}
return handler;
}
static MethodHandler create(Retrofit retrofit, Method method) {
//创建callAdapter， callAdapter是一个可以用来触发网络成功或失败的回调的对象，该方法主要
// 1.查找当前队列中可用的callAdapter
// 2.不管有没有查找成功都会获取method返回值(method.getGenericReturnType())的泛型type
// 3.验证合法性
CallAdapter<?> callAdapter = createCallAdapter(method, retrofit);
Type responseType = callAdapter.responseType();
if (responseType == Response.class || responseType == okhttp3.Response.class) {
throw Utils.methodError(method, "'"
+ Types.getRawType(responseType).getName()
+ "' is not a valid response body type. Did you mean ResponseBody?");
}
//创建responseConverter，这个方法不关注
Converter<ResponseBody, ?> responseConverter =
createResponseConverter(method, retrofit, responseType);
//解析获得请求的参数，创建requestFactory，最为核心且最复杂的方法
// RequestFactory:
// private final String method;
// private final BaseUrl baseUrl;
// private final String relativeUrl;
// private final Headers headers;
// private final MediaType contentType;
// private final boolean hasBody;
// private final boolean isFormEncoded;
// private final boolean isMultipart;
// private final RequestAction[] requestActions;
RequestFactory requestFactory = RequestFactoryParser.parse(method, responseType, retrofit);
return new MethodHandler(retrofit.callFactory(), requestFactory, callAdapter,
responseConverter);
}
static RequestFactory parse(Method method, Type responseType, Retrofit retrofit) {
RequestFactoryParser parser = new RequestFactoryParser(method);
Annotation[] methodAnnotations = method.getAnnotations();
//解析method方法的注解annotations[]
parser.parseMethodAnnotations(responseType, methodAnnotations);
//解析method参数的注解annotations[][]，此处是二维数组
parser.parseParameters(retrofit, methodAnnotations);
return parser.toRequestFactory(retrofit.baseUrl());
}
//该方法用于通过returnType查找对应的callAdapter并获取实例化的callAdapter对象
private static CallAdapter<?> createCallAdapter(Method method, Retrofit retrofit) {
Type returnType = method.getGenericReturnType();
if (Utils.hasUnresolvableType(returnType)) {
throw Utils.methodError(method,
"Method return type must not include a type variable or wildcard: %s", returnType);
}
if (returnType == void.class) {
throw Utils.methodError(method, "Service methods cannot return void.");
}
Annotation[] annotations = method.getAnnotations();
try {
return retrofit.callAdapter(returnType, annotations);
} catch (RuntimeException e) { // Wide exception range because factories are user code.
throw Utils.methodError(e, method, "Unable to create call adapter for %s", returnType);
}
}
JT的实现
主要实现的步骤：
- 动态代理实例化接口对象
- 在invoke函数中获取被调用的Method对象
- 解析并拿到Method中的request参数和返回值泛型的type
//return type
Type returnType = method.getGenericReturnType();
if (method.getReturnType() == Single.class) {
} else {
throw new IllegalArgumentException("you must return a type == Single.class");
}
if (returnType instanceof ParameterizedType) {
Type[] actualTypeArguments = ((ParameterizedType) returnType)
.getActualTypeArguments();
if (actualTypeArguments.length == 1) {
mReturnType = actualTypeArguments[0];
} else {
throw new IllegalArgumentException();
}
}
//缓存Method的request.builder参数，调用perform方法去注入builder
private List<RequestAction> requestActionList = new ArrayList<>();
- 通过jtclient发送http请求
5.根据3中的返回值泛型type解析response
6.最后，通知观察者，处理所订阅的事件
apiService = Proxy.newProxyInstance(service.getClassLoader(),
new Class<?>[] {service},
new InvocationHandler() {
//这个invoke方法会在代理对象的方法中调用，第一个参数就是代理对象
//第二个参数是代理对象调用的方法
//第三个参数方法的参数
@Override
public Object invoke(Object proxy, Method method, Object... args)
throws Throwable {
validateServiceInterface(service);
// If the method is a method from Object then defer to normal invocation.
if (method.getDeclaringClass() == Object.class) {
return method.invoke(this, args);
}
//调用loadMethodHandler
return loadMethodHandler(method).invoke(args);
}
});
Type returnType = method.getGenericReturnType();
if (method.getReturnType() == Single.class) {
} else {
throw new IllegalArgumentException("you must return a type == Single.class");
}
if (returnType instanceof ParameterizedType) {
Type[] actualTypeArguments = ((ParameterizedType) returnType)
.getActualTypeArguments();
if (actualTypeArguments.length == 1) {
mReturnType = actualTypeArguments[0];
} else {
throw new IllegalArgumentException();
}
}
MethodHandler(Method method) {
if (JTApi.get().isDebug()) {
Log.e("MethodHandler", "MethodHandler-method " + method.getName());
}
Type returnType = method.getGenericReturnType();
if (method.getReturnType() == Single.class) {
} else {
throw new IllegalArgumentException("you must return a type == Single.class");
}
if (returnType instanceof ParameterizedType) {
Type[] actualTypeArguments = ((ParameterizedType) returnType)
.getActualTypeArguments();
if (actualTypeArguments.length == 1) {
mReturnType = actualTypeArguments[0];
} else {
throw new IllegalArgumentException();
}
}
Annotation[] methodAnnotation = method.getAnnotations();
for (Annotation annotation : methodAnnotation) {
if (annotation instanceof Url) {
mUrl = ((Url) annotation).value();
} else if (annotation instanceof Security) {
security = ((Security) annotation).value();
}
}
Annotation[][] parameterAnnotations = method.getParameterAnnotations();
if (parameterAnnotations == null || parameterAnnotations.length == 0) {
return;
}
for (Annotation[] annotations : parameterAnnotations) {
if (annotations != null && annotations.length != 0) {
for (Annotation aMethodAnnotation : annotations) {
if (aMethodAnnotation instanceof Field) {
Field field = (Field) aMethodAnnotation;
requestActionList.add(new FieldRequestAction(field.value()));
break;
} else if (aMethodAnnotation instanceof FieldMap) {
requestActionList.add(new FieldMapRequestAction());
} else if (aMethodAnnotation instanceof Path) {
Path path = (Path) aMethodAnnotation;
requestActionList.add(new PathRequestAction(path.value()));
}
}
}
}
}
public Object invoke(Object... objects) {
JtRequest.Builder builder = JTHttpClient.create().url(mUrl);
if (objects != null && objects.length > 0) {
if (objects.length != requestActionList.size()) {
throw new NullPointerException("url: " + mUrl + "\nrequestActionList length is "
+ "not equals objects length");
}
for (int i = 0; i < requestActionList.size(); i++) {
requestActionList.get(i).perform(builder, objects[i]);
}
}
return builder.setSecLevel(security).build().post(mReturnType);
}
//execute
builder.setSecLevel(security).build().post(mReturnType);
