Retrofit是如何建立的？为何要用动态代理

时间  2019-11-24
标签 retrofit 如何 建立 为何 动态 代理 繁體版
原文   原文链接

Retrofit的出现让Android的网络请求变得异常简单，同时能够很好的配合后台的REST接口。很是值得咱们去探究一下它的原理。java

Retrofit的使用

一般咱们是Retrofit是和Rxjava配合使用，这里咱们不作用法上的过多研究，主要看原理，因此下面的代码都是Retrofit的自身API，没有用Rxjava。android

下面是一个普通get请求json

1.新建接口

新建接口API.java文件：数组

public interface API {
    @GET("请求地址，可是不包括服务器的地址")
    Call<Response> get( @Query("param1") String param1,//第一个参数 @Query("param2") int param2);//第二个参数
}
复制代码

在@GET注解里面加上除去服务器连接的请求地址，@Query注解里面是请求的参数名。服务器

2.建立Retrofit服务和请求客户端

新建一个单例类，RetrofitService.java(名字随意)，在里面定义一个静态的OkHttpClient网络

private RetrofitService() {//构造方法私有化
    }

public static RetrofitService getInstance() {//双重校验
        if (instance == null) {
            synchronized (RetrofitService.class) {
                if (instance == null) {
                    instance = new RetrofitService();
                }
            }
        }
        return instance;
    }

private static OkHttpClient mOkHttpClient;

private static void initOkHttpClient() {
    HttpLoggingInterceptor logInterceptor = new HttpLoggingInterceptor();//日志拦截器
    mOkHttpClient = new OkHttpClient.Builder().cache(cache)
                            .addInterceptor(logInterceptor)//日志拦截器，按照须要添加
                            .connectTimeout(10, TimeUnit.SECONDS).build();//链接超时时间
}
复制代码

向外提供一个方法，用于获取刚才的API接口ide

private volatile static API aPI = null;
    public static API createAPI() {
        if (aPI == null) {
            synchronized (RetrofitService.class) {
                if (aPI == null) {
                    initOkHttpClient();
                    aPI = new Retrofit.Builder()
                            .client(mOkHttpClient)
                            .baseUrl("服务器地址")
                            .addConverterFactory(GsonConverterFactory.create())//指定json处理库
                            .build().create(API.class);//将第一步建立的API接口传入
                }
            }
        }
        return aPI;
    }
复制代码

3.开始发送请求

Call<Response> = call = RetrofitService.getInstance()
                .createShowAPI()
                .get("参数1", "参数2");
                
call.enqueue(new Callback<Response>() {
            @Override
            public void onResponse(Call<Response> call, Response<Response> response) {
                //请求成功的处理
            }

            @Override
            public void onFailure(Call<ShowApiResponse<ShowApiNews>> call, Throwable t) {
                //请求失败的处理
            }
        });
复制代码

Retrofit的核心-动态代理

Retrofit是如何将咱们定义的接口方法最后转化成请求发送出去呢，这里就到源码去看看oop

建立者模式

首先来看Retrofit的建立，这里使用了建立者模式post

new Retrofit.Builder()
    .client(mOkHttpClient)
    .baseUrl("服务器地址")
    .addConverterFactory(GsonConverterFactory.create())//指定json处理库
    .build().create(API.class);//将第一步建立的API接口传入
复制代码

首先来看Retrofit.Builder()这个类的构造方法ui

public static final class Builder {
    public Builder() {
      this(Platform.get());
    }
}
复制代码

这里调用了一个带参数的构造方法，先看看Platform.get()是什么

private static final Platform PLATFORM = findPlatform();

  static Platform get() {
    return PLATFORM;
  }
  
复制代码

Platform.findPlatform

private static Platform findPlatform() {
    try {
      Class.forName("android.os.Build");
      if (Build.VERSION.SDK_INT != 0) {
        return new Android();
      }
    } catch (ClassNotFoundException ignored) {
    }
    try {
      Class.forName("java.util.Optional");
      return new Java8();
    } catch (ClassNotFoundException ignored) {
    }
    return new Platform();
  }
复制代码

能够看到，这个Platform类，顾名思义其实就是平台。在Retrofit中，内置了两种平台，一种是Android，一种是Java8。不一样的平台，处理的方式不一样。继续往下看代码就明白了

static class Android extends Platform {
    @Override public Executor defaultCallbackExecutor() {
      return new MainThreadExecutor();
    }

