Xutils3框架网络请求封装(单例模式)

最新推荐文章于 2022-02-04 17:12:30 发布
最新推荐文章于 2022-02-04 17:12:30 发布
阅读量1k 收藏
点赞数
分类专栏： Android框架 文章标签： Xutils3 xutils3-0 android Android 单例模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/z740852294/article/details/77700310
版权
本文详细介绍了如何在Android项目中使用Xutils3进行网络请求的单例模式封装，包括在build.gradle中添加依赖，自定义Application，配置AndroidManifest.xml，以及封装后的POST/GET请求和文件下载的使用方法。
摘要由CSDN通过智能技术生成

1.build.gradle中添加

    compile 'org.xutils:xutils:3.5.0’

2.自定义Application

public class BaseApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        x.Ext.init(this);
        // 是否输出debug日志, 开启debug会影响性能.
        x.Ext.setDebug(BuildConfig.DEBUG); 
    }
}

3.AndroidManifest.xml文件application节点添加

  android:name=".BaseApplication"

4.单例模式Xutils3封装

import android.os.Handler;
import android.os.Looper;
import android.widget.Toast;
import org.json.JSONException;
import org.json.JSONObject;
import org.xutils.common.Callback;
import org.xutils.http.RequestParams;
import org.xutils.x;
import java.io.File;
import java.util.Map;


public class XutilsHttp {

    private volatile static XutilsHttp instance;
    private Handler handler;

    private XutilsHttp() {
        handler = new Handler(Looper.getMainLooper());
    }

    /**
     * 单利模式
     *
     * @return
     */
    public static XutilsHttp getInstance() {
        if (instance == null) {
            synchronized (XutilsHttp.class) {
                if (instance == null) {
                    instance = new XutilsHttp();
                }
            }
        }
        return instance;
    }

    /**
     * 异步get请求返回结果,json字符串
     *
     * @param result
     * @param callBack
     */
    private void onSuccessResponse(final String result, final XCallBack callBack) {
        handler.post(new Runnable() {
            @Override
            public void run() {
                if (callBack != null) {
                    callBack.onResponse(result);
                }
            }
        });
    }

    private void onFailResponse(final String result, final XCallBack callBack) {
        handler.post(new Runnable() {
            @Override
            public void run() {
                if (callBack != null) {
                    callBack.onFail(result);
                }
            }
        });
    }

    private void onCancelResponse(final Callback.CancelledException cex, final XCallBack callBack) {
        handler.post(new Runnable() {
            @Override
            public void run() {
                if (callBack != null) {
                    callBack.onCancel(cex);
                }
            }
        });
    }


    //接口回调
    public interface XCallBack {
        void onResponse(String result);

        void onFail(String result);

        void onCancel(Callback.CancelledException cex);
    }

    //下载的接口回调
    public interface XDownLoadCallBack {
        void onstart();

        void onLoading(long total, long current, boolean isDownloading);

        void onSuccess(File result);

        void onFail(String result);

        void onFinished();
    }

    /**
     * 普通get请求
     *
     * @param url
     * @param maps
     * @param callback
     */
    public void get(String url, Map<String, String> maps, final XCallBack callback) {
        RequestParams params = new RequestParams(url);
        if (null != maps && !maps.isEmpty()) {
            for (Map.Entry<String, String> entry : maps.entrySet()) {
                params.addQueryStringParameter(entry.getKey(), entry.getValue());
            }
        }
        x.http().get(params, new Callback.CommonCallback<String>() {
            private boolean hasError = false;
            private String result = null;

            @Override
            public void onSuccess(String result) {
                if (result != null) {
                    this.result = result;
                }
            }

            @Override
            public void onError(Throwable ex, boolean isOnCallback) {
                hasError = true;
                Toast.makeText(x.app(), ex.getMessage(), Toast.LENGTH_LONG).show();
            }

            @Override
            public void onCancelled(CancelledException cex) {

            }

            @Override
            public void onFinished() {
                if (!hasError && result != null) {
                    onSuccessResponse(result, callback);
                }
            }
        });
    }

