Retrofit 源码解析简洁篇

最新推荐文章于 2024-05-05 00:09:24 发布
最新推荐文章于 2024-05-05 00:09:24 发布
阅读量258 收藏 1
点赞数
分类专栏： Android知识 文章标签： java android http
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42795723/article/details/125118900
版权

总结：

  1. 构造 retrofit，核心参数有 baseurl，callFactory（默认 okhttpclient）,converterFactories，adapterFactories 和 excallbackExecutor。
  2. 通过 Retrofit#create() 方法获取接口的实现类，运用了 Java 的动态代技术。
  3. 调用服务方法时会先实例化 ServiceMethod。ServiceMethod 通过解析服务方法上的注解
    在 invoke 方法内部，拿到我们所声明的注解以及实参等，构造 ServiceMethod。ServiceMethod 中解析了大量的信息，最后可以通过 toRequest 构造出 okhttp3.Request 对象。有了 okhttp3.Request 对象就可以很自然的构建出 okhttp3.call，最后 calladapter 对 Call 进行装饰返回。
    拿到 Call 就可以执行 enqueue 或者 execute 方法了

responseBodyConverter 主要是对应@Body 注解，完成 ResponseBody 到实际的返回类型的转化，这个类型对应 Call< XXX >里面的泛型，其实@Part 等注解也会需要 responseBodyConverter，只不过我们的参数类型都是 RequestBody，由默认的 converter 处理了。

requestBodyConverter 完成对象到 RequestBody 的构造。
一定要注意，检查 type 如果不是自己能处理的类型，记得 return null （因为可以添加多个，你不能处理 return null ,还会去遍历后面的 converter）.

概述

  1. Builder 模式构建；
  2. 动态代理；
  3. 自定义注解；
  4. 默认只能将响应体转换为 OkHttp 中的 ResponseBody。

Retrofit 只负责生产能做网络请求的工作对象，他有点像一个工厂，只提供产品，工厂本身不处理网络请求，产品才能处理网络请求。

在这里插入图片描述

基本使用

public interface GitHubService {
    @GET("/users/{user}")
    Call<GitHubUser> getUser(@Path("user") String user);
}

Retrofit retrofit = new Retrofit.Builder()
        .baseUrl("https://api.github.com/")
        .addConverterFactory(GsonConverterFactory.create())
        .build();

GitHubService service = retrofit.create(GitHubService.class);
Call<GitHubUser> userCall = service.getUser("square");
userCall.enqueue(new Callback<GitHubUser>() {
    @Override
    public void onResponse(Call<GitHubUser> call, Response<GitHubUser> response) {
        GitHubUser user = response.body();
    }

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

源码分析

Retrofit 整体流程如下：
在这里插入图片描述

1. 构造 Retrofit 对象

// Retrofit.java
public static final class Builder {
    Builder(Platform platform) {
        this.platform = platform;
    }

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

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

        // Make a defensive copy of the converters.
        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);
    }
}
  1. url 不能为空；
  2. callFactory 默认为 OkHttpClient；
  3. 支持 Java 和 Android 平台。
// Platform.java
private static Platform findPlatform() {
    return "Dalvik".equals(System.getProperty("java.vm.name"))
        ? new Android()
        : new Platform(true);
}

2. 创建服务接口对象

// Retrofit.java
public <T> T create(final Class<T> service) {
    validateServiceInterface(service);
    return (T)
        Proxy.newProxyInstance(
            service.getClassLoader(),
            new Class<?>[] {service},
            new InvocationHandler() {
              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);
                }
                args = args != null ? args : emptyArgs;
                return platform.isDefaultMethod(method)
                    ? platform.invokeDefaultMethod(method, service, proxy, args)
                    : loadServiceMethod(method).invoke(args);
              }
            });
}

