Retrofit源码分析

1.创建retrofit 对象

  Retrofit retrofit = new Retrofit.Builder()
                    .client(okHttpClient)
                    .baseUrl("http://gank.io/api/")
                    .addConverterFactory(gsonConverterFactory)
                    .addCallAdapterFactory(rxJavaCallAdapterFactory)
                    .build();

2.Builder 介绍

• builder 是用来初始化配置参数的内部类
• builder 是采用建造者设计模式
• 在build() 方法调用之前必须调用baseUrl 方法，其他方法都是可选的

builder 成员变量

1. Platform： retrofit 执行的的系统环境，通过findPlatform方法获取是不是是android环境
2. okhttp3.Call.Factory ：生成请求的工厂类，默认为okHttpClient
3. baseUrl ：HttpUrl 的请求地址
4. List<Converter.Factory> converterFactories：将实体类对象转换成http 传输的对象，或者将http 对象转换成实体类对象
5. List<CallAdapter.Factory> adapterFactories ：将返回结果生成指定的类型包装对象

3.创建请求

//创建api 类
public interface GankApi {
    @GET("data/福利/{number}/{page}")
    Observable<GankBeautyResult> getBeauties(@Path("number") int number, @Path("page") int page);
}

    创建api类的请求接口实体类
 retrofit.create(GankApi.class);

create方法介绍：

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

• 其内部使用了动态代理来实现

ServiceMethod

• 主要用于处理request 和 response 并将其适配成通过的请求格式
• 采用了适配器模式，其创建成本很高，所以retrofit 用一个ConcurrentHashMap serviceMethodCache 来保存，网络请求需要注意并发。

   ServiceMethod<Object, Object> serviceMethod =
                (ServiceMethod<Object, Object>) loadServiceMethod(method);

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

serviceMethod.callAdapter.adapt(okHttpCall)

• 这段代码主要作用是请求，并返回固定的格式结果

  @Override public Object adapt(Call<R> call) {
    Observable<Response<R>> 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;
  }

代理模式

静态代理

主要思路 代理类持有realsubject 对象，可以对相关操作进行拦截。
实例代码如下：

public interface IRunner {
//运动员的主要工作就是跑步
public void run();
}

public class Runner implements IRunner {
public void run() {
System.out.println("运动员跑步： 动作很潇洒");
}
}

public class RunnerAgent implements IRunner {
private IRunner runner;
public RunnerAgent(IRunner _runner){
this.runner = _runner;
}/
/代理人是不会跑的
public void run() {
Random rand = new Random();
if(rand.nextBoolean()){
System.out.println("代理人同意安排运动员跑步");
runner.run();
}else{
System.out.println("代理人心情不好， 不安排运动员跑步");
}
}
}

动态代理

动态生成对象，可以代理方法

InvocationHandler

• 产生一个对象的代理对象
• 代理对象在方法被调用的时候被触发
• 主要场景：面向切面编程

public class GamePlayIH implements InvocationHandler {
    //被代理者
    Class cls =null;
    //被代理的实例
    Object obj = null;
    //我要代理谁
    public GamePlayIH(Object _obj){
    this.obj = _obj;
}
//调用被代理的方法
public Object invoke(Object proxy, Method method, Object[] args)
    throws Throwable {
    Object result = method.invoke(this.obj, args);
    return result;
    }
}

public class Client {
public static void main(String[] args) throws Throwable {
    //定义一个痴迷的玩家
    IGamePlayer player = new GamePlayer("张三");
    //定义一个handler
    InvocationHandler handler = new GamePlayIH(player);
    //开始打游戏， 记下时间戳
    System.out.println("开始时间是： 2009-8-25 10:45");
    //获得类的class loader
    ClassLoader cl = player.getClass().getClassLoader();
    //动态产生一个代理者
    IGamePlayer proxy = (IGamePlayer)Proxy.newProxyInstance(cl,new Class[]{GamePlayer.class},handler);
    //登录
    proxy.login("zhangSan", "password");//开始杀怪
    proxy.killBoss();
    //升级
    proxy.upgrade();
    //记录结束游戏时间
    System.out.println("结束时间是： 2009-8-26 03:40");
    }
}