Retrofit源码分析

已于 2022-04-03 00:39:25 修改
阅读量2.5k 收藏
点赞数
文章标签： Retrofit
于 2022-04-03 00:07:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/linglingchenchen/article/details/123931591
版权

Retrofit

Retrofit 是一个 RESTful 的 HTTP 网络框架封装，底层使用的 OkHttp.


基本使用
引入依赖
implementation 'com.squareup.retrofit2:retrofit:2.9.0'
implementation 'com.squareup.retrofit2:converter-gson:2.9.0'

创建一个接口作为网络的请求集合，在方法上用注解进行配置
public interface GitHubService {
  @GET("users/{user}/repos")
  Call<List<Repo>> listRepos(@Path("user") String user);
}

使用 Retrofit 创建出接口的实例
Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("https://api.github.com/")
 		.addConverterFactory(GsonConverterFactory.create())
    .build();

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

调用接口的对应方法，就创建网络请求对象 Call
Call<List<Repo>> repos = service.listRepos("octocat");

使用 Call.enqueue() 或 Call.execute() 发起网络请求
repos.enqueue(new Callback<List<Repo>>() {
    @Override
    public void onResponse(Call<List<Repo>> call, Response<List<Repo>> response) {
        Log.e("TAG", "onResponse:" + response.body().get(0).getName());
    }

    @Override
    public void onFailure(Call<List<Repo>> call, Throwable t) {
      
    }
});

源码分析
Retrofit 实例创建

Retrofit 实例是通过建造者模式创建的

// Retrofit类
public final class Retrofit {
  // 网络请求配置对象（对接口中的方法注解解析后得到的对象）
  // 缓存，存储网络请求中的相关配置，请求的方法，数据转换器，适配器，基地址
  private final Map<Method, ServiceMethod<?>> serviceMethodCache = new ConcurrentHashMap<>();

  final okhttp3.Call.Factory callFactory;// 网络请求器的工厂
  final HttpUrl baseUrl;
  final List<Converter.Factory> converterFactories;// 数据转换器工厂集合
  final List<CallAdapter.Factory> callAdapterFactories;// 网络请求适配器工厂集合
  final @Nullable Executor callbackExecutor;// 回调方法执行器
  final boolean validateEagerly;// 是否提前对接口中的方法注解进行验证
  
  Retrofit(
      okhttp3.Call.Factory callFactory,
      HttpUrl baseUrl,
      List<Converter.Factory> converterFactories,
      List<CallAdapter.Factory> 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;
  }
  ...
    
  // Builder类
  public static final class Builder {
    private final Platform platform;
    private @Nullable okhttp3.Call.Factory callFactory;
    private @Nullable HttpUrl baseUrl;
    private final List<Converter.Factory> converterFactories = new ArrayList<>();
    private final List<CallAdapter.Factory> callAdapterFactories = new ArrayList<>();
    private @Nullable Executor callbackExecutor;
    private boolean validateEagerly;
    
    Builder(Platform platform) {
      this.platform = platform;// 平台类型对象
    }

    public Builder() {
      this(Platform.get());
    }
    
    // 添加url地址
    public Builder baseUrl(URL baseUrl) {
      Objects.requireNonNull(baseUrl, "baseUrl == null");
      return baseUrl(HttpUrl.get(baseUrl.toString()));
    }
    
    // 添加数据转化器，可以把返回的数据解析成指定的类型
    public Builder addConverterFactory(Converter.Factory factory) {
      converterFactories.add(Objects.requireNonNull(factory, "factory == null"));
      return this;
    }
    
    // 添加网络请求适配器，CallAdatper对原始Call进行再次封装，如Call<R>到Observable<R>
    public Builder addCallAdapterFactory(CallAdapter.Factory factory) {
      callAdapterFactories.add(Objects.requireNonNull(factory, "factory == null"));
      return this;
    }
    
    ...
    
