Android中Volley网络请求库封装

最新推荐文章于 2024-09-21 07:08:00 发布
最新推荐文章于 2024-09-21 07:08:00 发布
阅读量537 收藏 1
点赞数
分类专栏： Android 文章标签： android java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tzl870801/article/details/125797960
版权

Android项目开发中网络请求几乎是不可避免的，之前项目经常用到volley网络请求库，不做封装的话每次有新的项目都需要每个请求的去写，容易出问题，并且复用性不清，所以后来花时间重新整理了一下，对volley库进行了二次封装，封装出了自己需要用的常用方法，后面有新项目需要使用的话直接使用这个封装的公共库就行，大大提高了开发效率。
先分享一下，当然肯定还有需要修改优化的地方，目前自用基本够用。也欢迎大家提出修改优化建议
```
public class NetUtil {
    protected static final String TAG = "NetUtil";
    public static RequestQueue queue;
    public final static int TIME_OUT_NORMAL = 30 * 1000;
    public final static int RETRY_TIME = 0;

    public static final int GET = Method.GET;
    public static final int POST = Method.POST;
    public static final int PUT = Method.PUT;
    public static final int DELETE = Method.DELETE;


    /**
     * 回调接口
     */
    public interface NetListenerT {
        <T> void onResponse(T t);
    }


    /**
     * 异常回调接口
     **/
    public interface NetListenerError {
        void onErrorResponse(String error);
    }

    /**
     * 网络请求（POST、GET）
     */
    public static <T> void requestSimple(final int MethodType, String url, final Map<String, String> params, final Class<T> jBean, final NetListenerT listener, final NetListenerError listenerError) {
        addUserInfo(params);
        if (MethodType == GET) {
            url = URLBuilder(url, params);
            LogUtil.i(TAG, url);
        }
        final String finalUrl = url;

        StringRequest mRequest = new StringRequest(MethodType, url, new Response.Listener<String>() {
            @Override
            public void onResponse(String response) {
                LogUtil.i(TAG, response);
                T t = GsonUtil.json2bean(response, jBean);
                if (t == null) {
                    LogUtil.e(TAG, "JSON解析错误");
                }
                // 回调
                listener.onResponse(t);
            }
        }, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {

                if (error != null && error.networkResponse != null && error.networkResponse.statusCode == 401) {
                   //权限验证失败，退出登录
                } else {
                    if (listenerError != null) {
                        listenerError.onErrorResponse(error.getMessage());
                    }
                    LogUtil.e(TAG, "调用接口出错:" + finalUrl);
                    LogUtil.e(TAG, error + "");
                }
            }
        }) {
            @Override
            protected Map<String, String> getParams() throws AuthFailureError {
                if (MethodType == POST) {
                    return getUserParams(params);
                } else {
                    return null;
                }
            }
        };
        mRequest.setRetryPolicy(new DefaultRetryPolicy(TIME_OUT_NORMAL, RETRY_TIME, DefaultRetryPolicy.DEFAULT_BACKOFF_MULT));
        queue.add(mRequest);
    }

    /**
     * 网络请求（POST、GET）
     */
    public static <T> void requestJsonSimple(final int MethodType, String url, final Map<String, String> params, final Class<T> jBean, final NetListenerT listener, final NetListenerError listenerError) {
        addUserInfo(params);
        if (MethodType == GET) {
            url = URLBuilder(url, params);
            LogUtil.i(TAG, url);
        } else {
            Map<String, String> tmpparams = new HashMap<>();
            tmpparams.put(Constant.KEY_TOKEN, params.get(Constant.KEY_TOKEN));
            url = URLBuilder(url, tmpparams);

        }
        final String finalUrl = url;

        StringRequest mRequest = new StringRequest(MethodType, url, new Response.Listener<String>() {

            @Override
            public void onResponse(String jsonObject) {
                T t = GsonUtil.json2bean(jsonObject.toString(), jBean);
                if (t == null) {
                    LogUtil.e(TAG, "JSON解析错误");
                }
                // 回调
                listener.onResponse(t);
            }
        }, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {

                if (error != null && error.networkResponse != null && error.networkResponse.statusCode == 401) {
                    //权限验证失败
                } else {
                    if (listenerError != null) {
                        listenerError.onErrorResponse(error.getMessage());
                    }
                    LogUtil.e(TAG, "调用接口出错:" + finalUrl);
                    LogUtil.e(TAG, error + "");
                }
            }
        }) {

            @Override
            public byte[] getBody() throws AuthFailureError {
                return params.get("json").toString().getBytes();
            }

            @Override
            public String getBodyContentType() {
                return "application/json; charset=utf-8";
            }
        };
        mRequest.setRetryPolicy(new DefaultRetryPolicy(TIME_OUT_NORMAL, RETRY_TIME, DefaultRetryPolicy.DEFAULT_BACKOFF_MULT));
        queue.add(mRequest);
    }

    /**
     * 网络请求（POST、GET）
     */
    public static <T extends Base> void request(final Activity acivity, final int MethodType, String url, final Map<String, String> params, final Class<T> jBean, final NetListenerT listener, final NetListenerError listenerError) {

        if (!url.contains(!url.contains(NetURL.URL_LOGIN)) {
           if(MethodType==GET) {
               addUserInfo(params);
           }
        }
        if (acivity == null) {
            return;
        }
        if (MethodType == GET) {
            url = URLBuilder(url, params);
            LogUtil.i(TAG, url);
        }
        final String finalUrl = url;

        StringRequest mRequest = new StringRequest(MethodType, url, new Response.Listener<String>() {
            @Override
            public void onResponse(String response) {
                if (acivity == null || !EgovaApplication.isRunning(acivity) || acivity.isFinishing()) {
                    return;
                }
                LogUtil.i(TAG, response);
                T t = GsonUtil.json2bean(response, jBean);
                if (t == null) {
                    LogUtil.e(TAG, "JSON解析错误");
                }

                if (t == null || (!t.login && t.error_id!=0)) {
                    Intent intent = new Intent(acivity, LoginActivity.class);
                    if(t!=null && t.error_id>0){
                        intent.putExtra("message", t.description);
                    }else {
                        if (t == null || StringUtil.isNull(t.message)) {
                            intent.putExtra("message", "JSON解析错误");
                        } else {
                            intent.putExtra("message", t.message);
                        }
                    }
                    intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
                    acivity.startActivity(intent);
                    acivity.finish();
                } else {
                    // 回调
                    listener.onResponse(t);
                }
            }
        }, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {

                if (error != null && error.networkResponse != null && error.networkResponse.statusCode == 401) {
                  //权限验证失败，退出登录
                } else {
                
                    if (listenerError != null) {
                        if (!StringUtil.isNull(error.getMessage())) {
                            listenerError.onErrorResponse(error.getMessage());
                        } else {
                            listenerError.onErrorResponse("请求异常,请确认网络连接是否正常");
                        }
                    }
                    LogUtil.e(TAG, "调用接口出错:" + finalUrl);
                    LogUtil.e(TAG, error + "");
                }
            }
        }) {
            @Override
            protected Map<String, String> getParams() throws AuthFailureError {
                if (MethodType == POST || MethodType==PUT) {
                    return getUserParams(params);
                } else {
                    return null;
                }
            }
        };
      
        mRequest.setRetryPolicy(new DefaultRetryPolicy(TIME_OUT_NORMAL, RETRY_TIME, DefaultRetryPolicy.DEFAULT_BACKOFF_MULT));
        mRequest.setTag(acivity.getClass().getSimpleName());
        queue.add(mRequest);
    }


    /**
     * 网络请求（默认GET）
     */
    public static <T> void requestSM(String url, Map<String, String> params, final Class<T> jBean, final NetListenerT listener, final NetListenerError listenerError) {
        requestSimple(GET, url, params, jBean, listener, listenerError);
    }

    /**
     * 网络请求（默认POST）
     */
    public static <T> void postSM(String url, Map<String, String> params, final Class<T> jBean, final NetListenerT listener, final NetListenerError listenerError) {
        requestSimple(POST, url, params, jBean, listener, listenerError);
    }

    /**
     * 网络请求（默认PUT）
     */
    public static <T> void putSM(String url, Map<String, String> params, final Class<T> jBean, final NetListenerT listener, final NetListenerError listenerError) {
        requestSimple(PUT, url, params, jBean, listener, listenerError);
    }

    /**
     * 网络请求（默认POST）
     */
    public static <T> void postJsonSM(String url, Map<String, String> params, final Class<T> jBean, final NetListenerT listener, final NetListenerError listenerError) {
        requestJsonSimple(POST, url, params, jBean, listener, listenerError);
    }

    /**
     * 网络请求（默认GET）
     */
    public static <T> void requestJsonSM(String url, Map<String, String> params, final Class<T> jBean, final NetListenerT listener, final NetListenerError listenerError) {
        requestJsonSimple(GET, url, params, jBean, listener, listenerError);
    }

    /**
     * 网络请求（默认GET）
     */
    public static <T> void putJsonSM(String url, Map<String, String> params, final Class<T> jBean, final NetListenerT listener, final NetListenerError listenerError) {
        requestJsonSimple(PUT, url, params, jBean, listener, listenerError);
    }

    /**
     * 网络请求（默认GET）
     */
    public static <T extends Base> void request(Activity activity, String url, Map<String, String> params, final Class<T> jBean, final NetListenerT listener, final NetListenerError listenerError) {
        request(activity, GET, url, params, jBean, listener, listenerError);
    }

    /**
     * 网络请求（POST）
     */
    public static <T extends Base> void post(Activity activity, String url, Map<String, String> params, final Class<T> jBean, final NetListenerT listener, final NetListenerError listenerError) {
        request(activity, POST, url, params, jBean, listener, listenerError);
    }

    /**
     * 网络请求（POST）
     */
    public static <T extends Base> void put(Activity activity, String url, Map<String, String> params, final Class<T> jBean, final NetListenerT listener, final NetListenerError listenerError) {
        request(activity, PUT, url, params, jBean, listener, listenerError);
    }

    /**
     * 取消网络请求
     */
    public static void cancel(String tag) {
        if (!StringUtils.isEmpty(tag)) {
            queue.cancelAll(tag);
        }
    }

    /**
     * 在post的情况，为params加userID和password参数
     *
     * @param params 参数列表
     */
    protected static Map<String, String> getUserParams(Map<String, String> params) {
        if(UserConfig.getBKeyValue(Constant.KEY_IS_LOGIN, false)) {
            if (params != null) {
                if (!params.containsKey(Constant.KEY_TOKEN)) {
                    try {
                        params.put(Constant.KEY_TOKEN, URLEncoder.encode(UserConfig.getToken(), "UTF-8"));
                    } catch (UnsupportedEncodingException e) {
                        params.put(Constant.KEY_TOKEN, UserConfig.getToken());
                    }
                }
            }
        }
        return params;
    }

    /**
     * 为url添加user参数
     */
    private static String addUserInfo(String url) {
        if (UserConfig.getBKeyValue(Constant.SP_KEY_IS_LOGIN, false)) {
            //登录状态下要添加token

            if (UserConfig.getToken() != null && !UserConfig.getToken().equals("")) {
                if (!url.contains(Constant.KEY_TOKEN)) {
                    try {
                        url += "&" + Constant.KEY_TOKEN + "=" + URLEncoder.encode(UserConfig.getToken(), "UTF-8");
                    } catch (UnsupportedEncodingException e) {
                        LogUtil.e(TAG, e.getMessage());
                    }
                }
            }
        }
        return url;
    }

    /**
     * 构造URL
     *
     * @param url    请求url
     * @param params 请求参数
     */
    private static String URLBuilder(String url, Map<String, String> params) {
       /* List<NameValuePair> valueParams = new ArrayList<NameValuePair>();
        Set<String> keySet = params.keySet();
        for (String key : keySet) {
            valueParams.add(new BasicNameValuePair(key, params.get(key).toString()));
        }
        return url + "?" + URLEncodedUtils.format(valueParams, "UTF-8");*/

        String newUrl = url;
        StringBuffer param = new StringBuffer();
        for (String key : params.keySet()) {
            param.append(key + "=" + params.get(key) + "&");
        }
        String paramStr = param.toString();
        paramStr = paramStr.substring(0, paramStr.length() - 1);
        if (newUrl.indexOf("?") >= 0) {
            newUrl += "&" + paramStr;
        } else {
            newUrl += "?" + paramStr;
        }
        return newUrl;
    }


    /**
     * 为url添加用户user参数
     */
    private static void addUserInfo(Map<String, String> params) {
        if (params != null && UserConfig.getBKeyValue(Constant.KEY_IS_LOGIN, false)) {

            if (!params.containsKey(Constant.KEY_TOKEN)) {

                try {
                    params.put(Constant.KEY_TOKEN, URLEncoder.encode(UserConfig.getToken(), "UTF-8"));
                } catch (UnsupportedEncodingException e) {
                    params.put(Constant.KEY_TOKEN, UserConfig.getToken());
                }
            }
        }
    }

    /**
     * 为url添加用户user参数
     */
    private static void addUserInfo(JSONObject params) {
        if (params != null && UserConfig.getBKeyValue(Constant.KEY_IS_LOGIN, false)) {
            try {
                if (!params.has(Constant.KEY_TOKEN)) {
                    params.put(Constant.KEY_TOKEN, UserConfig.getToken());
                }
            }catch (Exception ex){
                LogUtil.e(TAG, ex.getMessage());
            }
        }
    }
}
```

