Loading [MathJax]/jax/input/TeX/config.js
文档建议反馈控制台
首页
学习
活动
专区
圈层
工具
MCP广场
文章/答案/技术大牛
发布
首页
学习
活动
专区
圈层
工具
MCP广场
返回腾讯云官网
社区首页 >专栏 >浅谈Retrofit 源码

浅谈Retrofit 源码

作者头像
用户1337002
发布于 2018-03-09 02:24:59
发布于 2018-03-09 02:24:59
1K00
代码可运行
举报
文章被收录于专栏：猿份到猿份到
运行总次数：0
代码可运行
关联问题
换一批

现在的项目界面都是按iOS的风格，虽然界面无法发挥出我们大Android的风格，网络框架动不动就是mvp+ okhttp +retrofit+rxjava,mvvm+databind的模式，但是网络框架什么的，我们也可以与时俱进的嘛。

今天就在此聊聊retrofit的相关内容，也可以算是给自己的这几周没有更新文章的一个交代吧。

首先关于使用方法，我们可以从官网上了解。

官网地址(http://square.github.io/retrofit/)

网络基本请求方法(官网)

Introduction

Retrofit turns your HTTP API into a Java interface.

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
public interface GitHubService {
  @GET("users/{user}/repos")
  Call<List<Repo>> listRepos(@Path("user") String user);
}

The Retrofit class generates an implementation of the GitHubService interface.

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("https://api.github.com/")
    .build();

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

Each Call from the created GitHubService can make a synchronous or asynchronous HTTP request to the remote webserver.

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
Call<List<Repo>> repos = service.listRepos("octocat");

Use annotations to describe the HTTP request:

  • URL parameter replacement and query parameter support
  • Object conversion to request body (e.g., JSON, protocol buffers)
  • Multipart request body and file upload

根据上述官网描述，简单总结为以下的几点:

1、创建一个接口来进行HTTP请求;

2、通过new Retrofit.Builde的builder构建出一个retrofit对象；

3、使用retrofit.create获取该网络接口请求实例;

4、由请求接口实例返回一个Call对象;

5、进行网络(同步、异步)请求

下面分析上述的几点:

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
public final class Retrofit {
  private final Map<Method, ServiceMethod> serviceMethodCache = new LinkedHashMap<>();

  private final okhttp3.Call.Factory callFactory;
  private final HttpUrl baseUrl;
  private final List<Converter.Factory> converterFactories;
  private final List<CallAdapter.Factory> adapterFactories;
  private final Executor callbackExecutor;
  private final boolean validateEagerly;

  Retrofit(okhttp3.Call.Factory callFactory, HttpUrl baseUrl,
      List<Converter.Factory> converterFactories, List<CallAdapter.Factory> adapterFactories,
      Executor callbackExecutor, boolean validateEagerly) {
    this.callFactory = callFactory;
    this.baseUrl = baseUrl;
    this.converterFactories = unmodifiableList(converterFactories); // Defensive copy at call site.
    this.adapterFactories = unmodifiableList(adapterFactories); // Defensive copy at call site.
    this.callbackExecutor = callbackExecutor;
    this.validateEagerly = validateEagerly;

首先通过Retorfit源码我们可以了解到它底层网络框架是基于okhttp实现的，整体的实现过程就是客户端通过给retrofit发送网络请求，构建一个Request请求，如队列，然后通过Excutor执行,进入Looper循环查找该出该request并执行，执行完成通过解析返回call对象然后交给客户端做相关处理。图解如下:

下面分析下总结的几点:

1、创建一个接口来进行HTTP请求,这就是写一个API接口类来存放所需要实现的服务端接口类。

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
public interface GitHubService {
  @GET("users/{user}/repos")
  Call<List<Repo>> listRepos(@Path("user") String user);
}

new Retrofit.Builde构建对象，创建Retrofit实例，我们现在通过源码分析下Builder到底做了什么？

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("https://api.github.com/")
    .build();

Builder源码部分:

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
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;
    // 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());
  }

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

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


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

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

  public Builder callbackExecutor(Executor executor) {
    this.callbackExecutor = checkNotNull(executor, "executor == null");
    return this;
  }

  public Builder validateEagerly(boolean validateEagerly) {
    this.validateEagerly = validateEagerly;
    return this;
  }


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

在源码中的builder方法我们可以看到除了baseurl是必须的参数，其他配置参数都可以为空(选配参数)。

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
 if (baseUrl == null) {
      throw new IllegalStateException("Base URL required.");
    }

简单说下

Converter<F, T>：数据转换器，用来将HTTP请求返回结果由F类型转换为T类型，或者将HTTP请求类型F转换为T，也就是我们通过添加的转换器

addConverterFactory方法,可以将call对象的数据返回成我们所需要的数据格式。

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
.addConverterFactory(RDConverterFactory.create())

CallAdapter<R, T>:请求适配器，用于将retrofit2.Call<R>网络请求类型转换为T类型，简单的说就是我们网络请求参数封装的格式。不过到目前为止我还没有用这个

在

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
.build()

之前看下builder构造方法:

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
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());
}