    /**
     * 带缓存数据的异步get请求
     *
     * @param url
     * @param maps
     * @param ifCache   是否缓存
     * @param cacheTime 缓存存活时间
     * @param callback
     */
    public void getCache(String url, Map<String, String> maps, final boolean ifCache, long cacheTime, final XCallBack callback) {
        RequestParams params = new RequestParams(url);
        params.setCacheMaxAge(cacheTime);
        if (null != maps && maps.isEmpty()) {
            for (Map.Entry<String, String> entry : maps.entrySet()) {
                params.addQueryStringParameter(entry.getKey(), entry.getValue());
            }
        }
        x.http().get(params, new Callback.CacheCallback<String>() {
            private boolean hasError = false;
            private String result = null;

            @Override
            public boolean onCache(String result) {
                if (ifCache && null != result) {
                    this.result = result;
                }
                // true: 信任缓存数据, 不在发起网络请求; false不信任缓存数据.
                return ifCache;
            }

            @Override
            public void onSuccess(String result) {
                if (result != null) {
                    this.result = result;
                }
            }

            @Override
            public void onError(Throwable ex, boolean isOnCallback) {
                hasError = true;
                Toast.makeText(x.app(), ex.getMessage(), Toast.LENGTH_LONG).show();
            }

            @Override
            public void onCancelled(CancelledException cex) {

            }

            @Override
            public void onFinished() {
                if (!hasError && result != null) {
                    onSuccessResponse(result, callback);
                }
            }
        });
    }

    /**
     * 异步post请求
     *
     * @param url
     * @param maps
     * @param callback
     */
    public void post(String url, Map<String, String> maps, final XCallBack callback) {
        RequestParams params = new RequestParams(url);
        if (null != maps && !maps.isEmpty()) {
            for (Map.Entry<String, String> entry : maps.entrySet()) {
                params.addBodyParameter(entry.getKey(), entry.getValue());
            }
        }
        x.http().post(params, new Callback.CommonCallback<String>() {
            private boolean hasError = false;
            private String result = null;

            @Override
            public void onSuccess(String result) {
                if (result != null) {
                    this.result = result;
                }
            }

            @Override
            public void onError(Throwable ex, boolean isOnCallback) {
                hasError = true;
                onFailResponse(ex.getMessage(), callback);
            }


            @Override
            public void onCancelled(CancelledException cex) {
                onCancelResponse(cex, callback);
            }

            @Override
            public void onFinished() {
                if (!hasError && result != null) {
                    onSuccessResponse(result, callback);
                }
            }
        });
    }

    /**
     * 带缓存数据的异步post请求
     *
     * @param url
     * @param maps
     * @param ifCache   是否缓存
     * @param cacheTime 缓存存活时间
     * @param callback
     */
    public void postCache(String url, Map<String, String> maps, final boolean ifCache, long cacheTime, final XCallBack callback) {
        RequestParams params = new RequestParams(url);
        params.setCacheMaxAge(cacheTime);
        if (null != maps && maps.isEmpty()) {
            for (Map.Entry<String, String> entry : maps.entrySet()) {
                params.addBodyParameter(entry.getKey(), entry.getValue());
            }
        }
        x.http().post(params, new Callback.CacheCallback<String>() {
            private boolean hasError = false;
            private String result = null;

            @Override
            public boolean onCache(String result) {
                if (ifCache && null != result) {
                    this.result = result;
                }
                // true: 信任缓存数据, 不在发起网络请求; false不信任缓存数据.
                return ifCache;
            }

            @Override
            public void onSuccess(String result) {
                if (result != null) {
                    this.result = result;
                }
            }

            @Override
            public void onError(Throwable ex, boolean isOnCallback) {
                hasError = true;
                Toast.makeText(x.app(), ex.getMessage(), Toast.LENGTH_LONG).show();
            }

            @Override
            public void onCancelled(CancelledException cex) {

            }

            @Override
            public void onFinished() {
                if (!hasError && result != null) {
                    onSuccessResponse(result, callback);
                }
            }
        });
    }

