retrofit源码解析--设计模式分析

建造者模式

先学习建造者模式，在结合来看代码

 Retrofit retrofit = new Retrofit.Builder()
                .baseUrl("baseurl")
                .addConverterFactory(GsonConverterFactory.create())
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                .build();

UML类图

Builder-Pattern.png

Retrofit的创建使用的是建造者模式，下面通过源码来看看它是怎么做的：

public final class Retrofit {
  private final Map> serviceMethodCache = new ConcurrentHashMap<>();

  final okhttp3.Call.Factory callFactory;
  final HttpUrl baseUrl;
  final List converterFactories;
  final List adapterFactories;
  final @Nullable Executor callbackExecutor;
  final boolean validateEagerly;

  Retrofit(okhttp3.Call.Factory callFactory, HttpUrl baseUrl,
      List converterFactories, List adapterFactories,
      @Nullable Executor callbackExecutor, boolean validateEagerly) {
    this.callFactory = callFactory;
    this.baseUrl = baseUrl;
    this.converterFactories = unmodifiableList(converterFactories); // Defensive copy at call site.
    this.adapterFactories = unmodifiableList(adapterFactories); // Defensive copy at call site.
    this.callbackExecutor = callbackExecutor;
    this.validateEagerly = validateEagerly;
  }

  public static final class Builder {
    private final Platform platform;
    private @Nullable okhttp3.Call.Factory callFactory;
    private HttpUrl baseUrl;
    private final List converterFactories = new ArrayList<>();
    private final List adapterFactories = new ArrayList<>();
    private @Nullable Executor callbackExecutor;
    private boolean validateEagerly;

    '这里省略了大部分细节代码，只为了了解Retrofit中的建造者模式'
    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;
    }
    public Builder baseUrl(String baseUrl) {
       '这里省略了大部分细节代码，只为了了解Retrofit中的建造者模式'
      return new Retrofit(callFactory, baseUrl, converterFactories, adapterFactories,
          callbackExecutor, validateEagerly);
    }
  }

省略了大部分细节代码，只为了了解Retrofit中的建造者模式。这里使用了建造者模式的链式调用，点这里查看建造者模式的具体使用和实现细节

---

---

工厂方法模式

先学习工厂方法模式，在结合来看代码

 Retrofit retrofit = new Retrofit.Builder()
                .baseUrl("baseurl")
                .addConverterFactory(GsonConverterFactory.create())
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                .build();

UML关系图:

Factory_Method.png

• 抽象工厂Factory、抽象产品CallAdapter：

public interface CallAdapter {
  Type responseType();
  T adapt(Call call);

  abstract class Factory {

    public abstract @Nullable CallAdapter get(Type returnType, Annotation[] annotations,Retrofit retrofit);

    protected static Type getParameterUpperBound(int index, ParameterizedType type) {
      return Utils.getParameterUpperBound(index, type);
    }
    protected static Class getRawType(Type type) {
      return Utils.getRawType(type);
    }
  }

• 具体产品RxJava2CallAdapter：

final class RxJava2CallAdapter implements CallAdapter {
  
  '省略代码'
  @Override public Type responseType() {
    return responseType;
  }

  @Override public Object adapt(Call call) {
    Observable> responseObservable = isAsync
        ? new CallEnqueueObservable<>(call)
        : new CallExecuteObservable<>(call);

    Observable observable;
    if (isResult) {
      observable = new ResultObservable<>(responseObservable);
    } else if (isBody) {
      observable = new BodyObservable<>(responseObservable);
    } else {
      observable = responseObservable;
    }

    if (scheduler != null) {
      observable = observable.subscribeOn(scheduler);
    }

    if (isFlowable) {
      return observable.toFlowable(BackpressureStrategy.LATEST);
    }
    if (isSingle) {
      return observable.singleOrError();
    }
    if (isMaybe) {
      return observable.singleElement();
    }
    if (isCompletable) {
      return observable.ignoreElements();
    }
    return observable;
  }
}

• 具体工厂RxJava2CallAdapterFactory：

public final class RxJava2CallAdapterFactory extends CallAdapter.Factory {

  '省略代码'

  @Override
  public CallAdapter get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
    Class rawType = getRawType(returnType);

    if (rawType == Completable.class) {
      // Completable is not parameterized (which is what the rest of this method deals with) so it
      // can only be created with a single configuration.
      return new RxJava2CallAdapter(Void.class, scheduler, isAsync, false, true, false, false,
          false, true);
    }

  '省略代码'
    return new RxJava2CallAdapter(responseType, scheduler, isAsync, isResult, isBody, isFlowable,
        isSingle, isMaybe, false);
  }
}

---

---

外观模式（Facade）

先学习外观模式（Facade），在结合来看代码

Facade-Pattern.png

public final class Retrofit {
  private final Map> serviceMethodCache = new ConcurrentHashMap<>();

  final okhttp3.Call.Factory callFactory;
  final HttpUrl baseUrl;
  final List converterFactories;
  final List adapterFactories;
  final @Nullable Executor callbackExecutor;
  '省略代码'

• Retrofit就是外观类
• Retrofit中的这些成员变量就是它的子系统