网络请求框架okhttp的使用

最新推荐文章于 2024-03-28 11:01:41 发布
最新推荐文章于 2024-03-28 11:01:41 发布
阅读量327 收藏
点赞数
分类专栏： android 文章标签： 网络 框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_19415675/article/details/73187497
版权

对okhttp、okio进行二次封装：

（非完整代码，只包含完整思路）

**
 * 网络操作类
 */
public class HttpBase {

    public static String push_token = "";
    private RequestQueue queue = null;// 请求队列
    private Context context;

    private AsyncHttpClient asyncHttpclient;

    public HttpBase(Context context) {
        super();
        queue = Volley.newRequestQueue(context);// 创建一个新的队列
        this.context = context;
        asyncHttpclient = new AsyncHttpClient();
    }

    /**
     * 队列停止工作
     */
    public void stopQueue() {
        if (queue != null) {
            queue.stop();
        }
    }

    /**
     * 获得jsonObject
     *
     * @param method   方法
     * @param url      路劲
     * @param list     参数列表
     * @param hasPath  List 中是否包含路径的KeyValue
     * @param listener 监听器
     */
    void doGetEntityConnect(int method, String url, List<MyKeyValues> list,
                            boolean hasPath, final JsonObjectListener listener) {
        JSONObject json = null;
        LogUtils.e(getClass().getName(), " url :" + url);
        try {
            json = JSONUtil.List2Json(list);
            if (hasPath)
                json = file_direction_repair(json.toString());
        } catch (JSONException e) {
            e.printStackTrace();
        }
        LogUtils.e(getClass().getName(), "请求的json：" + json + "\n  url :" + url);
        // 联网之前判断一下是否有网络
        if (!NetworkValue.isNetWorkEnable()) {
            listener.OnFailure(new ErrorReson(-4, context.getResources()
                    .getString(R.string.str_check_network)));
            return;
        }

        JsonObjectRequest request = new JsonObjectRequest(method, url, json,
                new Listener<JSONObject>() {
                    @Override
                    public void onResponse(JSONObject response) {
                        LogUtils.e(getClass().getName(), "response:" + response);
                        listener.OnSuccess(response);
                        int code;
                    }
                }, new ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                LogUtils.e(getClass().getSimpleName(), "失败");
                LogUtils.e("VOLLEY", error.toString());
                listener.OnFailure(new ErrorReson(-2, "服务器连接失败"));
            }
        });
        // request.setTag(tag);
        request.setRetryPolicy(new DefaultRetryPolicy(10000, 1, 1.0f));
        queue.add(request);
    }

    /**
     * 使用form的请求数据
     */
    void doGetForm(String url, List<MyKeyValues> list,
                   final JsonObjectListener listener) {
        // 联网之前判断一下是否有网络
        if (!NetworkValue.isNetWorkEnable()) {
            if (listener!=null)
                listener.OnFailure(new ErrorReson(-4, context.getResources()
                    .getString(R.string.str_check_network)));
            return;
        }
        RequestParams rParams = List2Parms(list);
        LogUtils.e(getClass().getName(), " url :" + url);
        LogUtils.e(getClass().getName(), "请求的Form：" + rParams.toString() + "\n  url :" + url);
        asyncHttpclient.post(url,
                rParams, new AsyncHttpResponseHandler() {
                    @Override
                    public void onSuccess(int i, Header[] headers, byte[] bytes) {
                        String json = new String(bytes);
                        LogUtils.e(getClass().getName(), "response:" + json);
                        try {
                            JSONObject jsonObject = new JSONObject(json);
                            if (listener!=null)
                                listener.OnSuccess(new JSONObject(json));
                        } catch (JSONException e) {
                            if (listener!=null)
                                listener.OnFailure(new ErrorReson(-1, "返回结果解析失败"));
                            e.printStackTrace();
                        }

                    }

                    @Override
                    public void onFailure(int i, Header[] headers, byte[] bytes, Throwable throwable) {
                        throwable.printStackTrace();
                        if (bytes == null || bytes.length == 0) {
                            if (listener!=null)
                                listener.OnFailure(new ErrorReson(i, i + ",服务器异常"));
                            return;
                        }
                        String msg = new String(bytes);
                        String error_message = "";
                        LogUtils.e("img上传失败 " + i, msg);
                        try {
                            JSONObject jsonObject = new JSONObject(msg);
                            error_message = jsonObject.getString("error_message");
                        } catch (JSONException e) {
                            e.printStackTrace();
                            if (listener!=null)
                                listener.OnFailure(new ErrorReson(i, i + ",服务器异常"));
                            return;
                        }
                        if (listener!=null)
                            listener.OnFailure(new ErrorReson(i, i + "," + error_message + ",数据异常"));
                    }
                });
    }

    public static RequestParams List2Parms(List<MyKeyValues> list) {
        RequestParams rParams = new RequestParams();
        for (MyKeyValues keyValues : list) {
            if (keyValues.getType() == MyKeyValues.STREAM)
                rParams.put(keyValues.getKey(), (InputStream) keyValues.getValue());
            else
                rParams.put(keyValues.getKey(), keyValues.getValue());
        }


        return rParams;
    }


    public void MyDoPostRequest(String url, String json, final JsonObjectListener listener) {
        JsonObjectRequest request = new JsonObjectRequest(Request.Method.POST, url, json,
                new Listener<JSONObject>() {
                    @Override
                    public void onResponse(JSONObject jsonObject) {
                        listener.OnSuccess(jsonObject);

                    }
                }, new ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError volleyError) {
                listener.OnFailure(new ErrorReson(500, volleyError.getMessage()));
            }
        });
        queue.add(request);
    }


    /**
     * get方法接口回调
     *
     * @param url
     * @param listener
     */
    public void doGetRequest(String url, final JsonObjectListener listener) {
        LogUtils.e(getClass().getName(), " url :" + url);
        JsonObjectRequest request = new JsonObjectRequest(url,
                new Listener<JSONObject>() {
                    @Override
                    public void onResponse(JSONObject jsonObject) {
                        LogUtils.e(getClass().getName(), "response:" + jsonObject.toString());
                        if (listener != null) {
                            listener.OnSuccess(jsonObject);
                        }
                    }
                }, new ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError volleyError) {
                if (listener != null) {
                    listener.OnFailure(new ErrorReson(500, volleyError.getMessage()));
                }
            }
        });
        queue.add(request);
    }

    /**
     * get方法接口回调
     *
     * @param url
     * @param listener
     */
    public void doGetNotJson(String url, final SimpleSuccessListener listener) {
        LogUtils.e(getClass().getName(), " url: " + url);
        Request request = new StringRequest(url,new Listener<String>() {
            @Override
            public void onResponse(String response) {
                LogUtils.e(getClass().getName(), "response: " + response);
                if (listener != null) {
                    listener.onSuccess(response);
                }
            }
        }, new ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError volleyError) {
                if (listener != null) {
                    listener.onFailure(new ErrorReson(500, volleyError.getMessage()));
                }
            }});
        queue.add(request);
    }

    /**
     * 处理不成功情况的接口回调
     *
     * @param code
     * @param listener
     */
    private void doOnErrorCode(int code, String msg, JsonObjectListener listener) {
        listener.OnFailure(new ErrorReson(code, msg));
//        switch (code) {
//
//            default:
//                listener.OnFailure(new ErrorReson(-1, "未知错误"));
//        }
    }

    /**
     * 返回得到的json
     *
     * @author huanghuanPC
     */
    public interface JsonObjectListener {
        void OnSuccess(JSONObject json);

        void OnFailure(ErrorReson reason);
    }

    /**
     * 简单的接口回调
     */
    public interface SimpleSuccessListener {
        void onSuccess(Object response);

        void onFailure(ErrorReson reason);
    }

    /**
     *
     */
    public static class ErrorReson {
        private int code;
        private String msg;

        public ErrorReson(int code, String msg) {
            super();
            this.code = code;
            this.msg = msg;
        }

        public int getCode() {
            return code;
        }

        public void setCode(int code) {
            this.code = code;
        }

        public String getMsg() {
            return msg;
        }

        public void setMsg(String msg) {
            this.msg = msg;
        }

        @Override
        public String toString() {
            return "ErrorReson [code=" + code + ", msg=" + msg + "]";
        }
    }

    /**
     * 文件路径调整（可优化）
     *
     * @param str
     * @return
     * @throws JSONException
     */
    private JSONObject file_direction_repair(String str) throws JSONException {
        char[] cha = str.toCharArray();
        int j = 0, k = 0;
        for (; j < cha.length; j++)
            if (cha[j] != '\\')
                cha[k++] = cha[j];
        str = new String(cha, 0, k);
        return new JSONObject(str);
    }

    /**
     * 下载bitmap
     *
     * @param url
     * @param width    图片的最大宽 指定0的话就是不压缩
     * @param height   图片的最大高 指定0的话就是不压缩
     * @param listener
     */
    void doGetBitmap(String url, int width, int height,
                     final OnEntityConnectListener<Bitmap> listener) {
        @SuppressWarnings("deprecation")
        ImageRequest request_image = new ImageRequest(url,
                new Listener<Bitmap>() {

                    @Override
                    public void onResponse(Bitmap response) {
                        listener.OnSuccess(response);
                    }
                }, width, height, Config.ARGB_8888, new ErrorListener() {

            @Override
            public void onErrorResponse(VolleyError error) {
                listener.OnFailure(new ErrorReson(-1, "下载图片失败"));
            }
        });
        queue.add(request_image);
    }

    public void getBitmapFromNet(String url,
                                 final OnEntityConnectListener<Bitmap> listener) {

        LogUtils.d("Bitmap Fetch", "URL : " + url);

        @SuppressWarnings("deprecation")
        ImageRequest imageRequest = new ImageRequest(url,
                new Listener<Bitmap>() {

                    @Override
                    public void onResponse(Bitmap arg0) {
                        listener.OnSuccess(arg0);

                    }
                }, 0, 0, Config.RGB_565, new ErrorListener() {

            @Override
            public void onErrorResponse(VolleyError arg0) {
                listener.OnFailure(new ErrorReson(-2, "Request Net Fail"));
            }
        });

        imageRequest.setRetryPolicy(new DefaultRetryPolicy(10000, 1, 1.0f));
        queue.add(imageRequest);

    }


    /**
     * 返回实体类的回调接口
     *
     * @param <T>
     */
    public static abstract class OnEntityConnectListener<T> {

        /**
         * 成功的时候回调该方法
         *
         * @param entity 联网获得的实体类
         */
        public abstract void OnSuccess(T entity);

        /**
         * 失败的时候回调该接口
         *
         * @param reason
         */
        public void OnFailure(ErrorReson reason) {
        }
    }

}