登山的蜗牛
关注
专栏目录
Android中网络请求框架的封装-Retrofit+RxJava+OkHttp
小羊子的技术专栏
04-15 2776
本文重点介绍了 retrofit 的封装与项目中实际使用。
Android 中Volley二次封装并实现网络请求缓存
08-29
Android 中Volley二次封装并实现网络请求缓存是指在Android 应用程序中使用Volley库进行网络请求时，通过二次封装Volley实现网络请求缓存，以提高应用程序的性能和用户体验。 Volley 库简介 Volley 是一个Android ...
Android 网络请求框架(二) Volley工具类的封装
高级开发者进阶ing... QaQ
07-15 886
上一篇给大家讲解了Volley的使用,因为重复代码比较多,这篇给大家简单的吧Volley封装一下.方便以后使用创建VolleyRequestUtil工具类StringRequest封装JsonObjectRequest GET封装JsonObjectRequest POST封装ImageRequest封装ImageLoader封装完整代码: 创建VolleyRequestUtil工具类 实现单利模式,保证实例唯一化: public class VolleyRequestUtil { private
Android 网络请求库 Net - 应用入门与配置指南
最新发布
gitblog_00440的博客
09-21 327
Android 网络请求库 Net - 应用入门与配置指南 Net Android 基于协程/OkHttp网络请求工具 项目地址: https://gitcode.com/gh_mirrors/net/Net ...
android volley 的封装
chuangqin1825的博客
10-21 133
volley 是google在2013 年发布的，Volley是Android平台上的网络通信库，能使网络通信更快，更简单，更健壮。 volley 提供了如下的便利功能： JSON，图像等的异步下载； 网络请求的排序（scheduling） 网络请求的优先...
Volley请求封装
豆豆的博客
07-14 434
在做项目时由于我们请求的数据量并不是很大，所以一直使用的都是Volley进行HTTP请求。 使用Volley的方法很简单，具体请参考郭神（http://blog.csdn.net/guolin_blog/article/details/17482095）。 因为项目在很多地方都需要进行Http请求。我将Volley的请求进行了封装，主要分为下面几个部分： 1.通过单例模式获取请求队列的对象（
Android 网络请求工具类封装
Notzuonotdied的博客
04-09 730
使用URLConnection进行简单封装 　　不多说，我们直接怼代码～O(∩_∩)O哈哈~ 　　 　　需要使用的时候，只需要继承下，就可以用了～ /** * 网络连接核心部分 * Created by Notzuonotdied on 2017/3/7. */ class accessNetwork { /** * 获取Json数组 * * @...
Volley网络请求封装
03-24
网络请求使用的Volley.Jar.Json解析使用的谷歌的Gson,此封装可以 重复调用 一个网络请求，并可以自动解析JSON为一个对象,我们都知道，在基本使用Volley的时候，每个Activity 都会去创建一个 网络 请求,这样显得代码...
android 网络请求封装
08-18
以下是一些关于“Android网络请求封装”的详细知识点： 1. **异步网络请求**： - Android中的网络操作必须在非UI线程中执行，否则会导致ANR（Application Not Responding）错误。因此，通常使用AsyncTask、Handler...
Android Volley+OkHttp3+Gson 开源库的封装
qy的专栏
04-23 5913
博客将按照下面的步骤介绍Volley的重新封装: 1.OkHttp3的关于Volley的HttpStack实现 2.HttpRequest的实现和HttpListener回调监听的封装 3.Volley原始的Request的Wrap 4.各种方式的请求的重新实现 5.统一请求的实现 6.使用
Android网络请求框架基于HttpUrlConnection的封装
12-05
这是我的博客Android框架 之网络请求框架系列文章第二弹的HttpUrilConnection封装的源码
Android网络请求封装，可动态切换网络引擎
07-12
对Http网络请求进行封装的网络请求模块，使用策略模式实现动态切换网络引擎的封装。默认使用OkHttp3作为网络引擎，使用中可通过implements网络引擎接口来实现切换网络引擎功能。
android volley,Android中volley封装实践记录
weixin_32325225的博客
05-27 248
前言在项目中一般使用使用volley方式如下，用起来给人一种很乱的感觉，于是一种盘它的想法油然而生。public void get() {String url = "https://tcc.taobao.com/cc/json/mobile_tel_segment.htm?tel=......";StringRequest request = new StringRequest(Request.M...
[从零开始系列]AndroidApp研发之路(一) 网络请求的封装(一)
chengzichen_的博客
08-28 9864
文章目录： - 前言 - 封装成果 - 封装细节 - 如何使用 - 注意 - 作者前言写在前面Flyabbit是一个使用Retrofit+Rxjava2+dagger2+Mvp+Material Design 快速搭建的一个app,ui是其一,更重要的是我将通过一系列的文章从项目零开始 技术选型->到封装->组件化设计->本地Maven(nexus)简单使用->自动打包(Jenkins
Android组件化开发（二）--网络请求组件封装
yuhaibing111的博客
11-03 1892
前面一篇文章我们讲解了maven私服的搭建，maven私服在组件化框架中有一个很重要的地位就是可以将我们的lib库放到局域网中，供公司其他开发者使用，实现类库的分享。下面是这个系列准备实现的一个组件化实战项目框架笔者打算从下往上依次来实现我们项目中的组件，毕竟地基稳固了，房子才可以搭的很结实。注意：这里不会对封装代码进行长篇大论，主要还是以思路点拨的方式进行，如果需要看完整代码的可以移步到github。
Android_volley GET、POST网络请求封装
Android_Mr_Zhao的博客
04-17 529
第一步导依赖 implementation 'com.mcxiaoke.volley:library:1.0.19' 第二步创建一个全局类 初始化volley /*Time:2019/4/16 *Author:zhaozhiwei *Description: */public class App extends android.app.Application { pri...
Shine——更简单的Android网络请求库封装
02-16 536
作者：FreddyChen 写在前面 距离上一篇文章跟我一起开发商业级IM（3）—— 长连接稳定性之连接及重连发布的时间，大概已有一年多，先跟大家说声抱歉。主要是因为工作太忙，业务需求过多，没办法专心写博客。先立个Flag：IM系列文章一定会坚持写完，同时Github项目也会逐步完善，敬请期待。 这次就暂不更新IM系列相关的文章及项目了，先给大家带来一个稍微轻量级同时也比较实用的网络请求封装库：Shine，同时也希望自己借此机会重新拾起写博客和开源项目的激情，废话少说，我们直接开始吧。 Shine是什么.
Volley封装
weixin_34191734的博客
12-25 70
Volley.jar下载 在Application初始化 Volley queues=Volley.newRequestQueue(appContext);  并返回RequestQueue 对象 public static RequestQueue getHttpQueues(){ return queues; }   import android.content.Con...
Android Volley 封装实战：打造整洁的网络请求
"Android中使用Volley进行网络请求的封装实践" 在Android开发中，Volley是一个高效的网络请求库，由Google开发，适用于处理各种类型的网络请求，如HTTP、JSON等。Volley以其高效的缓存机制、线程管理以及对异步处理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值