首先需要在gradle配置裏面增加對retrofit的引用。

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

下面主要分析下retrofit2框架的底層原理。

我下載到的版本是2.2.0的版本。

一．如何使用Retrofit

首先看一下Retrofit是怎麼用的。

public interface GithubService{
    @GET("user/{user}/repos")
    Call<List<ResponseBody>> listRpo(@Path("user") String user)
}
 
Retrofit tetrofit = new Retrofit.Builder()
        .client(new OkHttpClient())
        .baseUrl("https://www.github.com/")
        .build();
GithubService service = tetrofit.create(GithubService.class)
Call<List<ResponseBody>> call = service.listRpo("octocat");

call.enqueue(new Callback<List<ResponseBody>>() {
    @Override
    public void onResponse(Call<List<ResponseBody>> call, Response<List<ResponseBody>> response) {
        String result = response.getBody();
   }

    @Override
    public void onFailure(Call<List<ResponseBody>> call, Throwable t) {
	Log.d("TAG",t.getMessage());
    }
});

使用retrofit需要先創建一個interface接口，這個接口其實聲明瞭網絡請求的地址，參數，返回類型，請求方式等等。

這個接口在retrofit的轉化下轉化成網絡請求。

Retrofit的接口支持以下功能：
1.@GET 和 @Post支持切換請求方式
2.@Path支持請求格式的動態變化，@Header用於添加不固定的Header

3.支持FormUrlEncoded和Multipart等標記

Retrofit訪問網絡時，大概分爲1.構建網絡請求 2.發送網絡請求兩步驟。

1.構建網絡請求——創建一個Retrofit類，這個Retrofit類是用建造者模式構建的。client()方法指定了底層是用okhttp進行通訊，baseUrl()方法指定訪問的URL是www.github.com。然後獲得GithubService對象，這個GithubService對象其實就是我們自己定義的接口類，Retrofit會自動將我們定義的接口類轉化成網絡請求。

2.發送網絡請求——得到call對象，執行call對象。

二．構建網絡請求

接下來從源碼的角度來分析一下內部原理，首先來看一下Retrofit類。

public final class Retrofit {

private final Map<Method, ServiceMethod<?, ?>> serviceMethodCache = new ConcurrentHashMap<>();

final okhttp3.Call.Factory callFactory;
final HttpUrl baseUrl;
final List<Converter.Factory> converterFactories;
final List<CallAdapter.Factory> adapterFactories;
final Executor callbackExecutor;
final boolean validateEagerly;

Retrofit(okhttp3.Call.Factory callFactory, HttpUrl baseUrl,
    List<Converter.Factory> converterFactories, List<CallAdapter.Factory> adapterFactories,
    Executor callbackExecutor, boolean validateEagerly) {
  this.callFactory = callFactory;
  this.baseUrl = baseUrl;
  this.converterFactories = unmodifiableList(converterFactories); // Defensive copy at call site.
  this.adapterFactories = unmodifiableList(adapterFactories); // Defensive copy at call site.
  this.callbackExecutor = callbackExecutor;
  this.validateEagerly = validateEagerly;
}

最核心的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, 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);
        }
      });
}

private void eagerlyValidateMethods(Class<?> service) {
  Platform platform = Platform.get();
  for (Method method : service.getDeclaredMethods()) {
    if (!platform.isDefaultMethod(method)) {
      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;
}
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);
  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);
}

先來看一下build方法，調用Retrofit.build的build方法會生成一個Retrofit對象，通過建造者模式（建造者模式：構建和使用相分離）傳遞給它callFactory, baseUrl, converterFactories, adapterFactories這些參數，

callFacotry表示網絡請求採用的底層通信，

baseUrl表示請求的地址，

converterFactories表示轉換器，

adapterFactories是適配轉換器。

看一下核心的create方法，在create方法中首先會進行判斷所傳入進來的Service是否是一個接口，當我們將validateEagerly屬性設爲true的時候，在我們調用create方法創建一個Service，就直接調用eagerlyValidateMethods方法裏面。eagerlyValidateMethods有什麼作用呢？它通過反射獲取獲們創建service接口中所有的接口方法，然後根據接口方法和當前的retrofit對象來獲得ServiceMethod並且以接口方法作爲Key，ServiceMethod作爲值添加到serviceMethodCache緩存中。這樣做的目的是爲了下次便可以通過接口方法直接獲取ServiceMethod。這就是 eagerlyValidateMethods的作用。

繼續分析create方法裏面的代碼，接着往下看

