Android網絡之Retrofit2.0使用和解析

Android網絡之Retrofit2.0使用和解析

Retrofit2在項目中的使用

Android studio項目添加依賴

compile 'com.squareup.retrofit2:retrofit:2.0.1'

項目中使用樣例

定義HTTP API使用接口

public interface GitHubService {
    @GET("users/{user}/repos")
     Call<List<Repo>> listRepos(@Path("user") String user);
}

• 通過在接口上添加註解的方式來表示如何處理網絡請求。
• Retrofit支持5中類型的註解：GET,POST,PUT,DELETE和HEAD.
• 可以使用不帶參數的urljava @GET("users/list")，也可以使用帶參數的urljava @GET("users/list?sort=desc")

構造Retrofit實例

Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("https://api.github.com/")
    .build();
GitHubService service = retrofit.create(GitHubService.class);

創建同步或異步HTTP請求到遠程網絡服務器

Call<List<Repo>> repos = service.listRepos("octocat");

定製數據類型轉換器

• Gson: com.squareup.retrofit2:converter-gson
• Jackson: com.squareup.retrofit2:converter-jackson
• Moshi: com.squareup.retrofit2:converter-moshi
• Protobuf: com.squareup.retrofit2:converter-protobuf
• Wire: com.squareup.retrofit2:converter-wire
• Simple XML: com.squareup.retrofit2:converter-simplexml
• Scalars (primitives, boxed, and String): com.squareup.retrofit2:converter-scalars

Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("https://api.github.com")
    .addConverterFactory(GsonConverterFactory.create())
    .build();

GitHubService service = retrofit.create(GitHubService.class);

Retrofit使用擴展

自定義Gson類型轉換器

/**
{
    "resultcode":0,
    "resultmsg":"請求成功",
    "result":{}
}
*/
public class Wrapper {
    public int resultcode ;
    public String resultmsg ;
    public Object result ;
    public static class JsonAdapter implements JsonDeserializer<Wrapper02> {
        @Override
        public Wrapper deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
            try {
                String jsonRoot = json.getAsJsonObject().toString() ;
                Wrapper wrapper = new Wrapper() ;
                JSONObject jsobRespData = new JSONObject(jsonRoot) ;
                wrapper.resultcode = jsobRespData.getInt("resultcode") ;
                wrapper.resultmsg = jsobRespData.getString("resultmsg") ;
                wrapper.result = jsobRespData.get("result") ;
                return wrapper;
            } catch (JSONException e) {
                throw new JsonParseException(e) ;
            }
        }
    }

}

添加到Retrofit當中

Gson gson = new GsonBuilder()
            .registerTypeAdapter(Wrapper.class, new Wrapper.JsonAdapter())
            .create() ;
Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("https://api.github.com")
    .addConverterFactory(GsonConverterFactory.create(gson))
    .build();

GitHubService service = retrofit.create(GitHubService.class);      

請求時添加head信息

在定義請求接口時添加：

@Headers("Cache-Control: max-age=640000")
@GET("widget/list")
Call<List<Widget>> widgetList();

@Headers({
    "Accept: application/vnd.github.v3.full+json",
    "User-Agent: Retrofit-Sample-App"
})
@GET("users/{username}")
Call<User> getUser(@Path("username") String username);

@GET("user")
Call<User> getUser(@Header("Authorization") String authorization)

如果所示在Retrofit2.0中只支持okhttp，所以另一種方法是在okhttp的攔截器中addheader。

Retrofit2源碼解析

Retrofit請求框架實現了高度的解耦，通過解析註解的得到的代理類生成http請求，然後將請求交給OkHttp。通過在Retrofit創建時生成的Converter再將OkHttp返回的數據進行類型轉換得到自己需要的數據。現在Rxjava響應式編程已經廣泛應用，在使用Retrofit時也會結合RxJava使編碼更加簡單、高效。

一張圖簡單描述一下Retrofit的工作原理：

定義網絡請求接口

public interface GitHubService {
     @GET("users/{user}/repos")
     Call<List<Repo>> listRepos(@Path("user") String user);
}

創建Retrofit實例

Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("https://api.github.com")
    //支持RxJava
    .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
    .addConverterFactory(ByteArrayConverterFactory.create())
    .addConverterFactory(JSONObjectResponseConverterFactory.create())
    .addConverterFactory(StringResponseConverterFactory.create())
    //支持對象轉json串
    .addConverterFactory(GsonConverterFactory.create())
    .build();

