Retrofit 源码简单分析

最新推荐文章于 2024-02-05 15:15:58 发布
最新推荐文章于 2024-02-05 15:15:58 发布
阅读量254 收藏
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jh352160/article/details/78598128
版权

众所周知，在现在的Android开发中，针对与网络请求，Retrofit+okHtt的组合绝对是不二之选，而在网上针对与Retrofit分析的文章也有很多了，这次我也分享一些阅读Retrofit源码的心得，希望能够对大家有所帮助。由于我在工作中使用的版本为2.1，所以本次也是针对2.1版本进行分析，首先来看看Retrofit一种简单的用法：

Retrofit简单使用示例

首先创建出Retrofit对象，进行相应的初始化配置：

    retrofit=new Retrofit.Builder()
        .baseUrl(baseUrl)
        .addConverterFactory(GsonConverterFactory.create())
        .client(getClient())
        .build();

然后在Service接口中写入相应方法，并加上相应的注解：

    public interface Api {
        @GET(apiUrl)
        Call<Response> methodName();
    }

最后传入请求的回调方法Callback就可以就完成了：

    retrofit.create(Api.class).methodName().enqueue(Callback);

对于Retrofit对象的Build中，主要的都是对于参数的初始化，所以本次就从Retrofit类中的create(final Class service)入手

Retrofit.create

public <T> T create(final Class<T> service) {
    //api类必须为接口，且不能实现或继承其他接口，否则在动态代理步骤将会抛出异常
    Utils.validateServiceInterface(service);
    if (validateEagerly) {
        //立即开始遍历调用service中的所有方法
        eagerlyValidateMethods(service);
    }
    //返回service类的动态代理对象，当调用service中的方法时，就会进入其中进行处理
    return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] { service },
        new InvocationHandler() {
          //获取当前平台（Android或Java8）
          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.
            // 如果该方法为Class类中的方法，则直接执行
            if (method.getDeclaringClass() == Object.class) {
              return method.invoke(this, args);
            }
            //判断给方法是否为default method，针对Android平台，该值永远为false，所以不应在Service类中加入default方法，经尝试可能会导致崩溃
            //关于default method可以参考 http://ebnbin.com/2015/12/20/java-8-default-methods/
            if (platform.isDefaultMethod(method)) {
              return platform.invokeDefaultMethod(method, service, proxy, args);
            }
            //1.获取调用方法的ServiceMethod对象
            ServiceMethod serviceMethod = loadServiceMethod(method);
            //2.创建OkHttpCall对象
            OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
            //3.将上一步生成的OkHttpCall对象转换为在service中所配置的Call对象
            return serviceMethod.callAdapter.adapt(okHttpCall);
          }
        });
 }

在这段代码的最后所返回的Call对象就是用来使用的Call对象了。

其中有一个很有趣的地方，在 Platform 类中有一个通过判断特定的类是否存在的方式获取当前平台的步骤，在我的2.1版本中有这么一段代码：

try {
    Class.forName("org.robovm.apple.foundation.NSObject");
    return new IOS();
} catch (ClassNotFoundException ignored) {}

但在最新的2.3版本中这段代码已被移除，这说明Retrofit在之前版本中有对IOS平台的支持，但是我在网上却没有找到相关的资料，不知道有没有哪位朋友能为我解答一下。

在上面的代码中，重点是最后的三行代码，下面就分别对于这三行代码进分析：

1.ServiceMethod serviceMethod = loadServiceMethod(method);

Retrofit.loadServiceMethod

下面来通过loadServiceMethod方法看看ServiceMethod对象是如何创建出来的

  ServiceMethod loadServiceMethod(Method method) {
    ServiceMethod result;
    synchronized (serviceMethodCache) {
      //该方法的ServiceMethod对象是否已存在缓存中，如果是，则直接使用缓存中的对象
      result = serviceMethodCache.get(method);
      if (result == null) {
        //创建ServiceMethod对象并将其放入缓存
        result = new ServiceMethod.Builder(this, method).build();
        serviceMethodCache.put(method, result);
      }
    }
    return result;
  }

在代码中可以看出创建ServiceMethod对象主要都在ServiceMethod.Builder之中

在其中我发现了一点，在我所使用的2.1版本中，作为缓存使用的serviceMethodCache为LinkedHashMap，但在最新的2.3版本中已被换成了线程安全的ConcurrentHashMap。

ServiceMethod.Builder.Builder