private void validateServiceInterface(Class<?> service) {
    if (!service.isInterface()) {
      throw new IllegalArgumentException("API declarations must be interfaces.");
    }

    Deque<Class<?>> check = new ArrayDeque<>(1);
    check.add(service);
    while (!check.isEmpty()) {
      Class<?> candidate = check.removeFirst();
      if (candidate.getTypeParameters().length != 0) {
        // ...
        throw new IllegalArgumentException(message.toString());
      }
      // 检查父接口
      Collections.addAll(check, candidate.getInterfaces());
    }

    //是否提前加载服务方法
    if (validateEagerly) {
      Platform platform = Platform.get();
      for (Method method : service.getDeclaredMethods()) {
        if (!platform.isDefaultMethod(method) && !Modifier.isStatic(method.getModifiers())) {
          loadServiceMethod(method);
        }
      }
    }
}
  1. 服务类必须是接口，且不支持泛型；
  2. 判断是否预加载服务方法；
  3. 通过动态代理实例化服务接口对象。

3. 解析服务方法上的注解

// Retrofit.java
public <T> T create(final Class<T> service) {
    validateServiceInterface(service);
    return (T)
        Proxy.newProxyInstance(
            service.getClassLoader(),
            new Class<?>[] {service},
            new InvocationHandler() {
                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);
                    }
                    args = args != null ? args : emptyArgs;
                    return platform.isDefaultMethod(method)
                        ? platform.invokeDefaultMethod(method, service, proxy, args)
                        : loadServiceMethod(method).invoke(args);
                }
            });
}

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

通过动态对象调用服务方法。

  1. 服务方法存在，直接返回；
  2. 服务方法不存在，解析服务方法，并添加到缓存。
// ServiceMethod.java
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);
}
  1. 根据注解解析出请求方法，相对地址和请求头等数据，并包装成 RequestFactory；
  2. 服务方法返回类型不能是 void，类型变量和通配符类型；
  3. 返回 ServiceMethod 实例。
// RequestFactory.java
static RequestFactory parseAnnotations(Retrofit retrofit, Method method) {
    return new Builder(retrofit, method).build();
}

RequestFactory build() {
    for (Annotation annotation : methodAnnotations) {
        parseMethodAnnotation(annotation);
    }

    // 参数检查
    int parameterCount = parameterAnnotationsArray.length;
    parameterHandlers = new ParameterHandler<?>[parameterCount];
    for (int p = 0, lastParameter = parameterCount - 1; p < parameterCount; p++) {
        parameterHandlers[p] =
            parseParameter(p, parameterTypes[p], parameterAnnotationsArray[p], p == lastParameter);
    }

    // 必要的数据合法性检查
    return new RequestFactory(this);
}

private void parseMethodAnnotation(Annotation annotation) {
    if (annotation instanceof GET) {
        parseHttpMethodAndPath("GET", ((GET) annotation).value(), false);
    } else if (annotation instanceof POST) {
        parseHttpMethodAndPath("POST", ((POST) annotation).value(), true);
    } else if (annotation instanceof HTTP) {
        HTTP http = (HTTP) annotation;
        parseHttpMethodAndPath(http.method(), http.path(), http.hasBody());
    } else if (annotation instanceof retrofit2.http.Headers) {
        headers = parseHeaders(headersToParse);
    } else if (annotation instanceof Multipart) {
        isMultipart = true;
    } else if (annotation instanceof FormUrlEncoded) {
        isFormEncoded = true;
    }
}

private void parseHttpMethodAndPath(String httpMethod, String value, boolean hasBody) {
    this.httpMethod = httpMethod;
    this.hasBody = hasBody;

    if (value.isEmpty()) {
        return;
    }

    // Get the relative URL path and existing query string, if present.
    int question = value.indexOf('?');
    if (question != -1 && question < value.length() - 1) {
        // Ensure the query string does not have any named parameters.
        String queryParams = value.substring(question + 1);
        Matcher queryParamMatcher = PARAM_URL_REGEX.matcher(queryParams);
        if (queryParamMatcher.find()) {
            throw methodError(
                method,
                "URL query string \"%s\" must not have replace block. "
                    + "For dynamic query parameters use @Query.",
                queryParams);
        }
    }

    this.relativeUrl = value;
    this.relativeUrlParamNames = parsePathParameters(value);
}
  1. 根据具体的注解类型解析出数据；
