摘要：看下圖所示，摘自網(wǎng)絡(luò)的創(chuàng)建流程源碼分析實例是使用建造者模式通過類進行創(chuàng)建的。創(chuàng)建了一個含有對象實例的，并返回給源碼分析添加一個調(diào)用適配器工廠，用于支持服務(wù)方法返回類型注意生產(chǎn)的是，那么又是什么呢可以看到源代碼如下所示，它是一個接口。

1.首先回顧Retrofit簡單使用方法

2.Retrofit的創(chuàng)建流程源碼分析

2.1 Retrofit對象調(diào)用Builder()源碼解析

2.2 Retrofit對象調(diào)用baseUrl(url)源碼解析

2.3 addConverterFactory(Converter.Factory factory)源碼分析

2.4 addCallAdapterFactory(RxJava2CallAdapterFactory.create())源碼分析

2.5 client(okHttpClient)源碼分析

2.6 Retrofit對象調(diào)用build()源碼解析

3.創(chuàng)建ServiceMethod流程源碼分析

3.1 首先看看請求網(wǎng)絡(luò)代碼過程

3.2 分析create(final Class service)源碼

3.3 serviceMethod對象的創(chuàng)建過程

4.注解的解析

4.1 callAdapter的創(chuàng)建源碼分析

4.2 responseConverter的創(chuàng)建源碼分析

5.OkHttpCall的創(chuàng)建源碼分析

5.1 new OkHttpCall<>(serviceMethod, args)源碼分析

6.OkHttpCall的網(wǎng)絡(luò)請求

6.1 OkHttpCall.execute()同步請求

6.2 OkHttpCall.enqueue()異步請求

6.3 parseResponse解析網(wǎng)絡(luò)數(shù)據(jù)源碼解析

博客筆記大匯總【16年3月到至今】，包括Java基礎(chǔ)及深入知識點，Android技術(shù)博客，Python學(xué)習(xí)筆記等等，還包括平時開發(fā)中遇到的bug匯總，當(dāng)然也在工作之余收集了大量的面試題，長期更新維護并且修正，持續(xù)完善……開源的文件是markdown格式的！同時也開源了生活博客，從12年起，積累共計47篇[近20萬字]，轉(zhuǎn)載請注明出處，謝謝！

鏈接地址：https://github.com/yangchong2...

如果覺得好，可以star一下，謝謝！當(dāng)然也歡迎提出建議，萬事起于忽微，量變引起質(zhì)變！

關(guān)于Retrofit的使用，可以參考這篇文章：https://www.jianshu.com/p/989...

0.0.1 Retrofit創(chuàng)建中用了哪些設(shè)計模式，請談?wù)勈褂眠@些設(shè)計模式的優(yōu)勢？

0.0.2 Retrofit在創(chuàng)建的時候為什么要判斷是否在Android環(huán)境中，是如何做到的？

0.0.3 為什么設(shè)置baseUrl的時候，會以/結(jié)尾，如果沒有/會出現(xiàn)什么問題？

0.0.4 addConverterFactory的主要作用是什么？

0.0.5 Factory生產(chǎn)的是CallAdapter，那么CallAdapter又是什么呢？

0.0.6 網(wǎng)絡(luò)請求的類 service為什么要定義成接口？如果不定義成接口會出現(xiàn)什么情況？

0.0.7 創(chuàng)建了ServiceMethod對象是干什么用的？它是用什么進行存儲的？

0.0.8 創(chuàng)建ServiceMethod對象為什么要添加synchronized同步鎖

0.0.9 call調(diào)用enqueue異步方法中源碼是如何實現(xiàn)異步切換線程的？原理是怎樣的？

0.1.0 ServiceMethod是如何保存網(wǎng)絡(luò)請求所需要的數(shù)據(jù)，具體保存了哪些數(shù)據(jù)呢？

0.1.1 網(wǎng)絡(luò)傳輸都是二進制流，那么解析數(shù)據(jù)時，如何通過ServiceMethod使用Converter轉(zhuǎn)換成Java對象進行數(shù)據(jù)解析

//AdvertCommon是javabean實體類，并沒有序列化，那么網(wǎng)絡(luò)解析數(shù)據(jù)如何解析java對象呢？
Call getSplashImage(@Query("type") int type);

0.1.2 如下所示，為什么說apiService對象實際上是動態(tài)代理對象，而不是真正的網(wǎng)絡(luò)請求接口創(chuàng)建的對象

