Android source code advanced in-depth understanding of the working principle of Retrofit

[[422495]]

This article is reprinted from the WeChat public account "Android Development Programming", the author is Android Development Programming. Please contact the Android Development Programming public account for reprinting this article.

Preface

Retrofit is a network framework based on AOP concept and dynamic proxy for RestfulApi annotations;

Today we will discuss the implementation principles and make progress together

1. Using Retrofit

1. Package reference

Reference retrofit in gradle file

 compile 'com.squareup.retrofit2:retrofit:2.3.0' compile 'com.squareup.retrofit2:retrofit-converters:2.3.0' compile 'com.squareup.retrofit2:retrofit-adapters:2.3.0'

If you need to use more extended functions, such as gson conversion, rxjava adaptation, etc., you can continue to add references as needed;

 compile 'com.squareup.retrofit2:converter-gson:2.3.0' compile 'com.squareup.retrofit2:adapter-rxjava2:2.3.0'

If the existing extension packages cannot meet your needs, you can also expand the converter, adapter, etc. by yourself;

2. Define the interface

Retrofit requires the definition of a network request interface, in which the URL path, request parameters, and return type must be defined;

 public interface INetApiService { @GET("/demobiz/api.php") Call<BizEntity> getBizInfo(@Query("id") String id); }

In this interface definition, the url path is declared with the annotation @GET("/demobiz/api.php"), and the request parameters are declared with the annotation @Query("id");

Most importantly, Call declares that the return value is a Retrofit Call object, and declares that the data type processed by this object is BizEntity, which is our custom data model;

3. Obtain Retrofit object, interface instance object, and network work object in turn

First, you need to create a new retrofit object;

Then, according to the interface in the previous step, implement an interface object processed by Retrofit;

Finally, the interface function is called to obtain a network work object that can perform network access;

 //Create a new Retrofit object Retrofit retrofit=new Retrofit.Builder() .baseUrl(Config.DOMAIN)//Domain name of the network address to be accessed, such as http://www.zhihu.com .addConverterFactory(GsonConverterFactory.create()) .build(); ... //Use retrofit to process the corresponding interface instance object INetApiService netApiService= retrofit.create(INetApiService.class); //You can continue to process other interface instance objects IOtherService otherService= retrofit.create(IOtherService.class); ··· //Call the interface function to obtain the network worker object Call<BizEntity> callWorker= netApiService.getBizInfo("id001");

After this complex process, the final callWorker object can perform network access.

4. Access network data

Use the worker object obtained in the previous step to perform the network request

 callWorker.enqueue(new Callback<BizEntity>() { @Override public void onResponse(Call<BizEntity> call, Response<BizEntity> response) {...} @Override public void onFailure(Call<BizEntity> call, Throwable t) {...} });

In the callback function, get the BizEntity data object we need

2. Retrofit Implementation Principle

​​​

1. The construction of Retrofit objects is a simple builder mode, just look at create

 //Retrofit.java public <T> T create(final Class<T> service) { //Verification validateServiceInterface(service); return (T) //Dynamic proxy Proxy.newProxyInstance( service.getClassLoader(), //Class loader new Class<?>[] {service}, //A set of interfaces new InvocationHandler() { //Judge android and jvm platforms and their versions private final Platform platform = Platform.get(); @Override public Object invoke(Object proxy, Method method, Object[] args){ //If the method is an Object method, just execute it directly if (method.getDeclaringClass() == Object.class) { return method.invoke(this, args); } //isDefaultMethod: Check whether it is the default method of the interface supported by java8 return platform.isDefaultMethod(method) ? platform.invokeDefaultMethod(method, service, proxy, args) : loadServiceMethod(method).invoke(args); //We focus on this } }); }

