Retrofit使用及分析

开始使用Retrofit

• 首先先声明一个用于请求的接口

public interface GitHubService {    @GET("users/{user}/repos")//执行资源的地址后缀    Call<List<User>> listRepos(@Path("user") String user);}

• 创建一个Retrofit对象，传入一些必要的参数

Converter.Factory factory = GsonConverterFactory.create();//使用Gson来进行数据的解析Retrofit retrofit = new Retrofit.Builder().baseUrl("https://api.github.com/")                    .addConverterFactory(factory)                    .build();

• 通过Retrofit对象通过动态代理的形式创建一个对象，发起一个请求。

GitHubService service = retrofit.create(GitHubService.class);Call<List<User>> call = service.listRepos("zhaoyongchao");call.enqueue(new Callback<List<User>>() {                @Override                public void onResponse(Call<List<User>> call, Response<List<User>> response) {                    //成功后的回调                }                @Override                public void onFailure(Call<List<User>> call, Throwable t) {                    //失败的回调                }            });

分析具体的实现

• 在创建Retrofit对象的步骤就是一些赋值，在此只贴出build()的源码

public Retrofit build() {      //根路径的判断      if (baseUrl == null) {        throw new IllegalStateException("Base URL required.");      }      //如果不传入，则默认OKHttpClient为默认的请求工厂类      okhttp3.Call.Factory callFactory = this.callFactory;      if (callFactory == null) {        callFactory = new OkHttpClient();      }      // 使用副本，添加默认的适配器      List<CallAdapter.Factory> adapterFactories = new ArrayList<>(this.adapterFactories);      adapterFactories.add(Platform.get().defaultCallAdapterFactory(callbackExecutor));      // 创建一个用于类型转换的副本      List<Converter.Factory> converterFactories = new ArrayList<>(this.converterFactories);      return new Retrofit(callFactory, baseUrl, converterFactories, adapterFactories,          callbackExecutor, validateEagerly);    }  }//区分当前运行的平台（Android）static class Android extends Platform {    @Override CallAdapter.Factory defaultCallAdapterFactory(Executor callbackExecutor) {      if (callbackExecutor == null) {        callbackExecutor = new MainThreadExecutor();      }      return new ExecutorCallAdapterFactory(callbackExecutor);    }    static class MainThreadExecutor implements Executor {      //使用主线程的Looper来创建一个Handler，用来通信      private final Handler handler = new Handler(Looper.getMainLooper());      @Override public void execute(Runnable r) {        handler.post(r);      }    }  }

• 通过Retrofit的Create()方法来创建一个对象

public <T> T create(final Class<T> service) {    //判断是否为接口    Utils.validateServiceInterface(service);    if (validateEagerly) {      eagerlyValidateMethods(service);    }    //使用Proxy来创建动态创建一个代理对象，使用返回的对象调用接口的方法都会调用匿名内部类的invoke方法。    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, Object... args)              throws Throwable {            // 判断一下声明的类，如果是Object类，正常执行            if (method.getDeclaringClass() == Object.class) {              return method.invoke(this, args);            }            if (platform.isDefaultMethod(method)) {              return platform.invokeDefaultMethod(method, service, proxy, args);            }            return loadMethodHandler(method).invoke(args);          }        });  }

• 调用MethodHandler的creat()方法

static MethodHandler create(Retrofit retrofit, Method method) {    //根据方法的注解和返回类型创建具体的实现类，最终会到ExecutorCallAdapterFactory    CallAdapter<?> callAdapter = createCallAdapter(method, retrofit);    //得到泛型中的类型    Type responseType = callAdapter.responseType();    if (responseType == Response.class || responseType == okhttp3.Response.class) {      throw Utils.methodError(method, "'"          + Types.getRawType(responseType).getName()          + "' is not a valid response body type. Did you mean ResponseBody?");    }    //同样创建具体的转换类    Converter<ResponseBody, ?> responseConverter =        createResponseConverter(method, retrofit, responseType);    //根据请求类型和方法中的注解创建一个请求工厂类    RequestFactory requestFactory = RequestFactoryParser.parse(method, responseType, retrofit);    return new MethodHandler(retrofit.callFactory(), requestFactory, callAdapter,        responseConverter);  }

• createCallAdapter方法最终会调用到Retrofit中的nextCallAdapter方法

public CallAdapter<?> nextCallAdapter(CallAdapter.Factory skipPast, Type returnType,      Annotation[] annotations) {    checkNotNull(returnType, "returnType == null");    checkNotNull(annotations, "annotations == null");    //使用的是ExecutorCallAdapterFactory    int start = adapterFactories.indexOf(skipPast) + 1;    for (int i = start, count = adapterFactories.size(); i < count; i++) {      CallAdapter<?> adapter = adapterFactories.get(i).get(returnType, annotations, this);      if (adapter != null) {        return adapter;      }    }    throw new IllegalArgumentException(builder.toString());  }

• 继续分析一下ExecutorCallAdapterFactory中的get方法

public CallAdapter<Call<?>> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {    //此适配器只能处理返回类型为Call<?>    if (getRawType(returnType) != Call.class) {      return null;    }    //得到Call<T>的泛型T的类型，作为相应体的返回类型    final Type responseType = Utils.getCallResponseType(returnType);    return new CallAdapter<Call<?>>() {      @Override public Type responseType() {        return responseType;      }      @Override public <R> Call<R> adapt(Call<R> call) {        //创建一个对象进行返回        return new ExecutorCallbackCall<>(callbackExecutor, call);      }    };  }

• createResponseConverter得过程和上述相同不做分析。
• 根据请求类型和方法中的注解创建一个请求工厂类，通过parseMethodAnnotations来解析注解、parsePathParameters来解析注解的值，为工厂类相应的字段赋值。
• 调用创建好的MethodHandler对象的invoke方法，根据上述生成的对象创建OKHttpCall对象也是委派对象,把生成的对象传入ExecutorCallAdapterFactory的adapt方法。

@Override public <R> Call<R> adapt(Call<R> call) {        return new ExecutorCallbackCall<>(callbackExecutor, call);      }

• 通过返回的Call对象的调用enqueue方法及ExecutorCallbackCall的enqueue方法

//MethodHandler中的方法Object invoke(Object... args) {    return callAdapter.adapt(        new OkHttpCall<>(callFactory, requestFactory, args, responseConverter));  }@Override public void enqueue(final Callback<T> callback) {      //调用及上述根据请求工厂、类型转换工厂和请求参数创建的OkHttpCall对象      delegate.enqueue(new Callback<T>() {        @Override public void onResponse(final Call<T> call, final Response<T> response) {          //通过handler把回调发送到主线程          callbackExecutor.execute(new Runnable() {            @Override public void run() {              if (delegate.isCanceled()) {                // Emulate OkHttp's behavior of throwing/delivering an IOException on cancelation                callback.onFailure(call, new IOException("Canceled"));              } else {                callback.onResponse(call, response);              }            }          });        }        @Override public void onFailure(final Call<T> call, final Throwable t) {          callbackExecutor.execute(new Runnable() {            @Override public void run() {              callback.onFailure(call, t);            }          });        }      });    }

• OkHttpCall中的enqueue方法

@Override public void enqueue(final Callback<T> callback) {    okhttp3.Call call;    Throwable failure;    synchronized (this) {      if (executed) throw new IllegalStateException("Already executed.");      executed = true;      call = rawCall;      failure = creationFailure;      if (call == null && failure == null) {        try {          //创建真是的请求          call = rawCall = createRawCall();        } catch (Throwable t) {          failure = creationFailure = t;        }      }    }    //添加失败回调    if (failure != null) {      callback.onFailure(this, failure);      return;    }    if (canceled) {      call.cancel();    }    //真实的发起请求    call.enqueue(new okhttp3.Callback() {      @Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse)          throws IOException {        Response<T> response;        try {          //解析返回数据          response = parseResponse(rawResponse);        } catch (Throwable e) {          callFailure(e);          return;        }        callSuccess(response);      }      @Override public void onFailure(okhttp3.Call call, IOException e) {        try {          callback.onFailure(OkHttpCall.this, e);        } catch (Throwable t) {          t.printStackTrace();        }      }      private void callFailure(Throwable e) {        try {          callback.onFailure(OkHttpCall.this, e);        } catch (Throwable t) {          t.printStackTrace();        }      }      private void callSuccess(Response<T> response) {        try {          callback.onResponse(OkHttpCall.this, response);        } catch (Throwable t) {          t.printStackTrace();        }      }    });  }

• 到目前为止所有的注解和值已经解析，但是没有进行拼接。看一下RequestFactory的creat()方法

Request create(Object... args) throws IOException {    RequestBuilder requestBuilder =        new RequestBuilder(method, baseUrl.url(), relativeUrl, headers, contentType, hasBody,            isFormEncoded, isMultipart);    if (args != null) {      //从注解中解析的请求类型目前使用的是RequestAction.Path      RequestAction[] actions = requestActions;      if (actions.length != args.length) {        throw new IllegalArgumentException("Argument count ("            + args.length            + ") doesn't match action count ("            + actions.length            + ")");      }      for (int i = 0, count = args.length; i < count; i++) {        actions[i].perform(requestBuilder, args[i]);      }    }    return requestBuilder.build();  }}//RequestAction.Path类中重写的方法@Override void perform(RequestBuilder builder, T value) throws IOException {      if (value == null) {        throw new IllegalArgumentException(            "Path parameter \"" + name + "\" value must not be null.");      }      builder.addPathParam(name, valueConverter.convert(value), encoded);    }//进行完整路径的组合void addPathParam(String name, String value, boolean encoded) {    if (relativeUrl == null) {      // The relative URL is cleared when the first query parameter is set.      throw new AssertionError();    }    relativeUrl = relativeUrl.replace("{" + name + "}", canonicalizeForPath(value, encoded));  }//OKHttpClient中的 newCall转换为一个OkHttpCall的真正请求@Override public Call newCall(Request request) {    return new RealCall(this, request);  }

• 最终的请求在RealCall中
• 在以后还会加入RxJava的组合使用