首先看看Build中的构造方法：

    public Builder(Retrofit retrofit, Method method) {
      this.retrofit = retrofit;  //retrofit对象
      this.method = method;  //所调用的方法
      this.methodAnnotations = method.getAnnotations();  //方法上的注解
      this.parameterTypes = method.getGenericParameterTypes();  //方法中参数的类型
      this.parameterAnnotationsArray = method.getParameterAnnotations();  //方法中参数上的注解
    }

可以看出，构造方法中的代码很简单，就是针对各个变量的赋值操作。下面就是ServiceMethod中的重头戏，也就是build方法，对于注解的解析也都是在这里完成的，这一部分的代码虽多，但是大部分都是对于注解的解析与异常的判断，还是一样先来看看代码：

ServiceMethod.Builder.build

    public ServiceMethod build() {
      //代码中将略去其中的合法性检测部分

      //通过retrofit中的CallAdapterFactory生成CallAdapter，用以生成网络请求所需的执行器
      callAdapter = createCallAdapter();
      //数据数据转换工厂，例如常用的GsonConverterFactory
      responseConverter = createResponseConverter();

      //解析方法上的注解
      for (Annotation annotation : methodAnnotations) {
        parseMethodAnnotation(annotation);
      }

      //解析方法中各参数上的注解
      int parameterCount = parameterAnnotationsArray.length;
      parameterHandlers = new ParameterHandler<?>[parameterCount];
      for (int p = 0; p < parameterCount; p++) {
        Type parameterType = parameterTypes[p];

        Annotation[] parameterAnnotations = parameterAnnotationsArray[p];

        parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations);
      }

      //返回ServiceMethod对象
      return new ServiceMethod<>(this);
    }

其中最重要的应该是属于对于方法与参数的注解解析的部分了，这也是Retrofit的特色之一，先来看看对于方法部分的注解解析：

ServiceMethod.parseMethodAnnotation

    private void parseMethodAnnotation(Annotation annotation) {
      //除去异常判断后的代码
      if (annotation instanceof DELETE) {
        parseHttpMethodAndPath("DELETE", ((DELETE) annotation).value(), false);
      } else if (annotation instanceof GET) {
        parseHttpMethodAndPath("GET", ((GET) annotation).value(), false);
      } else if (annotation instanceof HEAD) {
        parseHttpMethodAndPath("HEAD", ((HEAD) annotation).value(), false);
      } else if (annotation instanceof PATCH) {
        parseHttpMethodAndPath("PATCH", ((PATCH) annotation).value(), true);
      } else if (annotation instanceof POST) {
        parseHttpMethodAndPath("POST", ((POST) annotation).value(), true);
      } else if (annotation instanceof PUT) {
        parseHttpMethodAndPath("PUT", ((PUT) annotation).value(), true);
      } else if (annotation instanceof OPTIONS) {
        parseHttpMethodAndPath("OPTIONS", ((OPTIONS) annotation).value(), false);
      } else if (annotation instanceof HTTP) {
        HTTP http = (HTTP) annotation;
        parseHttpMethodAndPath(http.method(), http.path(), http.hasBody());
      } else if (annotation instanceof retrofit2.http.Headers) {
        String[] headersToParse = ((retrofit2.http.Headers) annotation).value();
        headers = parseHeaders(headersToParse);
      } else if (annotation instanceof Multipart) {
        isMultipart = true;
      } else if (annotation instanceof FormUrlEncoded) {
        isFormEncoded = true;
      }
    }

可以看出来，这个方法中的逻辑很简单，主要是判断出注解的类型，并将对应的字符串传入之后的处理中，真正的处理还是在parseHttpMethodAndPath与parseHeaders两个方法中

ServiceMethod.parseHttpMethodAndPath

    private void parseHttpMethodAndPath(String httpMethod, String value, boolean hasBody) {
      //除去异常判断后的代码

      //方法的类型（如GET，POST，PUT等）
      this.httpMethod = httpMethod;
      //是否含有Body
      this.hasBody = hasBody;

      //判断相对路径是否为空
      if (value.isEmpty()) {
        return;
      }

      //将相对路径
      this.relativeUrl = value;
      //解析相对路径中的参数
      this.relativeUrlParamNames = parsePathParameters(value);
    }

在除去其中异常判断后，这个方法的逻辑就变得非常清晰了