return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] { service },
     new InvocationHandler() {

這裏用到了java的動態代理，java動態代理的作用是將這個在一段代碼的方法執行前插入一段執行的代碼。

關於java的動態機制，網上有很多比較好的文章，這裏也有一篇文章推薦。

那麼，當我們通過自己創建的接口去調用接口方法時，這時候動態代理會去先執行invoke方法。那麼究竟利用動態代理invoke了什麼代碼呢？在InvocationHandler的invoke方法裏面，我們可以看到執行了下面的代碼。

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

(method);

OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);

 return serviceMethod.callAdapter.adapt(okHttpCall);

這三句代碼是整個retrofit的核心代碼。ServiceMethod是幹嘛的？ServiceMethod負責將自定義接口轉化爲實際的http請求。

然後再調用servicemehtod的calladapter當中的adapt方法進行初始化。

也就是說當我們調用自己實現接口的方法時，Retrofit利用create方法然後通過java動態放射的方式去調用servicemethod當中的calladapter當中的adapt方法進行初始化。

這樣就得到的動態代理接口看起來是上面自己實現的GithubService，但是通過java動態代理會將這個GithubService在調用方法時轉化爲真正的http請求。

首先，通過loadServceMethod方法從這個緩存當中獲取ServiceMethod。

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

loadServceMethod方法首先去緩存裏面去取ServcieMethod，如果沒有，調用ServiceMehtod的build（）方法。

public ServiceMethod build() {
      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();

         ...//省略代碼   return new ServiceMethod<>(this);
    }

這ServiceMethod的build方法裏面調用了createCallAdapter方法創建calladapter對象。

  private CallAdapter<T, R> createCallAdapter() {
      Type returnType = method.getGenericReturnType();
      if (Utils.hasUnresolvableType(returnType)) {
        throw methodError(
            "Method return type must not include a type variable or wildcard: %s", returnType);
      }
      if (returnType == void.class) {
        throw methodError("Service methods cannot return void.");
      }
      Annotation[] annotations = method.getAnnotations();
      try {
        //noinspection unchecked
        return (CallAdapter<T, R>) 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);
      }
    }

裏面是調用了Retrofit類的callAdapter方法。

 /**
   * Returns the {@link CallAdapter} for {@code returnType} from the available {@linkplain
   * #callAdapterFactories() factories}.
   *
   * @throws IllegalArgumentException if no call adapter available for {@code type}.
   */
  public CallAdapter<?, ?> callAdapter(Type returnType, Annotation[] annotations) {
    return nextCallAdapter(null, returnType, annotations);
  }

原來createCallAdapter裏面默認遍歷了Retrofit的adapterFactories，但是Retrofit當中有哪些CallAdapter呢？

回過頭來再去看Retrofit類的build方法，Retrofit類在build方法中返回一個默認的defaultCallAdapterFactory。

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

也就是說，不管Retrofit有沒有往adapterFactories裏面增加CallAdapter對象，都有一個默認的defaultCallAdapterFactory。

Retrofit在創建的時候，默認的callFactory是OKHttpClient，默認的callbackexecutrot是platform.defaultCallbackExecutor();

platform是一個retrofit裏面表示當前平臺的接口，在Android設備中，這個paltform是一個Android類裏實現的，我們在下面這段代碼中找到了這個defaultCallbackExecutor.

class Platform {
  private static final Platform PLATFORM = findPlatform();

  static Platform get() {
    return PLATFORM;
  }

  private static Platform findPlatform() {
    try {
      Class.forName("android.os.Build");
      if (Build.VERSION.SDK_INT != 0) {
        return new Android();
      }
    } catch (ClassNotFoundException ignored) {
    }
    try {
      Class.forName("java.util.Optional");
      return new Java8();
    } catch (ClassNotFoundException ignored) {
    }
    return new Platform();
  }

  @Nullable Executor defaultCallbackExecutor() {
    return null;
  }

