OkHttp的简单封装

最新推荐文章于 2024-07-18 17:04:34 发布

松小猿

最新推荐文章于 2024-07-18 17:04:34 发布

阅读量2k

点赞数 1

本文链接：https://blog.csdn.net/ss498976239/article/details/83687438

版权

我们都知道，很多app的应用都离不开对网络的请求，OkHttp是一个很好的移动网络请求框架。使用起来非常方便，但是如果每使用一次网络请求就要去new 一个client，不仅代码冗长多余，而且没有必要浪费资源，所以我们今天要讲的就是将OkHttp进行简单的封装，作为一个工具类来调用，也体现了java三要素之一：封装。

在上一篇里，已经说过如何添加依赖和网络权限，这里就不赘述。Android目前不允许在主线程里对网络进行请求，因为会阻塞UI线程，用户体验非常不好，所以，所有的网络请求都应该在子线程里进行，这里也就涉及到多线程，我们将以单例的形式来做网络请求，让整个应用只有一个OkhttpClient。节省资源开销。

我们写的是一个工具类OkHttpUtil，所以谁使用这个工具类，就将获取到的网络数据回调给谁。所以，先写一个回调接口，包含两个方法java代码

 //创建接口，回调给调用者
    interface ResultCallback{
        void onError(Request request,Exception e);
        void onResponse(Response response) throws IOException;
    }

接着我们创建OkHttpUtil的实例，我们使用单例模式，网络请求最好使用单例模式。将其构造方法私有化，然后提供一个静态的方法返回OkHttpUtil对象。这里提一下，单例模式最好写两个判定语句，这里就不细说了，属于java设计模式范畴。

private volatile static OkHttpUtil okHttpUtil;//会被多线程使用，所以使用关键字volatile
    private OkHttpClient client;
    private Handler mHandler;
    //私有化构造方法
    private OkHttpUtil(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));//设置缓存的路径
                 client = builder.build();
                mHandler = new Handler();
    }
    //单例模式，全局得到一个OkHttpUtil对象
    public static OkHttpUtil getInstance(Context context){
        if (okHttpUtil == null){
            synchronized (OkHttpUtil.class){
                if (okHttpUtil == null){
                    okHttpUtil = new OkHttpUtil(context);
                }
            }
        }
        return okHttpUtil;
    }

在其私有的构造方法中，我们得到了一个OkHttpClient 和handler，他们分别是用来发起网络请求和在线程中传递数据。handler是一个很神奇的东东，传递数据就靠它了。我们刚刚说网络请求在子线程中进行的，而Android是不允许在子线程中更新UI的，那我们如何将数据更新到UI线程呢？其实就是handler帮我们完成的。

我们再写两个私有的方法，来处理如何将得到的网络数据传递出去，一个是当请求成功后的方法，一个是请求失败后的方法