    public Retrofit build() {
      ...
			
      okhttp3.Call.Factory callFactory = this.callFactory;// 网络请求执行器
      if (callFactory == null) {
        callFactory = new OkHttpClient();
      }

      Executor callbackExecutor = this.callbackExecutor;
      if (callbackExecutor == null) {
        // 如果没指定，则默认使用Platform检测环境时的默认callbackExecutor
        // 即Android默认的callbackExecutor
        callbackExecutor = platform.defaultCallbackExecutor();
      }

      // 配置网络请求适配器工厂
      List<CallAdapter.Factory> callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
      callAdapterFactories.addAll(platform.defaultCallAdapterFactories(callbackExecutor));

      // 配置数据转换器工厂
      List<Converter.Factory> converterFactories =
          new ArrayList<>(
              1 + this.converterFactories.size() + platform.defaultConverterFactoriesSize());

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

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

平台类型 Platform

// Platform 类型
class Platform {
  private static final Platform PLATFORM = findPlatform();

  static Platform get() {
    return PLATFORM;
  }

  private static Platform findPlatform() {
    return "Dalvik".equals(System.getProperty("java.vm.name"))
        ? new Android() //
        : new Platform(true);
  }
 	...
    
  // 用于接收服务器返回数据后进行线程切换在主线程显示结果
  static final class Android extends Platform {
    Android() {
      super(Build.VERSION.SDK_INT >= 24);
    }

    @Override
    public Executor defaultCallbackExecutor() {
      return new MainThreadExecutor();
    }

    // 回调方法执行器
    static final class MainThreadExecutor implements Executor {
      private final Handler handler = new Handler(Looper.getMainLooper());

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

数据转换器工厂 GsonConverterFactory

// GsonConverterFactory.crate() 创建了一个含有 Gson 对象实例
public final class GsonConverterFactory extends Converter.Factory {
 
  public static GsonConverterFactory create() {
    return create(new Gson());
  }

  @SuppressWarnings("ConstantConditions") // Guarding public API nullability.
  public static GsonConverterFactory create(Gson gson) {
    if (gson == null) throw new NullPointerException("gson == null");
    return new GsonConverterFactory(gson);
  }
  ...

}

Retrofit 使用建造者模式通过 Builder 类创建了一个 Retrofit 对象，配置了：

  • 平台类型对象 （Platform）
  • url地址（baseUrl）
  • 网络请求工厂（callFactory）
  • 网络请求适配器的集合（adpterFactories）
  • 数据转换器工厂集合（converterFactories）
  • 回调方法执行器（callbackExector）

请求接口实例创建

Retrofit 是通过 外观模式 和 代理模式 使用 Retrofit.create() 方法创建的网络请求接口的实例，从而使得接口 中配置的方法变得可用，这是 Retrofit 代码接口的核心。

外观模式：定义一个统一的接口，外部通过该接口对子系统里的其他接口进行访问

代理模式：通过访问代理对象的方式间接访问目标对象


Retrofit.create() 方法内部，使用的是 Proxy.newProxyInstance() 方法来创建 接口 的实例。这个方法内部会为入参的多个 inteface 创建了一个对象，这个对象实现了所有 interface 的每个方法，并且每个方法的实现都是雷同的：调用对象实例内部的一个 InvocationHandler 成员变量的 invoke() 方法，并把对应的方法信息传递进去。

因此 InvocationHandler 中的 invoke() 方法中的逻辑，就是执行接口中的方法。


// Retrofit类
public <T> T create(final Class<T> service) {
  validateServiceInterface(service);// 验证接口
  return (T)
    	// 创建了网络请求接口的动态代理对象
      Proxy.newProxyInstance(
          service.getClassLoader(),// 类加载器
          new Class<?>[] {service},// 要创建哪些接口
          new InvocationHandler() {// 当接口的方法触发，会间接调用到 InvocationHandler 的 invoke 方法
            private final Platform platform = Platform.get();
            private final Object[] emptyArgs = new Object[0];

            @Override
            public @Nullable 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);// 如果是Object类，直接触发方法
              }
              args = args != null ? args : emptyArgs;
              return platform.isDefaultMethod(method)
                  ? platform.invokeDefaultMethod(method, service, proxy, args)// 平台默认方法，直接触发方法
                  : loadServiceMethod(method).invoke(args);// 核心是这行代码，加载接口的方法，并执行
            }
          });
}

ServiceMethod 的创建

loadServiceMethod(method)，这行代码负责读取接口中原方法的信息（包括返回值类型、方法注解、参数类型、参数注解），并把这些信息做初步分析，最后实际返回的是一个 CallAdapted .

// Retrofit类
ServiceMethod<?> loadServiceMethod(Method method) {
  ServiceMethod<?> result = serviceMethodCache.get(method);
  if (result != null) return result;

  synchronized (serviceMethodCache) {
    result = serviceMethodCache.get(method);
    if (result == null) {
      result = ServiceMethod.parseAnnotations(this, method);// 关键是这句
      serviceMethodCache.put(method, result);
    }
  }
  return result;
}

// ServiceMethod类
// ServiceMethod.parseAnnotations
abstract class ServiceMethod<T> {
  static <T> ServiceMethod<T> parseAnnotations(Retrofit retrofit, Method method) {
    // 解析方法上的注解
    RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method);

    Type returnType = method.getGenericReturnType();
    if (Utils.hasUnresolvableType(returnType)) {
      throw methodError(
          method,
          "Method return type must not include a type variable or wildcard: %s",
          returnType);
    }
    if (returnType == void.class) {
      throw methodError(method, "Service methods cannot return void.");
    }

    return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);// 关键是这句
  }

