Android开发：从设计者角度看Retrofit原理，Android社招面经分享

原创于 2024-04-10 04:05:42 发布 · 931 阅读

22 ·

CC 4.0 BY-SA版权

文章标签：

#android #retrofit #oracle

2024年程序员学习专栏收录该内容

288 篇文章

订阅专栏

dao.update()

//上报

post()

}

以上这种方式存在一个问题：

上报操作本身与具体业务无关，一旦需要对上报进行修改，那就可能影响到业务，进而可能造成不可预期的问题产生

面对以上问题可以通过代理模式完美规避，改造后的代码如下：

class DaoProxy(){

//数据库插入操作

fun insert(){

dao.insert()

//上报

post()

}

//数据库更新操作

fun update(){

dao.update()

//上报

post()

}

//业务层方法test1

fun test1{

//数据库插入操作

daoProxy.insert()

}

//业务层方法test2

fun test2(){

//数据库更新操作

daoProxy.update()

}

新增一个代理类DaoProxy，将dao以及上报操作在代理类中执行，业务层直接操作代理对象，这样就将上报从业务层抽离出来，从而避免业务层改动带来的问题。实际使用代理模式时应遵守基于接口而非实现编程思想，但文章侧重于传授思想，规范上可能欠缺

此时还有一个问题，每次CRUD都会手动做一次上报操作，这显然是模版代码，如何解决？下面来看动态代理：

什么是动态代理？

java中的动态代理就是在运行时通过反射为目标对象做一些附加操作，代码如下：

class DaoProxy() {

//创建代理类

fun createProxy(): Any {

//创建dao

val proxyAny = Dao()

val interfaces = proxyAny.javaClass.interfaces

val handler = ProxyHandler(proxyAny)

return Proxy.newProxyInstance(proxyAny::class.java.classLoader, interfaces, handler)

}

//代理委托类

class ProxyHandler(private val proxyObject:Any): InvocationHandler {

//代理方法，p1为目标类方法、p2为目标类参数。调用proxyObject任一方法时都会执行invoke

override fun invoke(p0: Any, p1: Method, p2: Array): Any {

//执行Dao各个方法(CRUD)

val result = p1.invoke(proxyObject,p2)

//上报

post()

return result

}

//此处规范上应该使用基于接口而非实现编程。如果要替换Dao通过接口编程可提高扩展性

val dao:Dao = DaoProxy().createProxy() as Dao

dao.insert()

dao.update()

其中Proxy是JDK中用于创建动态代理的类，InvocationHandler是一个委托类，内部的invoke（代理方法）方法会随着目标类(Dao)任一方法的调用而调用，所以在其内部实现上报操作即可消除大量模版代码。

动态代理与静态代理核心思想一致，区别是动态代理可以在运行时通过反射动态创建一个切面(InvocationHandler#invoke),用来消除模板代码。喜欢思考的同学其实已经发现，代理模式符合面向切面编程(AOP)思想，而代理类就是切面

3.3 动态代理获取ApiService

================================================================================

2.2小节有提到可以通过retrofit.create()创建ApiService，跟一下retrofit的create()

#Retrofit.class

public T create(final Class service) {

//第一处

validateServiceInterface(service);

return (T) Proxy.newProxyInstance(

service.getClassLoader(),

new Class<?>[] {service},

new InvocationHandler() {

//第二处

@Override

public @Nullable Object invoke(Object proxy, Method method, @Nullable Object[] args)

throws Throwable {

…

return platform.isDefaultMethod(method)

? platform.invokeDefaultMethod(method, service, proxy, args)

: loadServiceMethod(method).invoke(args);

}

});

}

create()大致可以分为两部分：

第一部分为validateServiceInterface()内容，用来验证ApiService合法性，比较简单就不多描述，感兴趣的同学可自行查看。
第二部分就是invoke()，通过3.2小节可知这是一个代理方法，可通过调用ApiService中的任一方法执行，其中参数method和args代表ApiService对应的方法和参数。返回值中有一个isDefaultMethod，这里如果是Java8的默认方法直接执行，毕竟我们只需要代理ApiService中方法即可。经过反复筛选最后重任落在了loadServiceMethod，这也是Retrofit中最核心的一个方法，下面我们来跟一下

#Retrofit.class

ServiceMethod<?> loadServiceMethod(Method method) {

ServiceMethod<?> result = serviceMethodCache.get(method);

if (result != null) return result;

synchronized (serviceMethodCache) {

result = serviceMethodCache.get(method);

if (result == null) {

result = ServiceMethod.parseAnnotations(this, method);

serviceMethodCache.put(method, result);

}

return result;

}

大致就是对ServiceMethod做一个很常见的缓存操作，这样做的目的是为了提升运行效率，毕竟创建一个ServiceMethod会用到大量反射。创建ServiceMethod对象是通过其静态方法parseAnnotations实现的，再跟一下这个方法：

#ServiceMethod.class

static ServiceMethod parseAnnotations(Retrofit retrofit, Method method) {

//第一步

RequestFactory requestFactory =

RequestFactory.parseAnnotations(retrofit, method);

Type returnType = method.getGenericReturnType();

…

//第二步

return HttpServiceMethod.parseAnnotations(retrofit,

method, requestFactory);

}

第一步:

通过RequestFactory的parseAnnotations()解析method(ApiService的method)中的注解信息，具体代码很简单就不再贴了。不过需要注意这一步只是解析注解并保存在RequestFactory工厂中，会在请求时再通过RequestFactory将请求信息做拼装。

第二步:

调用HttpServiceMethod的parseAnnotations创建ServiceMethod，这个方法很长并且信息量很大，下一小节我再详细描述，此处你只需知道它做了什么即可。其实到这方法调用链已经很绕了，我先帮大家捋一下 HttpServiceMethod其实是ServiceMethod的子类，Retrofit动态代理里面的loadServiceMethod就是HttpServiceMethod类型对象，最后来看一下它的invoke()方法。

#HttpServiceMethod.class

@Override

final @Nullable ReturnT invoke(Object[] args) {

Call call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter);

return adapt(call, args);

}

创建了一个OkHttpCall实例，它内部其实就是对OkHttp的一系列操作，这里先按住不表后面我会再提到。把关注点切到返回值，返回的Call对象没做任何操作，而是传入到adapter()方法一并返回来，字面意思应该是一个适配操作，那究竟如何适配？这里再埋一个伏笔与3.1结尾相呼应，下一小节我们再一一揭开。

动态代理讲完了，那么它解决了什么问题？

假如不使用代理模式，那关于ApiService中方法注解解析的操作势必会浸入到业务当中，一旦对其修改就有可能影响到业务，其实也就是也违背了我们前面所说的门面模式和迪米特法则，通过代理模式做一个切面操作(AOP)可以完美规避了这一问题。可见这里的门面模式和代理模式是相辅相成的

Retrofit事先都不知道ApiService方法数量，就算知道也避免不了逐一解析而产生大量的模版代码，此时可通过引入动态代理在运行时动态解析从而解决这一问题。

4. ReturnT、ResponseT做一次适配的意义何在？

============================================================================================

ResponseT、ReturnT是 Retrofit 对响应数据类型和返回值类型的简称

4.1 创建HttpServiceMethod

===================================================================================

上一小节我们跟到了adapter()，这是一个抽象方法，其实现类是通过HttpServiceMethod的parseAnnotations创建的，继续跟下去：

#HttpServiceMethod.class

static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(

Retrofit retrofit, Method method, RequestFactory requestFactory) {

boolean isKotlinSuspendFunction = requestFactory.isKotlinSuspendFunction;

boolean continuationWantsResponse = false;

boolean continuationBodyNullable = false;

Annotation[] annotations = method.getAnnotations();

Type adapterType;

//1.获取adapterType，默认为method返回值类型

if (isKotlinSuspendFunction) {

Type[] parameterTypes = method.getGenericParameterTypes();

Type responseType =

Utils.getParameterLowerBound(

0, (ParameterizedType) parameterTypes[parameterTypes.length - 1]);

if (getRawType(responseType) == Response.class && responseType instanceof ParameterizedType) {

// Unwrap the actual body type from Response.

responseType = Utils.getParameterUpperBound(0, (ParameterizedType) responseType);

continuationWantsResponse = true;

} else {

}

adapterType = new Utils.ParameterizedTypeImpl(null, Call.class, responseType);

annotations = SkipCallbackExecutorImpl.ensurePresent(annotations);

} else {

adapterType = method.getGenericReturnType();

}

//2.创建CallAdapter

CallAdapter<ResponseT, ReturnT> callAdapter =

createCallAdapter(retrofit, method, adapterType, annotations);

Type responseType = callAdapter.responseType();

//3.创建responseConverter

Converter<ResponseBody, ResponseT> responseConverter =

createResponseConverter(retrofit, method, responseType);

okhttp3.Call.Factory callFactory = retrofit.callFactory;

//4.创建HttpServiceMethod类型具体实例

if (!isKotlinSuspendFunction) {

return new HttpServiceMethod.CallAdapted<>(requestFactory, callFactory, responseConverter, callAdapter);

}

//兼容kotlin suspend方法

else if (continuationWantsResponse) {

//noinspection unchecked Kotlin compiler guarantees ReturnT to be Object.

return (HttpServiceMethod<ResponseT, ReturnT>)

new HttpServiceMethod.SuspendForResponse<>(

requestFactory,

callFactory,

responseConverter,

(CallAdapter<ResponseT, Call>) callAdapter);

} else {

//noinspection unchecked Kotlin compiler guarantees ReturnT to be Object.

return (HttpServiceMethod<ResponseT, ReturnT>)

new HttpServiceMethod.SuspendForBody<>(

requestFactory,

callFactory,

responseConverter,

(CallAdapter<ResponseT, Call>) callAdapter,

continuationBodyNullable);

}

注释1：获取adapterType，这里的adapter指的是Retrofit构建时通过addCallAdapterFactory()添加的类型，如果添加的是RxJava那adapterType便是Observable。默认是method返回值，同时也会做kotlin suspend适配

注释2：创建callAdapter，暂时掠过，下面详细描述

注释3：创建responseConverter，暂时掠过，下面详细描述

注释4：这里会创建具体的HttpServiceMethod类型实例，总共有三种类型CallAdapted、SuspendForResponse、SuspendForBody，第一种为默认类型，后两种可兼容kotlin suspend。内部主要做的事情其实很简单，就是通过内部的adapter()调用callAdapter->adapter()，具体代码就不贴了，感兴趣的自行查看

4.2 如何管理callAdapter、responseConverter？

==================================================================================================

创建创建callAdapter

#HttpServiceMethod.class

private static <ResponseT, ReturnT> CallAdapter<ResponseT, ReturnT> createCallAdapter(

Retrofit retrofit, Method method, Type returnType, Annotation[] annotations) {

return (CallAdapter<ResponseT, ReturnT>) retrofit.callAdapter(returnType, annotations);

…

}

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip204888 （备注Android）

最后我想说

为什么很多程序员做不了架构师？
1、良好健康的职业规划很重要，但大多数人都忽略了
2、学习的习惯很重要，持之以恒才是正解。
3、编程思维没能提升一个台阶，局限在了编码，业务，没考虑过选型、扩展
4、身边没有好的架构师引导、培养。所处的圈子对程序员的成长影响巨大。

金九银十面试季，跳槽季，整理面试题已经成了我多年的习惯！在这里我和身边一些朋友特意整理了一份快速进阶为Android高级工程师的系统且全面的学习资料。涵盖了Android初级——Android高级架构师进阶必备的一些学习技能。

附上：我们之前因为秋招收集的二十套一二线互联网公司Android面试真题（含BAT、小米、华为、美团、滴滴）和我自己整理Android复习笔记（包含Android基础知识点、Android扩展知识点、Android源码解析、设计模式汇总、Gradle知识点、常见算法题汇总。）

里面包含不同方向的自学编程路线、面试题集合/面经、及系列技术文章等，资源持续更新中…

一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

学习的习惯很重要，持之以恒才是正解。
3、编程思维没能提升一个台阶，局限在了编码，业务，没考虑过选型、扩展
4、身边没有好的架构师引导、培养。所处的圈子对程序员的成长影响巨大。