Proxy.newProxyInstance dynamic proxy, a class (bytecode) such as $ProxyN will be generated at runtime, which implements the incoming interface, namely WanApi, rewrites the interface method and then forwards it to the invoke of InvocationHandler

 class $ProxyN extends Proxy implements WanApi{ Call<WanArticleBean> articleList(@Path("page") int page){ //Forward to invocationHandler invocationHandler.invoke(this,method,args); } }

2. validateServiceInterface validation logic

 //Retrofit.java private void validateServiceInterface(Class<?> service) { //Check: If WanApi is not an interface, throw an exception... //Check: WanApi cannot have generic parameters and cannot implement other interfaces... if (validateEagerly) { //Whether to perform strict check, closed by default Platform platform = Platform.get(); for (Method method : service.getDeclaredMethods()) { //Traverse WanApi methods //It is not a default method and it is not a static method if (!platform.isDefaultMethod(method) && !Modifier.isStatic(method.getModifiers())) { //Load the method in advance (check if there is any problem) loadServiceMethod(method); } } } }

If validateEagerly is turned on, all methods of the WanApi interface will be checked and loaded at once. You can turn it on in debug mode to find errors in advance. For example, if @Body is set in a @GET request, an exception will be thrown:

 java.lang.IllegalArgumentException: Non-body HTTP method cannot contain @Body.

3. loadServiceMethod

Then there is loadServiceMethod(method).invoke(args). As the name suggests, it first finds the method and then executes it.

 //Retrofit.java //Cache, using thread-safe ConcurrentHashMap final Map<Method, ServiceMethod<?>> serviceMethodCache = new ConcurrentHashMap<>(); ServiceMethod<?> loadServiceMethod(Method method) { ServiceMethod<?> result = serviceMethodCache.get(method); //WanApi's articleList method has been cached and returned directly if (result != null) return result; synchronized (serviceMethodCache) { result = serviceMethodCache.get(method); if (result == null) { //Parse articleList's annotations, create ServiceMethod and cache it result = ServiceMethod.parseAnnotations(this, method); serviceMethodCache.put(method, result); } } return result; }

Follow up ServiceMethod.parseAnnotations

 //ServiceMethod.java static <T> ServiceMethod<T> parseAnnotations(Retrofit retrofit, Method method) { //1. RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method); //Check: articleList method return type cannot use wildcards and void... //2. return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory); }

4. RequestFactory.parseAnnotations

 //RequestFactory.java static RequestFactory parseAnnotations(Retrofit retrofit, Method method) { return new Builder(retrofit, method).build(); } class Builder { RequestFactory build() { //Parsing method annotations such as GET for (Annotation annotation : methodAnnotations) { parseMethodAnnotation(annotation); } //Omit various checks... //Parsing parameter annotations such as Path int parameterCount = parameterAnnotationsArray.length; parameterHandlers = new ParameterHandler<?>[parameterCount]; for (int p = 0, lastParameter = parameterCount - 1; p < parameterCount; p++) { parameterHandlers[p] = parseParameter(p, parameterTypes[p], parameterAnnotationsArray[p], p == lastParameter); } //Omit various checks... return new RequestFactory(this); } }

After getting RequestFactory, HttpServiceMethod.parseAnnotations, HttpServiceMethod is responsible for adaptation and conversion processing, adjusting the call of the interface method to HTTP call

 //HttpServiceMethod.java //ResponseT response type such as WanArticleBean, ReturnT return type such as Call static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations( Retrofit retrofit, Method method, RequestFactory requestFactory) { //Omit kotlin coroutine logic... Annotation[] annotations = method.getAnnotations(); //Traverse to find the right adapter CallAdapter<ResponseT, ReturnT> callAdapter = createCallAdapter(retrofit, method, adapterType, annotations); //Get the response type, such as WanArticleBean Type responseType = callAdapter.responseType(); //Traverse to find the right converter Converter<ResponseBody, ResponseT> responseConverter = createResponseConverter(retrofit, method, responseType); okhttp3.Call.Factory callFactory = retrofit.callFactory; return new CallAdapted<>(requestFactory, callFactory, responseConverter, callAdapter); }

5. Finally, a CallAdapted is returned. See CallAdapted

 //CallAdapted extends HttpServiceMethod extends ServiceMethod class CallAdapted<ResponseT, ReturnT> extends HttpServiceMethod<ResponseT, ReturnT> { private final CallAdapter<ResponseT, ReturnT> callAdapter; CallAdapted( RequestFactory requestFactory, okhttp3.Call.Factory callFactory, Converter<ResponseBody, ResponseT> responseConverter, CallAdapter<ResponseT, ReturnT> callAdapter) { super(requestFactory, callFactory, responseConverter); this.callAdapter = callAdapter; } @Override protected ReturnT adapt(Call<ResponseT> call, Object[] args) { //Adapter return callAdapter.adapt(call); } }

Back to Retrofit.Builder

 //Retrofit.Builder.java public Retrofit build() { Executor callbackExecutor = this.callbackExecutor; //If the thread pool is not set, set a default MainThreadExecutor for the Android platform (use Handler to switch the callback back to the main thread) if (callbackExecutor == null) { callbackExecutor = platform.defaultCallbackExecutor(); } List<CallAdapter.Factory> callAdapterFactories = new ArrayList<>(this.callAdapterFactories); //Add the default DefaultCallAdapterFactory callAdapterFactories.addAll(platform.defaultCallAdapterFactories(callbackExecutor)); }

DefaultCallAdapterFactory This factory creates a specific CallAdapter instance

 //DefaultCallAdapterFactory.java public CallAdapter<?, ?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) { final Type responseType = Utils.getParameterUpperBound(0, (ParameterizedType) returnType); //If the SkipCallbackExecutor annotation is specified, it means that there is no need to switch back to the main thread final Executor executor = Utils.isAnnotationPresent(annotations, SkipCallbackExecutor.class) ? null : callbackExecutor; return new CallAdapter<Object, Call<?>>() { @Override public Type responseType() { return responseType; } @Override public Call<Object> adapt(Call<Object> call) { //By default, the return value is the Call wrapped in the main thread pool, and its enqueue will use the execute of the main thread pool return executor == null ? call : new ExecutorCallbackCall<>(executor, call); } }; }

6. invoke

LoadServiceMethod gets CallAdapted, and then executes invoke, which is implemented in the parent class HttpServiceMethod.

 //HttpServiceMethod.java final ReturnT invoke(Object[] args) { //Finally I saw okhttp! Call<ResponseT> call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter); return adapt(call, args); } class CallAdapted<ResponseT, ReturnT> extends HttpServiceMethod<ResponseT, ReturnT> { private final CallAdapter<ResponseT, ReturnT> callAdapter; @Override protected ReturnT adapt(Call<ResponseT> call, Object[] args) { //Use the adapter obtained earlier to wrap OkHttpCall into ExecutorCallbackCall return callAdapter.adapt(call); } }

Then the request is enqueued, ExecutorCallbackCall.enqueue -> OkHttpCall.enqueue,

 //ExecutorCallbackCall.java void enqueue(final Callback<T> callback) { delegate.enqueue( new Callback<T>() { @Override public void onResponse(Call<T> call, final Response<T> response) { //Switch the callback back to the main thread callbackExecutor.execute( () -> { callback.onResponse(ExecutorCallbackCall.this, response); }); //... } @Override public void onFailure(Call<T> call, final Throwable t) {} }); } //OkHttpCall.java void enqueue(final Callback<T> callback) { //okhttp logic okhttp3.Call call; call.enqueue(new okhttp3.Callback() { void onResponse(okhttp3.Call call, okhttp3.Response rawResponse) { callback.onResponse(OkHttpCall.this, response); } }) }

The whole process is now complete.

2. Functional expansion

1. OkHttpClient

Retrofit uses OkHttpClient to implement network requests. Although this OkHttpClient cannot be replaced by other network execution frameworks such as Volley, Retrofit allows us to extend OkHttpClient ourselves. Generally, the most commonly extended one is the Interceptor interceptor.

 OkHttpClient mClient = new OkHttpClient.Builder() .addInterceptor(new Interceptor() { @Override public intercept Response(Chain chain) throws IOException { try { Request.Builder builder = chain.request().newBuilder(); builder.addHeader("Accept-Charset", "UTF-8"); builder.addHeader("Accept", " application/json"); builder.addHeader("Content-type", "application/json"); Request request = builder.build(); return chain.proceed(request); } catch (Exception e) { e.printStackTrace(); } return null; } }).build(); Retrofit retrofit = new Retrofit.Builder() .baseUrl(Config.DOMAIN) .addConverterFactory(GsonConverterFactory.create()) .client(mClient) .build();

2. addConverterFactory

The extension is the automatic conversion of the returned data type, converting one data object into another;

GsonConverterFactory can convert the json string obtained from HTTP access into a Java data object BizEntity, which is required in the INetApiService interface;

If the existing extension package cannot meet your needs, you can inherit the Retrofit interface.

When creating a Retrofit object, you can insert our custom ConverterFactory;

 //retrofit object Retrofit retrofit=new Retrofit.Builder() .baseUrl(Config.DOMAIN) .addConverterFactory(GsonConverterFactory.create()) .addConverterFactory(YourConverterFactory.create())//Add a custom Converter .build();

3. addCallAdapterFactory

The extension is the automatic conversion of the network work object callWorker, which converts the Call object that executes the network request in Retrofit into the Call object defined in the interface;

This conversion is not easy to understand. We can understand it by referring to the following figure:

​​​

Retrofit itself uses an OkHttpCall class to handle network requests, and we need to define many kinds of Calls in the interface. The Call in the interface is not consistent with the OkHttpCall in Retrofit, so we need to use a CallAdapter to do an adaptation conversion;

This is actually a very core and very useful design of Retrofit. If the function return value required in the interface is an RxJava Flowable object

 public interface INetApiService { @GET("/demobiz/api.php") Flowable<BizEntity> getBizInfo(@Query("id") String id); }

Then we just need to add the corresponding extension for Retrofit;

 //retrofit object Retrofit retrofit=new Retrofit.Builder() .baseUrl(Config.DOMAIN) .addConverterFactory(GsonConverterFactory.create()) .addCallAdapterFactory(RxJava2CallAdapterFactory.create()) .build();

You can get a callWorker object of Flowable type;

 //Use retrofit to process the corresponding interface instance object INetApiService netApiService= retrofit.create(INetApiService.class); ··· //Call the interface function to get the network worker object Flowable<BizEntity> callWorker= netApiService.getBizInfo("id001"); Here, what callAdapter does is to adapt the retrofit2.Call object to a Flowable<T> object;

Similarly, if the existing extension package does not meet your needs, you can inherit the Retrofit interface; retrofit2.CallAdapter

4. Dynamically replace URL

When building Retrofit, pass in the HttpUrl object, and then this instance will always exist and will not change, so you can reflect and modify its fields such as host to dynamically replace the server address;

 String SERVER = "https://www.xxx.com/"; HttpUrl httpUrl = HttpUrl.get(SERVER); Retrofit retrofit = new Retrofit.Builder() //.baseUrl(SERVER) .baseUrl(httpUrl) //Use HttpUrl .build();

Summarize:

1. Retrofit abstracts HTTP requests into java interfaces

2. Use annotations in the interface to describe and configure network request parameters

3. Generate call objects using dynamic proxy.