Android面试Android进阶(十八)-Retrofit相关

时间:2021-6-4 作者:qvyue

Retrofit是基于OkHttp封装的一个网络请求框架,底层网络请求通信由OkHttp实现。
上篇文章讲了一些OkHttp相关的一些东西,没看过的可以去看看 OkHttp相关
本篇基于v2.9.0版本分析源码及问答,先看看Retrofit的简单使用,基于使用来分析。

        //1、创建OkHttpClient实例(非必须,内部帮你实例化了一个)
        val mOkHttpClient = OkHttpClient.Builder()
            .connectTimeout(30, TimeUnit.SECONDS)
            .readTimeout(30, TimeUnit.SECONDS)
            .writeTimeout(30, TimeUnit.SECONDS)
            .build()
        //2、创建Retrofit实例
        val mRetrofit = Retrofit.Builder()
            .client(mOkHttpClient)
            .baseUrl("http://api.wanandroid.com")
            .addConverterFactory(GsonConverterFactory.create())
            .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
            .build()
        //3、利用动态代理获取ApiService接口
        val apiService = mRetrofit.create(ApiService::class.java)
        //4、调用ApiService接口方法获取Call对象
        val call = apiService.getCall()

        //5、Call对象同步请求
        val response = call.execute()
        //5、Call对象异步请求
        call.enqueue(object : Callback{
            override fun onFailure(call: Call, t: Throwable) {
                //请求失败
            }

            override fun onResponse(call: Call, response: Response) {
                //请求成功
            }
        })

Retrofit的使用流程分为五个步骤:
1、创建OkHttpClient实例,但是这个步骤非必须,Retrofit中默认给初始化了一个OkHttpClient。
2、创建Retrofit实例(通过建造者模式),设置自定义的OkHttpClient对象、baseUrl、以及数据转换器、适配器等等。
3、利用动态代理获取ApiService接口的代理对象
4、使用代理对象获取Call对象
5、使用Call对象进行同步、异步网络请求。

创建OkHttpClient这步在上篇文章中已经说的挺多了,这里就不再解释。直接看如何创建Retrofit对象实例:
直接看看build方法,这里面其实默认了很多参数,唯独baseUrl

public Retrofit build() {
      if (baseUrl == null) {
        //如果baseUrl为空则直接抛出异常
        throw new IllegalStateException("Base URL required.");
      }
      //默认一个callFactory(OkHttpClient)
      okhttp3.Call.Factory callFactory = this.callFactory;
      if (callFactory == null) {
        callFactory = new OkHttpClient();
      }
      //回调执行器,默认实现为MainThreadExecutor,其实就是通过Handler切换线程用 
      Executor callbackExecutor = this.callbackExecutor;
      if (callbackExecutor == null) {
        callbackExecutor = platform.defaultCallbackExecutor();
      }

      // 网络请求适配器工厂类集合,默认设置为DefaultCallAdapterFactory,配合RxJava使用时,设置为RxJava2CallAdapterFactory
      List callAdapterFactories = new ArrayList(this.callAdapterFactories);
      callAdapterFactories.addAll(platform.defaultCallAdapterFactories(callbackExecutor));

      // 数据解析器
      List converterFactories =
          new ArrayList(
              1 + this.converterFactories.size() + platform.defaultConverterFactoriesSize());

      // 首先添加内置转换器工厂。这样既可以防止覆盖其行为,又可以在使用所有类型的转换器时确保正确的行为。
      converterFactories.add(new BuiltInConverters());
      converterFactories.addAll(this.converterFactories);
      converterFactories.addAll(platform.defaultConverterFactories());

      return new Retrofit(
          callFactory,
          baseUrl,
          unmodifiableList(converterFactories),
          unmodifiableList(callAdapterFactories),
          callbackExecutor,
          validateEagerly);
    }
  }
}

这里除了baseUrl没有默认,原因也很简单,不能默认请求地址吧?,所以如果请求地址为空,直接抛出异常。baseUrl方法可以将字符串转换成HttpUrl对象,具体看看源码:

    public Builder baseUrl(String baseUrl) {
      Objects.requireNonNull(baseUrl, "baseUrl == null");
      return baseUrl(HttpUrl.get(baseUrl));
    }
    //HttpUrl是一个final修饰的类,代表着设置了以后无法再修改,这里就会引出一个问题:多baseUrl的应用应该怎么做?    
    public final class HttpUrl {}