ServiceMethod.parsePathParameters

  static Set<String> parsePathParameters(String path) {
    // PARAM_URL_REGEX = \{([a-zA-Z][a-zA-Z0-9_-]*)\}
    Matcher m = PARAM_URL_REGEX.matcher(path);
    Set<String> patterns = new LinkedHashSet<>();
    while (m.find()) {
      patterns.add(m.group(1));
    }
    return patterns;
  }

这个方法也很好理解，使用正则表达式匹配出相对路径中以”{}”包裹的变量，然后放入Set集合中

ServiceMethod.parseHeaders

该方法的作用为Header注解的解析：

    private Headers parseHeaders(String[] headers) {
      Headers.Builder builder = new Headers.Builder();
      for (String header : headers) {
        //解析出header中的key和value
        int colon = header.indexOf(':');
        String headerName = header.substring(0, colon);
        String headerValue = header.substring(colon + 1).trim();
        //针对Content-type的头，将其存入contentType变量中
        if ("Content-Type".equalsIgnoreCase(headerName)) {
          MediaType type = MediaType.parse(headerValue);
          contentType = type;
        } else {
          builder.add(headerName, headerValue);
        }
      }
      //创建Headers对象
      return builder.build();
    }

ServiceMethod.parseParameterAnnotation

这个方法用于参数注解的解析

    private ParameterHandler<?> parseParameterAnnotation(
        int p, Type type, Annotation[] annotations, Annotation annotation) {
      if (annotation instanceof Url) {
        //do something
      } else if (annotation instanceof Path) {
        //do something
      } else if (annotation instanceof Query) {
        //do something
      } else if (annotation instanceof QueryMap) {
       //do something
      } else if (annotation instanceof Header) {
        //do something
      } else if (annotation instanceof HeaderMap) {
        //do something
      } else if (annotation instanceof Field) {
        //do something
      } else if (annotation instanceof FieldMap) {
        //do something
      } else if (annotation instanceof Part) {
        //do something
      } else if (annotation instanceof PartMap) {
        gotPart = true;
        //do something
      } else if (annotation instanceof Body) {
        //do something
      }

      return null; // Not a Retrofit annotation.
    }

parseParameterAnnotation这个方法中的代码虽然多，但是在简化之后可以看出来，就是针对不同的参数类型进行不同的处理然后返回相应的ParameterHandler对象，因为其中针对各个类型参数的处理比较繁琐，就不一一列举了。

需要提到的是，在这个方法中，有一个类的出现频率非常的高，这就是ParameterHandler类，这个类的主要作用是将注解中的各项参数通过RequestBuilder类转换为okHttp中使用的Request。

2.OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);

在OkHttpCall类中，最主要的就是execute与enqueue两个方法，分别为同步与异步的网络请求，但是需要注意的是，这两个方法并不是我们在使用中所调用的方法，真正提供给外界调用的方法，会在文章之后的部分讲到。

OkHttpCall.execute

  @Override public Response<T> execute() throws IOException {
    //okHttp中的call对象，由于本次分析限于Retrofit中，所以不做深究
    okhttp3.Call call;

    synchronized (this) {
      //一个OkhttpCall对象只能执行一次网络请求
      if (executed) throw new IllegalStateException("Already executed.");
      executed = true;

      //省略部分异常判断代码

      call = rawCall;
      if (call == null) {
        try {
          //如果okHttp对象未创建，则在创建后赋值给变量call
          call = rawCall = createRawCall();
        } catch (IOException | RuntimeException e) {
          creationFailure = e;
          throw e;
        }
      }
    }

    //防止当调用过cancel方法后新创建的Call未被cancel的情况
    if (canceled) {
      call.cancel();
    }

    //使用okhttp开始执行网络请求
    return parseResponse(call.execute());
  }

OkHttpCall.enqueue

  @Override public void enqueue(final Callback<T> callback) {
    if (callback == null) throw new NullPointerException("callback == null");

    //okHttp中的call对象，由于本次分析限于Retrofit中，所以不做深究
    okhttp3.Call call;
    Throwable failure;

    //一个OkhttpCall对象只能执行一次网络请求
    synchronized (this) {
      if (executed) throw new IllegalStateException("Already executed.");
      executed = true;

      call = rawCall;
      failure = creationFailure;
      if (call == null && failure == null) {
        try {
          //如果okHttp对象未创建，则在创建后赋值给变量call
          call = rawCall = createRawCall();
        } catch (Throwable t) {
          failure = creationFailure = t;
        }
      }
    }

    //创建okhttp对象失败时，直接进行Fail的回调方法
    if (failure != null) {
      callback.onFailure(this, failure);
      return;
    }

    //防止当调用过cancel方法后新创建的Call未被cancel的情况
    if (canceled) {
      call.cancel();
    }

    //使用okhttp开始执行网络请求，并针对返回结果调用Callback中相应的回调方法
    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();
        }
      }
    });
  }

