实现一个简单的Retrofit(二)

在上一篇《实现一个简单的Retrofit(一)》中使用 java 的动态代理和注解实现的 Retrofit 的大体框架,可以实现一个基本的 url 的 get请求,如下:

1
2
3
4
5
6
7
8
9
10
interface SimpleRequest{
@GET
String goBaidu(@Url String url);
}

SimpleRequest simpleRequest = new Retro.
Builder().
build().
create(SimpleRequest.class);
println(simpleRequest.goBaidu("http://www.baidu.com"));

在这篇文章中我们需要实现 Retrofit 的特性 CallAdapter

在构建 Retrofit 的实例的时候我们通常会调用 addCallAdapterFactory 方法,这个方法是什么作用我这里不多赘述,可以参考:http://square.github.io/retrofit/

HttpCall

在上一篇中我们简单的将 http 请求放在了 ServiceMethod 的 call 方法中,这样做显然是不妥当的。这里我们为 http 请求抽象出一个名为 HttpCall 的类,代码如下:

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
public class HttpCall {

private ServiceMethod mServiceMethod ;

interface Callback{
void onResponse(Response response);
}

public HttpCall(ServiceMethod serviceMethod){
mServiceMethod = serviceMethod;
}

public Response execute(){
HttpURLConnection connection;
Response response ;
try {
String urlStr = mServiceMethod.getUrl();
URL url = new URL(urlStr);
connection = (HttpURLConnection) url.openConnection();

connection.setDoInput(true);

//set http method
connection.setRequestMethod(mServiceMethod.getHttpMethod());

//set header
mServiceMethod.applyHeader(connection);

response = new Response(connection);

return response;
} catch (IOException e) {
e.printStackTrace();
}
return null;
}

public void submit(final Callback callback){
Response response = execute();
if(callback != null){
callback.onResponse(response);
}
}
}

此类比较简单,主要有 execute 和 submit 两个方法,前者直接执行 http 请求并返回 Response,后者使用 Callback 的方式来传递 Response。

