Android企业级架构-仿微信-网络架构

市场上的绝大多数APP,都离不开网络数据请求,从注册到登录、提交/拉取数据,都是我们必须要面对的问题,可见网络数据请求在APP产品中的重要性。那么网络请求在企业级架构中,应该怎样处理是比较合理的呢?这篇文章我们来聊一聊网络数据请求的架构处理。

可能有人会问:网上有太多合适的框架供我们选择和使用,比如原生的HttpClient、HttpURLConnection,Google在前两者上扩展的Volley,Square组织的OkHttp(+Retrofit组合)等等,都是很方便的网络请求框架,那我们为什么还要自己去探究,重复造轮呢?
PS:HttpClient因维护成本大,在2.3版本就不建议使用,6.0版本已经废弃,还在用的小伙伴要注意

原因很简单,在企业级开发过程中,最重要的指标是稳定,同时要控制更新、替换和后期维护的成本,这一指标对所有第三方框架都相同。另外还需要控制Apk文件的大小,不可以无限制的添加第三方库,或仅为一个小功能添加了一个庞大且没用的库。

说了这么多废话,下面扯正题

我们要做什么?是要自己写一套网络请求库?

No,网上有那么多写的牛X的网络库,我们怎么写也写不过他们。我们做的事,只为我们自己和我们的产品就够了。那应该做什么事呢?
封装
我们需要封装自己的网络层外壳,有了这个外壳,其它开发者不需要关注网络请求的具体实现,直接调用我们的API即可。以前Volley热门,我们可以使用Volley的实现,现在OkHttp比较火,我们可以使用OkHttp的实现,但是不管怎么换,都不会影响上层的使用。大大降低了更新、维护的成本。
时下最火的Retrofit是一款很时尚的封装框架,它的框架设计能力非一般人所能及,接口的设计与逻辑完全解耦,非常适合学习研究,只是今天火的是Retrofit,明天可能就是其它的XXX。所以笔者对于这种框架,仅停留在学习阶段,不会轻易使用,写一套最适合自己的,最普通的框架,对自己和团队的学习本成来说,都只有好处没有坏处

建议爱学习的朋友,仔细读一下Retrofit,网上有很多文章,我就不写了

原始底层封装

这节写封装的框架,是一套原始框架,其中不包涵任何的与需求相关的逻辑,所以今天这一节的代码,不管拿到哪个项目上,都可以适用。我们的网络连接层使用OkHttp3,优点大家都知道,不了解的去看一下。

网络数据请求是一套工作流,简单画了一副图,大家看一下

Android企业级架构-仿微信-网络架构_第1张图片
数据请求工作流

发起一个网络请求简单来说有5个节点:1. 发起请求,2. 连接请求,3. 请求响应,4. 数据解析,5. 返回结果。其中节点2我们使用OkHttp来帮我们做,那余下的4个节点,就是我们要做的事情了。

  1. 配置OkHttp3:打开OkHttp的GitHub地址我们看到OkHttp现在最新的版本是3.7.0,打开工程目录下的build.gradle文件,在ext中添加如下变量:
    Android企业级架构-仿微信-网络架构_第2张图片
    配置OkHttp的版本号

    然后打开network目录下的build.gradle文件,在dependencies下添加如下引用
    compile "com.squareup.okhttp3:okhttp:$rootProject.ext.okhttpVersion"
    然后同步一下工程,将OkHttp的库下载到本地。
  2. 打开network目录下的src->main->java->com.monch.network,开始我们真正的Code之旅。
    整个文件目录并不算复杂,如下图所示:


    Android企业级架构-仿微信-网络架构_第3张图片
    Java文件结构

    整个文件目录,是围绕图1的流程所示,从上到下分别是:executor(执行器)目录、AccountException(帐号异常)、ApiCallback(网络请求回调)、ApiRequest(网络请求)、ApiResponse(网络请求响应)、ApiResult(网络请求结果)、ArrayFactory(Array创建器)、Failed(错误类型枚举)
    在executor(执行器)目录下,包括IExecutor(执行器接口)、OkHttpCallback(OkHttp响应回调)、OkHttpClientFactory(OkHttpClient创建器)、OkHttpExecutor(OkHttp的执行器实现)、RequestUtils(请求工具类)

  3. 下面我们按照一个请求的流程来分解代码。
    请求的最开始是ApiRequest,代码如下