  abstract @Nullable T invoke(Object[] args);
}

// HttpServiceMethod类
// HttpServiceMethod.parseAnnotations
static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(
      Retrofit retrofit, Method method, RequestFactory requestFactory) {
  
  	...
    CallAdapter<ResponseT, ReturnT> callAdapter =
        createCallAdapter(retrofit, method, adapterType, annotations);
  	...
      
    if (!isKotlinSuspendFunction) {
      return new CallAdapted<>(requestFactory, callFactory, responseConverter, callAdapter);// 关键是这句
    } else if (continuationWantsResponse) {
      //noinspection unchecked Kotlin compiler guarantees ReturnT to be Object.
      return (HttpServiceMethod<ResponseT, ReturnT>)
          new SuspendForResponse<>(
              requestFactory,
              callFactory,
              responseConverter,
              (CallAdapter<ResponseT, Call<ResponseT>>) callAdapter);
    } else {
      //noinspection unchecked Kotlin compiler guarantees ReturnT to be Object.
      return (HttpServiceMethod<ResponseT, ReturnT>)
          new SuspendForBody<>(
              requestFactory,
              callFactory,
              responseConverter,
              (CallAdapter<ResponseT, Call<ResponseT>>) callAdapter,
              continuationBodyNullable);
    }
  }

OkHttpCall 的创建

invoke(args) 方法的调用，会触发 OkHttpCall 的创建。

// HttpServiceMethod类
@Override
final @Nullable ReturnT invoke(Object[] args) {
  Call<ResponseT> call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter);
  return adapt(call, args);// 会调用到 CallApter 的 adapter 方法
}

OkHttpCall 是 retrofit2.Call 的子类，OkHttpCall 的创建将 ServiceMethod 解读到信息（RequestFactory、OkHttpClient 和 ResponseConverter）封装进 OkHttpCall，OkHttpCall 在 enqueue() 方法被调用的时候，利用 RequestFactory 和 OkHttpClient 来创建一个 okhttp3.Call 对象，并调用 okhttp3.Call 来进行网络请求的发起，然后利用 ResponseConverter 对结果进行预处理之后，交回给 Retrofit 的 Callback .


适配器的处理

adapt(call, args) 方法调用会触发到 callAdapter.adapt(call) 的调用

callAdapter.adapt(call);

这个⽅法会使⽤⼀个 CallAdapter 对象来把 OkHttpCall 对象进⾏转换，⽣成⼀个新的对象。默认情况下，返回的是⼀个 ExecutorCallbackCall，它的作⽤是把操作切回主线程后再交给 Callback .

如果有自定义的 CallAdapter，这里也可以生成别的类型的对象，例如 RxJava 的 Observable，来让 Retrofit 和 RxJava 结合使用。