当我们调用

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("https://api.github.com/")
    .build();

首先进去Builder构造方法，在该方法中我们的converterFactories添加了一个

BuiltInConverters对象，我们知道converterFactories是处理HTTP返回结果进行

类型转换或者将HTTP请求体进行类型转换。现在看下源码中BuiltInConverters式怎样进行转换的？

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
final class BuiltInConverters extends Converter.Factory {
  @Override
  public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations,
      Retrofit retrofit) {
    if (type == ResponseBody.class) {
      if (Utils.isAnnotationPresent(annotations, Streaming.class)) {
        return StreamingResponseBodyConverter.INSTANCE;
      }
      return BufferingResponseBodyConverter.INSTANCE;
    }
    if (type == Void.class) {
      return VoidResponseBodyConverter.INSTANCE;
    }
    return null;
  }

  @Override
  public Converter<?, RequestBody> requestBodyConverter(Type type,
      Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {
    if (RequestBody.class.isAssignableFrom(Utils.getRawType(type))) {
      return RequestBodyConverter.INSTANCE;
    }
    return null;
  }

  @Override public Converter<?, String> stringConverter(Type type, Annotation[] annotations,
      Retrofit retrofit) {
    if (type == String.class) {
      return StringConverter.INSTANCE;
    }
    return null;
  }

  static final class StringConverter implements Converter<String, String> {
    static final StringConverter INSTANCE = new StringConverter();

    @Override public String convert(String value) throws IOException {
      return value;
    }
  }

  static final class VoidResponseBodyConverter implements Converter<ResponseBody, Void> {
    static final VoidResponseBodyConverter INSTANCE = new VoidResponseBodyConverter();

    @Override public Void convert(ResponseBody value) throws IOException {
      value.close();
      return null;
    }
  }

  static final class RequestBodyConverter implements Converter<RequestBody, RequestBody> {
    static final RequestBodyConverter INSTANCE = new RequestBodyConverter();

    @Override public RequestBody convert(RequestBody value) throws IOException {
      return value;
    }
  }

  static final class StreamingResponseBodyConverter
      implements Converter<ResponseBody, ResponseBody> {
    static final StreamingResponseBodyConverter INSTANCE = new StreamingResponseBodyConverter();

    @Override public ResponseBody convert(ResponseBody value) throws IOException {
      return value;
    }
  }

  static final class BufferingResponseBodyConverter
      implements Converter<ResponseBody, ResponseBody> {
    static final BufferingResponseBodyConverter INSTANCE = new BufferingResponseBodyConverter();

    @Override public ResponseBody convert(ResponseBody value) throws IOException {
      try {
        // Buffer the entire body to avoid future I/O.
        return Utils.buffer(value);
      } finally {
        value.close();
      }
    }
  }

  static final class ToStringConverter implements Converter<Object, String> {
    static final ToStringConverter INSTANCE = new ToStringConverter();

    @Override public String convert(Object value) {
      return value.toString();
    }
  }
}

返回结果转换的时候，有3种情况:

1、如果返回类型是ResponseBody类型，那么可能返回的是:StreamingResponseBodyConverter.INSTANCE或者BufferingResponseBodyConverter.INSTANCE，再跟踪进去这两个类里面的convert函数:

@Override public ResponseBody convert(ResponseBody value){···}