// 请求实例池
    private static final Pools.Pool POOL = new Pools.SynchronizedPool<>(30);

    // 生成ApiRequest实例
    public static ApiRequest obtain(Builder builder) {
        ApiRequest instance = POOL.acquire();
        if (instance == null) {
            instance = new ApiRequest(builder);
        }
        return instance;
    }

    // 释放ApiRequest实例
    public static void release(ApiRequest request) {
        if (request == null) return;
        IExecutor executor = request.executor;
        if (executor != null) {
            // 释放请求缓存
            executor.releaseCache(request);
        }
        request.url = null;
        // 在这里,我们将所有的ArrayMap都置为null,
        // 是因为之前的请求有可能已经将ArrayMap的空间增加的足够大
        // 为了避免浪费多余分配的空间,之后的每次使用我们都重新创建
        if (request.parameters != null) {
            request.parameters.clear();
            request.parameters = null;
        }
        if (request.headers != null) {
            request.headers.clear();
            request.headers = null;
        }
        if (request.files != null) {
            request.files.clear();
            request.files = null;
        }
        request.callback = null;
        request.charset = null;
        request.tag = null;
        POOL.release(request);
    }

    // 默认执行器
    private static IExecutor mDefaultExecutor = new OkHttpExecutor();
    // 默认编码方式
    private static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");

    /* 请求类型 */
    public static final int GET = 0;
    public static final int POST = GET + 1;
    public static final int UPLOAD = POST + 1;
    public static final int DOWNLOAD = UPLOAD + 1;

    private String url;     // 请求URL
    private int type;       // 请求类型
    private ArrayMap parameters;    // 参数集合
    private ArrayMap headers;       // 请求头集合
    private ArrayMap files;           // 上传文件集合
    private ApiCallback callback;                   // 请求回调
    private Charset charset;                        // 编码
    private Object tag;                             // 标记
    private IExecutor executor;                     // 执行器

    private ApiRequest(Builder builder) {
        this.url = builder.url;
        this.type = builder.type;
        this.parameters = builder.parameters;
        this.headers = builder.headers;
        this.files = builder.files;
        this.callback = builder.callback;
        this.charset = builder.charset != null ? builder.charset : DEFAULT_CHARSET;
        this.tag = builder.tag;
        this.executor = builder.executor != null ? builder.executor : mDefaultExecutor;
    }

    // 开始请求
    private void request() {
        switch (type) {
            case POST:
                executor.doPost(this);
                break;
            case UPLOAD:
                executor.doUpload(this);
                break;
            case DOWNLOAD:
                executor.doDownload(this);
                break;
            default:
                executor.doGet(this);
                break;
        }
    }

    public String getUrl() {
        return url;
    }

    public int getType() {
        return type;
    }

    public ArrayMap getParameters() {
        return parameters;
    }

    public ArrayMap getHeaders() {
        return headers;
    }

    public ArrayMap getFiles() {
        return files;
    }

    public ApiCallback getCallback() {
        return callback;
    }

    public Charset getCharset() {
        return charset;
    }

    public Object getTag() {
        return tag;
    }

    public IExecutor getExecutor() {
        return executor;
    }

    public void cancel() {
        if (executor != null) {
            executor.cancel(this);
        }
    }

    public static Builder newBuilder() {
        return new Builder();
    }
    
    public static class Builder {
        private String url;
        private int type = GET;
        private ArrayMap parameters;
        private ArrayMap headers;
        private ArrayMap files;
        private ApiCallback callback;
        private Charset charset;
        private Object tag;
        private IExecutor executor;
        private Builder(){}
        public Builder url(String url) {
            this.url = url;
            return this;
        }
        public Builder addParameter(String key, String value) {
            if (parameters == null) {
                parameters = ArrayFactory.createArrayMap();
            }
            parameters.put(key, value);
            return this;
        }
        public Builder addHeader(String key, String value) {
            if (headers == null) {
                headers = ArrayFactory.createArrayMap(1);
            }
            headers.put(key, value);
            return this;
        }
        public Builder addFile(String key, File file) {
            if (files == null) {
                files = ArrayFactory.createArrayMap(1);
            }
            files.put(key, file);
            return this;
        }
        public Builder callback(ApiCallback callback) {
            this.callback = callback;
            return this;
        }
        public Builder charset(Charset charset) {
            this.charset = charset;
            return this;
        }
        public Builder tag(Object tag) {
            this.tag = tag;
            return this;
        }
        public Builder executor(IExecutor executor) {
            this.executor = executor;
            return this;
        }
        public ApiRequest get() {
            this.type = GET;
            ApiRequest request = obtain(this);
            request.request();
            return request;
        }
        public ApiRequest post() {
            this.type = POST;
            ApiRequest request = obtain(this);
            request.request();
            return request;
        }
        public ApiRequest upload() {
            this.type = UPLOAD;
            ApiRequest request = obtain(this);
            request.request();
            return request;
        }
        public ApiRequest download() {
            this.type = DOWNLOAD;
            ApiRequest request = obtain(this);
            request.request();
            return request;
        }
    }