• 設置BaseUrl
• 添加CallAdapterFactory
• 添加converterFactory
• 此時也可以設置自定義的okHttpclient

接下來我們看

GitHubService service = retrofit.create(GitHubService.class);

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() {
          //判斷Android，IOS，java8
          private final Platform platform = Platform.get();

          @Override public Object invoke(Object proxy, Method method, Object... args)
              throws Throwable {
            //如果是對象裏的方法直接調用
            if (method.getDeclaringClass() == Object.class) {
              return method.invoke(this, args);
            }
            /**
            * 對java8做兼容，android和ios值恆爲false
            */
            if (platform.isDefaultMethod(method)) {
              return platform.invokeDefaultMethod(method, service, proxy, args);
            }
            //主要看這三行代碼
            /**
            * 1、生成獲取緩存中的method對應的ServiceMethod或者生產method對應的ServiceMethod
            * 2、生成OkHttpCall的實例
            * 3、根據生成的ServiceMethod實例中的callAdapter對象，調用callAdapter.adapt方法創建
            * 對應的Observable
            */
            ServiceMethod serviceMethod = loadServiceMethod(method);
            OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
            return serviceMethod.callAdapter.adapt(okHttpCall);
          }
        });
  }

Platfrom的獲取

class Platform {
    //這個方法Android中爲Plafrom默認的
    //Java8返回的是method.isDefault()，熟悉Java8的都知道這是Java8的新特性。。
    boolean isDefaultMethod(Method method) {
        return false;
    }
    //這個方法Android中有自己默認的實現MainThreadExecutor
    Executor defaultCallbackExecutor() {
        return null;
    }
    static class Android extends Platform {
        @Override 
        public Executor defaultCallbackExecutor() {
            return new MainThreadExecutor();
        }

        @Override 
        CallAdapter.Factory defaultCallAdapterFactory(Executor callbackExecutor) {
            return new ExecutorCallAdapterFactory(callbackExecutor);
        }
        //Rx默認請求方式都是同步請求，所以我們在發出請求和請求結果回來的時候切換線程
        static class MainThreadExecutor implements Executor {
            private final Handler handler = new Handler(Looper.getMainLooper());
            @Override 
            public void execute(Runnable r) {
                handler.post(r);
            }
        }
    }
}

ServiceMethod對象的生成

先看一張我debug時候的ServiceMethod的圖

ServiceMethod的獲取

/**Retrofit.java
* 首先從serviceMethodCache緩存中獲取，如果爲null則創建
*/
ServiceMethod loadServiceMethod(Method method) {
    ServiceMethod result;
    synchronized (serviceMethodCache) {
      result = serviceMethodCache.get(method);
      if (result == null) {
        result = new ServiceMethod.Builder(this, method).build();
        serviceMethodCache.put(method, result);
      }
    }
    return result;
  }

ServiceMethod的創建

final class ServiceMethod<T> {
    //部分代碼省略
    ServiceMethod(Builder<T> builder) {
        this.callFactory = builder.retrofit.callFactory();
        this.callAdapter = builder.callAdapter;
        this.baseUrl = builder.retrofit.baseUrl();
        this.responseConverter = builder.responseConverter;
        this.httpMethod = builder.httpMethod;
        this.relativeUrl = builder.relativeUrl;
        this.headers = builder.headers;
        this.contentType = builder.contentType;
        this.hasBody = builder.hasBody;
        this.isFormEncoded = builder.isFormEncoded;
        this.isMultipart = builder.isMultipart;
        this.parameterHandlers = builder.parameterHandlers;
    }
    static final class Builder<T> {
        public Builder(Retrofit retrofit, Method method) {
        this.retrofit = retrofit;
        this.method = method;
        this.methodAnnotations = method.getAnnotations();
        this.parameterTypes = method.getGenericParameterTypes();
        this.parameterAnnotationsArray = method.getParameterAnnotations();
    }

        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?");
            }
            //創建Converter<ResponseBody, T>
            responseConverter = createResponseConverter();
            for (Annotation annotation : methodAnnotations) {
             parseMethodAnnotation(annotation);
            }
            /********/
            return new ServiceMethod<>(this);
        }

        private CallAdapter<?> createCallAdapter() {
            Type returnType = method.getGenericReturnType();
            /*******/
            Annotation[] annotations = method.getAnnotations();
            try {
                //調用retrofit中的方法進行創建
                return retrofit.callAdapter(returnType, annotations);
            } catch (RuntimeException e) { // Wide exception range because factories are user code.
                throw methodError(e, "Unable to create call adapter for %s", returnType);
            }
        }
        private Converter<ResponseBody, T> createResponseConverter() {
            Annotation[] annotations = method.getAnnotations();
            try {
                //調用retrofit中的方法進行創建
                return retrofit.responseBodyConverter(responseType, annotations);
            } catch (RuntimeException e) { // Wide exception range because factories are user code.
                throw methodError(e, "Unable to create converter for %s", responseType);
            }
        }
    }
}