/**当请求失败时，都会调用这个方法
     * @param call
     * @param e
     * @param callback
     */
    private void sendFailedCallback(final Call call, final IOException e, final ResultCallback callback){
        mHandler.post(new Runnable() {
            @Override
            public void run() {
                Log.i("main","当前线程："+Thread.currentThread().getName());
                if (callback != null){
                    callback.onError(call.request(),e);
                }
            }
        });
    }

    /**请求成功调用该方法
     * @param response  返回的数据
     * @param callback 回调的接口
     */
    private void sendSuccessCallback(final Response response, final ResultCallback callback){
        mHandler.post(new Runnable() {
            @Override
            public void run() {
                Log.i("main","当前线程："+Thread.currentThread().getName());
                if (callback != null){
                    try {
                        callback.onResponse(response);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
    }

这里我们使用handler.post()来传递数据，这里看起来好像开启了一个新的线程，但是，我通过控制台获取当前线程的名称，竟然发现这个handler工作在主线程，也就是说，我们可以直接在回调里面更新UI了。

前期工作都准备就绪，我们可以写请求方法了，一个是get请求，一个是post请求（提交表单）

/**get异步请求
     * @param url
     * @param callback
     */
    public void getAsynHttp(String url, final ResultCallback callback){
         Request request = new Request.Builder()
                .url(url)
                .build();
        client.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                sendFailedCallback(call,e,callback);
            }

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

    /**提交表单数据
     * @param url
     * @param map
     * @param callback
     */
    public void postForm(String url, Map<String,String > map, final ResultCallback callback){
        FormBody.Builder form = new FormBody.Builder();//表单对象，包含以input开始的对象,以html表单为主
        if (map != null && !map.isEmpty()){
            //遍历Map集合
            for(Map.Entry<String ,String> entry : map.entrySet()){
                form.add(entry.getKey(),entry.getValue());
            }
            RequestBody body = form.build();
            Request request = new Request.Builder().url(url).post(body).build();//采用post提交数据
            client.newCall(request).enqueue(new Callback() {
                @Override
                public void onFailure(Call call, IOException e) {
                        sendFailedCallback(call,e,callback);
                }

                @Override
                public void onResponse(Call call, Response response) throws IOException {
                    if (response.isSuccessful()&&response != null){
                        sendSuccessCallback(response,callback);
                    }
                }
            });
        }

    }

其实，封装使用的知识点不是很多，弄清楚单例模式，接口回调，也就差不多了，当然，我们还可以添加很多方法，让这个工具类更充实，大家可以根据自己的实际情况添加。在最后我会贴上工具类的源码，以及具体使用例子

OkHttpUtil源码

public class OkHttpUtil {
    private volatile static OkHttpUtil okHttpUtil;//会被多线程使用，所以使用关键字volatile
    private OkHttpClient client;
    private Handler mHandler;
    //私有化构造方法
    private OkHttpUtil(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));//设置缓存的路径
                 client = builder.build();
                mHandler = new Handler();
    }
    //单例模式，全局得到一个OkHttpUtil对象
    public static OkHttpUtil getInstance(Context context){
        if (okHttpUtil == null){
            synchronized (OkHttpUtil.class){
                if (okHttpUtil == null){
                    okHttpUtil = new OkHttpUtil(context);
                }
            }
        }
        return okHttpUtil;
    }

    /**get异步请求
     * @param url
     * @param callback
     */
    public void getAsynHttp(String url, final ResultCallback callback){
         Request request = new Request.Builder()
                .url(url)
                .build();
        client.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                sendFailedCallback(call,e,callback);
            }

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

    /**提交表单数据
     * @param url
     * @param map
     * @param callback
     */
    public void postForm(String url, Map<String,String > map, final ResultCallback callback){
        FormBody.Builder form = new FormBody.Builder();//表单对象，包含以input开始的对象,以html表单为主
        if (map != null && !map.isEmpty()){
            //遍历Map集合
            for(Map.Entry<String ,String> entry : map.entrySet()){
                form.add(entry.getKey(),entry.getValue());
            }
            RequestBody body = form.build();
            Request request = new Request.Builder().url(url).post(body).build();//采用post提交数据
            client.newCall(request).enqueue(new Callback() {
                @Override
                public void onFailure(Call call, IOException e) {
                        sendFailedCallback(call,e,callback);
                }

                @Override
                public void onResponse(Call call, Response response) throws IOException {
                    if (response.isSuccessful()&&response != null){
                        sendSuccessCallback(response,callback);
                    }
                }
            });
        }

    }

    /**当请求失败时，都会调用这个方法
     * @param call
     * @param e
     * @param callback
     */
    private void sendFailedCallback(final Call call, final IOException e, final ResultCallback callback){
        mHandler.post(new Runnable() {
            @Override
            public void run() {
                Log.i("main","当前线程："+Thread.currentThread().getName());
                if (callback != null){
                    callback.onError(call.request(),e);
                }
            }
        });
    }

    /**请求成功调用该方法
     * @param response  返回的数据
     * @param callback 回调的接口
     */
    private void sendSuccessCallback(final Response response, final ResultCallback callback){
        mHandler.post(new Runnable() {
            @Override
            public void run() {
                Log.i("main","当前线程："+Thread.currentThread().getName());
                if (callback != null){
                    try {
                        callback.onResponse(response);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
    }

    //创建接口，回调给调用者
    interface ResultCallback{
        void onError(Request request,Exception e);
        void onResponse(Response response) throws IOException;
    }

}

在MainActivity中，我们添加一个按钮，这些代码就不一一讲解了，然后再按钮里发送请求

public class MainActivity extends AppCompatActivity {
    private utl_btn;
    private OkHttpUtil httpUtil;
    private String path = "xxxxxxxxxxx";
    private String path_url = "xxxxxxxxxxx";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        utl_btn = (Button) findViewById(R.id.btn3);
        httpUtil = OkHttpUtil.getInstance(MainActivity.this);
        utl_btn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                HashMap<String,String> map = new HashMap();
                map.put("xxx","yyy");
                map.put("zzz","aaa");
                httpUtil.postForm(path_url, map, new OkHttpUtil.ResultCallback() {
                    @Override
                    public void onError(Request request, Exception e) {

                    }

                    @Override
                    public void onResponse(Response response) throws IOException {
                        Log.i("main","response:"+response.body().string());
                    }
                });
            }

        });
    }

}

好了，其实如果网络请求不是很复杂，我们完全可以自己封装一个，没有必要使用开源库，当然，GitHub上有很多优秀的开源库，值得我们学习和借鉴，如果比较懒的话，可是直接添加依赖，这里推荐一个OkHttpFinal

松小猿

关注

1
点赞
踩
10

收藏

觉得还不错? 一键收藏
1
评论
OkHttp的简单封装

我们都知道，很多app的应用都离不开对网络的请求，OkHttp是一个很好的移动网络请求框架。使用起来非常方便，但是如果每使用一次网络请求就要去new 一个client，不仅代码冗长多余，而且没有必要浪费资源，所以我们今天要讲的就是将OkHttp进行简单的封装，作为一个工具类来调用，也体现了java三要素之一：封装。在上一篇里，已经说过如何添加依赖和网络权限，这里就不赘...
复制链接

扫一扫