这里出现了一个 Response 对象,在上一节中我们只是简单的在 call 方法中返回了一个表示返回内容的 String 对象,这样也是不合理的,如果返回内容是一个加密的字节数组或者发生了异常,显然单单 String 是无法满足的,所以这里还需要给 http 响应做一个简单封装。

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
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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
public class Response {

private int code = -1;

private HttpURLConnection connection;

private String errorMsg = "";

public Response(HttpURLConnection httpURLConnection) throws IOException {
connection = httpURLConnection;
code = connection.getResponseCode();
}

@Override
public String toString() {
return " response code : " + code + " \n errorMsg : " + errorMsg;
}

public boolean isError() {
return code >= 400;
}

public int getResponseCode() {
return code;
}

public String getResponseBodyAsString() {
if (code >= 400) {
throw new RuntimeException("response error , code = " + code);
}
InputStream inputStream = null;
ByteArrayOutputStream bos = null;
try {
inputStream = connection.getInputStream();
bos = new ByteArrayOutputStream();
int len;
byte[] buffer = new byte[1024];
while ((len = inputStream.read(buffer)) > 0) {
bos.write(buffer, 0, len);
}
String body = new String(bos.toByteArray());
return body;
} catch (Exception e) {
e.printStackTrace();
} finally {
if(bos != null){
try {
bos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(inputStream != null){
try {
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
connection.disconnect();
}
return "";
}

public String getResponseErrorMsg(){
if (code < 400) {
throw new RuntimeException("not error , code = " + code);
}
InputStream inputStream = null;
ByteArrayOutputStream bos = null;
try {
inputStream = connection.getErrorStream();
bos = new ByteArrayOutputStream();
int len;
byte[] buffer = new byte[1024];
while ((len = inputStream.read(buffer)) > 0) {
bos.write(buffer, 0, len);
}
String body = new String(bos.toByteArray());
return body;
} catch (Exception e) {
e.printStackTrace();
} finally {
if(bos != null){
try {
bos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(inputStream != null){
try {
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
connection.disconnect();
}
return "";
}
}

Response 类可以通过 isError 方法判断请求是否出错,然后通过 getResponseBodyAsString 和 getResponseErrorMsg 方法获得对应数据,如果此时需要 InputStream 的话也可再扩展这个类,这里为了简单起见没有进行扩展。

此时将 ServiceMethod 中的方法改为:

1
2
3
public Object call(){
return new HttpCall(this);
}

将接口改为:

1
2
3
4
interface SimpleRequest {
@GET
HttpCall go(@Url String url);
}

测试代码调整为如下:

1
2
3
4
5
6
7
8
9
10
11
12
@Test
public void testAnnotation_Url() {
SimpleRequest simpleRequest = new Retro.
Builder().
build().
create(SimpleRequest.class);
HttpCall httpCall = simpleRequest.go("http://www.baidu.com");
Response response = httpCall.execute();
if(! response.isError()){
println(response.getResponseBodyAsString());
}
}

运行接口OK。

到这里一个封装相对较好的 http 请求库已经有了,但看着总觉得复杂了些,这里明明可以直接返回给我们 Response 对象,为什么还要多此一举先返回个 HttpCall 呢?对了,有这想法是正确的,毕竟我们要追求代码的简洁性,但在确保简洁性的同时有不能丢失了它的扩展性,所以这里对 HttpCall 的处理就交个 CallAdapter 。

CallAdapter

CallAdapter 的责任就是将原本要返回的 HttpCall 对象做一次适配,将其转换成其他相对适合你使用的类,CallAdapter 定义如下:

1
2
3
public interface CallAdapter<T> {
T adapter(HttpCall httpCall);
}

很简单,只是一个接口,这里的泛型 T 就是目标类型。假设我们需要在 Http 请求上使用观察者模式,当有请求得到响应后将 Response 通知给所有观察者。我们定义一个名为 ObservableCallAdapter 的类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class ObservableCallAdapter implements CallAdapter<Observable> {
@Override
public Observable adapter(final HttpCall httpCall) {
return new Observable(){
@Override
public synchronized void addObserver(Observer observer) {
super.addObserver(observer);
httpCall.submit(new HttpCall.Callback() {
@Override
public void onResponse(Response response) {
setChanged();
notifyObservers(response);
}
});
}
};

}
}

然后将 ServiceCall 的 call 方法修改成如下:

1
2
3
4
public Object call(HttpCall httpCall){
CallAdapter callAdapter = mCallAdapters.get(0);
return callAdapter.adapter(httpCall);
}

此时调用 ObservableCallAdapter 的 adapter 方法,返回的是一个被观察对象,在 ObservableCallAdapter 中可以发现我们重写了 Observable 的 addObserver 方法,当有观察者被添加进来的时候就去进行 http 请求并在得到 Response 后通知给观察者。

我们来对我们的 SimpleRequest 做一个修改:

1
2
3
4
interface SimpleRequest {
@GET
Observable go(@Url String url);
}

测试代码调整如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@Test
public void testAnnotation_Url() {
SimpleRequest simpleRequest = new Retro.
Builder().callAdapter(new ObservableCallAdapter()).
build().
create(SimpleRequest.class);
simpleRequest.go("http://www.baidu.com").addObserver(new Observer() {
@Override
public void update(Observable o, Object arg) {
if(arg instanceof Response){
if(((Response) arg).isError()){
println(((Response) arg).getResponseBodyAsString());
}
}
}
});
}

这里总结一下 CallAdapter 的作用,如果你不满足与 HttpCall 提供的方法,可以使用 CallAdapter 进行封装,然后提供更具灵活性的 http 响应回调。

总结

CallAdapter 用途广泛,在 Retrofit 中有大家熟知的 RxJava2CallAdapter,可以将请求响应转换成 RxJava 中的 Observable 对象并提供响应的订阅功能。
另外提一下,在下一篇中我们将实现 Retrofit 中一个比较牛的特性:Converter

如文章对您有所帮助,可以请作者喝杯 🍵