    /**
     * 下载文件
     *
     * @param url
     * @param filePath
     * @param callback
     */
    public void downFile(String url, String filePath, final XDownLoadCallBack callback) {
        RequestParams params = new RequestParams(url);
        params.setSaveFilePath(filePath);
        params.setAutoRename(true);
        x.http().get(params, new Callback.ProgressCallback<File>() {
            @Override
            public void onSuccess(final File result) {
                //下载完成会走该方法
                handler.post(new Runnable() {
                    @Override
                    public void run() {
                        if (callback != null) {
                            callback.onSuccess(result);
                        }
                    }
                });
            }

            @Override
            public void onError(final Throwable ex, boolean isOnCallback) {
                handler.post(new Runnable() {
                    @Override
                    public void run() {
                        if (null != callback) {
                            callback.onFail(ex.getMessage());
                        }
                    }
                });
            }

            @Override
            public void onCancelled(CancelledException cex) {
            }

            @Override
            public void onFinished() {
                handler.post(new Runnable() {
                    @Override
                    public void run() {
                        if (callback != null) {
                            callback.onFinished();
                        }
                    }
                });
            }

            //网络请求之前回调
            @Override
            public void onWaiting() {
            }

            //网络请求开始的时候回调
            @Override
            public void onStarted() {
                handler.post(new Runnable() {
                    @Override
                    public void run() {
                        if (null != callback) {
                            callback.onstart();
                        }
                    }
                });
            }

            //下载的时候不断回调的方法
            @Override
            public void onLoading(final long total, final long current, final boolean isDownloading) {
                //当前进度和文件总大小
                handler.post(new Runnable() {
                    @Override
                    public void run() {
                        if (callback != null) {
                            callback.onLoading(total, current, isDownloading);
                        }
                    }
                });
            }
        });
    }

    /**
     * 文件上传
     *
     * @param url
     * @param maps
     * @param file
     * @param callback
     */
    public void upLoadFile(String url, Map<String, String> maps, Map<String, File> file, final XCallBack callback) {
        RequestParams params = new RequestParams(url);
        if (maps != null && !maps.isEmpty()) {
            for (Map.Entry<String, String> entry : maps.entrySet()) {
                params.addBodyParameter(entry.getKey(), entry.getValue());
            }
        }
        if (file != null) {
            for (Map.Entry<String, File> entry : file.entrySet()) {
                params.addBodyParameter(entry.getKey(), entry.getValue().getAbsoluteFile());
            }
        }
        // 有上传文件时使用multipart表单, 否则上传原始文件流.
        params.setMultipart(true);
        x.http().post(params, new Callback.CommonCallback<String>() {
            @Override
            public void onSuccess(String result) {
                onSuccessResponse(result, callback);
            }

            @Override
            public void onError(Throwable ex, boolean isOnCallback) {

            }

            @Override
            public void onCancelled(CancelledException cex) {
                onCancelResponse(cex, callback);
            }

            @Override
            public void onFinished() {

            }
        });

    }

    /**
     * 上传Json串到服务器
     *
     * @param url
     * @param maps 将需要传的各个参数放在Map集合里面
     */
    public void upLoadJson(String url, Map<String, String> maps, final XCallBack callback) {
        JSONObject js_request = new JSONObject();//服务器需要传参的json对象
        try {
            for (Map.Entry<String, String> entry : maps.entrySet()) {
                js_request.put(entry.getKey(), entry.getValue());
            }
        } catch (JSONException e) {
            e.printStackTrace();
        }

        RequestParams params = new RequestParams(url);
        params.setAsJsonContent(true);
        params.setBodyContent(js_request.toString());

        x.http().post(params, new Callback.CommonCallback<String>() {//发起传参为json的post请求，
            // Callback.CacheCallback<String>的泛型为后台返回数据的类型，
            // 根据实际需求更改
            private boolean hasError = false;
            private String result = null;

            @Override
            public void onSuccess(String result) {
                if (result != null) {
                    this.result = result;
                }
            }

            @Override
            public void onError(Throwable ex, boolean isOnCallback) {
                ex.printStackTrace();
            }

            @Override
            public void onCancelled(CancelledException cex) {
                onCancelled(cex);
            }

            @Override
            public void onFinished() {
                if (!hasError && result != null && callback != null) {
                    onSuccessResponse(result, callback);
                }
            }
        });
    }
}

5.使用方法

5.1 POST/GET请求

