Retrofit是怎样通过定义的接口执行网络请求的

Retrofit的基本用法
创建Retrofit

// 创建Retrofit
mRetrofit = new Retrofit.Builder()
         .client(httpClient)
         .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
         .addConverterFactory(GsonConverterFactory.create())
         .baseUrl(ApiConfig.BASE_URL)
         .build();

定义API接口Service

public interface MovieService {
    //获取豆瓣Top250 榜单
    @GET("top250")
    Observable<MovieSubject> getTop250(@Query("start") int start, @Query("count")int count);
}

生成接口Service实现类并调用接口方法

MovieService movieService = mRetrofit.create(MovieService.class);
movieService .getTop250(start,count)
	.subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe...

主要疑问，如何发送网络请求的？请求动作封装成了Observable；响应结果自动转换成了数据实体；

public <T> T create(final Class<T> 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.
            //如果是Object的方法正常调用
            if (method.getDeclaringClass() == Object.class) {
              return method.invoke(this, args);
            }
            if (platform.isDefaultMethod(method)) {
              return platform.invokeDefaultMethod(method, service, proxy, args);
            }
            //解析方法
            ServiceMethod<Object, Object> serviceMethod =
                (ServiceMethod<Object, Object>) loadServiceMethod(method);
            //封装对象OkHttpCall用来执行OkHttp请求
            OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
            //这里可对OkHttpCall进行一次转换封装
            return serviceMethod.callAdapter.adapt(okHttpCall);
          }
        });
  }

真正发送请求的地方是OkHttpCall的enqueue和execute分别执行异步和同步请求。看一下默认情况下执行的enqueue方法。

public void enqueue(final Callback<T> callback) {
	synchronized (this) {
          call = rawCall = createRawCall();
    }
    call.enqueue(new okhttp3.Callback() {
      @Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse)
          throws IOException {
        Response<T> response;
        try {
          response = parseResponse(rawResponse);
        } catch (Throwable e) {
          callFailure(e);
          return;
        }
        callSuccess(response);
      }

      @Override public void onFailure(okhttp3.Call call, IOException e) {
        try {
          callback.onFailure(OkHttpCall.this, e);
        } catch (Throwable t) {
          t.printStackTrace();
        }
      }
   }
}

createRawCall创建okhttp3请求

private okhttp3.Call createRawCall() throws IOException {
    Request request = serviceMethod.toRequest(args);
    okhttp3.Call call = serviceMethod.callFactory.newCall(request);
    if (call == null) {
      throw new NullPointerException("Call.Factory returned null.");
    }
    return call;
  }

parseResponse中解析响应，其中会调用响应转换

R toResponse(ResponseBody body) throws IOException {
    return responseConverter.convert(body);
  }