本文参考诸多博客，以及自己看源码分析。内容并非完全原创，写博客的目的只是让自己能够用文字去描述一遍源码实现，让自己总结一下。

先了解一下Retorift的使用步骤

1.创建retrofit实例
2.创建网络请求接口实例
3.进行网络请求
4.处理网络请求回来的数据

那么接下来就开始根据使用步骤一步一步分析

1.创建retrofit实例

创建Retrofit实例对象

Retrofit retrofit = new Retrofit.Builder()
                .addConverterFactory(GsonConverterFactory.create())
                .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                .baseUrl(AppUrl.getHttpUrl())
                .build();

retrofit使用的是建造者模式，可以看出，build()以后返回的是Retrofit实例对象，所以肯定会去调用构造方法，所以先看一下Retrofit的构造方法

Retrofit(okhttp3.Call.Factory callFactory, HttpUrl baseUrl,
      List<Converter.Factory> converterFactories, List<CallAdapter.Factory> adapterFactories,
      Executor callbackExecutor, boolean validateEagerly) {
     // 网络请求器的工厂，默认使用okhttp
    this.callFactory = callFactory;
    // 网络请求的url地址
    this.baseUrl = baseUrl;
    // 数据转换器工厂的集合
    this.converterFactories = unmodifiableList(converterFactories); 
     //网络请求适配器工厂作用：生产网络请求适配器（CallAdapter）
    this.adapterFactories = unmodifiableList(adapterFactories);
    // 回调方法执行器
    this.callbackExecutor = callbackExecutor;
    //是否提前对业务接口中的注解进行验证转换的标志位
    this.validateEagerly = validateEagerly;
  }

主要初始化了以上参数，就先大概熟悉一下上面几个参数具体是有什么作用
接下来根据上面的参数一个一个的进行分析

CallAdapter（网络请求执行器Call的适配器）

callAdapter默认是使用OkHttpCall,以下代码来自Platform内部实现
在Retrofit中提供了四种CallAdapterFactory： ExecutorCallAdapterFactory（默认）、GuavaCallAdapterFactory、Java8CallAdapterFactory、RxJavaCallAdapterFactory

接下来就继续分析Builder这个类，部分代码已经删掉了，留下一些代码分析

public static final class Builder {
    private Platform platform;
    private okhttp3.Call.Factory callFactory;
    private HttpUrl baseUrl;
    private List<Converter.Factory> converterFactories = new ArrayList<>();
    private List<CallAdapter.Factory> adapterFactories = new ArrayList<>();
    private Executor callbackExecutor;
    private boolean validateEagerly;

    Builder(Platform platform) {
      this.platform = platform;
      converterFactories.add(new BuiltInConverters());
    }

  //会调用这个无参构造,this再去调用有参构造
    public Builder() {
      this(Platform.get());
    }

那就先看看Platform里面都

class Platform {

 // 将findPlatform()赋给静态变量
  private static final Platform PLATFORM = findPlatform();
 
  static Platform get() {
    return PLATFORM;    
  }

//以下代码可以看出，支持3个平台：Android平台、Java平台、IOS平台
private static Platform findPlatform() {
    try {
      // Class.forName(xxx.xx.xx)的作用：要求JVM查找并加载指定的类（即JVM会执行该类的静态代码段）
      Class.forName("android.os.Build");
      if (Build.VERSION.SDK_INT != 0) {
      // 如果是Android平台，就创建一个Android对象返回
        return new Android();
      }
    } catch (ClassNotFoundException ignored) {
    }
    //java平台
    try {
      Class.forName("java.util.Optional");
      return new Java8();
    } catch (ClassNotFoundException ignored) {
    }
    //ios平台
    try {
      Class.forName("org.robovm.apple.foundation.NSObject");
      return new IOS();
    } catch (ClassNotFoundException ignored) {
    }
    return new Platform();
  }

因为我们是Android平台，所以看一下Android的内部实现

