Retrofit2.0 学习笔记（一）

Retrofit其实就是一个对Okhttp网络请求框架的包装，它通过注解去定义一个HTTP请求，然后在底层通过Okhttp发起网络请求，就是这样的一个简单的过程，其间运用了很多的设计模式：Builder 设计模式、动态代理模式、适配器模式、工厂设计模式等。

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 动态代理设计模式

 @SuppressWarnings("unchecked") // Single-interface proxy creation guarded by parameter safety.
  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);
          }
        });
  }

3 工厂设计模式（简单工厂，抽象工厂，方法工厂）

Converter，Factory，GsonConverterFactory：涉及抽象工厂
GsonConverterFactory.crete()  使用的方法工厂
Platform platform = Platform.get(); 简单工厂创建 Platform

4 Adapter 设计模式

serviceMethod.callAdapter.adapt(okHttpCall);

如果不采用 RxJava 直接返回 okHttpCall，为什么还调用一次，我们 Retrofit 返回的是 Call 但是一旦采用 RxJava 我想要的就必须是 Observable，这两个对象完全不一样

所以 Adapter 设计模式 在这里体现是，把 Call 适配成 Observable

5 模板设计模式

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

不同的对象调用的不同的 apply

制定通用的流程，具体的算法细节由不同的子类去实现，确定Retrofit请求流程 ，解析方法参数注解，但是其具体的各个参数细节由子类去实现

还可以衍生另一种设计模式叫做策略，不同的参数注解采用不同的添加策略。

6 享元设计模式（避免创建更多的同类型对象，从而达到复用）

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