lingchenjie_
关注
Retrofit源码分析&实践（四）【Retrofit 实现请求和返回】
itbird的专栏
01-20 718
由上一节，我们基于retrofit使用代码入手，搭建了整体的框架，但是为了简化，一步一步来，我们首先使用自己搭建的retrofit实现基本的请求和返回，那么我们暂时忽略convertfactory和callback的转换，本节我们先直接使用okhttp的call，直接返回okhttp的response，实现基本的retrofit核心功能代码，具体功能点有 接口动态代理创建对象 注解的处理，拼接url和请求参数 基于okhttp实现基本的请求 本章，我们一起来基于上节搭建的Retrofit框架，实现核
Retrofit源码分析&实践（六）【Retrofit 多BaseUrl问题解决】
itbird的专栏
02-01 5937
本节到这里就基本结束了，我们回顾一下。解决retrofit 多baseUrl的动态解决方案就是RetrofitManager作为单例类，使用map保存baseurl-retrofit的一一对应保存为了解决需要记忆baseurl-retrofit一一对应关系的问题，我们引入自定义注解BaseUrl，给需要的接口类，直接添加这个注解。
Retrofit源码解析
small-dream的博客
07-16 1281
Retrofit源码结构Retrofit： 通过注解，把一个Java接口转化成一个http 请求，底层网络请求基于okhttp从Retrofit源码结构可以看出，Retrofit 源码分成两部分 一部分是包retrofit2.http里面的，在Java接口方法中使用，用来控制http行为的注解。一部分是retrofit2里面的，负责把REST API转化成Java接口。Retrofit和okht
Retrofit 源码分析初探
01-04
介绍源码前，我们先看下Retrofit的基本使用，大致了解下流程，跟着这个流程来分析源码才不会乱。 1、初始化Retrofit对象 Retrofit retrofit = new Retrofit.Builder() //使用自定义的mGsonConverterFactory ....
Android Retrofit 源码分析_android retrofit解析
最新发布
2401_84520377的博客
04-28 1019
说一千道一万，不如自己去行动。要想在移动互联网的下半场是自己占有一席之地，那就得从现在开始，从今天开始，马上严格要求自己，既重视业务实现能力，也重视基础和原理。基础夯实好了，高楼才能够平地而起，稳如泰山。最后为了帮助大家深刻理解Android相关知识点的原理以及面试相关知识，这里放上相关的我搜集整理的24套腾讯、字节跳动、阿里、百度2020-2021面试真题解析，我把技术点整理成了视频和PDF（实际上比预期多花了不少精力），包知识脉络 + 诸多细节。还有。
Retrofit源码分析及理解
阿根的专栏
02-05 1108
Retrofit内部有着简捷、优雅的结构设计。当然对于新手来说，Retrofit也有着不宜理解和上手的问题。不过瑕不掩瑜，Retrofit仍然是一款优秀的网络请求框架。 这边文章除了进行源码分析，还有个人对Retrofit的一些浅见和感悟。仅供读者参考。
(源码篇)Retrofit源码解析
qq_32664007的博客
09-23 1189
Retrofit源码解析Retrofit内部如何实现接口调用callAdapter 以及 responseConverter 的作用 Retrofit内部如何实现接口调用 我们都知道Retrofit 是通过定义接口，然后拿到接口的实例并且调用对应的方法。我们就从使用流程开始看源码里是如何实现的。 1、首先通过 retrofit.create 方法拿到自定义的 service实例，上源码： 这里可以看到，通过动态代理的方式生成了自定义service 的对象。并且在调用自定义接口方法时 是执行了 1 处的方法
源码：Retrofit
weixin_42277946的博客
03-23 203
retrofit源码
Retrofit源码解析：请求对象转换与返回值定制
"Retrofit源码分析：请求对象的转换" 在Android开发中，Retrofit是一个流行的网络请求库，它允许开发者通过简单的Java接口来发送HTTP请求。在深入研究Retrofit的源码时，我们关注的重点之一是它如何将网络请求的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值