CallAdapter的創建

public CallAdapter<?> callAdapter(Type returnType, Annotation[] annotations) {
    return nextCallAdapter(null, returnType, annotations);
}

public CallAdapter<?> nextCallAdapter(CallAdapter.Factory skipPast, Type returnType,
  Annotation[] annotations) {
    checkNotNull(returnType, "returnType == null");
    checkNotNull(annotations, "annotations == null");
    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;
        }
    }
    /********************/
}

在創建Retrofit的時候我們添加過.addCallAdapterFactory(RxJavaCallAdapterFactory.create()),這是我們會調用RxJavaCallAdapterFactory.get 方法獲取CallAdapter，通過源代碼我們可以找到其返回的是new SimpleCallAdapter(observableType, scheduler)。

Converter的創建

public <T> Converter<T, RequestBody> requestBodyConverter(Type type,
   Annotation[] parameterAnnotations, Annotation[] methodAnnotations) {
   return nextRequestBodyConverter(null, type, parameterAnnotations, methodAnnotations);
}

public <T> Converter<T, RequestBody> nextRequestBodyConverter(Converter.Factory skipPast,
    Type type, Annotation[] parameterAnnotations, Annotation[] methodAnnotations) {
    checkNotNull(type, "type == null");
    checkNotNull(parameterAnnotations, "parameterAnnotations == null");
    checkNotNull(methodAnnotations, "methodAnnotations == null");
    int start = converterFactories.indexOf(skipPast) + 1;
    for (int i = start, count = converterFactories.size(); i < count; i++) {
        Converter.Factory factory = converterFactories.get(i);
        Converter<?, RequestBody> converter =
            factory.requestBodyConverter(type, parameterAnnotations, methodAnnotations, this);
        if (converter != null) {
            //noinspection unchecked
            return (Converter<T, RequestBody>) converter;
        }
    }
    /******/
}

相同的在創建Retrofit的時候我們也添加過許多的ConverterFactory，在尋找相匹配的Converter時我們是通過遍歷在尋找到第一個合適的Converter返回。什麼叫做合適的Converter，即該ConverterFactory能產生出匹配服務接口註解和返回類型。

retrofit的構造器中默認添加的適配器和轉化器

public static final class Builder {
    private Platform platform;
    private okhttp3.Call.Factory callFactory;
    private HttpUrl baseUrl;
    private List<Converter.Factory> converterFactories = new ArrayList<>();
    private List<CallAdapter.Factory> adapterFactories = new ArrayList<>();
    private Executor callbackExecutor;
    private boolean validateEagerly;

    Builder(Platform platform) {
      this.platform = platform;
      // Add the built-in converter factory first. This prevents overriding its behavior but also
      // ensures correct behavior when using converters that consume all types.
      //自動回添加加默認的轉化器
      converterFactories.add(new BuiltInConverters());
    }
    /****************/
    public Retrofit build() {
      if (baseUrl == null) {
        throw new IllegalStateException("Base URL required.");
      }

      okhttp3.Call.Factory callFactory = this.callFactory;
      if (callFactory == null) {
        callFactory = new OkHttpClient();
      }

      Executor callbackExecutor = this.callbackExecutor;
      if (callbackExecutor == null) {
        callbackExecutor = platform.defaultCallbackExecutor();
      }

      // Make a defensive copy of the adapters and add the default Call adapter.
      List<CallAdapter.Factory> adapterFactories = new ArrayList<>(this.adapterFactories);
      //添加一個默認的適配器（Android、IOS、Java8）
      adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));

      // Make a defensive copy of the converters.
      List<Converter.Factory> converterFactories = new ArrayList<>(this.converterFactories);

      return new Retrofit(callFactory, baseUrl, converterFactories, adapterFactories,
          callbackExecutor, validateEagerly);
    }

