0
点赞
收藏
分享

微信扫一扫

Retrofit系列文章(三) - Retrofit源码分析

亿奇学 2021-09-29 阅读 56

前言

Retrofit系列文章
Retrofit系列文章(一) - Retrofit简介
Retrofit系列文章(二) - Retrofit常见问题的解决
Retrofit系列文章(三) - Retrofit源码分析
Retrofit系列文章(四) - 手写Retrofit核心架构部分
拓展 - 应用是怎么来的?

1. Retrofit源码分析

1>:Builder设计模式
      Retrofit retrofit = new Retrofit.Builder()
                // 访问后台接口的主路径
                .baseUrl("http://192.168.8.169:8080/OkHttpServer/")
                // 添加解析转换工厂,Gson解析、Xml解析
                .addConverterFactory(GsonConverterFactory.create())
                // 添加OkHttpClient,不添加就是默认的光杆 OkHttpClient
                .client(okHttpClient)
                .build() ;
2>:动态代理设计模式
 mServiceApi = retrofit.create(ServiceApi.class) ;
  public <T> T create(final Class<T> 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();

          @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);
            }
            ServiceMethod<Object, Object> serviceMethod =
                (ServiceMethod<Object, Object>) loadServiceMethod(method);
            OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
            return serviceMethod.callAdapter.adapt(okHttpCall);
          }
        });
  }

动态代理作用:用作解耦;
体现形式有很多:绕过插件化 AndroidManifest.xml ,可以让Activity不需要在清单文件中注册,主要作用是用作Hook拦截;
MVP主要用作:AOP切面,AOP思想就是:把通用的代码统一管理起来,放到一个地方去处理,不要去写重复的代码,只要能够达到这种思想,那么不管是 MVP 或者其他都可以;

总之上边采用的原理其实都是:方法的拦截,像前两节写的Retrofit用法中的所有的类、所有的方法,不管是 RetrofitClient类中所有方法、ServiceApi所有代码、MainActivity用测试 Retrofit代码等等所有有关于 Retrofit的代码,调用之后都会执行 这个 Proxy.newProxyInstance()拦截方法的;

3>:工厂设计模式

简单工厂、抽象工厂、方法工厂

A:简单工厂:创建Platform,点击 mServiceApi = retrofit.create(ServiceApi.class) ;进入 create()方法中,然后点击 动态代理中的 Platform.get();进入下边代码:

private static final Platform PLATFORM = findPlatform();

  static Platform get() {
    return PLATFORM;
  }

  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();
  }

B:方法工厂:GsonConverterFactory.crete() ;

  public static GsonConverterFactory create() {
    return create(new Gson());
  }

  /**
   * Create an instance using {@code gson} for conversion. Encoding to JSON and
   * decoding from JSON (when no charset is specified by a header) will use UTF-8.
   */
  public static GsonConverterFactory create(Gson gson) {
    return new GsonConverterFactory(gson);
  }

C:抽象工厂:Converter,Factory,GsonConverterFactory;

// 添加解析转换工厂,Gson解析、Xml解析
.addConverterFactory(GsonConverterFactory.create())

点击addConverterFactory进到这个方法

    public Builder addConverterFactory(Converter.Factory factory) {
      converterFactories.add(checkNotNull(factory, "factory == null"));
      return this;
    }
4>:adapter设计模式

.addCallAdapterFactory()

下边这个方法是 第二个 动态代理模式的 Proxy.newProxyInstance() 中 最后的 return语句

serviceMethod.callAdapter.adapt(okHttpCall);

如果不采用 RxJava,默认直接返回okHttpCall就可以,这里为什么还调用一次?
Retrofit返回的 是 Call,但是一旦采用 RxJava,我想要的就必须是 Observable,Call 与 Observable 是两个完全不一样的对象,所以 adapter 设计模式 在这里的体现就是:把 Call 适配成 Observable;

5>:模板设计模式

ParameterHandler源码中:

abstract class ParameterHandler<T> {
  abstract void apply(RequestBuilder builder, @Nullable T value) throws IOException;

  final ParameterHandler<Iterable<T>> iterable() {
    return new ParameterHandler<Iterable<T>>() {
      @Override void apply(RequestBuilder builder, @Nullable Iterable<T> values)
          throws IOException {
        if (values == null) return; // Skip null values.

        for (T value : values) {
          ParameterHandler.this.apply(builder, value);
        }
      }
    };
  }

ServiceMethod的源码中:

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

不同的对象调用不同的 apply,ParameterHandler源码中:

  @Override void apply(RequestBuilder builder, @Nullable T value) throws IOException {
      if (value == null) return; // Skip null values.

      String headerValue = valueConverter.convert(value);
      if (headerValue == null) return; // Skip converted but null values.

      builder.addHeader(name, headerValue);
    }
  }

模板设计模式就是:
制定通用的流程,具体的算法细节由不同的子类去实现,确定 Retrofit的请求流程,解析方法参数注解,但是其具体的各个参数细节由子类去实现。
这里还可以衍生出另一种设计模式,叫做策略设计模式,不同的参数注解采用不同的添加策略;

6>:享元设计模式、原型、单例、观察者(回调)设计模式

享元设计模式:避免创建更多的对象,达到对象的复用
Retrofit源码中的:

// 对象的复用
private final Map<Method, ServiceMethod<?, ?>> serviceMethodCache = new ConcurrentHashMap<>();
  ServiceMethod<?, ?> loadServiceMethod(Method method) {
    ServiceMethod<?, ?> result = serviceMethodCache.get(method);
    if (result != null) return result;

    synchronized (serviceMethodCache) {
      result = serviceMethodCache.get(method);
      if (result == null) {
        result = new ServiceMethod.Builder<>(this, method).build();
        serviceMethodCache.put(method, result);
      }
    }
    return result;
  }
举报

相关推荐

0 条评论