也谈Retrofit

retrofit利用了动态代理模式,我们只需要写接口和注解就可以创建request。在结合rxjava和gson,使得我们在请求网络的时候变得非常简单简洁。

一、简单用法

    //1.创建api
    public interface Api {
        @GET("app/checkVersion")
        Observable<AppVersionEntity> checkVersion();
    }
    //2.创建httpClient
    OkHttpClient httpClient = new OkHttpClient.Builder().build();
    //3.创建api代理服务
    Api api = new Retrofit.Builder()
            .baseUrl("baseurl")
            .client(httpClient)
            .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
            .addConverterFactory(GsonConverterFactory.create())
            .build()
            .create(Api.class);
    //4.发起请求
    api.checkVersion()
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new BaseSubscriber<AppVersionEntity>() {
                @Override
                public void next(AppVersionEntity appVersionEntity) {
                    Log.e(TAG, "next: ");
                }
            });

整个请求的发起非常的简单,就和平常用rxjava一样的简洁。

二、创建请求

1.Retrofit.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);
        }
        //1.当调用service的某个方法时这里会进行解析创建相应的ServiceMethod
        ServiceMethod<Object, Object> serviceMethod =
            (ServiceMethod<Object, Object>) loadServiceMethod(method);
        //2.创建相应的请求
        OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
        //3.这里添加的是RxJava2CallAdapter，所以返回的是observable
        return serviceMethod.callAdapter.adapt(okHttpCall);
      }
    });
  }

最为重要的就是ServiceMethod这个类,这个类负责解析和记录请求信息。

2.Retrofit.loadServiceMethod()

ServiceMethod<?, ?> loadServiceMethod(Method method) {
//serviceMethodCache保存了已经发起过请求的的serviceMethod对象
ServiceMethod<?, ?> result = serviceMethodCache.get(method);
if (result != null) return result;
synchronized (serviceMethodCache) {
  result = serviceMethodCache.get(method);
  if (result == null) {
    //如果没有相应的缓存记录，则创建一个新的ServiceMethod对象
    result = new ServiceMethod.Builder<>(this, method).build();
    serviceMethodCache.put(method, result);
  }
}
return result;
}

通过serviceMethodCache存储之前已发起过请求的相应serviceMethod对象,这样就不用再进行解析接口方法创建了。

3.ServiceMethod.Builder<>(this, method).build()

public ServiceMethod build() {
  //创建callAdapter
  callAdapter = createCallAdapter();
  //获取返回值
  responseType = callAdapter.responseType();
  if (responseType == Response.class || responseType == okhttp3.Response.class) {
    throw methodError("'"
        + Utils.getRawType(responseType).getName()
        + "' is not a valid response body type. Did you mean ResponseBody?");
  }
  //创建转换类
  responseConverter = createResponseConverter();
  //解析方法注解
  for (Annotation annotation : methodAnnotations) {
    parseMethodAnnotation(annotation);
  }
  //判断参数合法性
  if (httpMethod == null) {
    throw methodError("HTTP method annotation is required (e.g., @GET, @POST, etc.).");
  }

  if (!hasBody) {
    if (isMultipart) {
      throw methodError(
          "Multipart can only be specified on HTTP methods with request body (e.g., @POST).");
    }
    if (isFormEncoded) {
      throw methodError("FormUrlEncoded can only be specified on HTTP methods with "
          + "request body (e.g., @POST).");
    }
  }

  int parameterCount = parameterAnnotationsArray.length;
  parameterHandlers = new ParameterHandler<?>[parameterCount];
  for (int p = 0; p < parameterCount; p++) {
    Type parameterType = parameterTypes[p];
    if (Utils.hasUnresolvableType(parameterType)) {
      throw parameterError(p, "Parameter type must not include a type variable or wildcard: %s",
          parameterType);
    }

    Annotation[] parameterAnnotations = parameterAnnotationsArray[p];
    if (parameterAnnotations == null) {
      throw parameterError(p, "No Retrofit annotation found.");
    }
  //解析方法注解参数
    parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations);
  }
  //判断参数合法性
  if (relativeUrl == null && !gotUrl) {
    throw methodError("Missing either @%s URL or @Url parameter.", httpMethod);
  }
  if (!isFormEncoded && !isMultipart && !hasBody && gotBody) {
    throw methodError("Non-body HTTP method cannot contain @Body.");
  }
  if (isFormEncoded && !gotField) {
    throw methodError("Form-encoded method must contain at least one @Field.");
  }
  if (isMultipart && !gotPart) {
    throw methodError("Multipart method must contain at least one @Part.");
  }

  return new ServiceMethod<>(this);
}

至此我们就已经解析创建好了一个包含请求信息的serviceMethod对象,主要是利用反射和解析注解来获取相应的请求信息。

4.创建OkHttpCall请求

4.1.创建Call

okhttp3Call.createRawCall()

private okhttp3.Call createRawCall() throws IOException {
Request request = serviceMethod.toRequest(args);
okhttp3.Call call = serviceMethod.callFactory.newCall(request);
if (call == null) {
  throw new NullPointerException("Call.Factory returned null.");
}
return call;
}

通过serviceMthrod对象来创建相应的request。

4.2.创建Observable

RxJava2CallAdapter.adapt()

@Override public Object adapt(Call<R> call) {
//根据请求是同步还是异步来创建observable
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;
}
//省略部分代码...
return observable;
 }

三、发起请求

到这里就已经创建好了发起请求的需要的相关信息了,那么接下来看下是如何发起请求的。
其实发起请求的触发和rxjava的订阅是一样的,当有订阅4.2创建好的observable时,整个请求就开始了。这里已异步请求来分析(即4.2创建的是CallEnqueueObservable)。

CallEnqueueObservable.subscribeActual()

@Override protected void subscribeActual(Observer<? super Response<T>> observer) {
// Since Call is a one-shot type, clone it for each new observer.
Call<T> call = originalCall.clone();
CallCallback<T> callback = new CallCallback<>(call, observer);
observer.onSubscribe(callback);
call.enqueue(callback);
 }

Okhttp3Call.enqueue()执行成功之后对response进行转换之后在回调CallEnqueueObservable中的onResponse()方法

@Override public void onResponse(Call<T> call, Response<T> response) {
  if (call.isCanceled()) return;
  try {
    observer.onNext(response);
    if (!call.isCanceled()) {
      terminated = true;
      observer.onComplete();
    }
  } catch (Throwable t) {
    if (terminated) {
      RxJavaPlugins.onError(t);
    } else if (!call.isCanceled()) {
      try {
        observer.onError(t);
      } catch (Throwable inner) {
        Exceptions.throwIfFatal(inner);
        RxJavaPlugins.onError(new CompositeException(t, inner));
      }
    }
  }
}

到这整个请求就已经完成了。

总结：
Retrofit通过动态代理来调用方法,利用反射和注解来获取相应的请求信息；通过okhtpp进行网络请求;在通过rxjava实现响应对结果的转换及回调。