Retrofit 2.0源码分析

Retrofit2.0是用注解的方式来描述一个HTTP请求，将HTTP请求抽象成一个Java的接口，然后用了Java动态代理的方式，将这个借口的注解“翻译”成一个HTTP请求，然后执行HTTP请求。
举例说明：
请求一个api: https://api.github.com/repos/{owner}/{repo}/contributors
查看github上某个repo的contributors.
首先你要这样建一个接口：

public interface GitHub {
	
	@GET("/repos/{owner}/{repo}/contributors")
	Call<List<Contributor>> contributors(@Path("owner")String owner,@Path("repo")String repo);
}

然后创建一个Retrofit

public static final String BASIC_URL="https://api.github.com";

Retrofit mRetrofit =new Retrofit.Builder().baseUrl(BASIC_URL).addConverterFactory
(GsonConverterFactory.create()).build();

创建一个GitHub

GitHub gitHub =mRetrofit.create(GitHub.class);
Call<List<Contributor>> call =gitHub.contributors("owner","repo");

最后回调获取数据

call.enqueue(new Callback<List<Contributor>>(){
	@Override
	public void onResponse(Response<List<Contributor>>respone){
		for(Contributor controbutor: respone.body){


		}
	}


	@Override
	public void onFailure(Throwable t){


	}
});

create方法重要就是返回了一个动态代理对象。（Java动态代理就是Java开发给了开发人员一种可能：当你要调用某个类的方法前，插入你想要执行的代码

比如你要执行某个操作前，你必须要判断这个用户是否登录，或者你在付款前，你需要判断这个人的账户中存在这么多钱。这么简单的一句话，我相信可以把一个不懂技术的人也讲明白Java动态代理是什么东西了。）

// Create an instance of our GitHub API interface.

GitHub github = retrofit.create(GitHub.class);

源码：

public <T> T create(final Class<T> service) {
  Utils.validateServiceInterface(service);
  if (validateEagerly) {
      eagerlyValidateMethods(service);
  }
  return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] { service },
    new InvocationHandler() {
      private final Platform platform = Platform.get();
      @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.
        if (method.getDeclaringClass() == Object.class) {
          return method.invoke(this, args);
        }
        if (platform.isDefaultMethod(method)) {
          return platform.invokeDefaultMethod(method, service, proxy, args);
        }
        return loadMethodHandler(method).invoke(args);
      }
    });

生成一个HTTP请求就是这句:Call<List<Contributor>> call = github.contributors("square", "retrofit");
github是一个动态代理对象，并不是一个真正的Githb接口的implements对象，当github对象调用contributors方法时

，Retrofit其实是执行了动态代理的InvocationHandler对象，最后会创建一个MethodHandler对象（Github接口翻译成一个HTTP请求，也就是MethodHandler对象），

这个对象中包含了4部分内容

static MethodHandler<?> create(Retrofit retrofit, Method method) {
    CallAdapter<Object> callAdapter = (CallAdapter<Object>) createCallAdapter(method, retrofit);
    Type responseType = callAdapter.responseType();
    Converter<ResponseBody, Object> responseConverter =
        (Converter<ResponseBody, Object>) createResponseConverter(method, retrofit, responseType);
    RequestFactory requestFactory = RequestFactoryParser.parse(method, responseType, retrofit);


    return new MethodHandler<>(retrofit.client(), requestFactory, callAdapter, responseConverter);
}

1. OkHttpClient：Retrofit默认生成的，发送网络请求的工具
2. RequestFactory： 类似于Volley中的Request，包含了HTTP请求的Url、Header信息，MediaType、Method以及RequestAction数组，通过RequestFactoryParser.parse(method, responseType, retrofit)生成，主要作用就是解析整个Http请求的所有数据，得到整个Http请求全部的信息，通过@Path和@Query注解拼接Url
3.  CallAdapter：HTTP请求返回数据的类型

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

4. Converter：数据转换器,HTTP返回的数据解析成Java对象
  private static Converter<ResponseBody, ?> createResponseConverter(Method method,

  Retrofit retrofit, Type responseType) {
  Annotation[] annotations = method.getAnnotations();
  try {
    return retrofit.responseBodyConverter(responseType, annotations);
  } catch (RuntimeException e) { // Wide exception range because factories are user code.
    throw Utils.methodError(e, method, "Unable to create converter for %s", responseType);
  }
}

创建这4个对象的目的就是为了执行下面这句代码

Object invoke(Object... args) {
  return callAdapter.adapt(new OkHttpCall<>(client, requestFactory, responseConverter, args));
}

这个也就是github.contributors("square", "retrofit")返回的Call对象
最后你调用Call对象的execute()或enqueue(Callback<T> callback)方法，就能发送一个Http请求了

Retrofit接口
1.这个接口就是retrofit请求数据返回的接口，只有两个方法
void onResponse(Response<T> response);
void onFailure(Throwable t);
2.Converter<F, T>
这个接口主要的作用就是将HTTP返回的数据解析成Java对象，主要由Xml、Gson、protobuf等等，你可以在创建Retrofit对象时添加你需要使用的Converter实现（看上面创建Retrofit对象的代码）
3.Call<T>
这个接口主要的作用就是发送一个HTTP请求，Retrofit默认的实现是OkHttpCall<T>，你可以根据实际情况实现你自己的Call类，这个设计和Volley的HttpStack接口设计的思想非常相似，子类可以实现基于HttpClient或HttpUrlConnetction的HTTP请求工具，这种设计非常的插件化，而且灵活
4.CallAdapter<T>

上面说到过，CallAdapter中属性只有responseType一个，还有一个<R> T adapt(Call<R> call)方法，这个接口的实现类也只有一个，DefaultCallAdapter。这个方法的主要作用就是将Call对象转换成另一个对象，可能是为了支持RxJava才设计这个类的吧。

===========================================》

文章转载：http://bxbxbai.github.io/2015/12/13/retrofit2/