在上一篇《实现一个简单的Retrofit（一）》中使用 java 的动态代理和注解实现的 Retrofit 的大体框架，可以实现一个基本的 url 的 get请求，如下：
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 的类，代码如下：
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 响应做一个简单封装。
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 中的方法改为：
public Object call(){
return new HttpCall(this);
}
将接口改为：
interface SimpleRequest {
@GET
HttpCall go(@Url String url);
}
测试代码调整为如下：
@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 定义如下：
public interface CallAdapter<T> {
T adapter(HttpCall httpCall);
}
很简单，只是一个接口，这里的泛型 T 就是目标类型。假设我们需要在 Http 请求上使用观察者模式，当有请求得到响应后将 Response 通知给所有观察者。我们定义一个名为 ObservableCallAdapter 的类：
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 方法修改成如下：
public Object call(HttpCall httpCall){
CallAdapter callAdapter = mCallAdapters.get(0);
return callAdapter.adapter(httpCall);
}
此时调用 ObservableCallAdapter 的 adapter 方法，返回的是一个被观察对象，在 ObservableCallAdapter 中可以发现我们重写了 Observable 的 addObserver 方法，当有观察者被添加进来的时候就去进行 http 请求并在得到 Response 后通知给观察者。
我们来对我们的 SimpleRequest 做一个修改：
interface SimpleRequest {
@GET
Observable go(@Url String url);
}
测试代码调整如下：
@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 。