在企业级工程中,网络请求的需求量是巨大的,所以我们对每个ApiRequest都使用Pools.Pool,这是一个实例缓存池,避免在运行时重复创建大量的实例,了解过JVM的同学都知道,创建实例是一个比较耗时的过程,而且大量实例废弃后会引发GC频繁,造成卡顿。这里我要强调一点,优化都是从一点一滴做起的,在优化的过程中,我们学习的内容也能更深入。
obtain和release两个静态方法,是生成和释放ApiRequest实例的方法,用法大家可以看一下代码。
接下来就是一些属性的定义:
mDefaultExecutor:这个是静态变量,存放默认的网络请求执行器,在我们的框架中,默认为OkHttpExecutor的实现,如果某一天大家需要更改执行器,那么直接替换这里就可以了。
默认的编码方式是UTF-8,这个没什么好说,大家都这样。

接下来是请求类型的定义,共使用4种:GET、POST、UPLOAD、DOWNLOAD,网络请求还有一些其它的类型,比如PUT、DELETE等,但现在基本很少使用,所以这里不定义。
以上的这些属性都是静态的,在内存中单独存在,不属于任何一个实例。下面是一个请求真正需要的变量:请求地址、请求类型、参数、请求头、文件、回调、编码、标记、执行器。ApiRequest类的构造函数是私有的,强制使用obtain方法创建实例。
tag(标记)属性需要说明一下,这是一个起到上下文的属性,举个粟子:我们在Service中发起了一个获取好友列表的请求,假设这个接口比较费时,当数据还没有返回时,用户已经退出登录又换了一个帐号登录上,然后获取好友列表的请求才返回,如果这些数据按照当前已经换帐号的环境去处理,必然是错的,所以这个时候,大家就有必要做一下处理了。这个属性我们可以在发起请求时保存一个userId,在处理之前,对比一下当前的userId是否一至,当一至时再处理。
代码很简单,大家都应该能看懂。对外暴露的接口就是ApiRequest.Builder创建请求。

接下来看一下IExecutor接口

/**
     * 拉取请求
     * @param request
     */
    void doGet(ApiRequest request);

    /**
     * 提交请求
     * @param request
     */
    void doPost(ApiRequest request);

    /**
     * 上传请求
     * @param request
     */
    void doUpload(ApiRequest request);

    /**
     * 下载请求
     * @param request
     */
    void doDownload(ApiRequest request);

    /**
     * 释放缓存
     * @param request
     */
    void releaseCache(ApiRequest request);

    /**
     * 取消请求
     * @param request
     */
    void cancel(ApiRequest request);

    /**
     * 取消所有请求
     */
    void cancelAll();

这个接口定义了这些方法,此版本我们使用OkHttp来实现这些接口,如果有一天我们需要换成Volley连接,那么直接创建一个VolleyExecutor类,实现IExecutor接口即可。

OkHttpExecutor的具体实现如下

