Retrofit源码分析

摘要：看下图所示，摘自网络的创建流程源码分析实例是使用建造者模式通过类进行创建的。创建了一个含有对象实例的，并返回给源码分析添加一个调用适配器工厂，用于支持服务方法返回类型注意生产的是，那么又是什么呢可以看到源代码如下所示，它是一个接口。

1.首先回顾Retrofit简单使用方法

2.Retrofit的创建流程源码分析

2.1 Retrofit对象调用Builder()源码解析

2.2 Retrofit对象调用baseUrl(url)源码解析

2.3 addConverterFactory(Converter.Factory factory)源码分析

2.4 addCallAdapterFactory(RxJava2CallAdapterFactory.create())源码分析

2.5 client(okHttpClient)源码分析

2.6 Retrofit对象调用build()源码解析

3.创建ServiceMethod流程源码分析

3.1 首先看看请求网络代码过程

3.2 分析create(final Class service)源码

3.3 serviceMethod对象的创建过程

4.注解的解析

4.1 callAdapter的创建源码分析

4.2 responseConverter的创建源码分析

5.OkHttpCall的创建源码分析

5.1 new OkHttpCall<>(serviceMethod, args)源码分析

6.OkHttpCall的网络请求

6.1 OkHttpCall.execute()同步请求

6.2 OkHttpCall.enqueue()异步请求

6.3 parseResponse解析网络数据源码解析

博客笔记大汇总【16年3月到至今】，包括Java基础及深入知识点，Android技术博客，Python学习笔记等等，还包括平时开发中遇到的bug汇总，当然也在工作之余收集了大量的面试题，长期更新维护并且修正，持续完善……开源的文件是markdown格式的！同时也开源了生活博客，从12年起，积累共计47篇[近20万字]，转载请注明出处，谢谢！

链接地址：https://github.com/yangchong2...

如果觉得好，可以star一下，谢谢！当然也欢迎提出建议，万事起于忽微，量变引起质变！

关于Retrofit的使用，可以参考这篇文章：https://www.jianshu.com/p/989...

0.0.1 Retrofit创建中用了哪些设计模式，请谈谈使用这些设计模式的优势？

0.0.2 Retrofit在创建的时候为什么要判断是否在Android环境中，是如何做到的？

0.0.3 为什么设置baseUrl的时候，会以/结尾，如果没有/会出现什么问题？

0.0.4 addConverterFactory的主要作用是什么？

0.0.5 Factory生产的是CallAdapter，那么CallAdapter又是什么呢？

0.0.6 网络请求的类 service为什么要定义成接口？如果不定义成接口会出现什么情况？

0.0.7 创建了ServiceMethod对象是干什么用的？它是用什么进行存储的？

0.0.8 创建ServiceMethod对象为什么要添加synchronized同步锁

0.0.9 call调用enqueue异步方法中源码是如何实现异步切换线程的？原理是怎样的？

0.1.0 ServiceMethod是如何保存网络请求所需要的数据，具体保存了哪些数据呢？

0.1.1 网络传输都是二进制流，那么解析数据时，如何通过ServiceMethod使用Converter转换成Java对象进行数据解析

//AdvertCommon是javabean实体类，并没有序列化，那么网络解析数据如何解析java对象呢？
Call getSplashImage(@Query("type") int type);

0.1.2 如下所示，为什么说apiService对象实际上是动态代理对象，而不是真正的网络请求接口创建的对象

ApiService apiService = retrofit.create(ApiService.class);

0.1.3 如何理解动态代理的机制。retrofit是如何加载接口类ApiService的，为什么这个类要设置成接口？

Api接口

