基于OkHttp 3封装的网络请求

最新推荐文章于 2023-05-13 14:06:49 发布
最新推荐文章于 2023-05-13 14:06:49 发布
阅读量967 收藏 3
点赞数
分类专栏： Android原创 文章标签： 网络请求
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wanxiaofan/article/details/83058446
版权

首先导入okhttp

compile 'com.squareup.okhttp3:okhttp:3.7.0'

 

封装的主要类

OkHttpHelper主要是封装的OkHttpClient以及请求参数的封装
BaseCallback 辅助类
SpotsCallBack加载的提示框，可以更改

OkHttpHelper类

首先把它做成一个单例

   private static class singleHolder {
        private static final OkHttpHelper instance = new OkHttpHelper();
    }

    private OkHttpHelper() {
        okHttpClient = new OkHttpClient().newBuilder()
                .readTimeout(10, TimeUnit.SECONDS)//设置读取超时时间
                .writeTimeout(10, TimeUnit.SECONDS)//设置写的超时时间
                .connectTimeout(10, TimeUnit.SECONDS)//设置连接超时时间
                .build();
        mGson = new Gson();
        mHandler = new Handler(Looper.getMainLooper());
    }

    public static OkHttpHelper getInstance() {

        return singleHolder.instance;
    }

在封装BaseCallback因为我们要根据它得到类型

static Type getSuperclassTypeParameter(Class<?> subclass) {

        Type superclass = subclass.getGenericSuperclass();
        if (superclass instanceof Class) {
            throw new RuntimeException("Missing type parameter.");
        }
        ParameterizedType parameterizedType = (ParameterizedType) superclass;

        return $Gson$Types.canonicalize(parameterizedType.getActualTypeArguments()[0]);
    }

然后在封装doRequest方法

   private void doRequest(Request request, final BaseCallback callback) {
        callback.onRequestBefore(request);
        okHttpClient.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                callback.onFailure(call.request(), e);
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                callback.OnResponse(response);
                if (response.isSuccessful()) {
                    if (callback.mType == String.class) {
                        String resultStr = response.body().string();

                        LogHelper.i("String 请求到的数据：" + resultStr);
                        callbackSuccess(callback, response, resultStr);
                    } else if (("" + callback.mType).equals("byte[]")) {
                        byte[] resultStr = response.body().bytes();
                        LogHelper.i("byte 请求到的数据：" + resultStr);
                        callbackSuccess(callback, response, resultStr);
                    } else {
                        try {
                            String resultStr = response.body().string();
                            LogHelper.i("json 请求到的数据：" + resultStr);
                            Object object = mGson.fromJson(resultStr, callback.mType);
                            callbackSuccess(callback, response, object);
                        } catch (Exception e) {
                            e.printStackTrace();
                            callbackError(callback, response, response.code(), e);
                        }
                    }

                } else {
                    callback.onError(response, response.code(), null);
                }
            }
        });
    }

 

最后测试

//请求参数
   Map<String, String> map = new HashMap<>();
        
        OkHttpHelper.getInstance().post("请求的地址", map, new SpotsCallBack<BannerClazz>(UIUtils.getContext(), false) {
            @Override
            public void onSuccess(Response response, BannerClazz bannerClazz) {
                    iBannerInterface.bannerSuccess(bannerClazz);
            }

            @Override
            public void onError(Response response, int code, Exception e) {

            }
        });

下边贴出完整代码

import android.os.Handler;
import android.os.Looper;

import com.google.gson.Gson;
import com.google.gson.JsonElement;
import com.google.gson.JsonParser;

import java.io.File;
import java.io.IOException;
import java.util.Map;
import java.util.concurrent.TimeUnit;

import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.FormBody;
import okhttp3.MediaType;
import okhttp3.MultipartBody;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;


public class OkHttpHelper {
    private static OkHttpClient okHttpClient;
    private Gson mGson;
    private Handler mHandler;

    private static class singleHolder {
        private static final OkHttpHelper instance = new OkHttpHelper();
    }

    private OkHttpHelper() {
        okHttpClient = new OkHttpClient().newBuilder()
                .readTimeout(10, TimeUnit.SECONDS)//设置读取超时时间
                .writeTimeout(10, TimeUnit.SECONDS)//设置写的超时时间
                .connectTimeout(10, TimeUnit.SECONDS)//设置连接超时时间
                .build();
        mGson = new Gson();
        mHandler = new Handler(Looper.getMainLooper());
    }