    @Override CallAdapter.Factory defaultCallAdapterFactory(@Nullable Executor callbackExecutor) {
      if (callbackExecutor == null) throw new AssertionError();
      return new ExecutorCallAdapterFactory(callbackExecutor);
    }

    static class MainThreadExecutor implements Executor {
      private final Handler handler = new Handler(Looper.getMainLooper());

      @Override public void execute(Runnable r) {
        handler.post(r);
      }
    }
  }
复制代码

这里先不深刻探究，后面还会再回来，不过咱们已经能够看到，Executor类在Android平台里是返回了MainThreadExecutor，里面提供了一个handler，而且这个handler是传入的主线程的Looper，也就是说在execute方法里面，handler.post其实是在主线程（UI线程）执行的。

这里再回到Retrofit.Builder()，看看那个带参数的构造方法：

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

    Builder(Retrofit retrofit) {
      platform = Platform.get();
      callFactory = retrofit.callFactory;
      baseUrl = retrofit.baseUrl;
      converterFactories.addAll(retrofit.converterFactories);
      adapterFactories.addAll(retrofit.adapterFactories);
      // Remove the default, platform-aware call adapter added by build().
      adapterFactories.remove(adapterFactories.size() - 1);
      callbackExecutor = retrofit.callbackExecutor;
      validateEagerly = retrofit.validateEagerly;
    }
复制代码

在这个构造方法里，对各类属性进行了初始化，来看看这些属性的定义

private final Platform platform;//刚才看到的平台，这里是Android
    private @Nullable okhttp3.Call.Factory callFactory;//后面在分析
    private HttpUrl baseUrl;//服务器地址
    private final List<Converter.Factory> converterFactories = new ArrayList<>();//json解析工厂列表
    private final List<CallAdapter.Factory> adapterFactories = new ArrayList<>();//后面再分析
    private @Nullable Executor callbackExecutor;//这里是Android的Executor，在主线程执行回调
    private boolean validateEagerly;//是否提早建立的标志
复制代码

挨个看看这几个属性，这里有些属性的做用咱们后面才知道，不过大部分看命名已经能够看到一些蹊跷：主要是callFactory和adapterFactories咱们如今暂时不知道做用，继续往下看，在构造方法初始化以后，是调用Builder.build()方法

Builder.build()

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> adapterFactories = new ArrayList<>(this.adapterFactories);
      adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));

      // Make a defensive copy of the converters.
      List<Converter.Factory> converterFactories = new ArrayList<>(this.converterFactories);

      return new Retrofit(callFactory, baseUrl, converterFactories, adapterFactories,
          callbackExecutor, validateEagerly);
    }
  }
复制代码

在这里是将Builder的属性，再传给Retrofit的构造方法，来看看咱们刚才疑惑的那两个属性怎么赋值：

callFactory

okhttp3.Call.Factory callFactory = this.callFactory;
      if (callFactory == null) {
        callFactory = new OkHttpClient();
      }
复制代码

callFactory在默认的状况下，实际上是一个OkHttpClient，也就是说Retrofit的内部请求原理实际上是用的OkHttp。还记得咱们最开始建立的时候也传入了一个静态类OkHttpClient么，这之间有什么关系呢？

new Retrofit.Builder().client(mOkHttpClient)
复制代码

Retrofit.Builder().client

public Builder client(OkHttpClient client) {
      return callFactory(checkNotNull(client, "client == null"));
    }
    
    public Builder callFactory(okhttp3.Call.Factory factory) {
      this.callFactory = checkNotNull(factory, "factory == null");
      return this;
    }
    
复制代码

