码农知识堂 - 1000bd
  •   Python
  •   PHP
  •   JS/TS
  •   JAVA
  •   C/C++
  •   C#
  •   GO
  •   Kotlin
  •   Swift

  • Retrofit原理 一篇文章就够了

    我们网络访问已经有了OkHttp，那为什么还需要一个Retrofit呢？

    我们先来看一下一个基本的OkHttp请求的步骤：

    1. String url = "http://wwww.baidu.com";
    2. OkHttpClient okHttpClient = new OkHttpClient();
    3. final Request request = new Request.Builder()
    4.         .url(url)
    5.         .get()//默认就是GET请求，可以不写
    6.         .build();
    7. Call call = okHttpClient.newCall(request);
    8. call.enqueue(new Callback() {
    9.     @Override
    10.     public void onFailure(Call call, IOException e) {
    11.         Log.d(TAG, "onFailure: ");
    12.     }
    13.  
    14.     @Override
    15.     public void onResponse(Call call, Response response) throws IOException {
    16.         Log.d(TAG, "onResponse: " + response.body().string());
    17.     }
    18. });

    这样的请求其实有几个问题：

    • response需要手动解析
    • 线程需要手动切换
    • 请求回调代码无法复用
    • 网络请求回调陷阱

    我们知道Retrofit是基于OkHttp的一层封装，Retrofit本身不负责网络请求，而是将请求交给OkHttp处理。我们知道，Retrofit的请求是写在一个个接口里面的，这样同样baseUrl的请求就可以写在一个接口里面，非常方便拓展和管理。而且直接将数据解析到javaBean，并且自动切换线程。这样就有效的解决了OkHttp的使用问题。

    上图是对Retrofit职责的一个很好的描述。

    我们来看一下Retrofit的基本使用：

    1. //step1
    2. Retrofit retrofit = new Retrofit.Builder()
    3.        .baseUrl("https://www.wanandroid.com/")
    4.        .addConverterFactory(GsonConverterFactory.create(new Gson()))
    5.        .build();
    6. //step2
    7. ISharedListService sharedListService =  retrofit.create(ISharedListService.class);
    8. //step3
    9. Call sharedListCall = sharedListService.getSharedList(2,1);
    10. //step4
    11. sharedListCall.enqueue(new Callback() {
    12.   @Override
    13.   public void onResponse(Call call, Response response{
    14.     if (response.isSuccessful()) {
    15.         System.out.println(response.body().toString());
    16.       }
    17.     }
    18.     @Override
    19.     public void onFailure(Call call, Throwable t) {
    20.      t.printStackTrace();
    21.    }
    22. });

    我们先来看build方法做了什么事情：

    1. public Retrofit build() {
    2.       if (baseUrl == null) {
    3.         throw new IllegalStateException("Base URL required.");
    4.       }
    5.  
    6.       okhttp3.Call.Factory callFactory = this.callFactory;
    7.       if (callFactory == null) {
    8.         callFactory = new OkHttpClient();//1
    9.       }
    10.  
    11.       Executor callbackExecutor = this.callbackExecutor;
    12.       if (callbackExecutor == null) {
    13.         callbackExecutor = platform.defaultCallbackExecutor();//2
    14.       }
    15.  
    16.       // Make a defensive copy of the adapters and add the default Call adapter.
    17.       List callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
    18.       callAdapterFactories.addAll(platform.defaultCallAdapterFactories(callbackExecutor));
    19.  
    20.       // Make a defensive copy of the converters.
    21.       List converterFactories =
    22.           new ArrayList<>(
    23.               1 + this.converterFactories.size() + platform.defaultConverterFactoriesSize());
    24.  
    25.       // Add the built-in converter factory first. This prevents overriding its behavior but also
    26.       // ensures correct behavior when using converters that consume all types.
    27.       converterFactories.add(new BuiltInConverters());
    28.       converterFactories.addAll(this.converterFactories);
    29.       converterFactories.addAll(platform.defaultConverterFactories());
    30.  
    31.       return new Retrofit(
    32.           callFactory,
    33.           baseUrl,
    34.           unmodifiableList(converterFactories),
    35.           unmodifiableList(callAdapterFactories),
    36.           callbackExecutor,
    37.           validateEagerly);
    38.     }
    39.   }

    注释1处可见创建了一个OkHttpClient。这里也用到了建造者设计模式。那我们要思考一下，何时该使用建造者模式呢？好多人看了大量的设计模式书籍，可是代码风格依然一眼难尽！

    1. public static final class Builder {
    2.     private final Platform platform;
    3.     private @Nullable okhttp3.Call.Factory callFactory;
    4.     private @Nullable HttpUrl baseUrl;
    5.     private final List converterFactories = new ArrayList<>();
    6.     private final List callAdapterFactories = new ArrayList<>();
    7.     private @Nullable Executor callbackExecutor;
    8.     private boolean validateEagerly;
    9.  
    10.     Builder(Platform platform) {
    11.       this.platform = platform;
    12.     }
    13.  
    14.     public Builder() {
    15.       this(Platform.get());
    16.     }
    17.  
    18.     Builder(Retrofit retrofit) {
    19.       platform = Platform.get();
    20.       callFactory = retrofit.callFactory;
    21.       baseUrl = retrofit.baseUrl;
    22.  
    23.       // Do not add the default BuiltIntConverters and platform-aware converters added by build().
    24.       for (int i = 1,
    25.               size = retrofit.converterFactories.size() - platform.defaultConverterFactoriesSize();
    26.           i < size;
    27.           i++) {
    28.         converterFactories.add(retrofit.converterFactories.get(i));
    29.       }
    30.  
    31.       // Do not add the default, platform-aware call adapters added by build().
    32.       for (int i = 0,
    33.               size =
    34.                   retrofit.callAdapterFactories.size() - platform.defaultCallAdapterFactoriesSize();
    35.           i < size;
    36.           i++) {
    37.         callAdapterFactories.add(retrofit.callAdapterFactories.get(i));
    38.       }
    39.  
    40.       callbackExecutor = retrofit.callbackExecutor;
    41.       validateEagerly = retrofit.validateEagerly;
    42.     }
    43.  
    44.     /**
    45.      * The HTTP client used for requests.
    46.      *
    47.      * 
      This is a convenience method for calling {@link #callFactory}.
    48.      */
    49.     public Builder client(OkHttpClient client) {
    50.       return callFactory(Objects.requireNonNull(client, "client == null"));
    51.     }
    52.  
    53.     /**
    54.      * Specify a custom call factory for creating {@link Call} instances.
    55.      *
    56.      * 
      Note: Calling {@link #client} automatically sets this value.
    57.      */
    58.     public Builder callFactory(okhttp3.Call.Factory factory) {
    59.       this.callFactory = Objects.requireNonNull(factory, "factory == null");
    60.       return this;
    61.     }
    62.  
    63.     /**
    64.      * Set the API base URL.
    65.      *
    66.      * @see #baseUrl(HttpUrl)
    67.      */
    68.     public Builder baseUrl(URL baseUrl) {
    69.       Objects.requireNonNull(baseUrl, "baseUrl == null");
    70.       return baseUrl(HttpUrl.get(baseUrl.toString()));
    71.     }
    72.  
    73.     /**
    74.      * Set the API base URL.
    75.      *
    76.      * @see #baseUrl(HttpUrl)
    77.      */
    78.     public Builder baseUrl(String baseUrl) {
    79.       Objects.requireNonNull(baseUrl, "baseUrl == null");
    80.       return baseUrl(HttpUrl.get(baseUrl));
    81.     }
    82.  
    83.     /**
    84.      * Set the API base URL.
    85.      *
    86.      * 
      The specified endpoint values (such as with {@link GET @GET}) are resolved against this
    87.      * value using {@link HttpUrl#resolve(String)}. The behavior of this matches that of an {@code
    88.      * } link on a website resolving on the current URL.
    89.      *
    90.      * 
      Base URLs should always end in {@code /}.
    91.      *
    92.      * 
      A trailing {@code /} ensures that endpoints values which are relative paths will correctly
    93.      * append themselves to a base which has path components.
    94.      *
    95.      * 
      Correct:
    96.      * Base URL: http://example.com/api/
    97.      * Endpoint: foo/bar/
    98.      * Result: http://example.com/api/foo/bar/
    99.      *
    100.      * 
      Incorrect:
    101.      * Base URL: http://example.com/api
    102.      * Endpoint: foo/bar/
    103.      * Result: http://example.com/foo/bar/
    104.      *
    105.      * 
      This method enforces that {@code baseUrl} has a trailing {@code /}.
    106.      *
    107.      * 
      Endpoint values which contain a leading {@code /} are absolute.
    108.      *
    109.      * 
      Absolute values retain only the host from {@code baseUrl} and ignore any specified path
    110.      * components.
    111.      *
    112.      * 
      Base URL: http://example.com/api/
    113.      * Endpoint: /foo/bar/
    114.      * Result: http://example.com/foo/bar/
    115.      *
    116.      * 
      Base URL: http://example.com/
    117.      * Endpoint: /foo/bar/
    118.      * Result: http://example.com/foo/bar/
    119.      *
    120.      * 
      Endpoint values may be a full URL.
    121.      *
    122.      * 
      Values which have a host replace the host of {@code baseUrl} and values also with a scheme
    123.      * replace the scheme of {@code baseUrl}.
    124.      *
    125.      * 
      Base URL: http://example.com/
    126.      * Endpoint: https://github.com/square/retrofit/
    127.      * Result: https://github.com/square/retrofit/
    128.      *
    129.      * 
      Base URL: http://example.com
    130.      * Endpoint: //github.com/square/retrofit/
    131.      * Result: http://github.com/square/retrofit/ (note the scheme stays 'http')
    132.      */
    133.     public Builder baseUrl(HttpUrl baseUrl) {
    134.       Objects.requireNonNull(baseUrl, "baseUrl == null");
    135.       List pathSegments = baseUrl.pathSegments();
    136.       if (!"".equals(pathSegments.get(pathSegments.size() - 1))) {
    137.         throw new IllegalArgumentException("baseUrl must end in /: " + baseUrl);
    138.       }
    139.       this.baseUrl = baseUrl;
    140.       return this;
    141.     }
    142.  
    143.     /** Add converter factory for serialization and deserialization of objects. */
    144.     public Builder addConverterFactory(Converter.Factory factory) {
    145.       converterFactories.add(Objects.requireNonNull(factory, "factory == null"));
    146.       return this;
    147.     }
    148.  
    149.     /**
    150.      * Add a call adapter factory for supporting service method return types other than {@link
    151.      * Call}.
    152.      */
    153.     public Builder addCallAdapterFactory(CallAdapter.Factory factory) {
    154.       callAdapterFactories.add(Objects.requireNonNull(factory, "factory == null"));
    155.       return this;
    156.     }
    157.  
    158.     /**
    159.      * The executor on which {@link Callback} methods are invoked when returning {@link Call} from
    160.      * your service method.
    161.      *
    162.      * 
      Note: {@code executor} is not used for {@linkplain #addCallAdapterFactory custom method
    163.      * return types}.
    164.      */
    165.     public Builder callbackExecutor(Executor executor) {
    166.       this.callbackExecutor = Objects.requireNonNull(executor, "executor == null");
    167.       return this;
    168.     }
    169.  
    170.     /** Returns a modifiable list of call adapter factories. */
    171.     public List callAdapterFactories() {
    172.       return this.callAdapterFactories;
    173.     }
    174.  
    175.     /** Returns a modifiable list of converter factories. */
    176.     public List converterFactories() {
    177.       return this.converterFactories;
    178.     }
    179.  
    180.     /**
    181.      * When calling {@link #create} on the resulting {@link Retrofit} instance, eagerly validate the
    182.      * configuration of all methods in the supplied interface.
    183.      */
    184.     public Builder validateEagerly(boolean validateEagerly) {
    185.       this.validateEagerly = validateEagerly;
    186.       return this;
    187.     }
    188.  
    189.     /**
    190.      * Create the {@link Retrofit} instance using the configured values.
    191.      *
    192.      * 
      Note: If neither {@link #client} nor {@link #callFactory} is called a default {@link
    193.      * OkHttpClient} will be created and used.
    194.      */
    195.     public Retrofit build() {
    196.       if (baseUrl == null) {
    197.         throw new IllegalStateException("Base URL required.");
    198.       }
    199.  
    200.       okhttp3.Call.Factory callFactory = this.callFactory;
    201.       if (callFactory == null) {
    202.         callFactory = new OkHttpClient();
    203.       }
    204.  
    205.       Executor callbackExecutor = this.callbackExecutor;
    206.       if (callbackExecutor == null) {
    207.         callbackExecutor = platform.defaultCallbackExecutor();
    208.       }
    209.  
    210.       // Make a defensive copy of the adapters and add the default Call adapter.
    211.       List callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
    212.       callAdapterFactories.addAll(platform.defaultCallAdapterFactories(callbackExecutor));
    213.  
    214.       // Make a defensive copy of the converters.
    215.       List converterFactories =
    216.           new ArrayList<>(
    217.               1 + this.converterFactories.size() + platform.defaultConverterFactoriesSize());
    218.  
    219.       // Add the built-in converter factory first. This prevents overriding its behavior but also
    220.       // ensures correct behavior when using converters that consume all types.
    221.       converterFactories.add(new BuiltInConverters());
    222.       converterFactories.addAll(this.converterFactories);
    223.       converterFactories.addAll(platform.defaultConverterFactories());
    224.  
    225.       return new Retrofit(
    226.           callFactory,
    227.           baseUrl,
    228.           unmodifiableList(converterFactories),
    229.           unmodifiableList(callAdapterFactories),
    230.           callbackExecutor,
    231.           validateEagerly);
    232.     }
    233.   }

    我们先来看一下Retrofit的静态内部类Builder，里面的baseUrl，addConverterFactory等方法返回的都是Builder类型，说明了在使用的时候可以做到可配置，另外一个大家都比较清楚，就是参数比较多的情况，一般认为在5个以上。

    我们分析完Retrofit的使用的第一步，接下来看第二步：

    ISharedListService sharedListService =  retrofit.create(ISharedListService.class);

    点进create看一下：

    1. public  T create(final Class service) {
    2.     validateServiceInterface(service);
    3.     return (T)
    4.         Proxy.newProxyInstance(
    5.             service.getClassLoader(),
    6.             new Class[] {service},
    7.             new InvocationHandler() {
    8.               private final Platform platform = Platform.get();
    9.               private final Object[] emptyArgs = new Object[0];
    10.  
    11.               @Override
    12.               public @Nullable Object invoke(Object proxy, Method method, @Nullable Object[] args)
    13.                   throws Throwable {
    14.                 // If the method is a method from Object then defer to normal invocation.
    15.                 if (method.getDeclaringClass() == Object.class) {
    16.                   return method.invoke(this, args);
    17.                 }
    18.                 args = args != null ? args : emptyArgs;
    19.                 return platform.isDefaultMethod(method)
    20.                     ? platform.invokeDefaultMethod(method, service, proxy, args)
    21.                     : loadServiceMethod(method).invoke(args);
    22.               }
    23.             });
    24.   }

    大家可能或多或少了解过一些关于代理设计模式，可是你真的熟悉或者说了解代理设计模式吗？

    代理模式分为静态代理和动态代理，如果大家不熟悉静态代理模式，可以看下我以前的一篇文章：

    设计模式 - 静态代理模式_AD钙奶-lalala的博客-CSDN博客生活中我们都有过去银行办理银行卡的体验，一般会有银行工作人员协助办理银行卡，那么这个工作人员就是一个代理，这种模式就是代理模式。我们用java代码简单实现一下这个场景首先将需要代理的事件写在一个接口里面：public interface IBank { //申请办卡 void applyCard();}银行卡实际办理人：public class Man...https://blog.csdn.net/qq_36428821/article/details/103491205这里就不展开了。

    下面重点讲一下动态代理，我们先来看newProxyInstance这个方法：

    1. public static Object newProxyInstance(ClassLoader loader,
    2.                                           Class[] interfaces,
    3.                                           InvocationHandler h)
    4.         throws IllegalArgumentException
    5.     {

    发现返回的是一个Object类型的对象，所以create方法本质上是返回了一个实现指定接口的对象。

    1. public static Object newProxyInstance(ClassLoader loader,
    2.                                           Class[] interfaces,
    3.                                           InvocationHandler h)
    4.         throws IllegalArgumentException
    5.     {
    6.         Objects.requireNonNull(h);
    7.  
    8.         final Class[] intfs = interfaces.clone();
    9.        
    10.         Class cl = getProxyClass0(loader, intfs);
    11.  
    12.         
    13.         try {
    14.            
    15.  
    16.             final Constructor cons = cl.getConstructor(constructorParams);
    17.             final InvocationHandler ih = h;
    18.             if (!Modifier.isPublic(cl.getModifiers())) {
    19.                
    20.  
    21.                 cons.setAccessible(true);
    22.                 // END Android-removed: Excluded AccessController.doPrivileged call.
    23.             }
    24.             return cons.newInstance(new Object[]{h});//1
    25.         } catch (IllegalAccessException|InstantiationException e) {
    26.             throw new InternalError(e.toString(), e);
    27.         } catch (InvocationTargetException e) {
    28.             Throwable t = e.getCause();
    29.             if (t instanceof RuntimeException) {
    30.                 throw (RuntimeException) t;
    31.             } else {
    32.                 throw new InternalError(t.toString(), t);
    33.             }
    34.         } catch (NoSuchMethodException e) {
    35.             throw new InternalError(e.toString(), e);
    36.         }
    37.     }

    注意注释1处，通过构造函数初始化了一个对象，并将h传了进去，这个h是啥呢？很明显：

    是实现InvocationHandler接口的一个对象。我们来写一个create生成的实现传入接口的对象的伪代码帮大家理解一下动态代理：

    我们前面看到cons.newInstance(new Object[]{h})传进来一个h，再看上图，调用了h的invoke方法，这样是不是有点顿悟的感觉。简而言之，动态代理的原理就是：Proxy.newProxyInstance生成一个实现某个接口的对象，并且传入一个实现InvocationHandler接口的对象，当该对象调用实现接口的方法时，实际上调用的实现InvocationHandler接口的对象的invoke方法，并且将接口方法和参数也传进来，后面在invoke里面反射调用。

    这样讲大家可能还不是很明白，说的简单点吧：Retrofit请求我们写成一个一个的接口，而这些接口最终通过Proxy.newProxyInstance最终会生成实现这个接口的对象，这是第一步；而生成这个对象的时候，在构造中传入了实现InvocationHandler接口的的对象，紧接着调用这个对象的invoke方法，并将方法信息以及方法参数传过去，实际上实现这个接口的的方法调用是在实现InvocationHandler接口的的对象中进行的，而实现我们所写接口的对象的方法只是调用了this.h.invoke。

    下面再讲一个Retrofit非常重要的一个点：线程切换。我们知道OkHttp的回调里面是没有切换线程的，这样我们使用的时候就会需要手动切换线程，不是那么的友好。

    我们先看Retrofit里面的一段代码：

    1. public Retrofit build() {
    2.       
    3.  
    4. ···
    5.       Executor callbackExecutor = this.callbackExecutor;
    6.       if (callbackExecutor == null) {
    7.         callbackExecutor = platform.defaultCallbackExecutor();//1
    8.       }
    9.  
    10.       ···
    11.   }

    我们进注释1看看实现，我们是Android平台：

    1. static final class Android extends Platform {
    2.     Android() {
    3.       super(Build.VERSION.SDK_INT >= 24);
    4.     }
    5.  
    6.     @Override
    7.     public Executor defaultCallbackExecutor() {
    8.       return new MainThreadExecutor();//1
    9.     }
    10.  
    11.     @Nullable
    12.     @Override
    13.     Object invokeDefaultMethod(
    14.         Method method, Class declaringClass, Object object, Object... args) throws Throwable {
    15.       if (Build.VERSION.SDK_INT < 26) {
    16.         throw new UnsupportedOperationException(
    17.             "Calling default methods on API 24 and 25 is not supported");
    18.       }
    19.       return super.invokeDefaultMethod(method, declaringClass, object, args);
    20.     }
    21.  
    22.     static final class MainThreadExecutor implements Executor {
    23.       private final Handler handler = new Handler(Looper.getMainLooper());
    24.  
    25.       @Override
    26.       public void execute(Runnable r) {
    27.         handler.post(r);//2
    28.       }
    29.     }
    30.   }

    原来本质上是用了Handler，记住一个很重要的结论：Android中线程切换最终都是Handler，进程间通信绝大部分都是Binder。

    我们既然知道了Retrofit是使用Handler来进行线程切换的，那么它是如何使用的呢？

    我们再来看下面的代码：

    1. return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class[] { service },
    2.         new InvocationHandler() {
    3.           private final Platform platform = Platform.get();
    4.  
    5.           @Override public Object invoke(Object proxy, Method method, @Nullable Object[] args)
    6.               throws Throwable {
    7.             // If the method is a method from Object then defer to normal invocation.
    8.             if (method.getDeclaringClass() == Object.class) {
    9.               return method.invoke(this, args);
    10.             }
    11.             if (platform.isDefaultMethod(method)) {
    12.               return platform.invokeDefaultMethod(method, service, proxy, args);
    13.             }
    14.             ServiceMethod serviceMethod =
    15.                 (ServiceMethod) loadServiceMethod(method);//1
    16.             OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);//2
    17.             return serviceMethod.callAdapter.adapt(okHttpCall);//3
    18.           }
    19.         });
      20.  

      （注：这个代码是Retrofit2.3.0版本的，前面是2.9.0版本的，有些不一样，但是这个版本线程切换更好理解）
       

      先来看注释1:
       

      1. ServiceMethod loadServiceMethod(Method method) {
      2.     ServiceMethod result = serviceMethodCache.get(method);
      3.     if (result != null) return result;
      4.  
      5.     synchronized (serviceMethodCache) {
      6.       result = serviceMethodCache.get(method);
      7.       if (result == null) {
      8.         result = new ServiceMethod.Builder<>(this, method).build();
      9.         serviceMethodCache.put(method, result);
      10.       }
      11.     }
      12.     return result;
      13.   }
       

      我们只需要关注一点，这里面传入了this，而这个this就是retrofit对象。
       

      我们再来关注OKHttpCall：
       

      1. final class OkHttpCall implements Call {
      2.   private final ServiceMethod serviceMethod;
      3.   private final @Nullable Object[] args;
      4.  
      5.   private volatile boolean canceled;
      6.  
      7.   @GuardedBy("this")
      8.   private @Nullable okhttp3.Call rawCall;
      9.   @GuardedBy("this")
      10.   private @Nullable Throwable creationFailure; // Either a RuntimeException or IOException.
      11.   @GuardedBy("this")
      12.   private boolean executed;
      13.  
      14.   OkHttpCall(ServiceMethod serviceMethod, @Nullable Object[] args) {
      15.     this.serviceMethod = serviceMethod;
      16.     this.args = args;
      17.   }
      18.  
      19.  ···
      20.  
      21.   @Override public void enqueue(final Callback callback) {
      22.     checkNotNull(callback, "callback == null");
      23.  
      24.     okhttp3.Call call;
      25.     Throwable failure;
      26.  
      27.     synchronized (this) {
      28.       if (executed) throw new IllegalStateException("Already executed.");
      29.       executed = true;
      30.  
      31.       call = rawCall;
      32.       failure = creationFailure;
      33.       if (call == null && failure == null) {
      34.         try {
      35.           call = rawCall = createRawCall();
      36.         } catch (Throwable t) {
      37.           failure = creationFailure = t;
      38.         }
      39.       }
      40.     }
      41.  
      42.     if (failure != null) {
      43.       callback.onFailure(this, failure);
      44.       return;
      45.     }
      46.  
      47.     if (canceled) {
      48.       call.cancel();
      49.     }
      50.  
      51.     call.enqueue(new okhttp3.Callback() {
      52.       @Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse)
      53.           throws IOException {
      54.         Response response;
      55.         try {
      56.           response = parseResponse(rawResponse);
      57.         } catch (Throwable e) {
      58.           callFailure(e);
      59.           return;
      60.         }
      61.         callSuccess(response);
      62.       }
      63.  
      64.       @Override public void onFailure(okhttp3.Call call, IOException e) {
      65.         try {
      66.           callback.onFailure(OkHttpCall.this, e);
      67.         } catch (Throwable t) {
      68.           t.printStackTrace();
      69.         }
      70.       }
      71.  
      72.       private void callFailure(Throwable e) {
      73.         try {
      74.           callback.onFailure(OkHttpCall.this, e);
      75.         } catch (Throwable t) {
      76.           t.printStackTrace();
      77.         }
      78.       }
      79.  
      80.       private void callSuccess(Response response) {
      81.         try {
      82.           callback.onResponse(OkHttpCall.this, response);
      83.         } catch (Throwable t) {
      84.           t.printStackTrace();
      85.         }
      86.       }
      87.     });
      88.   }
      89.  
      90.   @Override public synchronized boolean isExecuted() {
      91.     return executed;
      92.   }
      93.  
      94.   
      95.  
      96.   private okhttp3.Call createRawCall() throws IOException {
      97.     Request request = serviceMethod.toRequest(args);
      98.     okhttp3.Call call = serviceMethod.callFactory.newCall(request);
      99.     if (call == null) {
      100.       throw new NullPointerException("Call.Factory returned null.");
      101.     }
      102.     return call;
      103.   }
      104.  
      105.   Response parseResponse(okhttp3.Response rawResponse) throws IOException {
      106.     ResponseBody rawBody = rawResponse.body();
      107.  
      108.     // Remove the body's source (the only stateful object) so we can pass the response along.
      109.     rawResponse = rawResponse.newBuilder()
      110.         .body(new NoContentResponseBody(rawBody.contentType(), rawBody.contentLength()))
      111.         .build();
      112.  
      113.     int code = rawResponse.code();
      114.     if (code < 200 || code >= 300) {
      115.       try {
      116.         // Buffer the entire body to avoid future I/O.
      117.         ResponseBody bufferedBody = Utils.buffer(rawBody);
      118.         return Response.error(bufferedBody, rawResponse);
      119.       } finally {
      120.         rawBody.close();
      121.       }
      122.     }
      123.  
      124.     if (code == 204 || code == 205) {
      125.       rawBody.close();
      126.       return Response.success(null, rawResponse);
      127.     }
      128.  
      129.     ExceptionCatchingRequestBody catchingBody = new ExceptionCatchingRequestBody(rawBody);
      130.     try {
      131.       T body = serviceMethod.toResponse(catchingBody);
      132.       return Response.success(body, rawResponse);
      133.     } catch (RuntimeException e) {
      134.       // If the underlying source threw an exception, propagate that rather than indicating it was
      135.       // a runtime exception.
      136.       catchingBody.throwIfCaught();
      137.       throw e;
      138.     }
      139.   }
      140. ···
      141. }
       

      我们发现，内部创建了一个OkHttp的call，执行的也是OkHttp创建的call的异步方法，这里也可以看出来Retrofit的网络请求其实是交给OkHttp来处理的。我们再来关注一下这段代码：
       

      1. private void callSuccess(Response response) {
      2.         try {
      3.           callback.onResponse(OkHttpCall.this, response);
      4.         } catch (Throwable t) {
      5.           t.printStackTrace();
      6.         }
      7.       }
       

      这个时候线程还没有切换，那么这个callback又是什么呢？我们看下面一段代码：
       

      1. final class ExecutorCallAdapterFactory extends CallAdapter.Factory {
      2.   final Executor callbackExecutor;
      3.  
      4.   ExecutorCallAdapterFactory(Executor callbackExecutor) {
      5.     this.callbackExecutor = callbackExecutor;
      6.   }
      7.  
      8.   @Override
      9.   public CallAdapter get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
      10.     if (getRawType(returnType) != Call.class) {
      11.       return null;
      12.     }
      13.     final Type responseType = Utils.getCallResponseType(returnType);
      14.     return new CallAdapter>() {
      15.       @Override public Type responseType() {
      16.         return responseType;
      17.       }
      18.  
      19.       @Override public Call adapt(Call call) {
      20.         return new ExecutorCallbackCall<>(callbackExecutor, call);
      21.       }
      22.     };
      23.   }
      24.  
      25.   static final class ExecutorCallbackCall implements Call {
      26.     final Executor callbackExecutor;
      27.     final Call delegate;
      28.  
      29.     ExecutorCallbackCall(Executor callbackExecutor, Call delegate) {
      30.       this.callbackExecutor = callbackExecutor;
      31.       this.delegate = delegate;
      32.     }
      33.  
      34.     @Override public void enqueue(final Callback callback) {
      35.       checkNotNull(callback, "callback == null");
      36.  
      37.       delegate.enqueue(new Callback() {//注释1
      38.         @Override public void onResponse(Call call, final Response response) {
      39.           callbackExecutor.execute(new Runnable() {
      40.             @Override public void run() {
      41.               if (delegate.isCanceled()) {
      42.                 // Emulate OkHttp's behavior of throwing/delivering an IOException on cancellation.
      43.                 callback.onFailure(ExecutorCallbackCall.this, new IOException("Canceled"));
      44.               } else {
      45.                 callback.onResponse(ExecutorCallbackCall.this, response);
      46.               }
      47.             }
      48.           });
      49.         }
      50.  
      51.         @Override public void onFailure(Call call, final Throwable t) {
      52.           callbackExecutor.execute(new Runnable() {
      53.             @Override public void run() {
      54.               callback.onFailure(ExecutorCallbackCall.this, t);
      55.             }
      56.           });
      57.         }
      58.       });
      59.     }
      60.  
      61.     @Override public boolean isExecuted() {
      62.       return delegate.isExecuted();
      63.     }
      64.  
      65.     @Override public Response execute() throws IOException {
      66.       return delegate.execute();
      67.     }
      68.  
      69.     @Override public void cancel() {
      70.       delegate.cancel();
      71.     }
      72.  
      73.     @Override public boolean isCanceled() {
      74.       return delegate.isCanceled();
      75.     }
      76.  
      77.     @SuppressWarnings("CloneDoesntCallSuperClone") // Performing deep clone.
      78.     @Override public Call clone() {
      79.       return new ExecutorCallbackCall<>(callbackExecutor, delegate.clone());
      80.     }
      81.  
      82.     @Override public Request request() {
      83.       return delegate.request();
      84.     }
      85.   }
      86. }
        87.  

        这个delegate就是OkHttpCall，我们传了一个实现CallBack接口的对象进去。接着来看onResponse方法，关注callbackExecutor，这又是个什么东西呢？不着急我们一点一点分析。
         

        我们回过头来再看这一行代码：
         

        serviceMethod.callAdapter.adapt(okHttpCall)
         

        顺着这一行代码往下推：这个callAdapter是个啥?
         

        1.  public ServiceMethod build() {
        2.       callAdapter = createCallAdapter();
        3. ```
        4. }
         

        1. private CallAdapter createCallAdapter() {
        2.       Type returnType = method.getGenericReturnType();
        3.       if (Utils.hasUnresolvableType(returnType)) {
        4.         throw methodError(
        5.             "Method return type must not include a type variable or wildcard: %s", returnType);
        6.       }
        7.       if (returnType == void.class) {
        8.         throw methodError("Service methods cannot return void.");
        9.       }
        10.       Annotation[] annotations = method.getAnnotations();
        11.       try {
        12.         //noinspection unchecked
        13.         return (CallAdapter) retrofit.callAdapter(returnType, annotations);
        14.       } catch (RuntimeException e) { // Wide exception range because factories are user code.
        15.         throw methodError(e, "Unable to create call adapter for %s", returnType);
        16.       }
        17.     }
         

        调用了retrofit的callAdapter方法：
         

        1. public CallAdapter callAdapter(Type returnType, Annotation[] annotations) {
        2.     return nextCallAdapter(null, returnType, annotations);
        3.   }
        4.  
        5.   /**
        6.    * Returns the {@link CallAdapter} for {@code returnType} from the available {@linkplain
        7.    * #callAdapterFactories() factories} except {@code skipPast}.
        8.    *
        9.    * @throws IllegalArgumentException if no call adapter available for {@code type}.
        10.    */
        11.   public CallAdapter nextCallAdapter(@Nullable CallAdapter.Factory skipPast, Type returnType,
        12.       Annotation[] annotations) {
        13.     checkNotNull(returnType, "returnType == null");
        14.     checkNotNull(annotations, "annotations == null");
        15.  
        16.     int start = adapterFactories.indexOf(skipPast) + 1;
        17.     for (int i = start, count = adapterFactories.size(); i < count; i++) {
        18.       CallAdapter adapter = adapterFactories.get(i).get(returnType, annotations, this);//注释处
        19.       if (adapter != null) {
        20.         return adapter;
        21.       }
        22.     }
        23.  
        24.     StringBuilder builder = new StringBuilder("Could not locate call adapter for ")
        25.         .append(returnType)
        26.         .append(".\n");
        27.     if (skipPast != null) {
        28.       builder.append("  Skipped:");
        29.       for (int i = 0; i < start; i++) {
        30.         builder.append("\n   * ").append(adapterFactories.get(i).getClass().getName());
        31.       }
        32.       builder.append('\n');
        33.     }
        34.     builder.append("  Tried:");
        35.     for (int i = start, count = adapterFactories.size(); i < count; i++) {
        36.       builder.append("\n   * ").append(adapterFactories.get(i).getClass().getName());
        37.     }
        38.     throw new IllegalArgumentException(builder.toString());
        39.   }
         

        注意一下注释处：我们从adapterFactories里面去拿，那么callAdapter什么时候加入这个集合的呢？
         

        1. Executor callbackExecutor = this.callbackExecutor;
        2.       if (callbackExecutor == null) {
        3.         callbackExecutor = platform.defaultCallbackExecutor();
        4.       }
        5.  
        6.       // Make a defensive copy of the adapters and add the default Call adapter.
        7.       List adapterFactories = new ArrayList<>(this.adapterFactories);
        8.       adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));
        9.  
        10. static class Android extends Platform {
        11.     @Override public Executor defaultCallbackExecutor() {
        12.       return new MainThreadExecutor();
        13.     }
        14.  
        15.     @Override CallAdapter.Factory defaultCallAdapterFactory(@Nullable Executor callbackExecutor) {
        16.       if (callbackExecutor == null) throw new AssertionError();
        17.       return new ExecutorCallAdapterFactory(callbackExecutor);
        18.     }
        19.  
        20.     static class MainThreadExecutor implements Executor {
        21.       private final Handler handler = new Handler(Looper.getMainLooper());
        22.  
        23.       @Override public void execute(Runnable r) {
        24.         handler.post(r);
        25.       }
        26.     }
        27.   }
         

        终于找到了ExecutorCallAdapterFactory！这样跟前面结合起来就形成了一个完美的闭环不是吗？
         

        我们最后再来理一理这个逻辑，可能还是有很多同学不是很明白：
         

        Retrofit的Call调用enqueue方法，其实是ExecutorCallAdapterFactory的内部类ExecutorCallbackCall的enqueue方法，而这个方法其实调用了OkHttpCall的enqueue方法，而OkHttpCall的enqueue方法执行的是OKHttp的Call得enqueue方法。线程切换就是在callbackExecutor.execute这里完成的，这个callbackExecutor其实是一个MainThreadExecutor()，内部封装了一个Handler，实现了线程切换。
         

         

         

        
                
                    
                

                
      87. 

                    相关阅读:
        
                    
【使用教程】在Ubuntu下PMM60系列一体化伺服电机通过PDO跑循环同步位置模式详解                            
        
嵌入式系统软件层次结构                            
        
(七)admin-boot项目之全局处理字符串两边空格                            
        
【Mysql】第4篇--多表查询和事务                            
        
【SQL注入】关于GORM的SQL注入问题                            
        
Ardupilot开源飞控之AP_Follow                            
        
grafana 通过查询结果设置动态阈值                            
        
Angular：通过路由切换页面后，ngOnInit()不会被触发的问题                            
        
Keepalived+LVS高可用集群                            
        
蓝桥杯练习题                            
        
                            
                
        88. 
                
      88. 
                    原文地址：https://blog.csdn.net/qq_36428821/article/details/126878878
                
        89. 

            
        

        
        
            
          
                
        • 
                    最新文章
                
          • 
                
        • 
                    
攻防演习之三天拿下官网站群                            
          
数据安全治理学习——前期安全规划和安全管理体系建设                            
          
企业安全 | 企业内一次钓鱼演练准备过程                            
          
内网渗透测试 | Kerberos协议及其部分攻击手法                            
          
0day的产生 | 不懂代码的"代码审计"                            
          
安装scrcpy-client模块av模块异常，环境问题解决方案                            
          
leetcode hot100【LeetCode 279. 完全平方数】java实现                            
          
OpenWrt下安装Mosquitto                            
          
AnatoMask论文汇总                            
          
【AI日记】24.11.01 LangChain、openai api和github copilot                            
          
                              
                
          • 
            
        

            
          
                
        • 
                    热门文章
                
          • 
                
        • 
                    
十款代码表白小特效 一个比一个浪漫 赶紧收藏起来吧！！！                            
          
奉劝各位学弟学妹们，该打造你的技术影响力了！                            
          
五年了，我在 CSDN 的两个一百万。                            
          
Java俄罗斯方块，老程序员花了一个周末，连接中学年代！                            
          
面试官都震惊，你这网络基础可以啊！                            
          
你真的会用百度吗？我不信 — 那些不为人知的搜索引擎语法                            
          
心情不好的时候，用 Python 画棵樱花树送给自己吧                            
          
通宵一晚做出来的一款类似CS的第一人称射击游戏Demo！原来做游戏也不是很难，连憨憨学妹都学会了！                            
          
13 万字 C 语言从入门到精通保姆级教程2021 年版                            
          
10行代码集2000张美女图，Python爬虫120例，再上征途                            
          
                              
                
          • 
            
        

        
        
    




    
    
    
    

        
    
        
        
        
            
        
                
        
                    Copyright © 2022 侵权请联系2656653265@qq.com   
                    京ICP备2022015340号-1
                
        
                
        
                    正则表达式工具
                    cron表达式工具
                    密码生成工具
                
        
                
        
                    
                    
        京公网安备 11010502049817号