enqueue方法在主要的逻辑上，与上面的execute是基本相同的，但是有一点需要注意，就是当收到Response时并不会马上进行Callback中的onResponse回调，而是会调用parseResponse方法对返回的Response进行一次解析，如果解析中出现了异常，依然会进行onFailure的回调方法。

OkHttpCall.parseResponse

  Response<T> parseResponse(okhttp3.Response rawResponse) throws IOException {
    // 取出Response中的Body
    ResponseBody rawBody = rawResponse.body();

    // 这个变量就是最后获得的Response中的rawResponse，这实际上是一个在请求中返回的，去除了body部分的okhttp.Response原始对象
    // 移除okhttp3.Response中的Source部分并重建一个okhttp.Response对象
    // 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();

    int code = rawResponse.code();
    //如果code不在200~299的范围内，则代表请求异常
    if (code < 200 || code >= 300) {
      try {
        // Buffer the entire body to avoid future I/O.
        ResponseBody bufferedBody = Utils.buffer(rawBody);
        return Response.error(bufferedBody, rawResponse);
      } finally {
        rawBody.close();
      }
    }

    // 204 NO CONTENT 与 205 RESET CONTENT 两个code是不含有body的
    // 具体可以查阅https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/204与
    //           https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/205
    if (code == 204 || code == 205) {
      return Response.success(null, rawResponse);
    }

    // ExceptionCatchingRequestBody是为了捕获在解析rawBody中的内容的buffer时抛出的异常
    ExceptionCatchingRequestBody catchingBody = new ExceptionCatchingRequestBody(rawBody);
    try {
      // 通过Converter（如：GsonResponseBodyConverter）将Response中的流解析为所需的返回类型
      T body = serviceMethod.toResponse(catchingBody);
      return Response.success(body, rawResponse);
    } catch (RuntimeException e) {
      // If the underlying source threw an exception, propagate that rather than indicating it was
      // a runtime exception.
      catchingBody.throwIfCaught();
      throw e;
    }
  }

这个方法主要是对okhttp中返回的response进行一次解析，对其进行一些预处理，并将其转换为更易于使用的Response对象

OkHttpCall.createRawCall

  private okhttp3.Call createRawCall() throws IOException {
    //获取ServiceMethod生成的Request对象
    Request request = serviceMethod.toRequest(args);
    //通过callFactory将Request转换为Okhttp3.Call
    okhttp3.Call call = serviceMethod.callFactory.newCall(request);
    if (call == null) {
      throw new NullPointerException("Call.Factory returned null.");
    }
    return call;
  }

这个方法主要用于创建okHttp中的Call对象，逻辑非常简单，就不多做分析了

3.serviceMethod.callAdapter.adapt(okHttpCall)

这个方法实际是使用在创建Retrofit对象时传入的CallAdapterFactory将OkHttpCall对象转换为最后使用所需的对象，Retrofit中会默认配置一个ExecutorCallAdapterFactory，除此之外还有常用的RxJavaCallAdapterFactory与一个最简单的DefaultCallAdapterFactory。我们抽取出其中的adapt方法来看一看：

DefaultCallAdapterFactory

final class DefaultCallAdapterFactory extends CallAdapter.Factory {
  //DefaultCallAdapterFactory在返回时为一个单例对象
  static final CallAdapter.Factory INSTANCE = new DefaultCallAdapterFactory();

  //构造方法
  @Override
  public CallAdapter<?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
    if (getRawType(returnType) != Call.class) {
      return null;
    }

    final Type responseType = Utils.getCallResponseType(returnType);
    return new CallAdapter<Call<?>>() {
      //获取返回值的类型
      @Override public Type responseType() {
        return responseType;
      }

      //将传入的Call对象转换为最后处理所需要的对象返回，在DefaultCallAdapterFactory中为将传入其中的对象直接返回
      @Override public <R> Call<R> adapt(Call<R> call) {
        return call;
      }
    };
  }
}

