Retrofit原理简析

记得很久以前，写过一篇文章，主要说的是Retrofit应用的：Retrofit2+RxJava2踩坑

今天我们来简单说说Retrofit的原理，其实嘛，作为一个搞技术的人，对Retrofit应该有一种好奇的态度，毕竟这是个很优秀的框架，里面用了不少设计模式，很值得我们学习，我们先从Request说起吧。

笔者之前也写过一篇文章：Volley源码学习，就算不看Volley的源码，使用过Volley的人都知道，其实我们真正用的时候会根据请求类型的不同，创建出不同的Request对象，然后将Request对象投放到RequestQueue请求队列中去，然而当你使用Retrofit时，居然连Request对象都不用创建了，这也太神奇了吧！

我们来看看Retrofit到底是如何实现的？
通常我们都会创建一个interface（比如BaseApiService），里面会写各个请求的接口，然后是这么调用的：

BaseApiService apiService = retrofit.create(BaseApiService.class)

然后我们来看看源码：

 public  T create(final Class 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();
          private final Object[] emptyArgs = new Object[0];

          @Override public 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);
            }
            if (platform.isDefaultMethod(method)) {
              return platform.invokeDefaultMethod(method, service, proxy, args);
            }
            return loadServiceMethod(method).invoke(args != null ? args : emptyArgs);
          }
        });
  }

如果你对Java的代理模式比较熟悉的话，当你看到Proxy.newProxyInstance时，你瞬间就会明白：哦，原来用的是Java动态代理！（插个题外话，搞过JavaWeb的应该对这个很熟悉，大名鼎鼎的Spring框架就是用Java动态代理来优雅地实现AOP编程的，因其具有方法增强、高扩展性等优点，故Java动态代理是框架的常用手段）
如此说来，上面返回的BaseApiService对象其实是一个动态代理对象而已。
我们注意到上面invoke方法中的loadServiceMethod，它的返回值是ServiceMethod，其实我们使用了动态代理，最终的目的就是为了获取ServiceMethod对象，我们直接来看看ServiceMethod类的源码：

abstract class ServiceMethod {
  static  ServiceMethod parseAnnotations(Retrofit retrofit, Method method) {
    RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method);

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

    return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);
  }

  abstract T invoke(Object[] args);
}

这是一个非常简单的抽象类，第一步，很显然目的是为了获取RequestFactory，一看这个名字，我们就知道里面用了工厂模式和建造者模式，其实这一步主要就是根据method的各个注解进行拼凑成一个Request，当然其中也按照Retrofit的规则进行了很多的校验。
然后我们看到上面的返回值是一个HttpServiceMethod对象，它又继承于ServiceMethod，所以最终是调用的invoke方法是HttpServiceMethod的invoke方法，我们来看看HttpServiceMethod的构造函数和invoke方法：

  @Override ReturnT invoke(Object[] args) {
    return callAdapter.adapt(
        new OkHttpCall<>(requestFactory, args, callFactory, responseConverter));
  }

终于看到OkHttp的名字了，看样子Retrofit的底层是OkHttp所言非虚啊！
的确，Retrofit2中Call接口的默认实现是OkHttpCall，这话的意思就它默认的是OkHttpCall，当然你完全可以根据自己的需要来实现Call接口（也就是不一定要用OkHttp，当然一般情况下我们还是用OkHttp），该点的设计与Volley的HttpStack接口很相似，Volley默认提供了两个实现类：HurlStack和HttpClientStack，当然，我们也可以通过实现HttpStack接口使用OkHttp作为Volley底层的网络框架，这就是面向接口编程的好处。

再注意到上面的callAdapter和responseConverter，是不是也很熟悉啊？我们使用Retrofit时一般会与RxJava搭配使用，然后返回的结果我们会用Gson进行转换，相关的代码如下：

 .addConverterFactory(GsonConverterFactory.create())
 .addCallAdapterFactory(RxJava2CallAdapterFactory.create())

好啦，大概也就是这样子吧，事实又一次证明：静下心来分析源码，总能学到东西的，加油！

参考链接：https://blog.csdn.net/csdn_aiyang/article/details/80692384

Retrofit原理简析

你可能感兴趣的:(Retrofit原理简析)