一个使用例子

public class HttpUtil {
    HttpBase base;
    private Context context;

    public HttpUtil(Context context) {
        super();
        base = new HttpBase(context);
        this.context = context;
    }

    /**
     * 队列停止工作
     */
    public void StopQueue() {
        base.stopQueue();
    }

    private static final int P_VERSION = NetworkValue.P_VERSION;// 协议的版本号

    /**
     * 登录 post
     *
     * @param userno
     * @param machineid
     */
    public void Login(String userno, String machineid, HttpBase.JsonObjectListener jsonObjectListener) {
        String str=StaticValue.getRegistrationID();
        List<MyKeyValues> list = new ArrayList<>();
        list.add(new MyKeyValues("userno", userno, MyKeyValues.String));
        list.add(new MyKeyValues("machineid", machineid, MyKeyValues.String));
        if (TextUtils.equals(str,null)|| TextUtils.equals(str,"")){
            str= JPushInterface.getRegistrationID(context);
            StaticValue.setRegistrationID(str);
            Logger.e("推送注册id：", str);
        }
        list.add(new MyKeyValues("registrationid", str, MyKeyValues.String));

        base.doGetForm(NetworkValue.URL.str_login_url, list, jsonObjectListener);
    }
}
柯嘉少
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java http请求队列_okhttp请求任务如何从等待队列移动到请求队列？
weixin_35301706的博客
02-24 568
我们知道okhttp进行异步请求的时候是一个Okhttp的Call对象执行enqueue进行异步请求，然后会进入Call对象的实现列RealCall的enqueue方法，RealCall.java:@Override public void enqueue(Callback responseCallback) {synchronized (this) {if (executed) throw ne...
Okhttp任务队列工作原理
tangjiean的专栏
06-22 6501
1 概述1.1 引言 android完成非阻塞式的异步请求的时候都是通过启动子线程的方式来解决，子线程执行完任务的之后通过handler的方式来和主线程来完成通信。无限制的创建线程，会给系统带来大量的开销。如果在高并发的任务下，启用个线程池，可以不断的复用里面不再使用和有效的管理线程的调度和数量的管理。就可以节省系统的成本，有效的提高执行效率。 1.2 线程池ThreadPoolExecutor
Android ——网络请求框架OkHttp使用
七号座先生的博客
11-09 1098
前言 Android系统提供了两种HTTP通信类， 一个是 HttpURLConnection  和 HttpClient . 尽管Google在大部分安卓版本中推荐是使用HttpURLConnection  ，但这个类相比HTTPClient实在是太难用了. OkHttp是一个相对比较成熟的解决方案，据说Android4.4的源码中可以看到HttpURLConnection  已经替换成了
Asynchttpclient的使用及请求与响应封装
染火枫林的专栏
09-17 1148
Asynchttpclient的使用及请求与响应封装 android-async-http 开源框架可以使我们轻松地获取网络数据或者向服务器发送数据，最关键的是，它是异步框架，在底层使用线程池处理并发请求，效率很高，使用又特别简单。 一、简单使用public static void reg(final Context cont,Bitmap photodata,String regData) {
[Android] 主流网络请求框架 OkHttp 全方位详析
最新发布
weixin_74863998的博客
03-28 2782
OkHttp 是一个由 Square 公司开源的 HTTP 客户端库，本文将介绍 OkHttp 的简单用法，并从源码的角度分析 Dispathcer 和 Interceptors 的执行流程及原理。
android okhttp网络请求框架
08-08
**Android OkHttp 网络请求框架** OkHttp 是由 Square 公司开发的一个高效的网络请求库，广泛应用于 Android 开发中。它以其强大的性能、简单易用的 API 和丰富的特性，深受开发者喜爱。OkHttp 的核心设计理念是...
EasyHttp_OkHttp网络请求框架_EasyHttp_
09-30
EasyHttp是一个基于OkHttp的网络请求框架，专为简化Android应用中的网络操作而设计。OkHttp作为现代HTTP客户端，以其高效、稳定和易用性在Android开发者中广受欢迎。EasyHttp将OkHttp的功能进一步封装，提供了更加...
Okhttp+Retrofit2+RxJava1.0.0 网络请求框架
08-13
【Okhttp+Retrofit2+RxJava1.0.0 网络请求框架】是Android开发中一种高效、易用的网络请求解决方案，结合了三个强大的库：Okhttp作为网络底层通信，Retrofit作为接口调用的封装，以及RxJava用于异步处理和流式数据...
OkHttp基本使用教程（安卓端http请求框架）
01-20
android网络请求框架之OkHttp，一个处理网络请求的开源项目,是安卓端最火热的轻量级框架,用于替代HttpUrlConnection和Apache HttpClient(android API23 6.0里已移除HttpClient，但仍可引入Jar包使用)。 OkHttp是一个...
Android网络请求之OkHttp
01-03
OkHttp是一款优秀的HTTP框架，它支持get请求和post请求，支持基于Http的文件上传和下载，支持加载图片，支持下载文件透明的GZIP压缩，支持响应缓存避免重复的网络请求，支持使用连接池来降低响应延迟问题 Get请求 ...
C++利用mongoose搭建web服务器
热门推荐
千里小马哥的博客
04-17 1万+
0、前言 Mongoose是c语言写成的网络库。它为TCP、UDP、HTTP、WebSocket、CoAP、MQTT实现了事件驱动型的非阻塞api。其具有以下特性： 跨平台：可在linux/unix macos QNX eCos Windows Android Iphone FreeRtos上运行； 原生支持PicoTCP的嵌入式tcp/ip协议栈...
HTTP隧道通讯DELPHI封装
09-09 1663
{HTTP隧道通讯DELPHI封装，只通过语法检查，没测试。By 雪落的瞬间 QQ 418880764BLOG http://hi.baidu.com/cipherteam/BBS http://www.killabc.cn 完全翻译PcShare2个类代码。}unit hTTPPIDE;interfaceusesWindows,Shellapi,SysUtils,Vari
基于mongoose的httpclient配置SSL与cookie
fengruoying93的专栏
06-20 2173
一、mongoose简介 mongoose是一个轻量的开源http服务器项目：https://github.com/cesanta/mongoose 只需要使用mongoose.c和mongoose.h两个文件就可以搭建httpserver或httpclient 二、SSL配置 若要支持https，则需要配置SSL，这里使用OpenSSL开源库。 1、openssl源码地址为：https://www.openssl.org/source/old/，这里选择版本为openssl-1.0.1u.ta.
android应用权限检测工具类
柯嘉少的博客
04-02 2935
public class PermissionUtil { public static final int REQUEST_PERMISSION = 0x001; //app需要的全部危险权限在这里定义 public static final String[] ALL_PERMISSIONS = new String[]{ Manifest.permi
去应用商店给app评分
柯嘉少的博客
04-02 2226
/** * 作者：jiashao.ke on 2018/3/30 17:38 * 邮箱：2449926649@qq.com * 跳转到应用商店评分 */ public class MarketUtils { /** * 启动到app详情界面 * * @param context * * @param appPkg *
正则验证手机号码
柯嘉少的博客
04-02 963
public class VerifyUtil { /** * 移动：134、135、136、137、138、139、150、151、152、157(TD)、158、159、178(新)、182、184、187、188 * 联通：130、131、132、152、155、156、185、186 * 电信：133、153、170、173、177、180、181、189
android事件冲突解决之终极方案
柯嘉少的博客
05-01 728
一、事件冲突原因:（注：基础这部分参考并根据自身整理自《细说android事件传递机制》的博文）A、基础否析：android的两大基础控件类型:View和ViewGroup。 View即普通的控件，没有子布局的，如Button、TextView. ViewGroup继承自View，表示可以有子控件，如Linearlayout、Listview这些。而事件即MotionEvent，最重要的有3个:
android studio okhttp网络请求框架
04-19
OkHttp是一个开源的Java HTTP客户端库，用于发送和接收HTTP请求。它是一个高效、可扩展的库，对于Android应用程序的网络请求非常有用。你可以使用OkHttp轻松地执行GET、POST、PUT、DELETE等HTTP请求。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值