实现一个简单的Retrofit(二)

在上一篇《实现一个简单的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

推荐阅读更多精彩内容