前言

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