    public static OkHttpHelper getInstance() {

//        return new OkHttpHelper();
        return singleHolder.instance;
    }

    private void doRequest(Request request, final BaseCallback callback) {
        callback.onRequestBefore(request);
        okHttpClient.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                callback.onFailure(call.request(), e);
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                callback.OnResponse(response);
                if (response.isSuccessful()) {
                    if (callback.mType == String.class) {
                        String resultStr = response.body().string();

                        LogHelper.i("String 请求到的数据：" + resultStr);
                        callbackSuccess(callback, response, resultStr);
                    } else if (("" + callback.mType).equals("byte[]")) {
                        byte[] resultStr = response.body().bytes();
                        LogHelper.i("byte 请求到的数据：" + resultStr);
                        callbackSuccess(callback, response, resultStr);
                    } else {
                        try {
                            String resultStr = response.body().string();
                            LogHelper.i("json 请求到的数据：" + resultStr);
                            Object object = mGson.fromJson(resultStr, callback.mType);
                            callbackSuccess(callback, response, object);
                        } catch (Exception e) {
                            e.printStackTrace();
                            callbackError(callback, response, response.code(), e);
                        }
                    }

                } else {
                    callback.onError(response, response.code(), null);
                }
            }
        });
    }


    public void get(String url, BaseCallback callback) {
        Request request = buildRequest(url, null, HttpMethodType.GET);

        doRequest(request, callback);
    }

    public void post(String url, Map<String, String> params, BaseCallback callback) {
        Request request = buildRequest(url, params, HttpMethodType.POST);
        doRequest(request, callback);
    }

    public void file(String url, String localPath, BaseCallback callback) {
        if (!CommonUtil.getInstance().judgeStrIsNull(url) &&
                !CommonUtil.getInstance().judgeStrIsNull(localPath)) {
            File file = new File(localPath);
            if (!file.exists()) {
                LogHelper.e("该路径下找不到此文件");
                return;
            }

            RequestBody body = RequestBody.create(MediaType.parse("image/*"), file);
            // 初始化请求体对象，设置Content-Type以及文件数据流
            RequestBody requestBody = new MultipartBody.Builder()
                    .setType(MultipartBody.FORM) // multipart/form-data
                    .addFormDataPart("file", file.getName(), body)
                    .build();

            Request request = new Request.Builder().url(url).post(requestBody).build();
            doRequest(request, callback);

        } else {
            LogHelper.e("本地路径或者服务器上传路径为空");
        }
    }


    private Request buildRequest(String url, Map<String, String> params, HttpMethodType methodType) {
        Request.Builder builder = new Request.Builder();
        builder.url(url);
        LogHelper.i("Request Url::" + url);
        if (methodType == HttpMethodType.GET) {
            builder.get();
        } else if (methodType == HttpMethodType.POST) {
            RequestBody body = buildFormData(params);
            builder.post(body);
        }

        return builder.build();
    }

    private RequestBody buildFormData(Map<String, String> params) {
        FormBody.Builder body = new FormBody.Builder();
        if (params != null) {
            for (Map.Entry<String, String> entry : params.entrySet()) {
                try {
                    LogHelper.i("key::" + entry.getKey() + "--value::" + entry.getValue());
                    if (!CommonUtil.getInstance().judgeStrIsNull(entry.getKey())) {
                        body.add(entry.getKey(), entry.getValue());
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }


            }
        }
        return body.build();
    }

    enum HttpMethodType {
        GET, POST
    }

    private void callbackSuccess(final BaseCallback callback, final Response response, final Object object) {
        mHandler.post(new Runnable() {
            @Override
            public void run() {
                callback.onSuccess(response, object);
            }
        });

    }

    private void callbackError(final BaseCallback callback, final Response response, final int code, final Exception e) {
        mHandler.post(new Runnable() {
            @Override
            public void run() {
                callback.onError(response, code, e);
            }
        });

    }
}

 

public abstract class BaseCallback<T> {
    Type mType;
    public BaseCallback() {
        mType = getSuperclassTypeParameter(getClass());
    }



    static Type getSuperclassTypeParameter(Class<?> subclass) {

        Type superclass = subclass.getGenericSuperclass();
        if (superclass instanceof Class) {
            throw new RuntimeException("Missing type parameter.");
        }
        ParameterizedType parameterizedType = (ParameterizedType) superclass;

        return $Gson$Types.canonicalize(parameterizedType.getActualTypeArguments()[0]);
    }