  CallAdapter.Factory defaultCallAdapterFactory(@Nullable Executor callbackExecutor) {
    if (callbackExecutor != null) {
      return new ExecutorCallAdapterFactory(callbackExecutor);
    }
    return DefaultCallAdapterFactory.INSTANCE;
  }

通過分析上面的源代碼，這裏不難理解，platform對象默認返回的是Android對象，所以我們再看一下Android類的代碼

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

看defaultCallAdapterFactory這個方法返回的是ExecutorCallAdapterFactory

我們看一下ExecutorCallAdapterFactory的源碼。

@Override
  public CallAdapter<?, ?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
    if (getRawType(returnType) != Call.class) {
      return null;
    }
    final Type responseType = Utils.getCallResponseType(returnType);
    return new CallAdapter<Object, Call<?>>() {
      @Override public Type responseType() {
        return responseType;
      }


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

得出結論：serviceMethod.callAdapter.adapt(okHttpCall);

最終返回了一個ExecutorCallbackCall。

三，發送網絡請求

GithubService service = tetrofit.create(GithubService.class)

Call<List<ResponseBody>> call = service.listRpo("octocat");

執行service的xxxx方法，java動態代理幫助我們構建了一個完整的http請求。最後返回一個Call對象。

上面我們說了，動態代理執行的時候會返回一個ExecutorCallbackCall,我們來看一下它的源代碼。

static final class ExecutorCallbackCall<T> implements Call<T> {
    final Executor callbackExecutor;
    final Call<T> delegate;

    ExecutorCallbackCall(Executor callbackExecutor, Call<T> delegate) {
      this.callbackExecutor = callbackExecutor;
      this.delegate = delegate;
    }

    @Override public void enqueue(final Callback<T> callback) {
      if (callback == null) throw new NullPointerException("callback == null");

      delegate.enqueue(new Callback<T>() {
        @Override public void onResponse(Call<T> call, final Response<T> response) {
          callbackExecutor.execute(new Runnable() {
            @Override public void run() {
              if (delegate.isCanceled()) {
                // Emulate OkHttp's behavior of throwing/delivering an IOException on cancellation.
                callback.onFailure(ExecutorCallbackCall.this, new IOException("Canceled"));
              } else {
                callback.onResponse(ExecutorCallbackCall.this, response);
              }
            }
          });
        }

        @Override public void onFailure(Call<T> call, final Throwable t) {
          callbackExecutor.execute(new Runnable() {
            @Override public void run() {
              callback.onFailure(ExecutorCallbackCall.this, t);
            }
          });
        }
      });
    }

    @Override public boolean isExecuted() {
      return delegate.isExecuted();
    }

    @Override public Response<T> execute() throws IOException {
      return delegate.execute();
    }

ExecutorCallbackCall有enqueue和execute方法，但是具體裏面都是交給delegate對象去執行的。那麼這個delegate對象又是什麼呢？就是serviceMethod.callAdapter.adapt(okHttpCall)裏面的okHttpCall，一個實現了Call接口的OkHttpCall對象。看到這裏是不是有一種恍然大悟的感覺，如此我們只要研究下OkHttpCall對象就行了。

OkHttpCall對象是訪問請求的對象,默認的作用是發送一個HTTP請求,底層是使用了okhttp進行網絡通訊。從而就明白了Retrofit說到底只是對okhttp的一層層封裝而已。

privateokhttp3.Call createRawCall()throwsIOException {
  Request request =serviceMethod.toRequest(args);
  okhttp3.Call call =serviceMethod.callFactory.newCall(request);
  if(call == null) {
    throw newNullPointerException("Call.Factory returned null.");
  }
  return call;
}

OkHttpCall實現了enqueue和execute方法，這兩個方法纔是真正網絡請求發起的方法，並且通過createRawCall（）來創建請求。

execute方法是在當前線程執行，將具體執行的動作交給android的okhttp去完成，調用了okhttp3.Call.execute()函數。

相對於execute方法，enqueue方法則是將請求放到一個異步線程隊列當中。

調用okhttp3.Call.enqueue()函數。

Ps:可以參考下HttpCall裏面的execute方法

@OverridepublicResponse<T> execute() throwsIOException {
  okhttp3.Call call; 
  synchronized(this) {
    if(executed)throw newIllegalStateException("Already executed.");
    executed=true;

    if(creationFailure!=null) {
      if(creationFailureinstanceofIOException) {
        throw(IOException)creationFailure;
      }else{
        throw(RuntimeException)creationFailure;
      }
    }

    call =rawCall;
    if(call ==null) {
      try{
        call =rawCall= createRawCall();
      }catch(IOException | RuntimeException e) {
        creationFailure= e;
        throwe;
      }
    }
  }

  if(canceled) {
    call.cancel();
  }

  returnparseResponse(call.execute());
}

可以看到，最後是執行了call.execute方法。

四，支持報文解析

Retrofit還支持Gson、xml格式報文解析。比如我們想加入gson格式的解析，只需在構建的時候調用addConvertFactory方法。

Retrofit retrofit = new Retrofit.Builder().
baseUrl('https://api.github.com').
.addConvertFacotry(GsonConverterFactory.create()) //支持報文自動解析
.build
然後構建網絡請求：
final MehtodService methdoservice = retrofit.create(MehtodService.s);
發起網絡請求
	Call<Bean> call =  methdoservice.getMsg();

GsonConverterFacotry會自動解析你接受的gson格式的報文，在調用網絡請求後，轉化成爲這裏的Bean。

Bean類裏面的字段和Gson報文返回的字段應該一樣。如果字段不一樣，會在解析的時候拋出解析異常。

如果想讓你的Retrofit支持自動解析的方法，就必須先引入所需的第三方庫：

如果想要增加對xml解析器的支持：
compile(‘com.squareup.retrofit2:converter-simplexml:2.1.0’);
如果想要增加對gson格式解析器的支持：
compile 'com.squareup.retrofit2:converter-gson:2.0.2'
如果想要增加對rxjava的支持：
compile 'com.squareup.retrofit2:adapter-rxjava:2.0.2'
 也可以通過實現Converter.Factory接口來創建一個自定義的converter。addConvertFacotry裏面的操作就是往Retrofit這個類中增加Converter.Factory接口.

這個Converter對象是什麼時候創建的？首先我們在構建Retrofit的時候傳了一個GsonConverterFactory.create(),然後會在ServiceMethod的build()的時候將我們創建的Converter加入進去.關鍵代碼如下：

public ServiceMethod build() {
  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();
。。。
 }

關鍵是執行了createResponseConverter()方法，然後查看你createResponseConverter方法

private Converter<ResponseBody, T> createResponseConverter() {
  Annotation[] annotations = method.getAnnotations();
  try {
    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);
  }
}

主要執行了responseBodyConverter方法。找到responseBodyConverter方法再看一下（）。

public<T> Converter<ResponseBody, T>responseBodyConverter(Type type, Annotation[] annotations) {
  return nextResponseBodyConverter(null, type, annotations);
}

看下nextResponseBodyConverter（）這裏面的邏輯。

public <T> Converter<ResponseBody, T> nextResponseBodyConverter(Converter.Factory skipPast,
    Type type, Annotation[] annotations) {
  checkNotNull(type, "type == null");
  checkNotNull(annotations, "annotations == null");
  int start = converterFactories.indexOf(skipPast) + 1;
  for (int i = start, count = converterFactories.size(); i < count; i++) {
    Converter<ResponseBody, ?> converter =
        converterFactories.get(i).responseBodyConverter(type, annotations, this);
    if (converter != null) {
      //noinspection unchecked
      return (Converter<ResponseBody, T>) converter;
    }
  }
。。。
}

從上面的代碼可以知道，關鍵點是執行了從converterFactories當中查找到對應的factory，然後執行responseBodyConverter方法，如果這個factory是GsonConverterFactory,則執行GsonConverterFactory的responseBodyConverter方法.

如果是自定義的Converter.Factory,就是自己實現這個方法。

五,支持rxjava

Retrofit2支持了RxJava的使用。

首先需要在build.gradle當中加入

compile 'com.squareup.retrofit2:adapter-rxjava:2.0.2'

然後在Retrofit的構造時候加入對rxjava的支持

  Retrofit tetrofit = new Retrofit.Builder()
     .addCallAdapterFactory( RxJavaCallAdapterFactory.create())

好了。

那麼它裏面是怎麼實現的呢？RxJavaCallAdapterFactory裏面有個get方法，具體方法如下

@Override
public CallAdapter<?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
//..
//省略了部分源碼，
//通過getCallAdapter來獲取Adapter
 CallAdapter<Observable<?>> callAdapter = getCallAdapter(returnType, scheduler);

 return callAdapter;
}

接着看一下getCallAdapter方法

//獲取CallAdapter<Observable<?>>
private CallAdapter<Observable<?>> getCallAdapter(Type returnType, Scheduler scheduler) {
Type observableType = getParameterUpperBound(0, (ParameterizedType) returnType);
 Class<?> rawObservableType = getRawType(observableType);
  //..
 //省略了部分源碼，
 //一般會走SimpleCallAdapter
 return new SimpleCallAdapter(observableType, scheduler);
}

SimpleCallAdapter的源碼如下：

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) {
//通過Observable.create創建被觀察者
  Observable<R> observable = Observable.create(new CallOnSubscribe<>(call)) 
      .lift(OperatorMapResponseToBodyOrError.<R>instance());
  if (scheduler != null) {
    return observable.subscribeOn(scheduler);//切換到指定線程
  }
  return observable;
}
}

六,總結

Retrofit是一款熱門的網絡請求架構，拓展性非常好。理解這樣的開源框架的源碼，有助於我們擴展視野，以及更好解決在實際開發過程當中所遇到的問題。

Retrofit2 源碼分析

一．如何使用Retrofit

二．構建網絡請求

三，發送網絡請求

四，支持報文解析

五,支持rxjava

六,總結

使用neovim打造go ide(支持代碼跳轉, 代碼補全, 實時語法檢查)

挑戰程序設計競賽 2.3章習題 poj 3046 Ant Counting

Shell/Python中的用戶名獲取

react native 常用命令整理

觸摸事件分發機制的實例分析(二)

jenkins構建android項目

音視頻基礎詞彙

webview自定義緩存方案

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結