private OkHttpClient mOkHttpClient;
    private Map mRequestCache = ArrayFactory.createConcurrentHashMap();

    public OkHttpExecutor() {
        mOkHttpClient = OkHttpClientFactory.getClient();
    }

    @Override
    public void doGet(ApiRequest request) {
        OkHttpClient client = mOkHttpClient;
        Charset charset = request.getCharset();
        String url = RequestUtils.makeUrl(request.getUrl(), request.getParameters(), charset);
        ApiCallback apiCallback = request.getCallback();
        if (apiCallback != null) {
            apiCallback.onStart(request);
        }
        Request.Builder builder = new Request.Builder();
        builder.url(url);
        builder.tag(request.getTag());
        builder.get();
        RequestUtils.makeHeader(builder, request.getHeaders(), charset);
        Call call = client.newCall(builder.build());
        call.enqueue(new OkHttpCallback(request));
        mRequestCache.put(request, call);
    }

    @Override
    public void doPost(ApiRequest request) {
        OkHttpClient client = mOkHttpClient;
        Charset charset = request.getCharset();
        ApiCallback callback = request.getCallback();
        if (callback != null) {
            callback.onStart(request);
        }
        Request.Builder builder = new Request.Builder();
        builder.url(request.getUrl());
        builder.tag(request.getTag());
        builder.post(formBody(request.getParameters(), charset));
        RequestUtils.makeHeader(builder, request.getHeaders(), charset);
        Call call = client.newCall(builder.build());
        call.enqueue(new OkHttpCallback(request));
        mRequestCache.put(request, call);
    }

    private RequestBody formBody(Map params, Charset charset) {
        FormBody.Builder builder = new FormBody.Builder();
        if (params != null && !params.isEmpty()) {
            for (Map.Entry entry : params.entrySet()) {
                String key = RequestUtils.encode(entry.getKey(), charset);
                String value = RequestUtils.encode(entry.getValue(), charset);
                if (!TextUtils.isEmpty(key) && value != null) {
                    builder.addEncoded(key, value);
                }
            }
        }
        return builder.build();
    }

    @Override
    public void doUpload(ApiRequest request) {
        OkHttpClient client = mOkHttpClient;
        Charset charset = request.getCharset();
        ApiCallback callback = request.getCallback();
        if (callback != null) {
            callback.onStart(request);
        }
        Request.Builder builder = new Request.Builder();
        builder.url(request.getUrl());
        builder.tag(request.getTag());
        builder.post(formBody(request.getParameters(), request.getFiles(), charset));
        RequestUtils.makeHeader(builder, request.getHeaders(), charset);
        Call call = client.newCall(builder.build());
        call.enqueue(new OkHttpCallback(request));
        mRequestCache.put(request, call);
    }

    private static final String DEFAULT_CONTENT = "Content-Disposition";

    private RequestBody formBody(Map params, Map files, Charset charset) {
        MultipartBody.Builder builder = new MultipartBody.Builder();
        builder.setType(MultipartBody.FORM);
        if (params != null && !params.isEmpty()) {
            for (Map.Entry entry : params.entrySet()) {
                String key = RequestUtils.encode(entry.getKey(), charset);
                byte[] content = entry.getValue().getBytes(charset);
                builder.addPart(Headers.of(DEFAULT_CONTENT, getParamValue(key)),
                        RequestBody.create(MediaType.parse(charset.name()), content));
            }
        }
        if (files != null && !files.isEmpty()) {
            for (Map.Entry entry : files.entrySet()) {
                String name = RequestUtils.encode(entry.getKey(), charset);
                File file = entry.getValue();
                String fileName = file.getName();
                builder.addPart(Headers.of(DEFAULT_CONTENT, getFileValue(name, fileName)),
                        RequestBody.create(MediaType.parse(guessMimeType(fileName)), file));
            }
        }
        return builder.build();
    }

    private static String guessMimeType(String path) {
        FileNameMap fileNameMap = URLConnection.getFileNameMap();
        String contentTypeFor = fileNameMap.getContentTypeFor(path);
        if (contentTypeFor == null) {
            contentTypeFor = "application/octet-stream";
        }
        return contentTypeFor;
    }

    private static String getParamValue(String name) {
        return "form-data; name=\"" + name + "\"";
    }

    private static String getFileValue(String name, String fileName) {
        return "form-data; name=\"" + name + "\"; filename=\"" + fileName + "\"";
    }

    @Override
    public void doDownload(ApiRequest request) {
        doGet(request);
    }

    @Override
    public void releaseCache(ApiRequest request) {
        if (request == null) return;
        if (mRequestCache.containsKey(request)) {
            mRequestCache.remove(request);
        }
    }

    @Override
    public void cancel(ApiRequest request) {
        if (request == null) return;
        if (mRequestCache.containsKey(request)) {
            Call call = mRequestCache.get(request);
            if (call != null && !call.isCanceled()) {
                call.cancel();
            }
            mRequestCache.remove(request);
        }
    }

    @Override
    public void cancelAll() {
        if (!mRequestCache.isEmpty()) {
            for (Call call : mRequestCache.values()) {
                if (call != null && !call.isCanceled()) {
                    call.cancel();
                }
            }
            mRequestCache.clear();
        }
    }