// HttpServiceMethod.java
static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(
      Retrofit retrofit, Method method, RequestFactory requestFactory) {
    // ...
    Annotation[] annotations = method.getAnnotations();
    Type adapterType;
    if (isKotlinSuspendFunction) {
        // Kotlin 协程方法
    } else {
        // Call<GitHubUser>，Observable<GitHubUser>
        adapterType = method.getGenericReturnType();
    }
    // 查找能处理此请求的 CallAdapter
    CallAdapter<ResponseT, ReturnT> callAdapter =
        createCallAdapter(retrofit, method, adapterType, annotations);
    // Call<GitHubUser> 中的 GitHubUser
    Type responseType = callAdapter.responseType();
    // 查找能处理此请求的响应转换器
    Converter<ResponseBody, ResponseT> responseConverter =
        createResponseConverter(retrofit, method, responseType);

    okhttp3.Call.Factory callFactory = retrofit.callFactory;
    if (!isKotlinSuspendFunction) {
        return new CallAdapted<>(requestFactory, callFactory, responseConverter, callAdapter);
    } else if (continuationWantsResponse) {
      // ...
    } else {
      // ...
    }
}
  1. 适配 CallAdapter；
  2. 查找能处理此返回类型的 ConverterFactory。默认的 BuiltInConverters 只能处理 ResponseBody 和 Void 类型；
  3. 返回 CallAdapted 对象。

通过服务方法发起网络请求

abstract class HttpServiceMethod<ResponseT, ReturnT> extends ServiceMethod<ReturnT> {

    @Override
    final @Nullable ReturnT invoke(Object[] args) {
        Call<ResponseT> call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter);
        return adapt(call, args);
    }

    protected abstract @Nullable ReturnT adapt(Call<ResponseT> call, Object[] args);

    static final class CallAdapted<ResponseT, ReturnT> extends HttpServiceMethod<ResponseT, ReturnT> {
        private final CallAdapter<ResponseT, ReturnT> callAdapter;

        @Override
        protected ReturnT adapt(Call<ResponseT> call, Object[] args) {
            // DefaultCallAdapterFactory$CallAdapter
            return callAdapter.adapt(call);
        }
    }
}

final class DefaultCallAdapterFactory extends CallAdapter.Factory {

    @Override
    public @Nullable CallAdapter<?, ?> get(
        Type returnType, Annotation[] annotations, Retrofit retrofit) {
        if (getRawType(returnType) != Call.class) {
            return null;
        }
        if (!(returnType instanceof ParameterizedType)) {
            throw new IllegalArgumentException(
                "Call return type must be parameterized as Call<Foo> or Call<? extends Foo>");
        }
        final Type responseType = Utils.getParameterUpperBound(0, (ParameterizedType) returnType);

        final Executor executor =
            Utils.isAnnotationPresent(annotations, SkipCallbackExecutor.class)
                ? null
                : callbackExecutor;

        return new CallAdapter<Object, Call<?>>() {
            @Override
            public Type responseType() {
                return responseType;
            }

            @Override
            public Call<Object> adapt(Call<Object> call) {
                return executor == null ? call : new ExecutorCallbackCall<>(executor, call);
            }
        };
    }

    static final class ExecutorCallbackCall<T> implements Call<T> {

        @Override
        public void enqueue(final Callback<T> callback) {
            // delegate 是 retrofit2.OkHttpCall
            delegate.enqueue(
                new Callback<T>() {
                    @Override
                    public void onResponse(Call<T> call, final Response<T> response) {
                    callbackExecutor.execute(
                        () -> {
                            if (delegate.isCanceled()) {
                                // Emulate OkHttp's behavior of throwing/delivering an IOException on
                                // cancellation.
                                callback.onFailure(ExecutorCallbackCall.this, new IOException("Canceled"));
                            } else {
                                callback.onResponse(ExecutorCallbackCall.this, response);
                            }
                        });
                    }

                    @Override
                    public void onFailure(Call<T> call, final Throwable t) {
                        callbackExecutor.execute(() -> callback.onFailure(ExecutorCallbackCall.this, t));
                    }
                });
        }