 static class Android extends Platform {
    //创建默认的网络请求适配器工厂
    @Override public Executor defaultCallbackExecutor() {
      return new MainThreadExecutor();
    }

    // 返回一个默认的回调方法执行器
    @Override CallAdapter.Factory defaultCallAdapterFactory(Executor callbackExecutor) {
      return new ExecutorCallAdapterFactory(callbackExecutor);
    }

    static class MainThreadExecutor implements Executor {
      // 获取Android主线程绑定的Handler 
      private final Handler handler = new Handler(Looper.getMainLooper());

      @Override public void execute(Runnable r) {
        handler.post(r);
      }
    }
  }

再分析一下GsonConverterFactory.create()

public final class GsonConverterFactory extends Converter.Factory {

  public static GsonConverterFactory create() {
  //创建Gson对象
    return create(new Gson());
  }

  public static GsonConverterFactory create(Gson gson) {
  //创建了包含Gson对象实例的GsonConverterFactory
    return new GsonConverterFactory(gson);
  }

  private final Gson gson;

  private GsonConverterFactory(Gson gson) {
    if (gson == null) throw new NullPointerException("gson == null");
    this.gson = gson;
  }
}

从上面这段代码可以看出，GsonConverterFactory.create()实际上就是创建了一个含有Gson对象的GsonConverterFactory，再看看addConverterFactory的内部实现，实际上就是把GsonConverterFactory添加到了数据转换器工厂的集合当中

public Builder addConverterFactory(Converter.Factory factory) {
      converterFactories.add(checkNotNull(factory, "factory == null"));
      return this;
    }

再来分析一下baseUrl执行了什么操作，baseUrl(“www.baidu.com”)

public Builder baseUrl(String baseUrl) {
    //判断url是否为空
      checkNotNull(baseUrl, "baseUrl == null");
    //转换为Okhttp的HttpUrl类型
      HttpUrl httpUrl = HttpUrl.parse(baseUrl);
      if (httpUrl == null) {
        throw new IllegalArgumentException("Illegal URL: " + baseUrl);
      }
      return baseUrl(httpUrl);
    }

public Builder baseUrl(HttpUrl baseUrl) {
      checkNotNull(baseUrl, "baseUrl == null");
      List<String> pathSegments = baseUrl.pathSegments();
      //检查URL参数是不是以"/"结尾
      if (!"".equals(pathSegments.get(pathSegments.size() - 1))) {
        throw new IllegalArgumentException("baseUrl must end in /: " + baseUrl);
      }
      this.baseUrl = baseUrl;
      return this;
    }

由此得知，url会转换为Okhttp的HttpUrl类型，并且Url一定要以"/"结尾，否则会抛出异常。
最后再分析一下，.build()方法。

public Retrofit build() {
      //判断请求url地址是否为空
      if (baseUrl == null) {
        throw new IllegalStateException("Base URL required.");
      }

      okhttp3.Call.Factory callFactory = this.callFactory;
      //如果没有指定，默认用OkHttpClient
      if (callFactory == null) {
        callFactory = new OkHttpClient();
      }

      //如果没有指定，会默认使用MainThreadExecutor
     //之前已经判断了当前环境是Android，而继承自Platform的Android里面已经提供了默认的
      Executor callbackExecutor = this.callbackExecutor;
      if (callbackExecutor == null) {
        callbackExecutor = platform.defaultCallbackExecutor();
      }

      //添加网络请求适配器工厂到集合当中，默认适配器工厂（ExecutorCallAdapterFactory）添加到集合最后
      List<CallAdapter.Factory> adapterFactories = new ArrayList<>(this.adapterFactories);
      adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));

      //数据转换器工厂 1.默认的数据转换工厂 2.自定义的数据转换工厂
      List<Converter.Factory> converterFactories = new ArrayList<>(this.converterFactories);
    
      //最终返回Retrofit的对象，并传入已经配置好的成员变量
      return new Retrofit(callFactory, baseUrl, converterFactories, adapterFactories,
          callbackExecutor, validateEagerly);
    }

2.创建网络请求接口实例

