retrofit有幾個關鍵的地方.
1.用戶自定義的接口和接口方法.(由動態代理創建對象.)
2.converter轉換器.(把response轉換為一個具體的對象)
3.注解的使用.
讓我們跟隨Api來看吧.
RestAdapter restAdapter = new RestAdapter.Builder().setEndpoint(API_URL).build();
build()其內部實現是這樣的:
[代碼]java代碼：
|
1
2
3
4
5
6
7
8
|
public
RestAdapter build() {
if
(endpoint ==
null
) {
throw
new
IllegalArgumentException(
"Endpoint may not be null."
);
}
ensureSaneDefaults();
return
new
RestAdapter(endpoint, clientProvider, httpExecutor, callbackExecutor,
requestInterceptor, converter, profiler, errorHandler, log, logLevel);
}
|
當用戶沒有設置自定義的converter,client, httpExecutor(http訪問執行的線程–>只對異步的retrofit有效.), callBackExecutor(異步的callBack執行的線程), errorHandler, log, RequestInterceptor的時候,就會使用retrofit默認的配置.調用 ensureSaneDefaults();
[代碼]java代碼：
|
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
private
void
ensureSaneDefaults() {
if
(converter ==
null
) {
converter = Platform.get().defaultConverter();
}
if
(clientProvider ==
null
) {
clientProvider = Platform.get().defaultClient();
}
if
(httpExecutor ==
null
) {
httpExecutor = Platform.get().defaultHttpExecutor();
}
if
(callbackExecutor ==
null
) {
callbackExecutor = Platform.get().defaultCallbackExecutor();
}
if
(errorHandler ==
null
) {
errorHandler = ErrorHandler.DEFAULT;
}
if
(log ==
null
) {
log = Platform.get().defaultLog();
}
if
(requestInterceptor ==
null
) {
requestInterceptor = RequestInterceptor.NONE;
}
}
}
|
可以看到進行初始化的時候調用了Platform.get()。
[代碼]java代碼：
|
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
|
private
static
final
Platform PLATFORM = findPlatform();
static
Platform get() {
return
PLATFORM;
}
private
static
Platform findPlatform() {
try
{
Class.forName(
"android.os.Build"
);
//只要android.os.Build的class可以正常找到,證明是在android平台
if
(Build.VERSION.SDK_INT !=
0
) {
return
new
Android();
}
}
catch
(ClassNotFoundException ignored) {
}
if
(System.getProperty(
"com.google.appengine.runtime.version"
) !=
null
) {
return
new
AppEngine();
//google的app Engine平台
}
return
new
Base();
}
|
使用了單例的PLATFORM，通過findPlatform()初始化實例， 由於retrofit支持不同的平台，Platform用於判斷使用的是哪個平台，如果是Android平台就使用Platform.Android，retrofit的Android類繼承了Platform, 根據android的特性對配置項做了處理.如果是Google AppEngine就使用Platform.AppEngine，否則使用Platform.Base，這些都是Platform的子類，其中AppEngine又是Base的子類。 Platform是一個抽象類，定義了以下幾個抽象方法，這幾個方法的作用就是返回一些RestAdapter中需要要用到成員的默認實現
[代碼]java代碼：
|
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
|
private
static
class
Android
extends
Platform {
@Override
Converter defaultConverter() {
return
new
GsonConverter(
new
Gson());
//默認的轉換器是Gson
}
@Override
Client.Provider defaultClient() {
final
Client client;
if
(hasOkHttpOnClasspath()) {
//有okhttp的路徑就使用 Okhttp
client = OkClientInstantiator.instantiate();
}
else
if
(Build.VERSION.SDK_INT < Build.VERSION_CODES.GINGERBREAD) {
client =
new
AndroidApacheClient();
//沒有okhttp,且版本小於2.3 使用HttpClient
}
else
{
client =
new
UrlConnectionClient();
//沒有okhttp,且版本大於等於2.3 使用urlConnection.
}
return
new
Client.Provider() {
@Override
public
Client get() {
return
client;
}
};
}
@Override
Executor defaultHttpExecutor() {
//網絡訪問執行的線程.
return
Executors.newCachedThreadPool(
new
ThreadFactory() {
//一個cached的線程池.可以復用老線程且線程長時間不用會自動回收. 線程池中線程不夠會生成新線程.
@Override
public
Thread newThread(
final
Runnable r) {
return
new
Thread(
new
Runnable() {
@Override
public
void
run() {
Process.setThreadPriority(THREAD_PRIORITY_BACKGROUND);
//設置線程的優先級 為最低
r.run();
}
}, RestAdapter.IDLE_THREAD_NAME);
}
});
}
@Override
Executor defaultCallbackExecutor() {
//異步執行的線程.
return
new
MainThreadExecutor();
}
@Override
RestAdapter.Log defaultLog() {
//通過Log.d("Retrofit",String)打印log
return
new
AndroidLog(
"Retrofit"
);
}
}
|
其中判斷了是否有okHttp的路徑
[代碼]java代碼：
|
1
2
3
4
5
6
7
8
|
private
static
boolean
hasOkHttpOnClasspath() {
try
{
Class.forName(
"com.squareup.okhttp.OkHttpClient"
);
//是否可以找到OkHttpClient類.
return
true
;
}
catch
(ClassNotFoundException ignored) {
}
return
false
;
}
|
可以發現上面默認的Http的Executor是一個線程池.
而CallBack的Executor是在主線程執行的. 由綁定MainLooper的Handler提交到主線程執行.
[代碼]java代碼：
|
1
2
3
4
5
6
|
public
final
class
MainThreadExecutor
implements
Executor {
private
final
Handler handler =
new
Handler(Looper.getMainLooper());
//關聯主線程的Handler
@Override
public
void
execute(Runnable r) {
handler.post(r);
//提交到主線程執行
}
}
|
[代碼]java代碼：
|
1
2
3
4
|
public
final
boolean
post(Runnable r)
{
return
sendMessageDelayed(getPostMessage(r),
0
);
}
|
[代碼]java代碼：
|
1
2
3
4
5
|
private
static
Message getPostMessage(Runnable r) {
//把runnable封裝到Message中.
Message m = Message.obtain();
m.callback = r;
return
m;
}
|
現在有下面一個接口,
[代碼]java代碼：
|
1
2
3
4
|
interface
SimplePOST{
@POST
(
"/android"
)
Response getResponse();
}
|
下面了解下 SimplePOST simplePost= adapter.create(SimplePOST.class)的內部邏輯.
[代碼]java代碼：
|
1
2
3
4
5
|
public
<t> T create(Class<t> service) {
Utils.validateServiceClass(service);
return
(T) Proxy.newProxyInstance(service.getClassLoader(),
new
Class<!--?-->[] { service },
//動態代理
new
RestHandler(getMethodInfoCache(service)));
}</t></t>
|
[代碼]java代碼：
|
1
2
3
4
5
6
7
8
|
static
<t>
void
validateServiceClass(Class<t> service) {
//確保create()參數是一個接口類型,且這個接口沒有繼承其他的接口.(使用動態代理的前提)
if
(!service.isInterface()) {
throw
new
IllegalArgumentException(
"Only interface endpoint definitions are supported."
);
}
if
(service.getInterfaces().length >
0
) {
throw
new
IllegalArgumentException(
"Interface definitions must not extend other interfaces."
);
}
}</t></t>
|
可以發現adapter.create()方法的內部實現是利用動態代理生成了service接口的一個實現類. 根據動態代理的原理. 可以得知調用實現類的方法其實就是調用InvocationtHandler的對應方法. 雖然這里是運用了動態代理的技術.但是卻和一般的動態代理不一樣. 一般的動態代理的InvocationHandler應該通過構造函數中傳入委托類A.然后在invoke方法中調用A的方法, 但這里是沒有委托類的.只是利用動態代理自動生成接口的實現類.
因為java的動態代理是基於接口的,所以retrofit也要求用戶自定義的也必須是一個接口.
注意invocationHandler的invoke()方法執行是在我們調用接口的方法的時候執行的.對於上面的代碼就simplepost.getResponse()執行的時候.
所以上面的代碼先對傳入的Class 進行校驗：Utils.validateServiceClass(service)，必須是接口，並且不能是一個沒有自己函數並繼承自其他父接口的空接口。 校驗完成后返回一個動態代理類，我們想要知道retrofit使用用戶自定義的接口干了什么事，就需要查看new RestHandler(getMethodInfoCache(service)) 的具體實現。
RestHandler 繼承自 InvocationHandler 實現它的 invoke 函數，當代理類的接口函數被調用時，會先調用代理類的invoke 函數，然后在invoke 函數里通過反射調用用戶指定的接口函數。
查看invoke 函數的具體實現之間，我們先分析分析getMethodInfoCache(service)函數。
下面是getMethodInfoCache函數的實現部分
[代碼]java代碼：
|
01
02
03
04
05
06
07
08
09
10
|
Map<method, restmethodinfo=
""
> getMethodInfoCache(Class<!--?--> service) {
synchronized
(serviceMethodInfoCache) {
Map<method, restmethodinfo=
""
> methodInfoCache = serviceMethodInfoCache.get(service);
if
(methodInfoCache ==
null
) {
methodInfoCache =
new
LinkedHashMap<method, restmethodinfo=
""
>();
serviceMethodInfoCache.put(service, methodInfoCache);
}
return
methodInfoCache;
}
}</method,></method,></method,>
|
該函數使用了同步代碼塊 synchronized 以serviceMethodInfoCache為對象鎖，防止其他線程在該函數執行的時候入侵，之后在serviceMethodInfoCache查詢service是否在其中存在，如果不存在，就新new 一個LinkedHashMap<Method, RestMethodInfo>加入其中，RestMethodInfo是一個final 類型的class，下面是它的申明
[代碼]java代碼：
|
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
|
/** Request metadata about a service interface declaration. */
final
class
RestMethodInfo {
final
Method method;
boolean
loaded =
false
;
//方法是否已經load過(解析過)
// Method-level details
final
ResponseType responseType;
final
boolean
isSynchronous;
//方法是同步還是異步.
final
boolean
isObservable;
Type responseObjectType;
RequestType requestType = RequestType.SIMPLE;
String requestMethod;
boolean
requestHasBody;
String requestUrl;
Set<string> requestUrlParamNames;
String requestQuery;
List<retrofit.client.header> headers;
String contentTypeHeader;
boolean
isStreaming;
private
enum
ResponseType {
//方法的返回值是什么類型
VOID,
//void代表沒有返回值,-->異步的方式
OBSERVABLE,
//rxjava
OBJECT
//方法的返回值是對象--->同步的方式
}
RestMethodInfo(Method method) {
this
.method = method;
responseType = parseResponseType();
isSynchronous = (responseType == ResponseType.OBJECT);
isObservable = (responseType == ResponseType.OBSERVABLE);
}
private
ResponseType parseResponseType() {
// Synchronous methods have a non-void return type. //同步的方法有一個非void的返回值
// Observable methods have a return type of Observable. //Observable的方法 返回值類型應該是Observable
Type returnType = method.getGenericReturnType();
// Asynchronous methods should have a Callback type as the last argument. //異步的方法最后一個方法的參數類型應該是Callback.
Type lastArgType = nul
Class<!--?--> lastArgClass =
null
;
Type[] parameterTypes = method.getGenericParameterTypes();
if
(parameterTypes.length >
0
) {
Type typeToCheck = parameterTypes[parameterTypes.length -
1
];
lastArgType = typeToCheck;
if
(typeToCheck
instanceof
ParameterizedType) {
typeToCheck = ((ParameterizedType) typeToCheck).getRawType();
}
if
(typeToCheck
instanceof
Class) {
lastArgClass = (Class<!--?-->) typeToCheck;
}
}
boolean
hasReturnType = returnType !=
void
.
class
;
boolean
hasCallback = lastArgClass !=
null
&& Callback.
class
.isAssignableFrom(lastArgClass);
//如果有CallBack, CallBack只能是最后一個參數.
// Check for invalid configurations.
if
(hasReturnType && hasCallback) {
//返回值是非void類型和方法有CallBack參數有且只能有一個滿足.
throw
methodError(
"Must have return type or Callback as last argument, not both."
);
}
if
(!hasReturnType && !hasCallback) {
throw
methodError(
"Must have either a return type or Callback as last argument."
);
}
if
(hasReturnType) {
if
(Platform.HAS_RX_JAVA) {
Class rawReturnType = Types.getRawType(returnType);
if
(RxSupport.isObservable(rawReturnType)) {
returnType = RxSupport.getObservableType(returnType, rawReturnType);
responseObjectType = getParameterUpperBound((ParameterizedType) returnType);
return
ResponseType.OBSERVABLE;
}
}
responseObjectType = returnType;
return
ResponseType.OBJECT;
}
lastArgType = Types.getSupertype(lastArgType, Types.getRawType(lastArgType), Callback.
class
);
if
(lastArgType
instanceof
ParameterizedType) {
responseObjectType = getParameterUpperBound((ParameterizedType) lastArgType);
return
ResponseType.VOID;
}
throw
methodError(
"Last parameter must be of type Callback<x> or Callback<!--? super X-->."
);
}
private
void
parsePath(String path) {
//解析路徑 如GET(string),注意這里會對string進行判斷,必須以"/"開頭. 所以不能是空字符串,如""
...........
}
List<retrofit.client.header> parseHeaders(String[] headers) {
//解析Headers注解.
.....
}
private
void
parseParameters() {
//解析方法參數,如方法參數的@Header, @Query等.
.......
}
private
void
parseMethodAnnotations() {
//解析http方式.如GET(),POST()
.......
}
}</retrofit.client.header></x></retrofit.client.header></string>
|
從RestMethodInfo類的注釋來看，它和用戶自定義的接口有密切的關系，也就是說，用戶接口中定義的函數，由該類來解析說明和發出請求。
之后就將methodDetailsCache（LinkedHashMap<Method, RestMethodInfo>類型）傳入到RestHandler類的構造方法當中，為其的同名屬性完成賦值的同時返回該類的實例。接下來我們就開始分析RestHandler中的invoke 函數，這可以說是retrofit的精髓所在。
[代碼]java代碼：
|
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
021
022
023
024
025
026
027
028
029
030
031
032
033
034
035
036
037
038
039
040
041
042
043
044
045
046
047
048
049
050
051
052
053
054
055
056
057
058
059
060
061
062
063
064
065
066
067
068
069
070
071
072
073
074
075
076
077
078
079
080
081
082
083
084
085
086
087
088
089
090
091
092
093
094
095
096
097
098
099
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
|
private
class
RestHandler
implements
InvocationHandler {
private
final
Map<method, restmethodinfo=
""
> methodDetailsCache;
RestHandler(Map<method, restmethodinfo=
""
> methodDetailsCache) {
//一般的動態代理.InvocationHandler構造函數一般要傳入委托類.
this
.methodDetailsCache = methodDetailsCache;
}
@SuppressWarnings
(
"unchecked"
)
//
@Override
public
Object invoke(Object proxy, Method method,
final
Object[] args)
//動態代理的方法實現.調用委托類的方法,最終會調用invoke方法.
throws
Throwable {
// If the method is a method from Object then defer to normal invocation.
if
(method.getDeclaringClass() == Object.
class
) {
//因為接口默認也繼承Object.所以接口也有Object中的方法的. 如繼承自Object如equals()方法
return
method.invoke(
this
, args);
//這里需要注意下,這里調用的是invocationHandler(H)的方法.一般的動態代理這里應該是調用委托類(A)的方法.
}
// Load or create the details cache for the current method.
final
RestMethodInfo methodInfo = getMethodInfo(methodDetailsCache, method);
//把method和RestMethodInfo緩存起來.防止重復解析method.(把方法的注解,返回值,同步異步等信息都解析出來儲存在RestMethodInfo中.)
if
(methodInfo.isSynchronous) {
//同步的方式.
try
{
return
invokeRequest(requestInterceptor, methodInfo, args);
//核心方法(網絡訪問). //可以看到retrofit的synchronous類型方法並不是子線程執行的. 所以在Android平台使用同步方式的retrofit的話要在子線程中.
}
catch
(RetrofitError error) {
Throwable newError = errorHandler.handleError(error);
if
(newError ==
null
) {
throw
new
IllegalStateException(
"Error handler returned null for wrapped exception."
,
//自定義的ErrorHandler的hanleError()方法不能return null.
error);
}
throw
newError;
//注意,同步的方式,當遇到錯誤的時候,會拋出一個RuntimeException.在Android下盡量不要使用同步的方式(因為RuntimeException是不提示用戶主動捕捉的).
}
}
if
(httpExecutor ==
null
|| callbackExecutor ==
null
) {
throw
new
IllegalStateException(
"Asynchronous invocation requires calling setExecutors."
);
}
if
(methodInfo.isObservable) {
//rx的方式
if
(rxSupport ==
null
) {
if
(Platform.HAS_RX_JAVA) {
rxSupport =
new
RxSupport(httpExecutor, errorHandler, requestInterceptor);
}
else
{
throw
new
IllegalStateException(
"Observable method found but no RxJava on classpath."
);
}
}
return
rxSupport.createRequestObservable(
new
RxSupport.Invoker() {
@Override
public
ResponseWrapper invoke(RequestInterceptor requestInterceptor) {
return
(ResponseWrapper) invokeRequest(requestInterceptor, methodInfo, args);
}
});
}
//同步, Observable方式都不是的話,肯定是異步的方式了.
// Apply the interceptor synchronously, recording the interception so we can replay it later.
// This way we still defer argument serialization to the background thread.
final
RequestInterceptorTape interceptorTape =
new
RequestInterceptorTape();
requestInterceptor.intercept(interceptorTape);
Callback<!--?--> callback = (Callback<!--?-->) args[args.length -
1
];
httpExecutor.execute(
new
CallbackRunnable(callback, callbackExecutor, errorHandler) {
//可以看到在Android上異步方式是通過HttpExecutor執行的.是默認子線程執行的. 所以異步方式的retrofit不需要在子線程中執行.
@Override
public
ResponseWrapper obtainResponse() {
return
(ResponseWrapper) invokeRequest(interceptorTape, methodInfo, args);
}
});
return
null
;
// Asynchronous methods should have return type of void.
}
/**
* Execute an HTTP request.
*
* @return HTTP response object of specified {@code type} or {@code null}.
* @throws RetrofitError if any error occurs during the HTTP request.
*/
private
Object invokeRequest(RequestInterceptor requestInterceptor, RestMethodInfo methodInfo,
Object[] args) {
String url =
null
;
try
{
methodInfo.init();
// Ensure all relevant method information has been loaded. --->保證method的參數,返回值,注解都解析完成. 可以得到網絡訪問的url,header,query,訪問方式等信息.
String serverUrl = server.getUrl();
RequestBuilder requestBuilder =
new
RequestBuilder(serverUrl, methodInfo, converter);
requestBuilder.setArguments(args);
requestInterceptor.intercept(requestBuilder);
//在網絡訪問之前,執行攔截器的方法. 保證攔截器是最后起作用的.
Request request = requestBuilder.build();
url = request.getUrl();
if
(!methodInfo.isSynchronous) {
// If we are executing asynchronously then update the current thread with a useful name.
int
substrEnd = url.indexOf(
"?"
, serverUrl.length());
if
(substrEnd == -
1
) {
substrEnd = url.length();
}
Thread.currentThread().setName(THREAD_PREFIX
+ url.substring(serverUrl.length(), substrEnd));
}
if
(logLevel.log()) {
// Log the request data.
request = logAndReplaceRequest(
"HTTP"
, request, args);
}
Object profilerObject =
null
;
if
(profiler !=
null
) {
profilerObject = profiler.beforeCall();
}
long
start = System.nanoTime();
Response response = clientProvider.get().execute(request);
//調用okHttp或者其他Client進行網絡訪問.並把返回的數據封裝進retrofit的Response中.
long
elapsedTime = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start);
int
statusCode = response.getStatus();
//返回碼
if
(profiler !=
null
) {
RequestInformation requestInfo = getRequestInfo(serverUrl, methodInfo, request);
//noinspection unchecked
profiler.afterCall(requestInfo, elapsedTime, statusCode, profilerObject);
}
if
(logLevel.log()) {
// Log the response data.
response = logAndReplaceResponse(url, response, elapsedTime);
}
Type type = methodInfo.responseObjectType;
if
(statusCode >=
200
&& statusCode <
300
) {
// 2XX == successful request //返回碼在200到300之間認為是一次成功的網絡訪問.
// Caller requested the raw Response object directly.
if
(type.equals(Response.
class
)) {
//如果方法的返回值類型(封裝在responseObjectType)是retrofit的Response的話. 那就不用converter轉換.
if
(!methodInfo.isStreaming) {
// Read the entire stream and replace with one backed by a byte[].
response = Utils.readBodyToBytesIfNecessary(response);
}
if
(methodInfo.isSynchronous) {
//同步方式
return
response;
}
return
new
ResponseWrapper(response, response);
//異步的時候返回的是這個.
}
TypedInput body = response.getBody();
if
(body ==
null
) {
if
(methodInfo.isSynchronous) {
//① 結合下面的② ,返回值類型不同是因為invokeRequest()分別由2個不同的方法調用. ①是由 invoke()調用的.
return
null
;
}
return
new
ResponseWrapper(response,
null
);
//② 的情況是異步的. 是由callBack模式中的obtainResponse()中調用的. 下面和上面的返回值類型不同的情況皆是如此
}
ExceptionCatchingTypedInput wrapped =
new
ExceptionCatchingTypedInput(body);
try
{
Object convert = converter.fromBody(wrapped, type);
//方法的返回值是非Response. 那么由Converter把Response轉換成對應的類型.
logResponseBody(body, convert);
if
(methodInfo.isSynchronous) {
return
convert;
}
return
new
ResponseWrapper(response, convert);
}
catch
(ConversionException e) {
// If the underlying input stream threw an exception, propagate that rather than
// indicating that it was a conversion exception.
if
(wrapped.threwException()) {
throw
wrapped.getThrownException();
}
// The response body was partially read by the converter. Replace it with null.
response = Utils.replaceResponseBody(response,
null
);
throw
RetrofitError.conversionError(url, response, converter, type, e);
}
}
response = Utils.readBodyToBytesIfNecessary(response);
throw
RetrofitError.httpError(url, response, converter, type);
}
catch
(RetrofitError e) {
throw
e;
// Pass through our own errors.
}
catch
(IOException e) {
if
(logLevel.log()) {
logException(e, url);
}
throw
RetrofitError.networkError(url, e);
}
catch
(Throwable t) {
if
(logLevel.log()) {
logException(t, url);
}
throw
RetrofitError.unexpectedError(url, t);
}
finally
{
if
(!methodInfo.isSynchronous) {
Thread.currentThread().setName(IDLE_THREAD_NAME);
}
}
}
}</method,></method,>
|
下面來分析每一步的調用流程。 （一）判斷call的method是不是屬於當前代理Object申明的，如果是就返回方法調用后的結果而不繼續向下執行。
（二）調用getMethodInfo函數 傳入參數為調用RestHandler構造方法時傳入的methodDetailsCache（LinkedHashMap<Method, RestMethodInfo>類型）和具體調用的method(Method類型)，返回值是一個RestMethodInfo的實例。getMethodInfo函數主要作用是將用戶調用的method解析為一個RestMethodInfo實例，然后再將method和該RestMethodInfo實例以key-value鍵值對的形式綁定，存放在methodDetailsCache中，然后再將該RestMethodInfo實例返回。（ps: RestMethodInfo中的對Mehod接口解析是很重要的，但是這里作者就一筆帶過了，讀者自己看看吧，就是JAVA反射那套東西，還是很簡單的）
（三）調用並返回invokeRequest函數 這里拿到了將method解析后的methodInfo（RestMethodInfo類型），判斷該調用函數用戶是想讓它同步執行還是異步執行（利用RestMethodInfo中的isSynchronous屬性判斷），同步執行則進入到if判斷，調用並返回invokeRequest函數.
第一個參數RequestInterceptor接口是一個請求攔截器，能在請求執行之前向請求添加一些額外的數據，在最開始分析RestAdapter 創建的時候分析到ensureSaneDefaults 函數，如果沒有在創建RestAdapter的時候傳入自己實現的RequestInterceptor，那么Retrofit會給一個默認的RequestInterceptor空實現，指向RequestInterceptor接口類中的NONE屬性。第二個參數是剛才Method解析后的RestMethodInfo，第三個參數是用戶調用函數時傳入的參數數組。
methodInfo.init() 這個函數調用之后會將當前用戶調用的方法進行進一步的解析，比如對@POST @GET @HEAD…etc 這些annotation的解析，並且每個實例只解析一次。 RequestBuilder requestBuilder = new RequestBuilder(serverUrl, methodInfo, converter); 從字面字面意思看，這個類和請求有關。確實，這個類里包含了用戶請求網絡所包含的各種參數，比如Host地址，Http協議頭…etc 反正就是組成一個http請求所必要的東西。 Request request = requestBuilder.build(); 由requestBuilder調用build函數產生一個Request類，該類是一個常量實體類，包含了最少的請求Http時所需要的信息。之后是請求信息的日志打印，在接下來關鍵的地方來了。
[代碼]java代碼：
|
1
2
3
|
long
start = System.nanoTime();
Response response = clientProvider.get().execute(request);
long
elapsedTime = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start);
|
start 表示請求開始的時間，elapsedTime 表示該次請求花費的時間，而中間那句則是進行真正的網絡請求，clientProvider 表示你在前面創建RestAdapter 時調調用ensureSaneDefaults函數所初始化的網絡請求客戶端（可能是OkClient, AndroidApacheClient,UrlFetchClient或者UrlConnectionClient四個的其中之一）。執行完成后返回一個response 這是一個Response常量實體類，和前面提到的Request常量實體類對應（一個表示請求實體，一個表示相應實體），里面存放着該次請求返回的Http協議頭，狀態碼，body…etc .
在請求之前還有一個profiler
[代碼]java代碼：
|
1
2
3
4
|
Object profilerObject =
null
;
if
(profiler !=
null
) {
profilerObject = profiler.beforeCall();
}
|
這里用到了AOP（面向切面）設計模式，如果用戶設置了profiler的話，在請求的前后分別會調用profiler的beforeCall和afterCall函數，以通知用戶請求的完成情況（在afterCall函數中傳遞了響應結果）。 之后的代碼就是對response 的一個處理了，如果響應結果不在200到300之間，Retrofit會拋出一個自定義的異常進行進一步的處理，如果在200到300之間則會對response的請求數據做進一步的處理 .比如調用new ResponseWrapper(response, convert);利用converter（Converter接口類型，但實際上是GsonConverter，對Gson的一個封裝） 將數據解析為用戶想要返回的那個類型。
如果判斷用戶不是希望同步執行，那么invokeRequest函數的執行將會在之后執行。首先，會判斷你是否使用了RxJava。如果使用了RxJava ，則組建一個RxSupport（對RxJava 中類的簡單封裝），使用它的createRequestObservable函數對invokeRequest函數進行異步調用並返回一個ResponseWrapper。否則使用httpExecutor（前面初始化的時候被設置為CachedThreadPool（緩存線程池））對invokeRequest函數進行異步調用並返回一個ResponseWrapper。
最后看看CallbackRunnable的實現
[代碼]java代碼：
|
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
abstract
class
CallbackRunnable<t>
implements
Runnable {
private
final
Callback<t> callback;
private
final
Executor callbackExecutor;
private
final
ErrorHandler errorHandler;
CallbackRunnable(Callback<t> callback, Executor callbackExecutor, ErrorHandler errorHandler) {
this
.callback = callback;
this
.callbackExecutor = callbackExecutor;
this
.errorHandler = errorHandler;
}
@SuppressWarnings
(
"unchecked"
)
@Override
public
final
void
run() {
try
{
final
ResponseWrapper wrapper = obtainResponse();
callbackExecutor.execute(
new
Runnable() {
@Override
public
void
run() {
callback.success((T) wrapper.responseBody, wrapper.response);
}
});
}
catch
(RetrofitError e) {
Throwable cause = errorHandler.handleError(e);
final
RetrofitError handled = cause == e ? e : unexpectedError(e.getUrl(), cause);
callbackExecutor.execute(
new
Runnable() {
@Override
public
void
run() {
callback.failure(handled);
}
});
}
}
public
abstract
ResponseWrapper obtainResponse();
} </t></t></t>
|
就是一個普通的Runnable，在run方法中首先執行obtailResponse，從名字可以看到是執行請求返回Response，這個從前面可以看到執行了invokeRequest，和同步調用中一樣執行請求。 緊接着就提交了一個Runnable至callbackExecutor，在看Platform時看到了callbackExecotor是通過Platform.get().defaultCallbackExecutor()返回的，Android中是向主線程的一個Handler發消息
值得注意的事，對於同步調用，如果遇到錯誤是直接拋異常，而對於異步調用，是調用Callback.failure()
retrofit的大體流程
用戶自定義配置項的設置(如client,converter,攔截器等)—>解析接口的方法(如果曾經解析過就從緩存中獲取),確定http訪問的url,header,method等,確定是異步還是同步的方式——>使用具體的Client進行網絡訪問,並將數據封裝到Response—->執行Converter的邏輯(有可能不用執行),把Response數據轉換為一個具體對象.—>根據同步或者異步的方式,執行方法或者callBack的邏輯. ### retrofit框架的需要注意的幾個小點.
1.為什么同步方式不像正常的方式一樣要求用戶try_catch來提醒用戶捕捉異常?
通過上面的邏輯可以看到,真正進行網絡訪問,converter轉換的邏輯都在invokeHandler.invoke()方法執行的時候執行. 而這個方法的調用是在 用戶自定義接口調用接口方法的時候執行的.(不明白的可以看下動態代理的原理).而用戶自定義的接口方法是沒有拋出異常的.在java中,如果父類方法沒有拋出異常,子類方法也不能顯示的拋出異常.(子類方法只能拋出父類方法拋出異常或其子類).所以Retrofit就不能拋出各種異常(如IO異常). 並且要抓住異常后轉換為RuntimeException拋出.(動態代理生成的接口的實現類其實內部也采用了同樣的方法.)
異常抓住后不能直接內部處理,應該提醒用戶代碼執行的時候出了問題,所以必須抓住異常后再次拋出.而對於CallBack的方式,因為有failure()方法提示用戶代碼邏輯出了問題,所以就不用re-throw異常了.
2.關於 InvocationHandler的invoke()方法, 這個方法有個返回值. 那這個返回值返回的是什么呢?
首先明確Method.invoke(Object receiver,Object.. args)是和 receiver.method(args)等價的,2個方法的返回值是一樣的.
public Object invoke(Object receiver, Object… args) 這里的Object是方法執行的的返回值. —> Returns the result of dynamically invoking this method. Equivalent to {@code receiver.methodName(arg1, arg2, … , argN)}. 動態代理生成了接口A的代理類B,B的同名方法內部其實調用的是invocationHandler的 invoke()方法.返回的也是invoke方法的返回值. 所以invoke返回的類型就應該和接口方法的返回值類型一樣