发现传入的是ResponseBody，返回的也是ResponseBody（BufferingResponseBodyConverter里面有进行特殊处理，主要是为了去除future I/O），所以我们可以认为BuiltInConverters对HTTP返回结果没有进行转换处理。

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
static final class StreamingResponseBodyConverter
    implements Converter<ResponseBody, ResponseBody> {
  static final StreamingResponseBodyConverter INSTANCE = new StreamingResponseBodyConverter();

  @Override public ResponseBody convert(ResponseBody value) throws IOException {
    return value;
  }
}

static final class BufferingResponseBodyConverter
    implements Converter<ResponseBody, ResponseBody> {
  static final BufferingResponseBodyConverter INSTANCE = new BufferingResponseBodyConverter();

  @Override public ResponseBody convert(ResponseBody value) throws IOException {
    try {
      // Buffer the entire body to avoid future I/O.
      return Utils.buffer(value);
    } finally {
      value.close();
    }
  }
}

2、如果返回类型是Void类型，那么最终就将ResponseBody资源关闭后，直接返回null。

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
static final class VoidResponseBodyConverter implements Converter<ResponseBody, Void> {
  static final VoidResponseBodyConverter INSTANCE = new VoidResponseBodyConverter();

  @Override public Void convert(ResponseBody value) throws IOException {
    value.close();
    return null;
  }
}

3、如果返回类型不是ResponseBody和Void类型，直接返回null。

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
@Override
public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations,
    Retrofit retrofit) {
  if (type == ResponseBody.class) {
    if (Utils.isAnnotationPresent(annotations, Streaming.class)) {
      return StreamingResponseBodyConverter.INSTANCE;
    }
    return BufferingResponseBodyConverter.INSTANCE;
  }
  if (type == Void.class) {
    return VoidResponseBodyConverter.INSTANCE;
  }
  return null;
}