具體怎麼從Factory中獲取對應的Converter和Adapter我們從代碼中可以直觀的看到。

OkHttpCall的創建

OkHttpCall(ServiceMethod<T> serviceMethod, Object[] args) {
   this.serviceMethod = serviceMethod;
   this.args = args;
}

網絡請求

請求的準備

serviceMethod.callAdapter.adapt(okHttpCall) 對應SimpleCallAdapter.adapt

static final class SimpleCallAdapter implements CallAdapter<Observable<?>> {
    private final Type responseType;
    private final Scheduler scheduler;
    SimpleCallAdapter(Type responseType, Scheduler scheduler) {
        this.responseType = responseType;
        this.scheduler = scheduler;
    }
    @Override public Type responseType() {
        return responseType;
    }
    @Override public <R> Observable<R> adapt(Call<R> call) {
        //創建請求的觀察者，返回我們需要的Ovservable
        Observable<R> observable = Observable.create(new CallOnSubscribe<>(call)) //
          .lift(OperatorMapResponseToBodyOrError.<R>instance());
        if (scheduler != null) {
            return observable.subscribeOn(scheduler);
        }
        return observable;
    }
}

static class Android extends Platform {
    @Override
    public Executor defaultCallbackExecutor() {
        return new MainThreadExecutor();
    }
    @Override
    CallAdapter.Factory defaultCallAdapterFactory(Executor callbackExecutor) {
        return new ExecutorCallAdapterFactory(callbackExecutor);
    }
    static class MainThreadExecutor implements Executor {
        private final Handler handler = new Handler(Looper.getMainLooper());
        @Override
        public void execute(Runnable r) {
            handler.post(r);
        }
    }
}
/*
* 因爲默認的執行線程爲主線程，所以我們要切換到subscribeOn(Schedulers.io())線程從而達到異步的目的。
* 然後通過observeOn(AndroidSchedulers.mainThread())將線程切回UI線程。
* 當Okhttp請求完數據並進行相應的convert之後，就可以在UI處理相應的邏輯。
*/
service.listRepos("octocat")
.observeOn(AndroidSchedulers.mainThread())
.subscribeOn(Schedulers.io())
.subscribe(list->{ 
    if(list!=null){      
    //TODO 取得數據後邏輯處理     
    }     
});

請求的發起

回到CallAdapt方法，創建Observable，而new CallOnSubscribe<>(call)生成了一個OnSubscribe（）的實例，而OnSubscribe繼承自Action1，其只包含一個call()方法，而這個call是在CallOnSubscribe中實現：

static final class CallOnSubscribe<T> implements Observable.OnSubscribe<Response<T>> {
    private final Call<T> originalCall;
    CallOnSubscribe(Call<T> originalCall) {
    this.originalCall = originalCall;
    }
    @Override public void call(final Subscriber<? super Response<T>> subscriber) {
        // Since Call is a one-shot type, clone it for each new subscriber.
        Call<T> call = originalCall.clone();

        // Wrap the call in a helper which handles both unsubscription and backpressure.
        RequestArbiter<T> requestArbiter = new RequestArbiter<>(call, subscriber);
        subscriber.add(Subscriptions.create(requestArbiter));
        subscriber.setProducer(requestArbiter);
    }
}

首先clone了一份Call，然後生成了RequestArbiter，他繼承自AtomicBoolean，實現了Subscription, Producer接口，Producer只有一個request方法；一般實現該接口的類，都會包含一個Subscriber對象和一個待處理的數據：

static final class RequestArbiter<T> extends AtomicBoolean implements Action0,
    Producer {
    private final Call<T> call;
    private final Subscriber<?super Response<T>> subscriber;
    RequestArbiter(Call<T> call, Subscriber<?super Response<T>> subscriber) {
        this.call = call;
        this.subscriber = subscriber;
    }
    @Override
    public void request(long n) {
        if (n < 0) {
            throw new IllegalArgumentException("n < 0: " + n);
        }
        if (n == 0) {
            return; // Nothing to do when requesting 0.
        }
        if (!compareAndSet(false, true)) {
            return; // Request was already triggered.
        }
        try {
            //進行網絡請求
            Response<T> response = call.execute();
            if (!subscriber.isUnsubscribed()) {
                subscriber.onNext(response);
            }
        } catch (Throwable t) {
            Exceptions.throwIfFatal(t);
            if (!subscriber.isUnsubscribed()) {
                subscriber.onError(t);
            }
            return;
        }
        if (!subscriber.isUnsubscribed()) {
            subscriber.onCompleted();
        }
    }

    @Override
    public void call() {
        call.cancel();
    }
}

