Retrofit2源码分析（一）

1234567891011121314151617181920212223242526272829303132333435

/**   * Build a new {@link Retrofit}.   * <p>   * Calling {@link #baseUrl} is required before calling {@link #build()}. All other methods   * are optional.   */  public static final class Builder {  	//支持的平台    private Platform platform;    //发起请求的okhttp3的client工厂    private okhttp3.Call.Factory callFactory;    //okhttp3里的HttpUrl对象，用来解析和包装url    private HttpUrl baseUrl;    //转换器的工厂集合，retrofit构建可以插入多个转换器，比如gson转换器，Jackson转换器等    private List<Converter.Factory> converterFactories = new ArrayList<>();    //用来发起request和接收response的Call适配器，retrofit支持rxjava就是通过引入retrofit-adapters支持的，就是这个CallAdapter，这里先不作过多解释    private List<CallAdapter.Factory> adapterFactories = new ArrayList<>();    //Executor并发框架，包括线程池等    private Executor callbackExecutor;    //是否需要立即生效    private boolean validateEagerly;

    Builder(Platform platform) {      this.platform = platform;      // Add the built-in converter factory first. This prevents overriding its behavior but also      // ensures correct behavior when using converters that consume all types.      converterFactories.add(new BuiltInConverters());    }

    public Builder() {      this(Platform.get());    }

    ... }

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859

/**     * Set the API base URL.     * <p>     * The specified endpoint values (such as with {@link GET @GET}) are resolved against this     * value using {@link HttpUrl#resolve(String)}. The behavior of this matches that of an     * {@code <a href="">} link on a website resolving on the current URL.     * <p>     * <b>Base URLs should always end in {@code /}.</b>     * <p>     * A trailing {@code /} ensures that endpoints values which are relative paths will correctly     * append themselves to a base which has path components.     * <p>     * <b>Correct:</b><br>     * Base URL: http://example.com/api/<br>     * Endpoint: foo/bar/<br>     * Result: http://example.com/api/foo/bar/     * <p>     * <b>Incorrect:</b><br>     * Base URL: http://example.com/api<br>     * Endpoint: foo/bar/<br>     * Result: http://example.com/foo/bar/     * <p>     * This method enforces that {@code baseUrl} has a trailing {@code /}.     * <p>     * <b>Endpoint values which contain a leading {@code /} are absolute.</b>     * <p>     * Absolute values retain only the host from {@code baseUrl} and ignore any specified path     * components.     * <p>     * Base URL: http://example.com/api/<br>     * Endpoint: /foo/bar/<br>     * Result: http://example.com/foo/bar/     * <p>     * Base URL: http://example.com/<br>     * Endpoint: /foo/bar/<br>     * Result: http://example.com/foo/bar/     * <p>     * <b>Endpoint values may be a full URL.</b>     * <p>     * Values which have a host replace the host of {@code baseUrl} and values also with a scheme     * replace the scheme of {@code baseUrl}.     * <p>     * Base URL: http://example.com/<br>     * Endpoint: https://github.com/square/retrofit/<br>     * Result: https://github.com/square/retrofit/     * <p>     * Base URL: http://example.com<br>     * Endpoint: //github.com/square/retrofit/<br>     * Result: http://github.com/square/retrofit/ (note the scheme stays ‘http‘)     */    public Builder baseUrl(HttpUrl baseUrl) {      checkNotNull(baseUrl, "baseUrl == null");      List<String> pathSegments = baseUrl.pathSegments();      if (!"".equals(pathSegments.get(pathSegments.size() - 1))) {        throw new IllegalArgumentException("baseUrl must end in /: " + baseUrl);      }      this.baseUrl = baseUrl;      return this;    }

12345678910111213141516171819202122232425262728293031

/**     * Create the {@link Retrofit} instance using the configured values.     * <p>     * Note: If neither {@link #client} nor {@link #callFactory} is called a default {@link     * OkHttpClient} will be created and used.     */    public Retrofit build() {      if (baseUrl == null) {        throw new IllegalStateException("Base URL required.");      }

      okhttp3.Call.Factory callFactory = this.callFactory;      if (callFactory == null) {        callFactory = new OkHttpClient();      }

      Executor callbackExecutor = this.callbackExecutor;      if (callbackExecutor == null) {        callbackExecutor = platform.defaultCallbackExecutor();      }

      // Make a defensive copy of the adapters and add the default Call adapter.      List<CallAdapter.Factory> adapterFactories = new ArrayList<>(this.adapterFactories);      adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));

      // Make a defensive copy of the converters.      List<Converter.Factory> converterFactories = new ArrayList<>(this.converterFactories);

      return new Retrofit(callFactory, baseUrl, converterFactories, adapterFactories,          callbackExecutor, validateEagerly);    }

1234

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

1234567891011121314

/** Make a GET request. */@Documented@Target(METHOD)@Retention(RUNTIME)public @interface GET {  /**   * A relative or absolute path, or full URL of the endpoint. This value is optional if the first   * parameter of the method is annotated with {@link Url @Url}.   * <p>   * See {@linkplain retrofit2.Retrofit.Builder#baseUrl(HttpUrl) base URL} for details of how   * this is resolved against a base URL to create the full endpoint URL.   */  String value() default "";}

1

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

12345678910111213141516171819202122232425

@SuppressWarnings("unchecked") // Single-interface proxy creation guarded by parameter safety.  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);            }            ServiceMethod serviceMethod = loadServiceMethod(method);            OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);            return serviceMethod.callAdapter.adapt(okHttpCall);          }        });  }

123

// Make a defensive copy of the adapters and add the default Call adapter.      List<CallAdapter.Factory> adapterFactories = new ArrayList<>(this.adapterFactories);      adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));

123456

CallAdapter.Factory defaultCallAdapterFactory(Executor callbackExecutor) {    if (callbackExecutor != null) {      return new ExecutorCallAdapterFactory(callbackExecutor);    }    return DefaultCallAdapterFactory.INSTANCE;  }

1234567891011121314

/**   * Synchronously send the request and return its response.   *   * @throws IOException if a problem occurred talking to the server.   * @throws RuntimeException (and subclasses) if an unexpected error occurs creating the request   * or decoding the response.   */  Response<T> execute() throws IOException;

  /**   * Asynchronously send the request and notify {@code callback} of its response or if an error   * occurred talking to the server, creating the request, or processing the response.   */  void enqueue(Callback<T> callback);

1

final Call<T> delegate;

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748

@Override public void enqueue(final Callback<T> callback) {    ... //各种判空等代码，这里先省略了

    okhttp3.Call call;    Throwable failure;

    if (canceled) {      call.cancel();    }

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

      private void callFailure(Throwable e) {        try {          callback.onFailure(OkHttpCall.this, e);        } catch (Throwable t) {          t.printStackTrace();        }      }

      private void callSuccess(Response<T> response) {        try {          callback.onResponse(OkHttpCall.this, response);        } catch (Throwable t) {          t.printStackTrace();        }      }    });  }