        @Override
        public Response<T> execute() throws IOException {
            return delegate.execute();
        }
    }
}
  1. 适配成 retrofit2.Call、Single等；
  2. 通过 retrofit2.OkHttpCall 发起 http 请求；
  3. 响应消息回调。

CallAdapter<R, T>

负责把 Retrofit 中执行网络请求的 Call 对象，转换为接口中定义的 Call 对象（eg：Observable< User >，Flowable< User >）。

public interface CallAdapter<R, T> {

    Type responseType();
    T adapt(Call<R> 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);
        }
    }
}

Retrofit 默认实现了两个 CallAdapter：

  1. DefaultCallAdapterFactory
  2. CompletableFutureCallAdapterFactory

Converter<F, T>

负责把服务器返回的数据（JSON、XML、二进制或者其他格式，由 ResponseBody 封装）转化为 T 类型的对象。

public interface Converter<F, T> {
    T convert(F value) throws IOException;

    abstract class Factory {
        public @Nullable Converter<ResponseBody, ?> responseBodyConverter(
            Type type, Annotation[] annotations, Retrofit retrofit) {
            return null;
        }

        public @Nullable Converter<?, RequestBody> requestBodyConverter(
            Type type, Annotation[] parameterAnnotations,
                Annotation[] methodAnnotations, Retrofit retrofit) {
            return null;
        }

        public @Nullable Converter<?, String> stringConverter(
            Type type, Annotation[] annotations, Retrofit retrofit) {
            return null;
        }

        protected static Type getParameterUpperBound(int index, ParameterizedType type) {
            return Utils.getParameterUpperBound(index, type);
        }

        protected static Class<?> getRawType(Type type) {
            return Utils.getRawType(type);
        }
    }
}

Converter.Factory 的默认实现类有 BuiltInConverters 和 OptionalConverterFactory。

final class BuiltInConverters extends Converter.Factory {
    @Override
    public @Nullable Converter<ResponseBody, ?> responseBodyConverter(
        Type type, Annotation[] annotations, Retrofit retrofit) {
        if (type == ResponseBody.class) {
            return Utils.isAnnotationPresent(annotations, Streaming.class)
                ? StreamingResponseBodyConverter.INSTANCE
                : BufferingResponseBodyConverter.INSTANCE;
        }
        if (type == Void.class) {
            return VoidResponseBodyConverter.INSTANCE;
        }
        if (checkForKotlinUnit) {
            try {
                if (type == Unit.class) {
                return UnitResponseBodyConverter.INSTANCE;
                }
            } catch (NoClassDefFoundError ignored) {
                checkForKotlinUnit = false;
            }
        }
        return null;
    }
}

ParameterHandler

负责解析 API 定义时每个方法的参数，并在构造 HTTP 请求时设置参数。

OkHttpCall

final class OkHttpCall<T> implements Call<T> {