问:多baseUrl该怎么处理

答:Retrofit中baseUrl(String baseUrl)方法最终会将baseUrl字符串转换成HttpUrl对象,而HttpUrl是final修饰的,也就是说设置了baseUrl以后,HttpUrl无法修改,解决方案如下:
1、不同baseUrl创建不同Retrofit的方式(这样会造成部分资源浪费,如果比较多的baseUrl也将难以管理)
1、@GET、@POST 等不仅可以传入接口地址,也可以传入全路径,从而实现多baseUrl效果。但是注解上的值只能是 final 的常量
3、 @Url 这个标注到每个接口方法参数上的注解,它可以将全路径作为参数传进接口作为每次请求的 Url 地址,每次请求接口都可以将不同的全路径作为参数,从而达到支持多个 BaseUrl 以及在运行时动态改变 BaseUrl
4、通过OkHttp拦截器实现动态切换baseUrl(传入不同的header,如果有特殊标识的header则使用新的url重新构建HttpUrl对象)
5、final修饰的HttpUrl无法修改,但是可以使用反射机制来实现动态切换baseUrl

Retrofit帮我们做了一件事就是允许开发者设置数据解析器,利用数据解析器将数据解析成开发者较为容易处理的数据。
接下来就是使用动态代理技术获取接口对象,通过接口对象调用接口中的方法获取Call对象,利用Call对象调用同步或异步请求方法,最终会转化为OkHttp的同步或异步方法。

来看看create()方法都做了些什么:

  public  T create(final Class 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 {
                // 如果该方法是Object的方法,直接执行 
                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);      //重点关注一下这个方法(获取方法执行)
              }
            });
  }

动态代理中最后执行了 获取方法并执行的操作:

//Retrofit.java
//缓存,用了线程安全ConcurrentHashMap
final Map> serviceMethodCache = new ConcurrentHashMap();

ServiceMethod> loadServiceMethod(Method method) {
    ServiceMethod> result = serviceMethodCache.get(method);
    //如果Service中的方法已经缓存,则直接返回缓存的方法
    if (result != null) return result;
    synchronized (serviceMethodCache) {
        result = serviceMethodCache.get(method);
        if (result == null) {
            //解析method的注解,创建ServiceMethod并缓存起来
            result = ServiceMethod.parseAnnotations(this, method);
            serviceMethodCache.put(method, result);
        }
    }
    return result;
}

//解析method的注解 ServiceMethod.java
static  ServiceMethod parseAnnotations(Retrofit retrofit, Method method) {
    //检查方法注解的path、返回值、请求方式等等是否合规,最后返回RequestFactory对象
    RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method);
    //处理获取合适的 请求适配器以及数据处理转换器等,最后返回CallAdapted(先不管kotlin挂起函数)
    return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);
}

//返回的CallAdapted对象后执行invoke函数,调用到了
protected ReturnT adapt(Call call, Object[] args) {
      return callAdapter.adapt(call);
    }

之后,adapt的方法实现方法有:

Android面试Android进阶(十八)-Retrofit相关
image.png

这里就是在使用建造者模式创建Retrofit对象实例时addCallAdapterFactory()方法的CallAdapter适配器,如果不传则使用默认:

最后在代理对象调用同步或者异步方法时,调用响应的同步或异步方法,最终再通过OkHttp进行网络请求。

总结一下:

Retrofit就是一个网络请求框架的封装,底层的网络请求默认使用的Okhttp,本身只是简化了用户网络请求的参数配置等,还能与Rxjava相结合,使用起来更加简洁方便。
1、App应用程序通过Retrofit请求网络,实际上是使用Retrofit接口层封装请求参数,之后由OkHttp完成后续的请求操作。
2、在服务端返回数据之后,OkHttp将原始的结果交给Retrofit,Retrofit根据用户的需求对结果进行解析。

声明:本文内容由互联网用户自发贡献自行上传,本网站不拥有所有权,未作人工编辑处理,也不承担相关法律责任。如果您发现有涉嫌版权的内容,欢迎发送邮件至:qvyue@qq.com 进行举报,并提供相关证据,工作人员会在5个工作日内联系你,一经查实,本站将立刻删除涉嫌侵权内容。