从 Retrofit 源码学习 Java 的动态代理的使用

Retrofit 是当前 Android 最流行的 HTTP 网络库之一了,其使用方式比较特殊,是通过定义一个接口类,通过给接口中方法和方法参数添加注解的方式来定义网络请求接口。这种风格下定义一个网络接口变得很简单。不过 Retrofit 是如何使用一个接口的 Class 创建出来实现了该接口的对象呢?最近因为工作原因想封装项目中的网络请求部分,在解决获取泛型嵌套问题的时候,一直没有找到比较理想的方案,所以拜读了 Retrofit 的源码看看这个明星网络库是如何实现这一黑科技的。

Java 的动态代理机制

在 Retrofit 2.0 中,create 方法中是这样定义的:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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 {
//...
}
});
}

前两段的Utils.validateServiceInterface(service)eagerlyValidateMethods(service)从命名可以看出是验证传入接口合法性的,所以跳过。

接下来调用了一个关键方法 Proxy.newProxyInstance(),这个方法就是创建一个代理实例的方法,该方法需要三个参数,ClassLoader loader, Class<?>[] interfaces, InvocationHandler h,其中 interfaces 放置了我们传入的接口 class,InvocationHandler 也是一个接口,只有一个回调方法,也回调了三个参数:Object proxy, Method method, Object… args:其中 proxy 就是构造出来的代理实例,使用 proxy 调用一个方法时,这里传进来的 mthod 就是该方法,而 args 就是这个参数。

空说无凭,使用代码测试一下:

首先假装已经有个一个 retrofit,来定义一个接口类

1
2
3
4
5
6
7
interface Api {
@POST("http://example.com")
CallAdapter<User> fetchUser();

@POST("http://example.com")
CallAdapter<String> login(@Param("username") String username, @Param("password") String password);
}

跟真的一样。

接下来 retrofit 调用了一个 create 方法返回的 Api 对象就让它能 fetchUser,能 login 了。那么可以想象一下,如果需要实现这些事情,它需要从这个接口定义中获取什么?

首先是 @POST,它让 retrofit 知道了这个请求是使用 post,然后里面的值是一个 PATH(这里为了实现简单直接放上了完整的路径),通过它和构造 retrofit 对象时的 baseUrl 就得到了接口的完整 URL。再后面需要知道定义的参数,每个注解对应的是一个参数,同时注解里标注了这个参数的名字,所以这里获取的应该是所有参数注解值和参数的值。知道这些也就万事俱备了,接下来 retrofit 只要把请求构造出来交给 OkHttp 然后等待返回结果再传给返回值。

为了获得上面所说的信息,在 invoke方法里尝试以下代码:

1
2
3
4
5
6
7
8
9
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
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 打印调用的请求方法
System.out.println("调用的请求方法:" + method.getName());

// 这里获取了方法的注解,retrofit 就是在这里判断使用的哪种请求方式,以及获取 path
POST annotation = method.getAnnotation(POST.class);
String postUrl = annotation.value();
System.out.println("Url: " + postUrl);

// 非法判断是个麻烦的事情,这里我们只实现例子中 api 的解析,所以以下代码不进行异常判断。
if (args != null && args.length != 0) {
List<String> params = new ArrayList<>();
// 获取所有参数的所有注解。得到的是一个二维数组,前面一个下标代表的是第几个参数,后面下标代表的是这个参数的所有注解。这里我们每个参数只定义了一个注解,所以直接取了[0]
Annotation[][] annotations = method.getParameterAnnotations();
for (int i = 0; i < args.length; i++) {
Annotation[] paramsAnnotation = annotations[i];
// 取到 Param 注解中的值,这个值在 retrofit 中一般是参数的键,而 args[i] 则是参数的值
params.add(String.format("%s: %s", ((Param) paramsAnnotation[0]).value(), args[i].toString()));
}
// 打印所有参数
System.out.printf("Params: %s\n", params.toString());
}

// 下面的内容可能更加关键:如何获得返回值类型。
// 我们用了默认的 CallAdapter 来实现

// 首先获得 CallAdapter 里定义的泛型,也就是我们最终需要的数据 class
Type genericReturnType = method.getGenericReturnType(); // 这里获得的是最外层,也就是 CallAdapter
// 这里偷懒使用了 Retrofit 工具类中的方法来获取 CallAdapter 的泛型。这边为了显示方便又强制转换成了 Class 对象,实际上例如 Gson,直接传入 Type 就可以解析出实体了不需要再转换为 Class
Class resultClass = (Class) getParameterUpperBound(0, (ParameterizedType) genericReturnType);
System.out.println("return: type" + resultClass.getSimpleName());
// 返回调用需要的实体。这里为了篇幅没有再模拟网络请求,而只是调用了 newInstance 来创建一个对象回调出去。
return (CallAdapter<T>) call -> {
if (call != null) {
try {
//noinspection unchecked
call.call((T) resultClass.newInstance());
} catch (InstantiationException | IllegalAccessException e) {
e.printStackTrace();
}
}
};
}

好了验证一下结果:

1
2
3
4
5
6
7
8
9
Api print = create(Api.class);
print.fetchUser().call(user -> {
String result = "print.fetchUser().call => " + user.getClass().getSimpleName();
System.out.println(result);
});
print.login("user1", "passw0rd").call(s -> {
String result = "print.login(\"user1\", \"passw0rd\").call => " + s.getClass().getSimpleName();
System.out.println(result);
});

打印结果:

1
2
3
4
5
6
7
8
9
调用请求方法:fetchUser
Url: http://example.com
return: typeUser
print.fetchUser().call => User
调用请求方法:login
Url: http://example.com
Params: [username: user1, password: passw0rd]
return: typeString
print.login("user1", "passw0rd").call => String

完全符合预期。有了这些参数,Retrofit 就可以统一封装网络请求进行处理后返回给用户定义的方法了。

结语

实际 Retrofit 这个模块的实现要比本文中复杂的多,不仅考虑到各个模块的解耦,对于各种请求的支持也远远超出想象。感谢 Square 提供给开源社区和 Android 这么优秀的网络库,虽然在暂时用不到它,但通过阅读源码还是能对自己有很大帮助。

(例子中的源码可以从这里获得:https://github.com/twiceyuan/DynamicProxyDemo)

Comments

Your browser is out-of-date!

Update your browser to view this website correctly. Update my browser now

×