    @Override
    public void enqueue(final Callback<T> callback) {

        synchronized (this) {
            if (executed) throw new IllegalStateException("Already executed.");
            executed = true;

            call = rawCall;
            failure = creationFailure;
            if (call == null && failure == null) {
                call = rawCall = createRawCall();
            }
        }

        call.enqueue(
            new okhttp3.Callback() {
                @Override
                public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse) {
                    Response<T> response = parseResponse(rawResponse);
                    callback.onResponse(OkHttpCall.this, response);
                }
            });
    }

    Response<T> parseResponse(okhttp3.Response rawResponse) throws IOException {
        ResponseBody rawBody = rawResponse.body();

        // Remove the body's source (the only stateful object) so we can pass the response along.
        rawResponse =
            rawResponse
                .newBuilder()
                .body(new NoContentResponseBody(rawBody.contentType(), rawBody.contentLength()))
                .build();

        ExceptionCatchingResponseBody catchingBody = new ExceptionCatchingResponseBody(rawBody);
        T body = responseConverter.convert(catchingBody);
        return Response.success(body, rawResponse);
    }
}
迷路国王
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Retrofit源码解析
small-dream的博客
07-16 1256
Retrofit源码结构Retrofit： 通过注解，把一个Java接口转化成一个http 请求，底层网络请求基于okhttp从Retrofit源码结构可以看出，Retrofit 源码分成两部分 一部分是包retrofit2.http里面的，在Java接口方法中使用，用来控制http行为的注解。一部分是retrofit2里面的，负责把REST API转化成Java接口。Retrofit和okht
全网最详细Retrofit源码解析
qq_35090026的博客
01-18 1738
最详细Retrofit原理、源码解析---------------------------------------------
Retrofit源码分析
Allence的博客
10-28 1611
Retrofit的中文翻译是改造，改造什么呢？我认为是对OkHttp的使用、RxJava的使用进行改造。具体体现在哪里？在使用OkHttp请求前：1.用注解统一配置网络请求头和请求参数2.通过动态代理统一获取注解的请求头和请求参数然后一致组装适配成请求的request，交给okHttp进行请求使用OkHttp结果返回后:1.线程切换线程切换分为两种一种是用Retrofit默认的，另一种是使用RxJava2.把返回的数据json适配成javabean。
2024年java RetroFit的源码详解以及使用，2024非科班生的Java面试之路
最新发布
2401_83977369的博客
05-05 719
毕竟工作也这么久了 ，除了途虎一轮，也七七八八面试了不少大厂，像阿里、饿了么、美团、滴滴这些面试过程就不一一写在这篇文章上了。我会整理一份详细的面试过程及大家想知道的一些问题细节。
(源码篇)Retrofit源码解析
qq_32664007的博客
09-23 1006
Retrofit源码解析Retrofit内部如何实现接口调用callAdapter 以及 responseConverter 的作用 Retrofit内部如何实现接口调用 我们都知道Retrofit 是通过定义接口，然后拿到接口的实例并且调用对应的方法。我们就从使用流程开始看源码里是如何实现的。 1、首先通过 retrofit.create 方法拿到自定义的 service实例，上源码： 这里可以看到，通过动态代理的方式生成了自定义service 的对象。并且在调用自定义接口方法时 是执行了 1 处的方法
工作24:封装请求
歌谣的博客
10-23 197
import { axios } from "./axios"; export { axios }; export function httpAction(url, parameter, method) { return axios({ url: url, method: method, data: parameter }); } /*封装系统需要的post请求 第一个参数传入url地址 第二个传入数据参数*/ export function postAction(ur.
Android应用源码之简洁天气项目源码.zip
06-07
【标题】"Android应用源码之简洁天气项目源码.zip" 涵盖了一个完整的Android应用程序，专注于简洁天气展示的功能。这个源码是开发者学习Android编程、理解移动应用开发流程，特别是天气应用开发的重要资源。 【描述...
安卓Android源码——简洁天气项目源码.rar
10-10
《安卓Android源码——简洁天气项目解析》 在Android开发领域，掌握源码分析是提升技术深度的关键。这里我们探讨的是一款名为“简洁天气”的Android应用源码，它提供了丰富的学习资源，帮助开发者深入理解Android...
安卓Andriod源码——简洁天气项目源码.zip
10-13
6. **网络请求与数据解析**：应用可能使用HTTP库（如Retrofit或OkHttp）来从网络获取JSON或XML格式的天气数据，然后通过Gson或Jackson等库解析成Java对象。 7. **权限管理**：考虑到应用需要访问网络和位置信息，...
Retrofit 最新源码解析 （附源码下载）
01-03
目录 1. 前言 2. 简介 3. 火热热的4个网络框架 4. 如何使用 5. 源码分析 6. 后记 1. 前言         今年是2020年了，也是我正式入驻CSDN博客的第一年，说起来也凑巧，因为今年的黑天鹅事件导致我们不得不在家宅着，当然到2月中下旬很多企业都复工了，本人也一样进入了远程办公状态，其实本人挺懒的，写文章这种事情我其实是不怎么热衷的，主要还是因为在家宅久了觉得会不够充实，于是乎有时间去学习下当下流行的Android开发技术，想通过写博客的方式梳理下自己学到的知识点。好了，我就不废话了，直接进入真题吧，以下便是关于我学习Retrofit网络框架的总结。 2. 简介    
Android Retrofit框架解析
09-28
详见http://blog.csdn.net/huaxun66/article/details/52674013
安卓Android源码——简洁天气项目源码.zip
10-11
这个压缩包文件“安卓Android源码——简洁天气项目源码.zip”显然包含了安卓应用程序开发相关的源代码，特别是针对一个简洁天气应用的实现。这个项目可能是为了教学目的或个人学习而设计的，它允许开发者深入理解...
Android高级应用源码-简洁天气项目源码.zip
10-14
这个压缩包文件“Android高级应用源码-简洁天气项目源码.zip”包含了Android平台上一个高级天气应用的源代码。从标题和描述中我们可以推断，这个项目名为“MagicWeather”，是一个展示高级Android开发技巧和实践的...
Android 网络框架之Retrofit源码解析，2024年Android工作或许更难找
2301_79058150的博客
04-03 778
Android架构学习进阶是一条漫长而艰苦的道路，不能靠一时激情，更不是熬几天几夜就能学好的，必须养成平时努力学习的习惯。所以：贵在坚持！上面分享的字节跳动公司2021年的面试真题解析大全，笔者还把一线互联网企业主流面试技术要点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节。【Android高级架构视频学习资源】Android部分精讲视频领取学习后更加是如虎添翼！进军BATJ大厂等（备战）！
Retrofit源码分析及理解
阿根的专栏
02-05 982
Retrofit内部有着简捷、优雅的结构设计。当然对于新手来说，Retrofit也有着不宜理解和上手的问题。不过瑕不掩瑜，Retrofit仍然是一款优秀的网络请求框架。 这边文章除了进行源码分析，还有个人对Retrofit的一些浅见和感悟。仅供读者参考。
一定能看懂的 Retrofit 最详细的源码解析
nufuli123的博客
01-21 705
前提 只有了解了框架的原理才能更好的使用她，才能定位问题的根本。写这篇文章的也是为了自我的学习和提升。其实看源码就跟看书一样，看了这么多本书有什么用呢，其实不然，这些知识已经潜移默化的影响了你的思维。你之后在阅读源码时，会发现能更快的上手了。 引用别人的一句话：当我还是个孩子时吃的很多食物，大部分已经一去不复返而且被我忘掉了，但可以肯定的是，它们中的一部分已经长成我的骨头和肉 友情提醒 1.这篇文章主要讲retrofit如何request 和 response 2.不会详细到每个api 3.文章会以
Retrofit源码解析(三)
haoxl1994的博客
02-20 350
前两篇介绍了retrofit与okhttp的关系以及retrofit的内部属性组成，这一遍正式开始剖析retrofit发送一个网络请求的全过程。我们使用最简单的方式构建retrofit，没有搭配RxJava2CallAdapterFactory也没有设置GsonConvertFactory，看看最原汁原味的retrofit是如何工作的。 一、retrofit构建 val retrofit = Retrofit.Builder().baseUrl("http://www.base.com/").build()
Retrofit2与网络框架深度解析
"这篇内容主要探讨了Android网络框架中的Retrofit2、Volley以及OkHttp，特别是深入解析了Retrofit2的工作原理，并提及了Retrofit与RxJava的结合使用。" 在Android应用开发中，网络框架是至关重要的部分，它们帮助...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值