    public abstract void onRequestBefore(Request request);

    public abstract void onFailure(Request request, IOException e);

    public abstract void onSuccess(Response response, T t);

    public abstract void onError(Response response, int code, Exception e);

    public abstract void OnResponse(Response response);
}

 

public abstract class SpotsCallBack<T> extends BaseCallback<T> {
    private SpotsDialog dialog;
    private boolean isShow = true;

    public SpotsCallBack(Context context) {
        try {
            dialog = new SpotsDialog(context);
        } catch (Exception e) {
            e.printStackTrace();
        }
        setMessage("加载中......");
    }

    public SpotsCallBack(Context context, boolean show) {
        this.isShow = show;
        if(isShow){
            try {
                dialog = new SpotsDialog(context);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }


        setMessage("加载中......");
    }

    public SpotsCallBack(Context context, String message) {
        try {
            dialog = new SpotsDialog(context);
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (!TextUtils.isEmpty(message)) {
            setMessage(message);
        }

    }

    protected void showDialog() {
        try {
            if (dialog != null) {
                dialog.show();
            }
        } catch (Exception e) {
            //e.printStackTrace();
        }

    }

    protected void dismissDialog() {
        try {
            if (dialog != null)
                dialog.dismiss();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    protected void setMessage(String message) {

        try {
            if (dialog != null) {
                dialog.setMessage(message);
            }
        } catch (Exception e) {
//            e.printStackTrace();
        }
    }

    @Override
    public void onRequestBefore(Request request) {
        if (isShow)
            showDialog();
    }



    @Override
    public void onFailure(Request request, IOException e) {
        dismissDialog();
    }

    @Override
    public void OnResponse(Response response) {
        dismissDialog();
    }
}

 

 

wanxiaofan
关注
专栏目录
SpringBoot实战（三十）发送HTTP/HTTPS请求的五种实现方式【下篇】（Okhttp3、RestTemplate、Hutool）
ACGkaka的博客
09-22 1700
SpringBoot实战（三十）发送HTTP/HTTPS请求的五种实现方式【下篇】（Okhttp3、RestTemplate、Hutool）
基于RxJava + Retrofit + okHttp3封装的网络请求包
12-26
此网络请求封装基于 RxJava + Retrofit + okHttp3，里面包含使用文档。可适用于所有 json 数据返回的网络请求，包括多文件上传，默认适用Gson解析返回结果，支持自定义解析对象，支持自定义解析方式。
okhttp3简单封装使用
05-15
okhttp3的简单的封装使用，只有get post2种网络请求的使用
OkHttp的使用
Mydtudysy的博客
10-13 580
1.导入依赖     compile 'com.squareup.okio:okio:1.5.0'     compile 'com.squareup.okhttp3:okhttp:3.2.0'     compile 'com.squareup.okhttp3:logging-interceptor:3.4.1'     compile 'com.google.code.gson:gso
基于okhttp的简单封装
zhaozhe
06-06 283
/** * Created by zhaozhe on 2017/6/5/005. */public class OKHttpManager { private volatile static OKHttpManager manager; //防止多个线程访问时 private final String TAG = OKHttpManager.class.getSimpleN
Okhttp3的封装
mChenys的博客
06-17 496
直接上代码，关于介绍的可以先看这篇文章，OkHttp3使用介绍 package mchenys.net.csdn.blog.research.utils; import android.app.Activity; import android.app.Application; import android.content.Context; import android.content.Conte...
okhttp3的封装
tiger_Angle
07-10 2815
https://github.com/hongyangAndroid/okhttputils 此处借鉴鸿洋大神分享的框架：https://github.com/hongyangAndroid/okhttputils 还有鸿洋大神的博客：https://blog.csdn.net/lmj623565791/article/details/47911083 使用前导入： implementation 'com.zhy:okhttputils:2.6.2' ​​​​​​Okhttp3封装_Snow_I.
基于OkHttp3封装的Java上传下载.zip
03-24
本教程将深入探讨如何基于OkHttp3进行文件的上传和下载操作。 首先，我们需要了解OkHttp3的核心概念。OkHttp通过连接池、HTTP/2多路复用以及响应缓存等机制，提高了网络请求的性能。它的设计目标是提供一个易于使用...
纯kotlin，基于okhttp封装的网络库。提供DSL调用方式.zip
02-17
【项目资源】： 包含前端、后端、移动开发、操作系统、人工智能、物联网、信息化管理、数据库、硬件开发、大数据、课程资源、音视频、网站开发等各种技术项目的源码。 ... 【项目质量】： 所有源码都经过严格测试，...
基于OkHttp进行封装，简化OkHttp网络请求操作，对于文件上传和下载均实现了进度
最新发布
09-29
基于OkHttp进行封装，简化OkHttp网络请求操作，对于文件上传和下载均实现了进度百分比，对于请_TigerOkHttp
Android-基于RxJava封装的OkHttp网络请求库
08-13
本文将详细解析如何基于RxJava封装OkHttp来构建一个强大的网络请求库，Lina-RxOkHttp。 首先，让我们理解下两个核心组件：RxJava和OkHttp。RxJava是一个用于处理异步数据流的库，它提供了观察者模式的实现，使得...
Okhttp3封装
weixin_43957085的博客
05-13 269
5.支持多url使用线程池。
okHttp3自用封装
weixin_33895475的博客
08-06 99
okHttp都已经出到3.2.0了，现在才开始要用到它，感觉自己好low~~ 根据平时自己的习惯，还是自己做一下封装，让代码撸起来更加顺畅一点！ okhttp-3.2.0和okio-1.7.0就不多说 首先建一个OkHttpUtils的类   [java] view plain copy     /**   * HTTP通讯结构处理器   *   */   ...
【Android】OkHttp3总结与封装
深蓝旭的博客
10-12 814
开始使用 在app目录下的build.gradle中添加依赖： implementation 'com.squareup.okhttp3:okhttp:3.13.1' implementation 'com.squareup.okio:okio:2.2.2' GET方法 OkHttpClient client = new OkHttpClient.Builder().build(); Request.Builder builder = new Request.Builder().url(url)...
Android okhttp3封装
小白james
12-07 1936
Okhttp确实是功能强大，高效率，简洁的网络请求框架，所以最近项目也集成了改框架，写了一个Manager管理类，整理下给大家看下。*** * 使用OkHttp框架执行网络请求 * */public class OkHttpManager { private static final String TAG = "OkHttpManager"; //提交json数据 pr
android okhttp3的封装
early-youth的博客
12-18 502
最近由于苦逼的学校课程，我们需要用android开发一款教学辅助软件，所以我就开始看android开发的相关知识，今天实战的时候发现okhttp还是蛮好用的，但是我不会对其进行封装，于是乎就百度了一发，看了下别人的博客，发现有位大佬写的真的好用，就把复制过来，以备以后使用。 大佬博客链接在此： http://blog.csdn.net/qq_30379689/article/details/52
okHttp3封装
qq_35999545的博客
12-10 565
public class OkHttp3Util { /** * 懒汉 安全 加同步 * 私有的静态成员变量 只声明不创建 * 私有的构造方法 * 提供返回实例的静态方法 */ private static OkHttpClient okHttpClient = null; private OkHttp3Util() { } public static OkHttpClient getInstance() { .
OkHttp3封装
weixin_33985507的博客
01-09 114
简单封装了OkHttp3的请求方法，包含：GET、POST、上传文件、下载文件。 1.GET请求 HttpUtils.getInstance() .url("url") .addHeader("key", "value") .add("key", "value") .debug(true) .get(new StringCallBack() { ...
Okhttp3的封装 搞定常用的请求
丶legend的博客
02-14 1373
开篇 这篇博客写下Okhttp的封装，作为安卓最应用最广泛的网络请求框架，okhttp也是被玩出了各种姿势，虽然已经帮我们把一个原生的网络请求封装精简了很多，不过为了更加的方便，还是再进行一层的封装，这里的封装包括了常用的GET,POST,DELETE,PUT的请求，其中post包括了基于json格式的请求，以及表单形式的请求，因为上传文件基本都是用的表单去提交的，基本这一套封装可以搞定安卓应用...
EasyHttp: 基于OkHttp的高效网络请求框架
资源摘要信息:"EasyHttp是一个基于OkHttp网络请求框架的封装库，它提供了一套简洁易用的API来简化HTTP网络请求的操作。OkHttp是一个高效的HTTP客户端，支持同步、异步请求以及多个HTTP协议特性，比如HTTP/2和SPDY。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值