其实client里面传入的OkHttpClient也是赋值给了callFactory，因此callFactory就是OkHttp的网络请求客户端

adapterFactories

// Make a defensive copy of the adapters and add the default Call adapter.
      List<CallAdapter.Factory> adapterFactories = new ArrayList<>(this.adapterFactories);
      adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));
复制代码

建立了一个新的列表，而且加入了默认的CallAdapterFactory，刚才咱们知道platform是Android，因此再看看以前的代码：

Platform.Android

static class Android extends Platform {
    @Override public Executor defaultCallbackExecutor() {
      return new MainThreadExecutor();
    }

    @Override CallAdapter.Factory defaultCallAdapterFactory(@Nullable Executor callbackExecutor) {
      if (callbackExecutor == null) throw new AssertionError();
      return new ExecutorCallAdapterFactory(callbackExecutor);
    }

    static class MainThreadExecutor implements Executor {
      private final Handler handler = new Handler(Looper.getMainLooper());

      @Override public void execute(Runnable r) {
        handler.post(r);
      }
    }
  }
复制代码

defaultCallAdapterFactory返回的是ExecutorCallAdapterFactory

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

  ExecutorCallAdapterFactory(Executor callbackExecutor) {
    this.callbackExecutor = callbackExecutor;
  }
}
复制代码

能够看到构造方法并无作什么，只是将回调处理类传入。里面的其余方法后面调用的时候再来看。因此到这里咱们仍是不知道adapterFactories是干吗的，可是咱们看到了这个类里面有enqueue方法，还有一些处理响应的一些方法，因此咱们能够知道它的做用是处理请求和响应，具体的用法后面继续看源码能够看到。

Retrofit.creat

在建立者初始化了全部属性以后，来到了Retrofit.creat方法

aPI = new Retrofit.Builder()
    .client(mOkHttpClient)
    .baseUrl("服务器地址")
    .addConverterFactory(GsonConverterFactory.create())//指定json处理库
    .build().create(API.class);
复制代码

Retrofit.creat

public <T> T create(final Class<T> service) {
    Utils.validateServiceInterface(service);//验证是否传入的为接口类
    if (validateEagerly) {//提早建立，默认为false，这里跳过
      eagerlyValidateMethods(service);
    }
    return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] { service },
        new InvocationHandler() {
          private final Platform platform = Platform.get();

          @Override public Object invoke(Object proxy, Method method, @Nullable Object[] args) throws Throwable {
            // 方法定义所在的类，这里咱们是定义在接口里面，返回false
            if (method.getDeclaringClass() == Object.class) {
              return method.invoke(this, args);
            }
            //platform.isDefaultMethod没作任何处理，直接返回false
            if (platform.isDefaultMethod(method)) {
              return platform.invokeDefaultMethod(method, service, proxy, args);
            }
            ServiceMethod<Object, Object> serviceMethod =
                (ServiceMethod<Object, Object>) loadServiceMethod(method);
            OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
            return serviceMethod.callAdapter.adapt(okHttpCall);
          }
        });
  }
复制代码

这里看到了Retrofit的核心，使用动态代理来处理咱们在接口中定义的方法。在调用咱们定义的接口方法时，会来到动态代理类的invoke方法，而后执行最后的三行，在这里会解析定义的接口方法，而且作相应的处理。

总结

Retrofit在建立的过程当中，有这么一些东西须要咱们注意

platform

这个是Retrofit支持的平台，里面有Android和Java8，这里天然是Android

callFactory

执行请求的客户端，这里是OkHttpClient，在建立的时候.client传入

converterFactories

json解析处理工厂数组，这里是GsonConverterFactory。进行请求和响应的解析，将json字符串转换为具体的实体类

callAdapterFactories

请求和响应的具体处理适配器工厂数组，这里没有传的话默认为ExecutorCallAdapterFactory，若是须要使用rxjava，为RxJava2CallAdapterFactory

callbackExecutor

回调处理类，用于对回调数据的处理，这里是Android平台默认的MainThreadExecutor，使用Handler在主线程中处理回调。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程