前言

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>：動態(tài)代理設計模式

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

動態(tài)代理作用：用作解耦；
體現(xiàn)形式有很多：繞過插件化 AndroidManifest.xml ，可以讓Activity不需要在清單文件中注冊，主要作用是用作Hook攔截；
MVP主要用作：AOP切面，AOP思想就是：把通用的代碼統(tǒng)一管理起來，放到一個地方去處理，不要去寫重復的代碼，只要能夠達到這種思想，那么不管是 MVP 或者其他都可以；

總之上邊采用的原理其實都是：方法的攔截，像前兩節(jié)寫的Retrofit用法中的所有的類、所有的方法，不管是 RetrofitClient類中所有方法、ServiceApi所有代碼、MainActivity用測試 Retrofit代碼等等所有有關于 Retrofit的代碼，調用之后都會執(zhí)行 這個 Proxy.newProxyInstance()攔截方法的；

3>：工廠設計模式

簡單工廠、抽象工廠、方法工廠

A：簡單工廠：創(chuàng)建Platform，點擊 mServiceApi = retrofit.create(ServiceApi.class) ;進入 create()方法中，然后點擊 動態(tài)代理中的 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，F(xiàn)actory，GsonConverterFactory；

// 添加解析轉換工廠，Gson解析、Xml解析
.addConverterFactory(GsonConverterFactory.create())

點擊addConverterFactory進到這個方法

    public Builder addConverterFactory(Converter.Factory factory) {
      converterFactories.add(checkNotNull(factory, "factory == null"));
      return this;
    }

4>：adapter設計模式

.addCallAdapterFactory()

下邊這個方法是 第二個 動態(tài)代理模式的 Proxy.newProxyInstance() 中 最后的 return語句

serviceMethod.callAdapter.adapt(okHttpCall);

如果不采用 RxJava，默認直接返回okHttpCall就可以，這里為什么還調用一次？
Retrofit返回的 是 Call，但是一旦采用 RxJava，我想要的就必須是 Observable，Call 與 Observable 是兩個完全不一樣的對象，所以 adapter 設計模式 在這里的體現(xiàn)就是：把 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);
    }
  }

模板設計模式就是：
制定通用的流程，具體的算法細節(jié)由不同的子類去實現(xiàn)，確定 Retrofit的請求流程，解析方法參數(shù)注解，但是其具體的各個參數(shù)細節(jié)由子類去實現(xiàn)。
這里還可以衍生出另一種設計模式，叫做策略設計模式，不同的參數(shù)注解采用不同的添加策略；

6>：享元設計模式、原型、單例、觀察者（回調）設計模式

享元設計模式：避免創(chuàng)建更多的對象，達到對象的復用
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;
  }