OkHttp的具体用法在这就不讲了,如果有不清楚的,去看一下OkHttp的使用即可。
这里有一点需要注意,就是我们的mRequestCache(请求缓存)变量,因为存在并发的问题,所以我这里定义为线程安全的ConcurrentHashMap。
请求的参数,在这里都已经做过Encoder处理,GET请求也会自动的将参数拼接到URL上,所以大家不需要担心。

OkHttpClient的赋值,是使用OkHttpClientFactory类的getClient方法,这个方法是获取了一个支持所有证书的SSL连接的实例,可用于https的请求。代码如下
···

private static final int TIMEOUT = 60;
private volatile static OkHttpClient mOkHttpClient;
static OkHttpClient getClient() {
    if (mOkHttpClient == null) {
        synchronized (OkHttpClientFactory.class) {
            if (mOkHttpClient == null) {
                try {
                    X509TrustManager trustManager = createInsecureTrustManager();
                    SSLSocketFactory sslSocketFactory = createInsecureSslSocketFactory(trustManager);
                    mOkHttpClient = new OkHttpClient.Builder()
                            .connectTimeout(TIMEOUT, TimeUnit.SECONDS)
                            .readTimeout(TIMEOUT, TimeUnit.SECONDS)
                            .writeTimeout(TIMEOUT, TimeUnit.SECONDS)
                            .sslSocketFactory(sslSocketFactory, trustManager)
                            .hostnameVerifier(createInsecureHostnameVerifier())
                            .build();
                } catch (Exception e) {
                    Log.e(TAG, "Get client error", e);
                    mOkHttpClient = new OkHttpClient.Builder()
                            .connectTimeout(TIMEOUT, TimeUnit.SECONDS)
                            .readTimeout(TIMEOUT, TimeUnit.SECONDS)
                            .writeTimeout(TIMEOUT, TimeUnit.SECONDS)
                            .build();
                }
            }
        }
    }
    return mOkHttpClient;
}

private static HostnameVerifier createInsecureHostnameVerifier() {
    return new HostnameVerifier() {
        @Override public boolean verify(String s, SSLSession sslSession) {
            return true;
        }
    };
}

private static SSLSocketFactory createInsecureSslSocketFactory(TrustManager trustManager) {
    try {
        SSLContext context = SSLContext.getInstance("TLS");
        context.init(null, new TrustManager[] {trustManager}, new SecureRandom());
        return context.getSocketFactory();
    } catch (Exception e) {
        throw new AssertionError(e);
    }
}

/**
 * 信任所有证书
 */
private static X509TrustManager createInsecureTrustManager() {
    return new X509TrustManager() {
        @Override public void checkClientTrusted(X509Certificate[] chain, String authType) {
        }

        @Override public void checkServerTrusted(X509Certificate[] chain, String authType) {
        }

        @Override public X509Certificate[] getAcceptedIssuers() {
            return new X509Certificate[0];
        }
    };
}

···
接下来再看如下代码:
Call call = client.newCall(builder.build());
call.enqueue(new OkHttpCallback(request));
这是将每个具体请求加入到请求队列中,我们都创建了一个OkHttpCallback实例,用于请求响应的回调。代码如下

public class OkHttpCallback implements Callback {

    /** 主线程执行器 **/
    private static Handler mResponseHandler = new Handler(Looper.getMainLooper());
    private static Executor mResponsePoster = new Executor() {
        @Override
        public void execute(@NonNull Runnable command) {
            mResponseHandler.post(command);
        }
    };

    private ApiRequest apiRequest;

    public OkHttpCallback(ApiRequest apiRequest) {
        this.apiRequest = apiRequest;
    }

    @Override
    public void onFailure(Call call, IOException e) {
        // 请求失败,将任务抛回主线程执行
        mResponsePoster.execute(new FailedRunnable(apiRequest, call, e));
    }