这个是Retrofit中最为基本的CallAdapter，也只有在平台为Java8或者无法判断平台时才会使用，也由于这个类的逻辑非常简单，也可以通过这个类了解到CallAdapter.Factory最核心的两个方法的作用

ExecutorCallAdapterFactory

ExecutorCallAdapterFactory类为Android平台的默认CallAdapter：

final class ExecutorCallAdapterFactory extends CallAdapter.Factory { 
  final Executor callbackExecutor;

  //构造方法
  ExecutorCallAdapterFactory(Executor callbackExecutor) {
    this.callbackExecutor = callbackExecutor;
  }

  //获取CallAdapter对象
  @Override
  public CallAdapter<Call<?>> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
    if (getRawType(returnType) != Call.class) {
      return null;
    }
    final Type responseType = Utils.getCallResponseType(returnType);
    return new CallAdapter<Call<?>>() {
      //获取返回参数的类型
      @Override public Type responseType() {
        return responseType;
      }

      //将传入的Call对象转换为最后处理所需要的对象返回,在这里的返回类型为内部类ExecutorCallbackCall
      @Override public <R> Call<R> adapt(Call<R> call) {
        return new ExecutorCallbackCall<>(callbackExecutor, call);
      }
    };
  }

  //这就是在ExecutorCallAdapterFactory中返回给外界去使用的对象，也就是在文章开头调用了相应的api方法后所返回的对象
  static final class ExecutorCallbackCall<T> implements Call<T> {
    final Executor callbackExecutor;
    final Call<T> delegate;

    ExecutorCallbackCall(Executor callbackExecutor, Call<T> delegate) {
      this.callbackExecutor = callbackExecutor;
      this.delegate = delegate;
    }

    //在文章开头的使用示例中所传入的CallBack实际就是在这里调用相应的回调方法
    @Override public void enqueue(final Callback<T> callback) {
      if (callback == null) throw new NullPointerException("callback == null");

      delegate.enqueue(new Callback<T>() {
        @Override public void onResponse(Call<T> call, final Response<T> response) {
          //这里的callbackExecutor来源于针对当前平台的对象Platform中的defaultCallbackExecutor方法
          //在Android平台中，该方法的返回语句为 return new MainThreadExecutor(); 
          //MainThreadExecutor的实现为通过handler将Runnable对象发送至主线程执行
          callbackExecutor.execute(new Runnable() {
            @Override public void run() {
              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作用同上
          callbackExecutor.execute(new Runnable() {
            @Override public void run() {
              callback.onFailure(ExecutorCallbackCall.this, t);
            }
          });
        }
      });
    }

    //do something
  }

结语

那么，到现在为止，我们简单梳理了Retrofit中的Call的创建流程与ServiceMethod类中的主要逻辑，而这些，也只是Retrofi中的一部分而已，而我也是第一次写这样的文章，加上我的技术还不到位，所以肯定会有很多的不足，欢迎大家来批评指正。

jh352160
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Retrofit之OKHttpCall源码分析
01-05
之前在Retrofit源码初探一文中我们提出了三个问题： 什么时候开始将注解中参数拼装成http请求的信息的？ 如何产生发起http请求对象的？ 如何将对象转换成我们在接口中指定的返回值的？ 其中第一个问题前几篇文章...
Retrofit源码之请求对象的转换笔记
08-27
在深入源码分析请求对象的转换过程之前，我们需要先理解Retrofit的工作原理。Retrofit将我们的HTTP请求抽象为Java方法，并通过注解（如@GET、@POST等）来配置请求细节。当调用这些方法时，Retrofit会自动处理请求的...
Retrofit源码分析
H_xxxxd的博客
02-22 686
深入理解Retrofit源码
Retrofit源码简单分析
qq_32091725的博客
09-19 295
Retrofit源码简单分析 基础介绍 Retrofit 是对okhttp的封装，使用了大量的设计模式，核心原理：运行期，JDK动态代理。Retrofit官网 JDk动态代理实现步骤 新建接口类，添加接口方法（不继承其他接口） 新建接口实现类，实现接口 新建代理类实现反射包java.lang.reflect.InvocationHandle的invoke方法，接口类的实现都由invoke代理，可...
Retrofit源码分析及理解
阿根的专栏
02-05 1022
Retrofit内部有着简捷、优雅的结构设计。当然对于新手来说，Retrofit也有着不宜理解和上手的问题。不过瑕不掩瑜，Retrofit仍然是一款优秀的网络请求框架。 这边文章除了进行源码分析，还有个人对Retrofit的一些浅见和感悟。仅供读者参考。
Retrofit2 源码分析
蜗牛快跑
08-04 614
Retrofit介绍 Retrofit是Square公司的一个开源网络访问框架。主要是把网络请求的数据，通过接口来封装。内部通过OKHttpClient来请求。 Retrofit的简单配置，使用 Retrofit retrofit = new Retrofit .Builder() .baseUrl(&amp;amp;amp;amp;quot;https://ap...
Retrofit源码分析之流程分析
楊帥
04-09 276
本篇承接 Retrofit简单使用 Retrofit底层还是okhttp3，但是对比okhttp3简单实用及源码分析（一）可以看出来，retrofit不需要进行okhttp3的配置，并且retrofit引入了GsonConverterFactory，简化了json解析过程，具体的下面分析。 配置Retrofit： private httpInter Createhttp(){ ...
Retrofit2源码分析
qq_32534441的博客
03-20 210
一、概述     在了解Retrofit2源码架构之前先说明，本文默认读者对Retrofit2框架的使用有一定了解，除此之外还要先熟悉okhttp3框架和Java代理模式中的动态代理，不然后面咱们看Retrofit2源码时会很难理解：     Java代理模式     严格地说，Retrofit2并不是一个网络请求交易框架，它只是对网络请...
Retrofit源码解析
m0_61130325的博客
04-23 180
Retrofit的create()方法最终会调用动态代理对象的invoke()方法来处理方法调用。在invoke()方法中，会根据方法的注解和参数等信息创建一个对象，并使用OkHttpCall类创建一个Call对象并返回。以下是invoke()invoke()方法是动态代理对象的一种方法，用于在代理对象上处理方法调用。// ... }在invoke()方法中，会使用类来解析方法的注解和参数等信息，并构建一个对象。类的build()方法会根据方法的注解和参数等信息构建一个对象，并返回该对象。在。
Retrofit源码流程分析
Z2LYYYY的博客
06-17 376
Retrofit源码
Retrofit源码分析三 源码分析
BlackFlagBin的博客
05-17 186
Retrofit源码分析三 源码分析 使用方法 我们先来看一下Retrofit的常见使用方法： //创建网络请求接口类 public interface GitHubService { @GET("users/{user}/repos") Call&lt;List&lt;Repo&gt;&gt; listRepos(@Path("user") String user); } ...
Retrofit2 Demo源码
12-17
Retrofit2是一款在Android开发中广泛使用的网络请求库，它由Square公司开发，以其简洁的API设计和强大的功能深受...通过分析和实践这些示例，你可以更深入地了解Retrofit2的工作原理，以及如何根据项目需求进行定制。
RxJava + Retrofit2 基本使用实例详解（附源码 效果图）
01-20
本文将详细解析如何使用这两个库进行基本的网络调用，并提供一个实际的使用实例，包括源码分析和运行效果。 首先，让我们了解RxJava和Retrofit2的基本概念： **RxJava** 是一个用于处理异步数据流的库，它提供了...
50个经典安卓项目源码
05-07
1. **UI设计与布局**：通过分析源码，你可以了解如何使用Android Studio中的XML布局文件创建用户界面，包括线性布局、相对布局、网格布局等。同时，你还能学习到自定义View和动画效果的实现。 2. **事件处理**：...
基于Cocos Creator 3.x开发的Excel转Json格式的插件，同时会根据表格中的字段生成数据结构TypeScr代码
最新发布
08-16
oops-plugin-excel-to-json 是基于 Cocos Creator 3.x 开发的Excel转Json格式的插件，同时会根据表格中的字段生成数据结构TypeScript代码
FIJKPlayer-简介
08-16
FIJKPlayer-简介
vue+cesium+heatmap实现全球热力图
08-16
vue+cesium+heatmap实现全球热力图
印象笔记旧版本Evernote-6.22.36.3870.exe
08-16
这个版本还是不错，没有广告，支持多个账号添加同时打开使用。也能专注于笔记内容，列表和菜单栏都可以调节较小，内容窗口编辑界面也可以调节很大。
Retrofit入门指南：打造Android高效API客户端
Retrofit教程深入讲解了如何在Android平台上优雅地构建API客户端。由Marcus Pöhls编著，该教程适合对Android应用开发和网络通信感兴趣的开发者。主要内容包括： 1. **入门指南**： - 介绍Retrofit：Retrofit是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值