請求的執行

回顧創建Retrofit.create()代碼中serviceMethod.callAdapter.adapt(okHttpCall)，所以上面的call.execute() 就是OkHttpCall.execute

public Response<T> execute() throws IOException{
    okhttp3.Call call;
    synchronized (this) {
        if ( executed )
            throw new IllegalStateException( "Already executed." );
        executed = true;
        if ( creationFailure != null ){
            if ( creationFailure instanceof IOException ){
                throw (IOException) creationFailure;
            } else {
                throw (RuntimeException) creationFailure;
            }
        }
        call = rawCall;
        if ( call == null ){
            try {
                //獲取okhttp實例
                call = rawCall = createRawCall();
            } catch ( IOException | RuntimeException e ) {
                creationFailure = e;
                throw e;
            }
        }
    }
    if ( canceled ){
        call.cancel();
    }
    //執行okhttp請求
    return(parseResponse( call.execute() ) );
}

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

請求的OkHttpClient實例獲取

public okhttp3.Call.Factory callFactory() {
    return callFactory;
}
public Builder callFactory(okhttp3.Call.Factory factory) {
    this.callFactory = checkNotNull(factory, "factory == null");
    return this;
}
//使用自定義OkHttpClient
public Builder client(OkHttpClient client) {
    return callFactory(checkNotNull(client, "client == null"));
}

public Retrofit build(){
    if ( baseUrl == null ){
        throw new IllegalStateException( "Base URL required." );
    }
    okhttp3.Call.Factory callFactory = this.callFactory;
    //沒有自定義OkHttpClient，則會新創建一個
    if ( callFactory == null ){
        callFactory = new OkHttpClient();
    }
    Executor callbackExecutor = this.callbackExecutor;
    if ( callbackExecutor == null ){
        callbackExecutor = platform.defaultCallbackExecutor();
    }
    List<CallAdapter.Factory> adapterFactories = new ArrayList<>( this.adapterFactories );
    adapterFactories.add( platform.defaultCallAdapterFactory( callbackExecutor ) );
    List<Converter.Factory> converterFactories = new ArrayList<>( this.converterFactories );
    return(new Retrofit( callFactory, baseUrl, converterFactories, adapterFactories,
                 callbackExecutor, validateEagerly ) );
    }
}

請求結果的處理

Response<T> parseResponse( okhttp3.Response rawResponse ) throws IOException{
    ResponseBody rawBody = rawResponse.body();
    rawResponse = rawResponse.newBuilder()
              .body( new NoContentResponseBody( rawBody.contentType(), rawBody.contentLength() ) )
              .build();
    int code = rawResponse.code();
    if ( code < 200 || code >= 300 ){
        try {
            ResponseBody bufferedBody = Utils.buffer( rawBody );
            return(Response.error( bufferedBody, rawResponse ) );
        } finally {
            rawBody.close();
        }
    }
    if ( code == 204 || code == 205 ){
        return(Response.success( null, rawResponse ) );
    }
    ExceptionCatchingRequestBody catchingBody = new ExceptionCatchingRequestBody( rawBody );
    try {
        //使用Converter將返回結果轉化爲接口返回的數據格式類型
        T body = serviceMethod.toResponse( catchingBody );
        //包裝成Response並返回
        return(Response.success( body, rawResponse ) );
    } catch ( RuntimeException e ) {
        catchingBody.throwIfCaught();
        throw e;
    }
}

還記得創建Observable時 Observable<R> observable = Observable.create(new CallOnSubscribe<>(call)).lift(OperatorMapResponseToBodyOrError.<R>instance()); ，OperatorMapResponseToBodyOrError將包裝的Response中的body取出來並進行發射。

總結

現在隨着Rxjava響應式編程越來越多的程序猿使用，自己也開始接觸和使用。Retrofit+Rxjava+okhttp是時下比較受歡迎的網絡請求框架，其源代碼並不是很多，其底層網絡通信時交由 OkHttp來完成的，但是Retrofit運用了大量的設計模式，代碼邏輯很清晰，筆者以前用的是AsyncHttpClient作爲app的網絡請求框架，其源碼也沒自己的研究過。但看完Retrofit代碼之後覺得收穫很大，建議如果感興趣可以抽時間仔細的閱讀。