public interface DouBookApi {
    /**
    * 根据tag获取图书
    * @param tag  搜索关键字
    * @param count 一次请求的数目 最多100

    */
    @GET("v2/book/search")
    Observable getBook(@Query("tag") String tag,
                                    @Query("start") int start,
                                    @Query("count") int count);
}
```

Model类

public class DouBookModel {

    private static DouBookModel bookModel;
    private DouBookApi mApiService;

    public DouBookModel(Context context) {
        mApiService = RetrofitWrapper
                .getInstance(ConstantALiYunApi.API_DOUBAN)   //baseUrl地址
                .create(DouBookApi.class);
    }

    public static DouBookModel getInstance(Context context){
        if(bookModel == null) {
            bookModel = new DouBookModel(context);
        }
        return bookModel;
    }

    public Observable getHotMovie(String tag, int start , int count) {
        Observable book = mApiService.getBook(tag, start, count);
        return book;
    }
}

抽取类

public class RetrofitWrapper {

    private static RetrofitWrapper instance;
    private Retrofit mRetrofit;

    public RetrofitWrapper(String url) {
        OkHttpClient.Builder builder = new OkHttpClient.Builder();

        //打印日志
        HttpLoggingInterceptor logging = new HttpLoggingInterceptor();
        logging.setLevel(HttpLoggingInterceptor.Level.BODY);
        builder.addInterceptor(logging).build();
        OkHttpClient client = builder.addInterceptor(new LogInterceptor("HTTP")).build();

        //解析json
        Gson gson = new GsonBuilder()
                .setLenient()
                .create();
        
        mRetrofit = new Retrofit
                .Builder()
                .baseUrl(url)
                .addConverterFactory(GsonConverterFactory.create(gson))
                .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                .client(client)
                .build();
    }

    public  static RetrofitWrapper getInstance(String url){
        //synchronized 避免同时调用多个接口，导致线程并发
        synchronized (RetrofitWrapper.class){
            instance = new RetrofitWrapper(url);
        }
        return instance;
    }

    public  T create(final Class service) {
        return mRetrofit.create(service);
    }
}

使用

DouBookModel model = DouBookModel.getInstance(activity);
model.getHotMovie(mType,start,count)
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Subscriber() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(DouBookBean bookBean) {

            }
        });

针对Retrofit，需要注意

Retrofit 是一个 RESTful 的 HTTP 网络请求框架的封装。网络请求的工作本质上是 OkHttp 完成，而 Retrofit 仅负责 网络请求接口的封装。看下图所示，摘自网络

Retrofit实例是使用建造者模式通过Builder类进行创建的。Builder模式的优势：将一个复杂对象的构建与表示分离，使得用户在不知道对象的创建细节情况下就可以直接创建复杂的对象。

针对builder设计模式，可以参考我的这篇博客：https://blog.csdn.net/m0_3770...

关于使用builder模式写代码的案例，可以参考我的弹窗封装lib：https://github.com/yangchong2...

首先看看里面的源代码，如下所示

可以看到Platform.get()获取的是单利对象。那么也许你会问，这个方法的作用主要是什么呢？通过Class.forName获取类名的方式，来判断当前的环境是否在Android中，这在之后获取默认的CallAdapterFactory时候将会用到。下面我会分析到……

关于单利设计模式，如果还有疑问，或者想知道所有的获取单利的方法，可以参考我的这篇博客：设计模式之一：单例模式

//第一步
public Builder() {
  this(Platform.get());
}


//第二步，追踪到Platform类中
private static final Platform PLATFORM = findPlatform();
static Platform get() {
    return PLATFORM;
}

private static Platform findPlatform() {
try {
  Class.forName("android.os.Build");
  if (Build.VERSION.SDK_INT != 0) {
    //此处表示：如果是Android平台，就创建并返回一个Android对象
    return new Android();
  }
} catch (ClassNotFoundException ignored) {
}
try {
  Class.forName("java.util.Optional");
  return new Java8();
} catch (ClassNotFoundException ignored) {
}
return new Platform();
}

然后看一下new Android()是做了什么？

static class Android extends Platform {
    @Override public Executor defaultCallbackExecutor() {
        // 返回一个默认的回调方法执行器
        // 该执行器作用：切换线程（子->>主线程），并在主线程（UI线程）中执行回调方法
      return new MainThreadExecutor();
    }
    
    @Override CallAdapter.Factory defaultCallAdapterFactory(@Nullable Executor callbackExecutor) {
      if (callbackExecutor == null) throw new AssertionError();
       // 创建默认的网络请求适配器工厂 
       // 该默认工厂生产的 adapter 会使得Call在异步调用时在指定的 Executor 上执行回调 
       // 采用了策略模式
      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是上面获取的与Android 主线程绑定的Handler 
        // 在UI线程进行对网络请求返回数据处理等操作。
        handler.post(r);
      }
    }
}

都知道这个方法主要是设置baseUrl。源码如下所示

首先先对baseUrl进行非空判断。然后再解析baseUrl，如果解析的httpUrl为null，则会抛出IllegalArgumentException非法参数异常。那么思考一下，什么情况下解析baseUrl会导致解析内容httpUrl为null呢？

public Builder baseUrl(String baseUrl) {
  checkNotNull(baseUrl, "baseUrl == null");
  HttpUrl httpUrl = HttpUrl.parse(baseUrl);
  if (httpUrl == null) {
    throw new IllegalArgumentException("Illegal URL: " + baseUrl);
  }
  return baseUrl(httpUrl);
}

HttpUrl是如何解析url，对url有什么条件，来看一下parse方法源码

可以看到url必须是以http或者https才可以。如果随便写一个url，则会出问题

public static @Nullable HttpUrl parse(String url) {
    Builder builder = new Builder();
    Builder.ParseResult result = builder.parse(null, url);
    return result == Builder.ParseResult.SUCCESS ? builder.build() : null;
}

ParseResult parse(@Nullable HttpUrl base, String input) {
  int pos = skipLeadingAsciiWhitespace(input, 0, input.length());
  int limit = skipTrailingAsciiWhitespace(input, pos, input.length());

  // Scheme.
  int schemeDelimiterOffset = schemeDelimiterOffset(input, pos, limit);
  if (schemeDelimiterOffset != -1) {
    if (input.regionMatches(true, pos, "https:", 0, 6)) {
      this.scheme = "https";
      pos += "https:".length();
    } else if (input.regionMatches(true, pos, "http:", 0, 5)) {
      this.scheme = "http";
      pos += "http:".length();
    } else {
      return ParseResult.UNSUPPORTED_SCHEME; // Not an HTTP scheme.
    }
  } else if (base != null) {
    this.scheme = base.scheme;
  } else {
    return ParseResult.MISSING_SCHEME; // No scheme.
  }
  
  //下面代码省略了

思考一下，传递的url为什么是String BASE_URL = "http://beta.goldenalpha.com.cn/"这个格式呢？接着看看baseUrl(httpUrl)源码

可以看到这里的url地址必须是以/结尾。所以如果是没有加上/，则会出现异常

public Builder baseUrl(HttpUrl baseUrl) {
  checkNotNull(baseUrl, "baseUrl == null");
  List pathSegments = baseUrl.pathSegments();
  if (!"".equals(pathSegments.get(pathSegments.size() - 1))) {
    throw new IllegalArgumentException("baseUrl must end in /: " + baseUrl);
  }
  this.baseUrl = baseUrl;
  return this;
}

其实个人感觉这块工作并不难，只要有点英文基础的，就可以完全看的明白。接着往下分析，如果想了解更多，欢迎看我的博客汇总：https://github.com/yangchong2...

在创建的时候会调用addConverterFactory(GsonConverterFactory.create(JsonUtils.getJson()))添加Gson转换器

这个方法主要是添加用于对象序列化和反序列化的转换器工厂

将上面创建的GsonConverterFactory放入到 converterFactories数组

.addConverterFactory(GsonConverterFactory.create(JsonUtils.getGson()))

//看这行代码
public Builder addConverterFactory(Converter.Factory factory) {
    //将上面创建的GsonConverterFactory放入到 converterFactories数组
  converterFactories.add(checkNotNull(factory, "factory == null"));
  return this;
}

然后看看GsonConverterFactory.creat()方法源码

使用{@code gson}创建一个实例以进行转换。编码到JSON并从JSON解码(当没有由头指定字符集时)将使用UTF-8。

创建了一个含有Gson对象实例的GsonConverterFactory，并返回给addConverterFactory（）

public static GsonConverterFactory create(Gson gson) {
    if (gson == null) throw new NullPointerException("gson == null");
    return new GsonConverterFactory(gson);
}

添加一个调用适配器工厂，用于支持服务方法返回类型

public Builder addCallAdapterFactory(CallAdapter.Factory factory) {
  callAdapterFactories.add(checkNotNull(factory, "factory == null"));
  return this;
}

CallAdapterFactory：注意Factory生产的是CallAdapter，那么CallAdapter又是什么呢？

可以看到CallAdapter源代码如下所示，它是一个接口。主要作用是：将响应类型{@代码R}的{@链接调用}改编为{@代码T}的类型。实例由{@LinkplanFactory(一个工厂)创建，该工厂}是{@Link平原Retrofit.Builder#addCallAdapterFactory(Factory)已安装}到{@LinkRetroflit}实例中。

网络请求执行器（Call）的适配器，并且在Retrofit中提供了三种CallAdapterFactory： ExecutorCallAdapterFactory（默认）、DefaultCallAdapterFactory、RxJava2CallAdapterFactory

public interface CallAdapter {
  Type responseType();
  T adapt(Call call);
  abstract class Factory {
    public abstract @Nullable CallAdapter get(Type returnType, Annotation[] annotations,
        Retrofit retrofit);
    protected static Type getParameterUpperBound(int index, ParameterizedType type) {
      return Utils.getParameterUpperBound(index, type);
    }
    protected static Class getRawType(Type type) {
      return Utils.getRawType(type);
    }
  }
}

接着，有伙伴可能会问它的作用是什么呢？

将默认的网络请求执行器（OkHttpCall）转换成适合被不同平台来调用的网络请求执行器形式

一开始Retrofit只打算利用OkHttpCall通过ExecutorCallbackCall切换线程；但后来发现使用Rxjava更加方便（不需要Handler来切换线程）。想要实现Rxjava的情况，那就得使用RxJavaCallAdapterFactoryCallAdapter将OkHttpCall转换成Rxjava(Scheduler)

.addCallAdapterFactory(RxJava2CallAdapterFactory.create())

用于请求的HTTP客户端

指定用于创建{@link Call}实例的自定义调用工厂。

public Builder client(OkHttpClient client) {
  return callFactory(checkNotNull(client, "client == null"));
}

public Builder callFactory(okhttp3.Call.Factory factory) {
  this.callFactory = checkNotNull(factory, "factory == null");
  return this;
}

看看源码

大概的流程就是创建适配器的防御性副本，并添加默认调用适配器。然后复制转换器的防御性副本，在然后添加内置的转化工厂.这可以防止重写其行为，但也可以确保在使用消耗所有类型的转换器时的正确行为。

通过前面步骤设置的变量，将Retrofit类的所有成员变量都配置完毕。就成功创建了对象！

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 callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
  callAdapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));

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

  // 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());
  converterFactories.addAll(this.converterFactories);

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

然后看看Retrofit的构造方法

成功建立一个Retrofit对象的标准：配置好Retrofit类里的成员变量，即配置好：

serviceMethod：包含所有网络请求信息的对象

baseUrl：网络请求的url地址

callFactory：网络请求工厂

adapterFactories：网络请求适配器工厂的集合

converterFactories：数据转换器工厂的集合

callbackExecutor：回调方法执行器

Retrofit(okhttp3.Call.Factory callFactory, HttpUrl baseUrl,
  List converterFactories, List callAdapterFactories,
  @Nullable Executor callbackExecutor, boolean validateEagerly) {
    this.callFactory = callFactory;
    this.baseUrl = baseUrl;
    this.converterFactories = converterFactories; // Copy+unmodifiable at call site.
    this.callAdapterFactories = callAdapterFactories; // Copy+unmodifiable at call site.
    this.callbackExecutor = callbackExecutor;
    this.validateEagerly = validateEagerly;
}

然后总结一下创建的过程

平台类型对象（Platform - Android）

网络请求的url地址（baseUrl）

网络请求工厂（callFactory） 默认使用OkHttpCall

网络请求适配器工厂的集合（adapterFactories） 本质是配置了网络请求适配器工厂- 默认是ExecutorCallAdapterFactory

数据转换器工厂的集合（converterFactories） 本质是配置了数据转换器工厂

回调方法执行器（callbackExecutor） 默认回调方法执行器作用是：切换线程（子线程 - 主线程）

大概的流程如下代码所示

定义网络请求的接口类 ApiService

public interface ApiService {
    @POST("api/v1/user/old")
    Call> isUserOld();
}

//创建接口类实例
ApiService apiService = retrofit.create(ApiService.class);
//生成最终的网络请求对象
Call> userOld = apiService.isUserOld();
//异步机制
userOld.enqueue(new Callback>() {
    @Override
    public void onResponse(Call> call, retrofit2.Response> response) {
        
    }
    @Override
    public void onFailure(Call> call, Throwable t) {

    }
});

源代码如下所示，这段代码很重要。

创建接口定义的API端点的实现。给定方法的相对路径是从描述请求类型的方法的注释中获得的。

先对service类进行判断是否是接口。这个时候你就知道为何只能定义service为接口呢……

接着就创建了ServiceMethod对象，并且把这个对象以键的形式存储到ConcurrentHashMap集合中

最后创建了网络请求接口的动态代理对象，通过代理模式中的动态代理模式，动态生成网络请求接口的代理类，并将代理类的实例创建交给InvocationHandler类 作为具体的实现，并最终返回一个动态代理对象。

service.getClassLoader()作用是动态生成接口的实现类

new Class[] { service }作用是动态创建实例

new InvocationHandler()作用是将代理类的实现交给 InvocationHandler类作为具体的实现

即通过动态生成的代理类，调用interfaces接口的方法实际上是通过调用InvocationHandler对象的invoke方法来完成指定的功能

public  T create(final Class 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, @Nullable 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 serviceMethod =
            (ServiceMethod) loadServiceMethod(method);
        //根据配置好的serviceMethod对象创建okHttpCall对象 
        OkHttpCall