//定义接收网络数据的类
public interface HttpService {
    //   app版本检查
    //注解GET：采用Get方法发送网络请求
    @GET("app/version/get-newversioninfo?versionCode=1")
    // 接受网络请求数据的方法
    Call<JavaBean> newVersionInfo();
}

HttpService httpService = retrofit.create(HttpService.class);

Call<JavaBean> call = httpService.newVersionInfo();

接下来就看看retrofit.create(service)到底做了什么。

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() {  // 将代理类的实现交给 InvocationHandler类作为具体的实现
          private final Platform platform = Platform.get();
          @Override public Object invoke(Object proxy, Method method, Object... args)
              throws Throwable {
           
            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);
          }
        });
  }

private void eagerlyValidateMethods(Class<?> service) {
    //获取当前系统环境
    Platform platform = Platform.get();
    //获取本类中的所有方法，包含private,protected以及默认权限
    for (Method method : service.getDeclaredMethods()) {
      if (!platform.isDefaultMethod(method)) {
        //将传入的ServiceMethod对象加入LinkedHashMap<Method, ServiceMethod>集合
        loadServiceMethod(method);
      }
    }
  }

  ServiceMethod loadServiceMethod(Method method) {
    ServiceMethod result;
    synchronized (serviceMethodCache) {
    //先通过key获取ServiceMethod(以Method为键将该对象存入LinkedHashMap集合中)
      result = serviceMethodCache.get(method);
    //如果ServiceMethod为空，则创建ServiceMethod并添加
      if (result == null) {
        result = new ServiceMethod.Builder(this, method).build();
        serviceMethodCache.put(method, result);
      }
    }
    return result;
  }

前面提到invoke有三行代码，现在开始分析这三行代码，loadServiceMethod在上面已经大概添加了注解了，继续看loadServiceMethod方法中的new ServiceMethod.Builder(this, method).build() 具体内部实现

final class ServiceMethod<T> {
  static final String PARAM = "[a-zA-Z][a-zA-Z0-9_-]*";
  static final Pattern PARAM_URL_REGEX = Pattern.compile("\\{(" + PARAM + ")\\}");
  static final Pattern PARAM_NAME_REGEX = Pattern.compile(PARAM);
   // 网络请求工厂  
  final okhttp3.Call.Factory callFactory;
   //网络请求适配器工厂
  final CallAdapter<?> callAdapter;
  // 网络请求地址 
  private final HttpUrl baseUrl;
  // Response内容转换器
  private final Converter<ResponseBody, T> responseConverter;
  // 网络请求的Http方法 
  private final String httpMethod;
  // 网络请求的相对地址
  private final String relativeUrl;
  // 网络请求的http请求头
  private final Headers headers;
  // 网络请求的http报文body的类型
  private final MediaType contentType;
  private final boolean hasBody;
  private final boolean isFormEncoded;
  private final boolean isMultipart;
  private final ParameterHandler<?>[] parameterHandlers;
  ServiceMethod(Builder<T> builder) {
      this.callFactory = builder.retrofit.callFactory();
      this.callAdapter = builder.callAdapter;
      this.baseUrl = builder.retrofit.baseUrl();
      this.responseConverter = builder.responseConverter;
      this.httpMethod = builder.httpMethod;
      this.relativeUrl = builder.relativeUrl;
      this.headers = builder.headers;
      this.contentType = builder.contentType;
      this.hasBody = builder.hasBody;
      this.isFormEncoded = builder.isFormEncoded;
      this.isMultipart = builder.isMultipart;
      this.parameterHandlers = builder.parameterHandlers;
    }
}

通过上面的代码可以知道，SeviceMethod包含了网络请求的基本信息
再看看build的实现