Map<String, String> map = new HashMap<>();
map.put("username", username);
map.put("password", password);
XutilsHttp.getInstance().post("http://000.000.000.000/index.php?s=/app/login/login", map, new XutilsHttp.XCallBack() {
    @Override
    public void onResponse(String result) {
            //成功
           }
    @Override
    public void onFail(String result) {
              //失败
    }
    @Override
    public void onCancel(Callback.CancelledException cex) {
             //取消
    }
});

5.2 文件下载

String url = ".............";
//保存路径
final String filepath = Environment.getExternalStorageDirectory() + "/lll/avatar/01.png";
XutilsHttp.getInstance().downFile(url, filepath, new
        XutilsHttp.XDownLoadCallBack() {
            @Override
            public void onstart() {
            }
            @Override
            public void onLoading(long total, long current, boolean isDownloading) {
            }
            @Override
            public void onSuccess(File result) {
                //成功
            }
            @Override
            public void onFail(String result) {
            }
            @Override
            public void onFinished() {
            }
        });
Owen_le
关注
专栏目录
Flutter 笔记 | Flutter 文件IO、网络请求、JSON、日期与国际化
川峰的博客
05-29 1595
Flutter 笔记 | Flutter 文件IO、网络请求、JSON、日期与国际化，Flutter 笔记 | Flutter 文件IO、网络请求、JSON、日期与国际化Flutter 笔记 | Flutter 文件IO、网络请求、JSON、日期与国际化Flutter 笔记 | Flutter 文件IO、网络请求、JSON、日期与国际化Flutter 笔记 | Flutter 文件IO、网络请求、JSON、日期与国际化Flutter 笔记 | Flutter 文件IO、网络请求、JSON、日期与国际化Flu
Android 各种 Utils工具类封装 Utils大全集合
qq_46041134的博客
11-04 2628
Android各种工具类封装Utils大全集合AppUtils 获取项目的Application context 方便每个Utils去init(); 一定要在Application中初始化BitmapUtil ==》图片工具类GlideRoundTransform ==》glide加载任意想加载的圆角CrashHandler ==》异常捕获ThreadManager ==》线程池管理线程ButtonClickUtils ==》防止快速点击DataUtils ==》填充数据工具类GsonUtilKeyBo
Android Xutils3网络请求的封装详解及实例代码
01-04
Xutils3网络请求的封装详解 封装了一个Xutil3的网络请求工具类，分享给大家，本人水平有限，不足之处欢迎指出。 使用前先配置xutils3： 1.gradle中添加 compile 'org.xutils:xutils:3.3.40' 2.自定义Application /** * Created by Joe on 2016/9/25. */ public class MyApp extends Application { @Override public void onCreate() { super.onCreate(); x.Ext.in
Xutils3网络请求的封装
zhou_anzhuojinjie的博客
12-30 3886
封装了一个Xutil3的网络请求工具类，分享给大家，本人水平有限，不足之处欢迎指出。 使用前先配置xutils3： 1.gradle中添加compile 'org.xutils:xutils:3.3.40'2.自定义Application/** * Created by Joe on 2016/9/25. */ public class MyApp extends Application {
xUtils的网络请求简单封装
zjp776的博客
07-27 1637
其他的前提条件就不多说了，只要你会使用xutils就完全可以使用。不多说了，直接上代码。 HttpxUtils.java类： /**  * @Title 封装xUtils网络请求  * @Authour zhoujp  * @Time 2016年7月27日 下午3:25:21  *   */ public class HttpxUtils { /** * 发送get请求
Xutils 3 网络封装 简易版
Nade的博客
03-27 1022
AS 集成 需添加依赖 compile ‘org.xutils:xutils:3.5.0’ 最基础的就不多说了 xutils 是一个特稳定的网络请求框架 使用起来也是非常方便的 上传下载速度 以及https 相对来说是一个全面 稳定 好用的第三方库 下面是我自己封装的一个简单网络助手 public class NetHelper { public static String Ty...
浅谈Retrofit封装-让框架更加简洁易用
热门推荐
gengqiquan的博客
08-26 6万+
尊重他人的劳动成果，转载请标明出处：http://blog.csdn.net/gengqiquan/article/details/52329259， 本文出自:【gengqiquan的博客】不知不觉在在这家公司快三个月了，刚接手项目的时候是真的被里面的代码恶心到了，网络请求用的原生的httpURLconnection。这本来什么，关键是根本就没有进行任何封装。activity里面充斥着大量的han
设计模式-＞数据存储,视图UI,业务逻辑控制数据的传递 ，单例模式，工厂模式，架构模式【开发框架MVC(大智慧)】
qq_42838904的博客
03-16 294
1：单例模式 属于创建型模式，是建对象的最佳方式 2：工厂模式 属于创建型模式，是建对象的最佳方式 3：单例模式 4：单例模式 5：单例模式 单例模式 属于创建型模式，是一种创建对象的最佳方式。 涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。 public class...
上门洗车APP --- Android客户端开发 之 网络框架封装介绍（一）
m0_66265052的博客
02-04 188
import java.io.File; import org.apache.http.Header; import org.gaochun.android.http.AsyncHttpClient; import org.gaochun.android.http.RequestParams; import org.gaochun.android.http.network.IRequestCallback; import org.gaochun.android.http.network.RequestCal
安卓Xutils3网络工具,注解工具,图片工具和日志工具的使用,以及对网络工具的封装
02-23
安卓Xutils3网络工具,注解工具,图片工具和日志工具的使用,以及对网络工具的封装的demo,简单明了!
Android xUtils网络框架二次封装
03-21
Android xUtils网络框架二次封装
XUtils3的基本使用方法
12-17
XUtils3的最新使用方法，本demo对XUtils的网络请求进行了封装，大家可以下载下来基于此demo做个性化的定制，满足公司的开发要求.
XUtils网络请求封装类
大先生
07-28 429
这个直接封装成一个类 可以直接拿来直接用。 但是要导入Xutils夹包。import com.lidroid.xutils.HttpUtils; import com.lidroid.xutils.exception.HttpException; import com.lidroid.xutils.http.ResponseInfo; import com.lidroid.xutils.http.c
android xutils json请求,Android Xutils3网络请求的封装详解及实例代码
weixin_30925033的博客
05-27 417
Xutils3网络请求的封装详解封装了一个Xutil3的网络请求工具类，分享给大家，本人水平有限，不足之处欢迎指出。使用前先配置xutils3：1.gradle中添加compile 'org.xutils:xutils:3.3.40'2.自定义Application/*** Created by Joe on 2016/9/25.*/public class MyApp extends Appli...
对Xutils3的联网进行封装
qq_33737742的博客
12-26 351
本文为原创，转载请写明出处，[原文链接](http://blog.csdn.net/qq_33737742) 1，先描述一下需求 目前正在用的http请求是Xutils，现在发现使用OkHttp来封装一套会更好。又比方说，目前正在用的数据存储方案是OrmLite， 现在使用greenDao或者Realm会更好，在类似这些情况下，如何做到不修改Activity/Fragment/Present
关于xutils3.0框架的封装以及抽取，方便使用
yxhx92的专栏
04-15 833
以前一直使用xutil这个轻量级开发工具，因为它的使用简单，运行高效，开发便捷。 但是未得到作者很好的维护与更新。 前几天在网上看到有作者放出xtuils3的源码，所以研究了一下午。然后做了一些简单的封装！ xutil3.0基于xutils进行二次重构与开发，数据库操作的效率有了大幅度提升，而且也支持了https协议。整个项目也十分的简洁，十分的适合开发人员的使用！ 但是我看到一个十分不满意的地方，
Android全能开源项目xUtils3开发教程、简单封装
码农笔录-微信公众号博客
05-19 1万+
Android全能开源项目xUtils3开发教程、简单封装 一、简介 xUtils是一个比较全能的开源项目了， 包含了orm, http(s), image, view注解, 但依然很轻量级(246K), 并且特性强大, 方便扩展。这是xUtils3 的 github地址https://github.com/wyouflf/xUtils3 xUtils3 的一些特性 xUtils支...
xUtils3的二次封装使用
yzj5380的博客
03-30 761
xUtils封装
js面向对象入门：封装、继承与单例模式详解
对象的封装性体现在将相似的功能和数据结构组合在一起，形成模块化的代码，如通过单例模式来管理全局变量或方法，避免名称冲突。例如，小王和小华的故事展示了如何通过单例模式（即命名空间）确保同一名称的函数不会...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Owen_le

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值