    @Override
    public void onResponse(Call call, Response response) throws IOException {
        if (call.isCanceled()) {
            // 请求已终止
            mResponsePoster.execute(new FailedRunnable(apiRequest, call, null));
            return;
        }
        if (response == null) {
            // 请求未响应
            mResponsePoster.execute(new FailedRunnable(apiRequest, call,
                    new IOException("Response is null.")));
            return;
        }
        if (!response.isSuccessful()) {
            // 请求失败
            mResponsePoster.execute(new FailedRunnable(apiRequest, call,
                    new IOException("Unexpected code " + response)));
            return;
        }
        ApiCallback apiCallback = apiRequest.getCallback();
        if (apiCallback == null) return;
        ResponseBody body = response.body();
        try {
            // 填充请求响应数据
            ApiResponse apiResponse = ApiResponse.obtain();
            apiResponse.setCode(response.code());
            apiResponse.setCharset(apiRequest.getCharset());
            apiResponse.setBody(body.bytes());
            Headers headers = response.headers();
            for (String key : headers.names()) {
                apiResponse.addHeader(key, headers.get(key));
            }
            apiResponse.setTag(apiRequest.getTag());
            // 回调响应,运行在子线程,用于数据解析
            ApiResult apiResult = apiCallback.onResponse(apiResponse);
            // 释放响应数据
            ApiResponse.release(apiResponse);
            // 抛回主线程执行完成
            mResponsePoster.execute(new SuccessRunnable(apiRequest, call, apiResult));
        } catch (Exception e) {
            // 抛回主线程执行失败
            mResponsePoster.execute(new FailedRunnable(apiRequest, call, e));
        } finally {
            if (body != null) body.close();
        }
    }

    // 请求错误处理
    private static class FailedRunnable implements Runnable {
        private ApiRequest apiRequest;
        private Call call;
        private Throwable throwable;
        FailedRunnable(ApiRequest apiRequest, Call call, Throwable throwable) {
            this.apiRequest = apiRequest;
            this.call = call;
            this.throwable = throwable;
        }
        @Override
        public void run() {
            ApiCallback apiCallback = apiRequest.getCallback();
            if (apiCallback != null) {
                if (call.isCanceled()) {
                    apiCallback.onCancel();
                } else {
                    Failed f = Failed.OTHER;
                    if (throwable != null) {
                        if (throwable instanceof IOException) {
                            f = Failed.NETWORK_ERROR;       // 网络异常
                        } else if (throwable instanceof TimeoutException) {
                            f = Failed.TIMEOUT_ERROR;       // 请求超时
                        } else if (throwable instanceof JSONException) {
                            f = Failed.PARSE_ERROR;         // 数据解析异常
                        } else if (throwable instanceof AccountException) {
                            apiCallback.onAccountError();   // 帐户信息异常
                            return;
                        }
                    }
                    apiCallback.onFailure(f, throwable);
                }
            }
            ApiRequest.release(apiRequest);
        }
    }

    // 请求成功处理
    private static class SuccessRunnable implements Runnable {
        private ApiRequest apiRequest;
        private Call call;
        private ApiResult apiResult;
        SuccessRunnable(ApiRequest apiRequest, Call call, ApiResult apiResult) {
            this.apiRequest = apiRequest;
            this.call = call;
            this.apiResult = apiResult;
        }
        @Override
        public void run() {
            ApiCallback callback = apiRequest.getCallback();
            if (callback != null) {
                if (call.isCanceled()) {
                    callback.onCancel();
                } else {
                    callback.onComplete(apiResult);
                }
            }
            ApiResult.release(apiResult);
            ApiRequest.release(apiRequest);
        }
    }

}

这个类实现了okhttp3.Callback接口,需要实现两个方法onFailure和onResponse,大家应该都知道这两个方法的作用吧?
在onResponse回调方法中,我们创建了ApiResponse实例,将主要的响应数据填充进去,包括响应码、响应数据、响应头等信息,依靠这些数据,我们使用ApiCallback的回调,将这些数据抛给上层使用者去解析
ApiResult apiResult = apiCallback.onResponse(apiResponse);
然后将结果使用mResponsePoster抛回到主线程处理,至此,一个完整的请求流程完成了。
下面我们看一下ApiCallback都有哪些回调