public ServiceMethod build() {
      // 根据网络请求接口方法的返回值和注解类型，从Retrofit对象中获取对应的网络请求适配器
      callAdapter = createCallAdapter();
      // 根据网络请求接口方法的返回值和注解类型，从Retrofit对象中获取该网络适配器返回的数据类型
      responseType = callAdapter.responseType();
      if (responseType == Response.class || responseType == okhttp3.Response.class) {
        throw methodError("'"
            + Utils.getRawType(responseType).getName()
            + "' is not a valid response body type. Did you mean ResponseBody?");
      }
      // 根据网络请求接口方法的返回值和注解类型，从Retrofit对象中获取对应的数据转换器
      responseConverter = createResponseConverter();

      for (Annotation annotation : methodAnnotations) {
        // 解析网络请求接口中方法的注解
        parseMethodAnnotation(annotation);
      }

      if (httpMethod == null) {
        throw methodError("HTTP method annotation is required (e.g., @GET, @POST, etc.).");
      }

      if (!hasBody) {
        if (isMultipart) {
          throw methodError(
              "Multipart can only be specified on HTTP methods with request body (e.g., @POST).");
        }
        if (isFormEncoded) {
          throw methodError("FormUrlEncoded can only be specified on HTTP methods with "
              + "request body (e.g., @POST).");
        }
      }

      int parameterCount = parameterAnnotationsArray.length;
      parameterHandlers = new ParameterHandler<?>[parameterCount];
      for (int p = 0; p < parameterCount; p++) {
        Type parameterType = parameterTypes[p];
        if (Utils.hasUnresolvableType(parameterType)) {
          throw parameterError(p, "Parameter type must not include a type variable or wildcard: %s",
              parameterType);
        }
        
        Annotation[] parameterAnnotations = parameterAnnotationsArray[p];
        if (parameterAnnotations == null) {
          throw parameterError(p, "No Retrofit annotation found.");
        }
        //为方法中的每个参数创建一个ParameterHandler<?>对象并解析每个参数使用的注解类型
        parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations);
      }

      if (relativeUrl == null && !gotUrl) {
        throw methodError("Missing either @%s URL or @Url parameter.", httpMethod);
      }
      if (!isFormEncoded && !isMultipart && !hasBody && gotBody) {
        throw methodError("Non-body HTTP method cannot contain @Body.");
      }
      if (isFormEncoded && !gotField) {
        throw methodError("Form-encoded method must contain at least one @Field.");
      }
      if (isMultipart && !gotPart) {
        throw methodError("Multipart method must contain at least one @Part.");
      }

      return new ServiceMethod<>(this);
    }

private CallAdapter<?> createCallAdapter() {
      // 获取网络请求接口里方法的返回值类型
      Type returnType = method.getGenericReturnType();
      if (Utils.hasUnresolvableType(returnType)) {
        throw methodError(
            "Method return type must not include a type variable or wildcard: %s", returnType);
      }
      if (returnType == void.class) {
        throw methodError("Service methods cannot return void.");
      }

      // 获取网络请求接口接口里的注解
      // 此处使用的是@Get
      Annotation[] annotations = method.getAnnotations();
      try {
        return retrofit.callAdapter(returnType, annotations);
      } catch (RuntimeException e) { // Wide exception range because factories are user code.
        throw methodError(e, "Unable to create call adapter for %s", returnType);
      }
    }

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

@Override
public Converter<ResponseBody, ?> responseBodyConverter(Type type, 
    Annotation[] annotations, Retrofit retrofit) {

  
  TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
  // 根据目标类型，利用 Gson#getAdapter 获取相应的 adapter
  return new GsonResponseBodyConverter<>(gson, adapter);
}

// 做数据转换时调用 Gson 的 API 即可。
final class GsonResponseBodyConverter<T> implements Converter<ResponseBody, T> {
  private final Gson gson;
  private final TypeAdapter<T> adapter;

  GsonResponseBodyConverter(Gson gson, TypeAdapter<T> adapter) {
    this.gson = gson;
    this.adapter = adapter;
  }

  @Override 
   public T convert(ResponseBody value) throws IOException {
    JsonReader jsonReader = gson.newJsonReader(value.charStream());
    try {
      return adapter.read(jsonReader);
    } finally {
      value.close();
    }
  }
}