ApiService apiService = retrofit.create(ApiService.class);

0.1.3 如何理解動態(tài)代理的機制。retrofit是如何加載接口類ApiService的，為什么這個類要設(shè)置成接口？

Api接口

public interface DouBookApi {
    /**
    * 根據(jù)tag獲取圖書
    * @param tag  搜索關(guān)鍵字
    * @param count 一次請求的數(shù)目 最多100

    */
    @GET("v2/book/search")
    Observable getBook(@Query("tag") String tag,
                                    @Query("start") int start,
                                    @Query("count") int count);
}
```

Model類

public class DouBookModel {

    private static DouBookModel bookModel;
    private DouBookApi mApiService;

    public DouBookModel(Context context) {
        mApiService = RetrofitWrapper
                .getInstance(ConstantALiYunApi.API_DOUBAN)   //baseUrl地址
                .create(DouBookApi.class);
    }

    public static DouBookModel getInstance(Context context){
        if(bookModel == null) {
            bookModel = new DouBookModel(context);
        }
        return bookModel;
    }

    public Observable getHotMovie(String tag, int start , int count) {
        Observable book = mApiService.getBook(tag, start, count);
        return book;
    }
}

抽取類

public class RetrofitWrapper {

    private static RetrofitWrapper instance;
    private Retrofit mRetrofit;

    public RetrofitWrapper(String url) {
        OkHttpClient.Builder builder = new OkHttpClient.Builder();

        //打印日志
        HttpLoggingInterceptor logging = new HttpLoggingInterceptor();
        logging.setLevel(HttpLoggingInterceptor.Level.BODY);
        builder.addInterceptor(logging).build();
        OkHttpClient client = builder.addInterceptor(new LogInterceptor("HTTP")).build();

        //解析json
        Gson gson = new GsonBuilder()
                .setLenient()
                .create();
        
        mRetrofit = new Retrofit
                .Builder()
                .baseUrl(url)
                .addConverterFactory(GsonConverterFactory.create(gson))
                .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                .client(client)
                .build();
    }

    public  static RetrofitWrapper getInstance(String url){
        //synchronized 避免同時調(diào)用多個接口，導(dǎo)致線程并發(fā)
        synchronized (RetrofitWrapper.class){
            instance = new RetrofitWrapper(url);
        }
        return instance;
    }

    public  T create(final Class service) {
        return mRetrofit.create(service);
    }
}

使用

DouBookModel model = DouBookModel.getInstance(activity);
model.getHotMovie(mType,start,count)
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Subscriber() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(DouBookBean bookBean) {

            }
        });

針對Retrofit，需要注意

Retrofit 是一個 RESTful 的 HTTP 網(wǎng)絡(luò)請求框架的封裝。網(wǎng)絡(luò)請求的工作本質(zhì)上是 OkHttp 完成，而 Retrofit 僅負(fù)責(zé) 網(wǎng)絡(luò)請求接口的封裝?？聪聢D所示，摘自網(wǎng)絡(luò)

Retrofit實例是使用建造者模式通過Builder類進行創(chuàng)建的。Builder模式的優(yōu)勢：將一個復(fù)雜對象的構(gòu)建與表示分離，使得用戶在不知道對象的創(chuàng)建細(xì)節(jié)情況下就可以直接創(chuàng)建復(fù)雜的對象。

針對builder設(shè)計模式，可以參考我的這篇博客：https://blog.csdn.net/m0_3770...

關(guān)于使用builder模式寫代碼的案例，可以參考我的彈窗封裝lib：https://github.com/yangchong2...

首先看看里面的源代碼，如下所示

可以看到Platform.get()獲取的是單利對象。那么也許你會問，這個方法的作用主要是什么呢？通過Class.forName獲取類名的方式，來判斷當(dāng)前的環(huán)境是否在Android中，這在之后獲取默認(rèn)的CallAdapterFactory時候?qū)玫健Ｏ旅嫖視治龅健?/p>

關(guān)于單利設(shè)計模式，如果還有疑問，或者想知道所有的獲取單利的方法，可以參考我的這篇博客：設(shè)計模式之一：單例模式

//第一步
public Builder() {
  this(Platform.get());
}


//第二步，追蹤到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) {
    //此處表示：如果是Android平臺，就創(chuàng)建并返回一個Android對象
    return new Android();
  }
} catch (ClassNotFoundException ignored) {
}
try {
  Class.forName("java.util.Optional");
  return new Java8();
} catch (ClassNotFoundException ignored) {
}
return new Platform();
}

然后看一下new Android()是做了什么？

static class Android extends Platform {
    @Override public Executor defaultCallbackExecutor() {
        // 返回一個默認(rèn)的回調(diào)方法執(zhí)行器
        // 該執(zhí)行器作用：切換線程（子->>主線程），并在主線程（UI線程）中執(zhí)行回調(diào)方法
      return new MainThreadExecutor();
    }
    
    @Override CallAdapter.Factory defaultCallAdapterFactory(@Nullable Executor callbackExecutor) {
      if (callbackExecutor == null) throw new AssertionError();
       // 創(chuàng)建默認(rèn)的網(wǎng)絡(luò)請求適配器工廠 
       // 該默認(rèn)工廠生產(chǎn)的 adapter 會使得Call在異步調(diào)用時在指定的 Executor 上執(zhí)行回調(diào) 
       // 采用了策略模式
      return new ExecutorCallAdapterFactory(callbackExecutor);
    }
    
    static class MainThreadExecutor implements Executor {
    // 獲取與Android 主線程綁定的Handler 
      private final Handler handler = new Handler(Looper.getMainLooper());
    
      @Override public void execute(Runnable r) {
       // 該Handler是上面獲取的與Android 主線程綁定的Handler 
        // 在UI線程進行對網(wǎng)絡(luò)請求返回數(shù)據(jù)處理等操作。
        handler.post(r);
      }
    }
}

都知道這個方法主要是設(shè)置baseUrl。源碼如下所示

首先先對baseUrl進行非空判斷。然后再解析baseUrl，如果解析的httpUrl為null，則會拋出IllegalArgumentException非法參數(shù)異常。那么思考一下，什么情況下解析baseUrl會導(dǎo)致解析內(nèi)容httpUrl為null呢？

public Builder baseUrl(String baseUrl) {
  checkNotNull(baseUrl, "baseUrl == null");
  HttpUrl httpUrl = HttpUrl.parse(baseUrl);
  if (httpUrl == null) {
    throw new IllegalArgumentException("Illegal URL: " + baseUrl);
  }
  return baseUrl(httpUrl);
}

HttpUrl是如何解析url，對url有什么條件，來看一下parse方法源碼

可以看到url必須是以http或者h(yuǎn)ttps才可以。如果隨便寫一個url，則會出問題

public static @Nullable HttpUrl parse(String url) {
    Builder builder = new Builder();
    Builder.ParseResult result = builder.parse(null, url);
    return result == Builder.ParseResult.SUCCESS ? builder.build() : null;
}

ParseResult parse(@Nullable HttpUrl base, String input) {
  int pos = skipLeadingAsciiWhitespace(input, 0, input.length());
  int limit = skipTrailingAsciiWhitespace(input, pos, input.length());

  // Scheme.
  int schemeDelimiterOffset = schemeDelimiterOffset(input, pos, limit);
  if (schemeDelimiterOffset != -1) {
    if (input.regionMatches(true, pos, "https:", 0, 6)) {
      this.scheme = "https";
      pos += "https:".length();
    } else if (input.regionMatches(true, pos, "http:", 0, 5)) {
      this.scheme = "http";
      pos += "http:".length();
    } else {
      return ParseResult.UNSUPPORTED_SCHEME; // Not an HTTP scheme.
    }
  } else if (base != null) {
    this.scheme = base.scheme;
  } else {
    return ParseResult.MISSING_SCHEME; // No scheme.
  }
  
  //下面代碼省略了

思考一下，傳遞的url為什么是String BASE_URL = "http://beta.goldenalpha.com.cn/"這個格式呢？接著看看baseUrl(httpUrl)源碼

可以看到這里的url地址必須是以/結(jié)尾。所以如果是沒有加上/，則會出現(xiàn)異常

public Builder baseUrl(HttpUrl baseUrl) {
  checkNotNull(baseUrl, "baseUrl == null");
  List pathSegments = baseUrl.pathSegments();
  if (!"".equals(pathSegments.get(pathSegments.size() - 1))) {
    throw new IllegalArgumentException("baseUrl must end in /: " + baseUrl);
  }
  this.baseUrl = baseUrl;
  return this;
}

其實個人感覺這塊工作并不難，只要有點英文基礎(chǔ)的，就可以完全看的明白。接著往下分析，如果想了解更多，歡迎看我的博客匯總：https://github.com/yangchong2...

在創(chuàng)建的時候會調(diào)用addConverterFactory(GsonConverterFactory.create(JsonUtils.getJson()))添加Gson轉(zhuǎn)換器

這個方法主要是添加用于對象序列化和反序列化的轉(zhuǎn)換器工廠

將上面創(chuàng)建的GsonConverterFactory放入到 converterFactories數(shù)組

.addConverterFactory(GsonConverterFactory.create(JsonUtils.getGson()))

//看這行代碼
public Builder addConverterFactory(Converter.Factory factory) {
    //將上面創(chuàng)建的GsonConverterFactory放入到 converterFactories數(shù)組
  converterFactories.add(checkNotNull(factory, "factory == null"));
  return this;
}

然后看看GsonConverterFactory.creat()方法源碼

使用{@code gson}創(chuàng)建一個實例以進行轉(zhuǎn)換。編碼到JSON并從JSON解碼(當(dāng)沒有由頭指定字符集時)將使用UTF-8。

創(chuàng)建了一個含有Gson對象實例的GsonConverterFactory，并返回給addConverterFactory（）

public static GsonConverterFactory create(Gson gson) {
    if (gson == null) throw new NullPointerException("gson == null");
    return new GsonConverterFactory(gson);
}

添加一個調(diào)用適配器工廠，用于支持服務(wù)方法返回類型

public Builder addCallAdapterFactory(CallAdapter.Factory factory) {
  callAdapterFactories.add(checkNotNull(factory, "factory == null"));
  return this;
}

CallAdapterFactory：注意Factory生產(chǎn)的是CallAdapter，那么CallAdapter又是什么呢？

可以看到CallAdapter源代碼如下所示，它是一個接口。主要作用是：將響應(yīng)類型{@代碼R}的{@鏈接調(diào)用}改編為{@代碼T}的類型。實例由{@LinkplanFactory(一個工廠)創(chuàng)建，該工廠}是{@Link平原Retrofit.Builder#addCallAdapterFactory(Factory)已安裝}到{@LinkRetroflit}實例中。

網(wǎng)絡(luò)請求執(zhí)行器（Call）的適配器，并且在Retrofit中提供了三種CallAdapterFactory： ExecutorCallAdapterFactory（默認(rèn)）、DefaultCallAdapterFactory、RxJava2CallAdapterFactory

public interface CallAdapter {
  Type responseType();
  T adapt(Call call);
  abstract class Factory {
    public abstract @Nullable CallAdapter get(Type returnType, Annotation[] annotations,
        Retrofit retrofit);
    protected static Type getParameterUpperBound(int index, ParameterizedType type) {
      return Utils.getParameterUpperBound(index, type);
    }
    protected static Class getRawType(Type type) {
      return Utils.getRawType(type);
    }
  }
}

接著，有伙伴可能會問它的作用是什么呢？

將默認(rèn)的網(wǎng)絡(luò)請求執(zhí)行器（OkHttpCall）轉(zhuǎn)換成適合被不同平臺來調(diào)用的網(wǎng)絡(luò)請求執(zhí)行器形式

一開始Retrofit只打算利用OkHttpCall通過ExecutorCallbackCall切換線程；但后來發(fā)現(xiàn)使用Rxjava更加方便（不需要Handler來切換線程）。想要實現(xiàn)Rxjava的情況，那就得使用RxJavaCallAdapterFactoryCallAdapter將OkHttpCall轉(zhuǎn)換成Rxjava(Scheduler)

.addCallAdapterFactory(RxJava2CallAdapterFactory.create())

用于請求的HTTP客戶端

指定用于創(chuàng)建{@link Call}實例的自定義調(diào)用工廠。

public Builder client(OkHttpClient client) {
  return callFactory(checkNotNull(client, "client == null"));
}

public Builder callFactory(okhttp3.Call.Factory factory) {
  this.callFactory = checkNotNull(factory, "factory == null");
  return this;
}

看看源碼

大概的流程就是創(chuàng)建適配器的防御性副本，并添加默認(rèn)調(diào)用適配器。然后復(fù)制轉(zhuǎn)換器的防御性副本，在然后添加內(nèi)置的轉(zhuǎn)化工廠.這可以防止重寫其行為，但也可以確保在使用消耗所有類型的轉(zhuǎn)換器時的正確行為。

通過前面步驟設(shè)置的變量，將Retrofit類的所有成員變量都配置完畢。就成功創(chuàng)建了對象！

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 callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
  callAdapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));

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

  // 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());
  converterFactories.addAll(this.converterFactories);

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

然后看看Retrofit的構(gòu)造方法

成功建立一個Retrofit對象的標(biāo)準(zhǔn)：配置好Retrofit類里的成員變量，即配置好：

serviceMethod：包含所有網(wǎng)絡(luò)請求信息的對象

baseUrl：網(wǎng)絡(luò)請求的url地址

callFactory：網(wǎng)絡(luò)請求工廠

adapterFactories：網(wǎng)絡(luò)請求適配器工廠的集合

converterFactories：數(shù)據(jù)轉(zhuǎn)換器工廠的集合

callbackExecutor：回調(diào)方法執(zhí)行器

Retrofit(okhttp3.Call.Factory callFactory, HttpUrl baseUrl,
  List converterFactories, List callAdapterFactories,
  @Nullable Executor callbackExecutor, boolean validateEagerly) {
    this.callFactory = callFactory;
    this.baseUrl = baseUrl;
    this.converterFactories = converterFactories; // Copy+unmodifiable at call site.
    this.callAdapterFactories = callAdapterFactories; // Copy+unmodifiable at call site.
    this.callbackExecutor = callbackExecutor;
    this.validateEagerly = validateEagerly;
}

然后總結(jié)一下創(chuàng)建的過程

平臺類型對象（Platform - Android）

網(wǎng)絡(luò)請求的url地址（baseUrl）

網(wǎng)絡(luò)請求工廠（callFactory） 默認(rèn)使用OkHttpCall

網(wǎng)絡(luò)請求適配器工廠的集合（adapterFactories） 本質(zhì)是配置了網(wǎng)絡(luò)請求適配器工廠- 默認(rèn)是ExecutorCallAdapterFactory

數(shù)據(jù)轉(zhuǎn)換器工廠的集合（converterFactories） 本質(zhì)是配置了數(shù)據(jù)轉(zhuǎn)換器工廠

回調(diào)方法執(zhí)行器（callbackExecutor） 默認(rèn)回調(diào)方法執(zhí)行器作用是：切換線程（子線程 - 主線程）

大概的流程如下代碼所示

定義網(wǎng)絡(luò)請求的接口類 ApiService

public interface ApiService {
    @POST("api/v1/user/old")
    Call> isUserOld();
}

//創(chuàng)建接口類實例
ApiService apiService = retrofit.create(ApiService.class);
//生成最終的網(wǎng)絡(luò)請求對象
Call> userOld = apiService.isUserOld();
//異步機制
userOld.enqueue(new Callback>() {
    @Override
    public void onResponse(Call> call, retrofit2.Response> response) {
        
    }
    @Override
    public void onFailure(Call> call, Throwable t) {

    }
});

源代碼如下所示，這段代碼很重要。

創(chuàng)建接口定義的API端點的實現(xiàn)。給定方法的相對路徑是從描述請求類型的方法的注釋中獲得的。

先對service類進行判斷是否是接口。這個時候你就知道為何只能定義service為接口呢……

接著就創(chuàng)建了ServiceMethod對象，并且把這個對象以鍵的形式存儲到ConcurrentHashMap集合中

最后創(chuàng)建了網(wǎng)絡(luò)請求接口的動態(tài)代理對象，通過代理模式中的動態(tài)代理模式，動態(tài)生成網(wǎng)絡(luò)請求接口的代理類，并將代理類的實例創(chuàng)建交給InvocationHandler類 作為具體的實現(xiàn)，并最終返回一個動態(tài)代理對象。

service.getClassLoader()作用是動態(tài)生成接口的實現(xiàn)類

new Class[] { service }作用是動態(tài)創(chuàng)建實例

new InvocationHandler()作用是將代理類的實現(xiàn)交給 InvocationHandler類作為具體的實現(xiàn)

即通過動態(tài)生成的代理類，調(diào)用interfaces接口的方法實際上是通過調(diào)用InvocationHandler對象的invoke方法來完成指定的功能

public  T create(final Class 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);
        }
        
        //讀取網(wǎng)絡(luò)請求接口里的方法，并根據(jù)前面配置好的屬性配置serviceMethod對象
        ServiceMethod serviceMethod =
            (ServiceMethod) loadServiceMethod(method);
        //根據(jù)配置好的serviceMethod對象創(chuàng)建okHttpCall對象 
        OkHttpCall