同理可知

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
@Override
public Converter<?, RequestBody> requestBodyConverter(Type type,
    Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {
  if (RequestBody.class.isAssignableFrom(Utils.getRawType(type))) {
    return RequestBodyConverter.INSTANCE;
  }
  return null;
}
代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
static final class RequestBodyConverter implements Converter<RequestBody, RequestBody> {
  static final RequestBodyConverter INSTANCE = new RequestBodyConverter();

  @Override public RequestBody convert(RequestBody value) throws IOException {
    return value;
  }
}

如果是RequestBody就不转换，直接返回，如果不是RequestBody则返回null。

从结构图来看，BuiltInConverter只转换ResponseBody和RequestBody，其他的都不进行转换。

分析了Builder的构造后终于可以进入到builder构造方法构建出一个Retrofit对象了。

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
/**
 * 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默认为OkHttpClient
       callFactory = new OkHttpClient();
  }
  Executor callbackExecutor = this.callbackExecutor;
  if (callbackExecutor == null) {
    callbackExecutor = platform.defaultCallbackExecutor();
  }
  List<CallAdapter.Factory> adapterFactories = new ArrayList<>(this.adapterFactories);
  adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));
  List<Converter.Factory> converterFactories = new ArrayList<>(this.converterFactories);
  return new Retrofit(callFactory, baseUrl, converterFactories, adapterFactories,
      callbackExecutor, validateEagerly);
}

从源码中我们知道callFactory默认是OKhttpClient，所以说我们除了需要传递一个baseUrl参数，其他可选配置参数都会为我们提供一个默认值。

好了build我们就先了解这么多了，至于深入的就需要读者自己去研究了。

现在我们来说下create方法

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
GitHubService service = retrofit.create(GitHubService.class);
代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
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);
        }
      });
}
代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
private void eagerlyValidateMethods(Class<?> service) {
  Platform platform = Platform.get();
  for (Method method : service.getDeclaredMethods()) {
    if (!platform.isDefaultMethod(method)) {
      loadServiceMethod(method);
    }
  }
}

ServiceMethod loadServiceMethod(Method method) {
  ServiceMethod result;
  synchronized (serviceMethodCache) {
    result = serviceMethodCache.get(method);
    if (result == null) {
      result = new ServiceMethod.Builder(this, method).build();
      serviceMethodCache.put(method, result);
    }
  }
  return result;
}

我们可以看到create方法返回的是一个 (T) Proxy.newProxyInstance产生的一个动态代理对象，通过InvocationHandler拦截进入到invoke函数中。

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,
                                      InvocationHandler invocationHandler)
        throws IllegalArgumentException {

    if (invocationHandler == null) {
        throw new NullPointerException("invocationHandler == null");
    }
    Exception cause;
    try {
        return getProxyClass(loader, interfaces)
                .getConstructor(InvocationHandler.class)
                .newInstance(invocationHandler);
    } catch (NoSuchMethodException e) {
        cause = e;
    } catch (IllegalAccessException e) {
        cause = e;
    } catch (InstantiationException e) {
        cause = e;
    } catch (InvocationTargetException e) {
        cause = e;
    }
    AssertionError error = new AssertionError();
    error.initCause(cause);
    throw error;
}

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
public interface InvocationHandler {
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
}

最重要的就是

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
 ServiceMethod serviceMethod = loadServiceMethod(method);
          OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
          return serviceMethod.callAdapter.adapt(okHttpCall);

主要做的就是对接口方法注解进行解析，最终生成一个Request。关于create方法先说到这。

最后通过callInit.enqueue方法进行真正发送网络请求,通过OkHttp代码片段可以

可以看到，请求成功的时候，会调用parseResponse得到一个我们需要的Response<T>类型对象，在这个方法中可以将我们的数据转换成我们自己需要的数据格式

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
//OkHttpCall.enqueue片段代码
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();
    }
}

retrofit就到此结束了，其中的分析过程不是那么好，那么的详细完整，也算使用这个框架的部分心得了吧，如果你有更好的见解,欢迎探讨学习，期待你的回复。

本文参与 腾讯云自媒体同步曝光计划，分享自微信公众号。
原始发表：2017-12-07，如有侵权请联系 cloudcommunity@tencent.com 删除
android

本文分享自 猿份到 微信公众号，前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ，欢迎热爱写作的你一起参与！

android
评论
登录后参与评论
暂无评论
登录 后参与评论
推荐阅读
编辑精选文章
换一批
万字详解高可用架构设计
3953
Go 开发者必备：Protocol Buffers 入门指南
2345
10分钟带你彻底搞懂分布式链路跟踪
1633
多租户的 4 种常用方案
3464
亿级月活的社交 APP，陌陌如何做到 3 分钟定位故障？
2407
60页PPT全解：DeepSeek系列论文技术要点整理
3747
Retrofit解析9之流程解析
其他
我们讲解Retrofit整体流程，就依据官方给的demo来吧，代码如下： 代码如下：
隔壁老李头
2018/08/30
2.3K0
Retrofit解析9之流程解析
【Android】Retrofit2.0源码解析
httpandroid网络安全
Retrofit 前言 使用Retrofit已经一段时间了，这货挺好用的，还很特别，特别是使用接口来定义请求方式，这用法让我对它的源码很是好奇。今天就来看看源码吧... 参靠源码retrofit:2.0.2 基本的用法 首先来简单得实现一次GET请求 定义接口 interface Service { @GET("News") Call<ResponseBody> getNews( @Query("limit") String limit); } 完成一次请求
Gavin-ZYX
2018/05/18
1.1K0
Android网络之Retrofit2.0使用和解析
javahttpandroid
javacompile 'com.squareup.retrofit2:retrofit:2.0.1'
静默加载
2020/05/31
1.8K0
retrofit 源码分析
其他
loadServiceMethod: 拿到对应的解析器，根据注解解析方法的返回类型，方法参数，网络请求的一系列参数 封装成一个对象
曾大稳
2018/09/11
9340
Android网络编程（十一）源码解析Retrofit
android
前言 最近博客的产出确实很少，因为博主我正在写一本Android进阶书籍，两头很难兼顾，但是每个月也得至少发一篇博客。上一篇我们介绍了Retrofit的使用方法，这一篇我们照例来学习Retrofit
用户1269200
2018/02/01
9980
Android网络编程（十一）源码解析Retrofit
Retrofit源码解析
httpapilinux
Retrofit 其实是对 OkHttp 进行了一层封装，让开发者对网络操作更加方便快捷。
俞其荣
2022/07/28
7840
Retrofit解析8之核心解析——ServiceMethod及注解2
其他
这个方法内部很简单，主要就是通过遍历annotations，内部调用parseParameterAnnotation来获取ParameterHandler对象并返回。 那让我们来看看parseParameterAnnotation()方法里面是怎么调用的
隔壁老李头
2018/08/30
1.4K0
Retrofit原理_Retrofit
httpandroid
一：Retrofit是什么？ 准确来说，Retrofit 是一个 RESTful 的 HTTP 网络请求框架的封装。 原因：网络请求的工作本质上是 OkHttp 完成，而 Retrofit 仅负责 网络请求接口的封装 我们先来看看下面这个图：
全栈程序员站长
2022/11/17
9240
Retrofit原理_Retrofit
Android 2 新框架 rxjava ，retrifit
rxjava框架网络注解android
Rxjava主要作用就是用来处理异步，当你的业务需要访问数据库，访问网络，或者任何耗时的操作，都可以借助Rxjava来实现。  但是有人说在Android中已经有很多异步操作的API，比如Handler，AsyncTask等，这些都能满足基本的异步操作，为什么还要使用Rxjava呢？  首先我们开看一个例子做个比较：
zhangjiqun
2024/12/16
2250
Android高频面试专题 - 架构篇（三）Retrofit
android
Retrofit并不是网络请求框架，严格说只是对网络请求的一种封装，我们只需要定义一个接口类，在请求方法上加上相应的注解，甚至都不需要实现，就可以实现网络请求。但面试可就不只是要求会使用了，咱得知道内部是怎么实现的，才能顺利过关。
Android扫地僧
2020/03/19
1.9K0
源码解析: Retrofit2.5
android
Retrofit是Square公司开发的一款针对Android网络请求的框架,遵循Restful设计风格,我们查看 invoke 可以发现:底层基于OkHttp实现的 ,相比其他网络请求框架,有以下优势:
小木箱
2020/11/24
8370
源码解析: Retrofit2.5
入木三分：从设计者角度看Retrofit原理
http缓存
通常我不喜欢去写分析源码类的文章，流水线式的分析 枯燥乏味，但读完Retrofit源码后让我有了改变这种想法的冲动～～
Rouse
2021/05/28
1.4K0
Carson带你学Android：网络请求库Retrofit源码分析
httpjavaandroidjson
具体请看我写的文章：这是一份很详细的 Retrofit 2.0 使用教程（含实例讲解）
Carson.Ho
2022/03/24
1.3K0
Carson带你学Android：网络请求库Retrofit源码分析
Retrofit 解析
http编程算法php文件存储
Retrofit在生成Retrofit对象和ServiceMethod对象时候都用到了Builder模式。通过Builder来生成类的实例对象更加优雅，尤其在如果类有多个可选的构造参数时，参数较多，初始化时我们可以指定其中的一些而其他的参数如果不指定可以为默认。 Builder也有缺点：对多生成Builder对象，增加开销，但总的来说在一些场景下还是利大于弊。
Yif
2019/12/26
1.3K0
源码阅读--Retrofit
http
1.使用方法 1、构造retrofit实例（建造者模式，类似于Dialog） Retrofit retrofit = new Retrofit.Builder() .baseUrl("https://api.github.com/") .build(); //https://api.github.com/repos/square/retrofit/contributors GitHubApi
提莫队长
2019/02/21
4190
深入浅出 Retrofit，这么牛逼的框架你们还不来看看？
androidapache
文章来源：腾讯Bugly Android 开发中，从原生的 HttpUrlConnection 到经典的 Apache 的 HttpClient，再到对前面这些网络基础框架的封装，比如 Volley、Async Http Client，Http 相关开源框架的选择还是很多的，其中由著名的 Square 公司开源的 Retrofit 更是以其简易的接口配置、强大的扩展支持、优雅的代码结构受到大家的追捧。也正是由于 Square 家的框架一如既往的简洁优雅，所以我一直在想，Square 公司是不是只招处女座的程
腾讯大讲堂
2018/02/13
1.9K0
深入浅出 Retrofit，这么牛逼的框架你们还不来看看？
Retrofit是如何创建的？为什么要用动态代理
androidapi
通常我们是Retrofit是和Rxjava配合使用，这里我们不做用法上的过多研究，主要看原理，所以下面的代码都是Retrofit的自身API，没有用Rxjava。
Android技术干货分享
2019/04/18
2.5K0
retrofit-helper 简洁的封装retrofit，优雅的取消请求
http面向对象编程网络安全android
Retrofit是很多android开发者都在使用的Http请求库！他负责网络请求接口的封装,底层实现是OkHttp,它的一个特点是包含了特别多注解，方便简化你的代码量,CallAdapter.Factory 和Converter.Factory可以很灵活的扩展你的请求。我们在使用的时候还是需要封装一层便于我们使用，retrofit-helper的作用就是再次简化你的请求。
Android技术干货分享
2019/05/17
3K0
Android |《看完不忘系列》之Retrofit
http网络安全java面向对象编程
嗨，我是哈利迪~《看完不忘系列》将以从树干到细枝的思路分析一些技术框架，本文将对开源项目Retrofit进行介绍。
Holiday
2020/08/20
9520
Android |《看完不忘系列》之Retrofit
源码分析Retrofit请求流程
httpgitgithub开源
Retrofit 是 square 公司的另一款广泛流行的网络请求框架。前面的一篇文章《源码分析OKHttp执行过程》已经对 OkHttp 网络请求框架有一个大概的了解。今天同样地对 Retrofit 的源码进行走读，对其底层的实现逻辑做到心中有数。
阳仔
2019/07/30
4360
源码分析Retrofit请求流程
推荐阅读
编辑精选文章
万字详解高可用架构设计Go 开发者必备：Protocol Buffers 入门指南10分钟带你彻底搞懂分布式链路跟踪
相关讨论
大佬，求求源码？源码怎么上传？有源码吗？
相关课程
轻量应用构建训练营JavaAI代码助手快速上手训练营
Retrofit解析9之流程解析
2.3K0
【Android】Retrofit2.0源码解析
1.1K0
Android网络之Retrofit2.0使用和解析
1.8K0
retrofit 源码分析
9340
Android网络编程（十一）源码解析Retrofit
9980
Retrofit源码解析
7840
Retrofit解析8之核心解析——ServiceMethod及注解2
1.4K0
Retrofit原理_Retrofit
9240
Android 2 新框架 rxjava ，retrifit
2250
Android高频面试专题 - 架构篇（三）Retrofit
1.9K0
源码解析: Retrofit2.5
8370
入木三分：从设计者角度看Retrofit原理
1.4K0
Carson带你学Android：网络请求库Retrofit源码分析
1.3K0
Retrofit 解析
1.3K0
源码阅读--Retrofit
4190
深入浅出 Retrofit，这么牛逼的框架你们还不来看看？
1.9K0
Retrofit是如何创建的？为什么要用动态代理
2.5K0
retrofit-helper 简洁的封装retrofit，优雅的取消请求
3K0
Android |《看完不忘系列》之Retrofit
9520
源码分析Retrofit请求流程
4360
相关推荐
Retrofit解析9之流程解析
更多 >
用户13370020
LV.0
这个人很懒，什么都没有留下～
文章
9
获赞
78
专栏
1
作者相关精选
换一批
加入讨论
的问答专区 >
大熊计算机0
1架构师擅长5个领域
相关课程
一站式学习中心 >
云开发微搭低代码平台-一人构建企业级应用实战训练营
2297人在学
腾讯云微搭低代码
云开发
Java
2002人在学
java
AI代码助手快速上手训练营
1880人在学
腾讯云代码助手
领券

腾讯云开发者

扫码关注腾讯云开发者

扫码关注腾讯云开发者

领取腾讯云代金券

热门产品

热门推荐

更多推荐

Copyright © 2013 - 2025 Tencent Cloud. All Rights Reserved. 腾讯云 版权所有 

深圳市腾讯计算机系统有限公司 ICP备案/许可证号：粤B2-20090059 深公网安备号 44030502008569

腾讯云计算（北京）有限责任公司 京ICP证150476号 |  京ICP备11018762号 | 京公网安备号11010802020287

问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档

Copyright © 2013 - 2025 Tencent Cloud.

All Rights Reserved. 腾讯云 版权所有

登录 后参与评论
8