public interface ApiCallback {

    /**
     * 请求开始回调,运行在当前线程
     * @param request 请求数据
     */
    void onStart(ApiRequest request);

    /**
     * 请求响应回调,运行在子线程,主要用于数据解析。
     * 在解析过程中,如果发现后台返回的错误为帐户异常,
     * 可直接抛出AccountException,在onAccountError回调中统一处理
     * @param response 响应数据
     * @return
     * @throws JSONException JSON解析异常
     * @throws AccountException 帐户登录异常
     */
    ApiResult onResponse(ApiResponse response) throws JSONException, AccountException;

    /**
     * 请求完成,运行在主线程,将解析后的结果返回
     * @param result 解析结果
     */
    void onComplete(ApiResult result);

    /**
     * 请求失败回调,运行在主线程
     * @param failed 错误类型
     * @param throwable 异常信息
     */
    void onFailure(Failed failed, Throwable throwable);

    /**
     * 帐户异常回调,运行在主线程,在onResponse回调中,如果接收到AccountException异常,会直接回调到这里
     */
    void onAccountError();

    /**
     * 请求取消回调,运行在主线程
     */
    void onCancel();

}

注释写的比较清楚,不再赘述。

整个封装的代码框架差不多就这些,此框架当前状态下,有着非常好的扩展性。当我需要替换成Volley,我只需要做到以下几点:

  1. 创建一个类叫VolleyExecutor,实现IExecutor接口,然后按照Volley的方式填充各个方法。
  2. 再创建一个叫VolleyCallback的类,将Volley的回调转换成我们的ApiCallback。
  3. 将ApiRequest类的mDefaultExecutor属性,默认实现替换成new VolleyExecutor();即可,完全不影响上层的任何使用。
    这只是一个简单的封装,我们也可以更彻底一点,做一个请求分发流,这样我们只需要使用OkHttp的连接功能,不过这样做太费事,暂时不考虑。

下面的代码,是现在状态的使用

ApiRequest req = ApiRequest.newBuilder()
                .url("https://www.baidu.com")
                .addParameter("key1", "value1")
                .addParameter("key2", "value2")
                .addHeader("header1", "headerValue1")
                .callback(new ApiCallback() {
                    @Override
                    public void onStart(ApiRequest request) {
                        // 请求开始
                    }

                    @Override
                    public ApiResult onResponse(ApiResponse response) throws JSONException, AccountException {
                        JSONObject jsonObject = new JSONObject(response.getString());
                        ApiResult result = ApiResult.obtain();
                        int code = jsonObject.optInt("code");
                        
                        // 假如我们与服务端的同学设定,code等于10的时候,说明帐号异常,那么处理代码如下:
                        if (code == 10) {
                            throw new AccountException();
                        }
                        
                        result.setCode(code);
                        result.setErrorMessage(jsonObject.optString("errorMsg"));
                        if (result.isSuccess()) {   // 当code为0时,表示成功
                            Object object = jsonObject.optString("test");
                            result.put("object", object);
                        }
                        return result;
                    }

                    @Override
                    public void onComplete(ApiResult result) {
                        if (result.isSuccess()) {
                            Object object = result.get("object");
                            if (object != null) {
                                Log.e("Test", object.toString());
                            }
                        }
                    }

                    @Override
                    public void onFailure(Failed failed, Throwable throwable) {
                        Toast.makeText(this, failed.error(), Toast.LENGTH_SHORT).show();
                    }

                    @Override
                    public void onAccountError() {
                        // 这里表示登录异常,我们可以将用户踢到登录页面
                    }

                    @Override
                    public void onCancel() {
                        // 请求取消的回调
                    }
                })
                .get();
        if (如果需要取消请求) {
            req.cancel();
        }

各位看官,是不是一看吓了一跳,我擦,这么费事还搞个屁呀。。。
说明,说明,说明。。。这是半成品,现在的状态,是扩展性非常好的状态,但是使用还不方便,在真正的工程使用时,我们还需要结合具体业务,做二次封装。比如我们所有的接口都需要上传用户的位置、版本号等信息,现在的状态是不方便的。

今天说到这,具体代码请移步GitHub查看。感谢!

你可能感兴趣的:(Android企业级架构-仿微信-网络架构)