engine方式封装OkHttp的异步GET

OkHttpEngine

首先，OkHttp是通过单例模式得到的。单例模式有一个私有的构造方法和一个静态的get方法。先看构造方法中做了什么。

    private OkHttpEngine(Context context) {
        File sdcache = context.getExternalCacheDir();
        int cacheSize = 10 * 1024 * 1024;
        OkHttpClient.Builder builder = new OkHttpClient.Builder()
                .connectTimeout(15, TimeUnit.SECONDS)
                .writeTimeout(20,TimeUnit.SECONDS)
                .readTimeout(20,TimeUnit.SECONDS)
                .cache(new Cache(sdcache.getAbsoluteFile(),cacheSize));
        mOkHttpClient = builder.build();
        mHandler = new Handler();
    }

主要做了两件事：

• 通过创建者模式构造了OkHttpClient，设置了缓存地址，缓存大小等。
• 新建了一个handler。

然后在getInstance方法中利用双重校验锁的方式得到单例。

    public static OkHttpEngine getInstance(Context context){
        if (mInstance == null){
            synchronized (OkHttpEngine.class){
                if (mInstance  == null){
                    mInstance = new OkHttpEngine(context);
                }
            }
        }
        return mInstance;
    }

然后发送异步请求：

    public void getAsynHttp(String url,ResultCallback callback){

        final Request request = new Request.Builder()
                .url(url)
                .build();
        Call call = mOkHttpClient.newCall(request);
        dealResult(call, callback);
    }

做了三件事情：

1. 构建request。
2. OkHttpClient根据request得到call。
3. dealResult根据call和回调结果callback处理结果。

dealResult

   private void dealResult(Call call, final ResultCallback callback) {
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                sendFailedCallback(call.request(), e, callback);
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                sendSuccessCallback(response.body().string(), callback);
            }
        });
    }

call通过enqueue方法实现Callback异步，重写回调结果的onFailure和onResponse方法。最终调用了sendFailedCallback和sendSuccessCallback方法。

sendSuccesCallback

    private void sendSuccessCallback(final String str,final ResultCallback callback) {
        mHandler.post(new Runnable() {
            @Override
            public void run() {
                if (callback != null){
                    try {
                        callback.onResponse(str);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
    }

通过handler的post方法开启子线程发送请求。这里callback是抽象类，方法需要被重写。

然后在主线程中通过Engine的方式来发送请求。

    private void getAsynForEngine() {
        OkHttpEngine.getInstance(MainActivity.this).getAsynHttp(
            "http://www.baidu.com", new ResultCallback() {
                @Override
                public void onError(Request request, Exception e) {

                }

                @Override
                public void onResponse(String str) throws IOException {
                    Log.d(TAG, str);
                    Toast.makeText(getApplicationContext(),"请求成功",
                            Toast.LENGTH_SHORT).show();
                }
            });
    }

直接得到engine对象，调用getAsynHttp方法重写onError和onResponse方法即可。