Android---Xutils3.0 网络请求框架封装（包含解析）

最新推荐文章于 2024-07-10 03:09:55 发布
最新推荐文章于 2024-07-10 03:09:55 发布
阅读量1k 收藏 2
点赞数
分类专栏： Android学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32816979/article/details/79115761
版权

一、Xutils 3.0简介

xUtils是目前功能比较完善的一个 Android 开源框架，最近又发布了xUtil3.0，在增加新功能的同时又提高了框架的性能，下面来看看官方（ https://github.com/wyouflf/xUtils3 ）对xUtils3的介绍：

  • xUtils包含了很多实用的android工具；
  • xUtils支持超大文件(超过2G)上传，更全面的http请求协议支持(11种谓词)，拥有更加灵活的ORM，更多的事件注解支持且不受混淆影响；
  • xUtils 最低兼容Android 4.0 (api level 14)；
  • xUtils3变化较多所以建立了新的项目不在旧版(github.com/wyouflf/xUtils)上继续维护, 相对于旧版本： 

    • HTTP实现替换HttpClient为UrlConnection, 自动解析回调泛型, 更安全的断点续传策略；
    • 支持标准的Cookie策略, 区分domain, path；
    • 事件注解去除不常用的功能, 提高性能；
    • 数据库api简化提高性能, 达到和greenDao一致的性能；
    • 图片绑定支持gif(受系统兼容性影响, 部分gif文件只能静态显示), webp; 支持圆角, 圆形, 方形等裁剪, 支持自动旋转。
二、Xutils引入和初始化（基于AS）
    1.build.gradle文件配置

    2.Application里进行初始化

x.Ext.init(this);

3、框架封装

public class NetRequestUtil {

    private volatile static NetRequestUtil instance;

    /**
     * Double Check 单例模式
     *
     * @return
     */
    public static NetRequestUtil getInstance() {
        if (instance == null) {
            synchronized (NetRequestUtil.class) {
                if (instance == null) {
                    instance = new NetRequestUtil();
                }
            }
        }
        return instance;
    }

    /**
     * /appLogin','/version','/applogout','/weekReportDel','/idcode','/islogin','/losepwd'
     * 不需要传token
     */
    public static final int REQUEST_TOKEN = 0;// 默认需要token
    public static final int REQUEST_NO_TOKEN = 1; // 在登录等几个特殊接口不需要token

    public static final int REQUEST_METHOD_GET = 0;// get请求
    public static final int REQUEST_METHOD_POST = 1; // post请求

    /**
     * 基地址
     */
    private String TestUrl = "http://a.http.cn/"; // 测试环境
  
    private String BaseUrl = TestUrl;

    /**
     * 接口地址
     */

    /  登录  退出  /
    public String LOGIN = "appLogin";  // 登录接口
    public String LOGOUT = "applogout"; // 退出
    public String IS_LOGIN = "islogin"; // 每次判断是否要重新登录，有效期内不需要每次登录
   
    /**
     * 取得完整地址
     *
     * @param apiUrl
     * @return
     */
    public String getUrl(String apiUrl) {
        return BaseUrl + apiUrl;
    }

    /**
     * 取得公共参数
     *
     * @return
     */
    public Map<String, Object> getBaseMap() {
        Map<String, Object> map = new HashMap<>();

        // 添加公参
        map.put("device_token", Tools.getDeviceId(MyApplication.getInstance())); //  设备唯一标识
        map.put("device_uuid", Tools.getDeviceId(MyApplication.getInstance()));
        map.put("appid", "android");
        map.put("version", Tools.getVersion(MyApplication.getInstance()));

        if (EmptyUtils.isNotEmpty(MyApplication.getInstance().getUser())
                && EmptyUtils.isNotEmpty(MyApplication.getInstance().getUser().getData().getUsername())) {
            map.put("username", MyApplication.getInstance().getUser().getData().getUsername());
        }

        return map;
    }

    /**
     * 异步get请求
     *
     * @param url
     * @param maps
     * @param requestCode
     * @param clazz
     * @param listener
     * @return
     */
    public Callback.Cancelable get(String url, Map<String, String> maps, final int requestCode,
                                   final Class<? extends MResponse> clazz, final NetResponseListener listener) {


        if (!NetworkUtils.isConnected()) {
            ToastU.showShortToast(R.string.no_network);
        }

        maps.put("sign", Tools.getSign(maps)); // MD5加密

        RequestParams params = new RequestParams(url);
        if (maps != null && !maps.isEmpty()) {
            for (Map.Entry<String, String> entry : maps.entrySet()) {
                params.addQueryStringParameter(entry.getKey(), entry.getValue());
            }
        }

        Callback.Cancelable cancelable = x.http().get(params, new Callback.CommonCallback<String>() {
            @Override
            public void onSuccess(String result) {
                MResponse mResponse = GsonUtil.processJS(result, clazz); //按正常响应解析
                listener.onSuccess(mResponse, requestCode, result);
            }

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

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

            @Override
            public void onFinished() {
                listener.onFinish();
            }
        });

        return cancelable;
    }

    /**
     * 带缓存的异步get请求
     *
     * @param url
     * @param maps
     * @param requestCode
     * @param clazz
     * @param listener
     * @return
     */
    public Callback.Cancelable getCache(String url, Map<String, String> maps, final int requestCode,
                                        final Class<? extends MResponse> clazz, final NetResponseListener listener) {

        if (!NetworkUtils.isConnected()) {
            ToastU.showShortToast(R.string.no_network);
        }

        maps.put("sign", Tools.getSign(maps)); // MD5加密

        RequestParams params = new RequestParams(url);
        if (maps != null && !maps.isEmpty()) {
            for (Map.Entry<String, String> entry : maps.entrySet()) {
                params.addQueryStringParameter(entry.getKey(), entry.getValue());
            }
        }

        // 默认缓存存活时间, 单位:毫秒（如果服务器没有返回有效的max-age或Expires则参考）
        params.setCacheMaxAge(1000 * 60);//设置缓存当这个缓存事件过了的时候, 这时候就会不走这个onCache方法, 直接发起网络请求,

        Callback.Cancelable cancelable = x.http().get(params, new Callback.CacheCallback<String>() {
            @Override
            public boolean onCache(String result) {
                MResponse mResponse = GsonUtil.processJS(result, clazz);//按正常响应解析
                listener.onSuccess(mResponse, requestCode, result);
                return true;//这里返回一个true, 就是走了cache就不再发起网络请求了, 返回一个false, 就是不信任缓存数据, 再次发起网络请求
            }

            @Override
            public void onSuccess(String result) {
                if (result != null) {
                    //如果走了cache方法返回了true, 将不再发起网络请求, 这里拿到的result就是null,
                    MResponse mResponse = GsonUtil.processJS(result, clazz);//按正常响应解析
                    listener.onSuccess(mResponse, requestCode, result);
                }
            }

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

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

            @Override
            public void onFinished() {
                listener.onFinish();
            }
        });
        return cancelable;
    }

    /**
     * 异步post请求，去除请求标志，默认为0
     *
     * @param url
     * @param maps
     * @param clazz
     * @param listener
     * @return
     */
    public Callback.Cancelable post(Context context, String url, Map<String, Object> maps,
                                    final Class<? extends MResponse> clazz, final NetResponseListener listener) {
        return post(context, url, maps, REQUEST_TOKEN, clazz, listener);
    }

    /**
     * 异步post请求
     *
     * @param context
     * @param url
     * @param maps
     * @param requestCode
     * @param clazz
     * @param listener
     * @return
     */
    public Callback.Cancelable post(final Context context, String url, Map<String, Object> maps,
                                    final int requestCode, final Class<? extends MResponse> clazz,
                                    final NetResponseListener listener) {

        if (!NetworkUtils.isConnected()) {
            ToastU.showShortToast(R.string.no_network);
        }

        if (requestCode == REQUEST_TOKEN) {
            maps.put("token", MyApplication.getInstance().getUser().getData().getToken()); // 添加token
        }

        maps.put("sign", Tools.getSign(maps)); // MD5加密

        RequestParams params = new RequestParams(url);
        params.setReadTimeout(30 * 1000); // 设置网络超时时间
        params.setConnectTimeout(30 * 1000);
        params.setMethod(HttpMethod.POST);

        if (!maps.isEmpty()) {
            for (Map.Entry<String, Object> entry : maps.entrySet()) {
                params.addParameter(entry.getKey(), entry.getValue());
            }
        }

        AppLog.i(Const.HTTP_LOG_KEY, "=======http-request-url::::::" + url);
        AppLog.i(Const.HTTP_LOG_KEY, "=======http-request-parameters::::::" + params.toString());

        //为了防止app登录成功以后im当时的登录失败，每次访问接口的时候判断一下是否需要im失败，如果失败就进行重新登录
        if (!IMUseHelper.isImLogin()) {
            IMUseHelper.initImLogin();
        }

        final Callback.Cancelable post = x.http().post(params, new Callback.CommonCallback<String>() {

            @Override
            public void onSuccess(final String result) {
                try {
                    JSONObject jsonObject = new JSONObject(result);

                    // 1. 判断为token过期则重新去登录,比如在其他设备上登录   2.人员角色变化，需要重新登录更新个人信息
                    if (jsonObject.getInt("code") == Const.LOGIN_OUT_TIME

                            || Const.ROLE_CHANGES == jsonObject.getInt("code")) {

                        if (!TextUtils.isEmpty(jsonObject.getString("message"))) {
                            ToastU.showLongToast(jsonObject.getString("message"));
                        }
                        Tools.logout(context);
                    } else {
                        final MResponse mResponse = GsonUtil.processJS(result, clazz);//按正常响应解析
                        listener.onSuccess(mResponse, requestCode, result);
                    }
                } catch (JSONException e) {
                    e.printStackTrace();
                }

                AppLog.i(Const.HTTP_LOG_KEY, "=======---onSuccess---======:" + result);
            }

            @Override
            public void onError(Throwable ex, boolean isOnCallback) {
                if (ex instanceof HttpException) { // 网络错误
                    HttpException httpEx = (HttpException) ex;
                    int responseCode = httpEx.getCode();
                    String responseMsg = httpEx.getMessage();
                    String errorResult = httpEx.getResult();
                    AppLog.i(Const.HTTP_LOG_KEY, "=======---onError---网络错误======:"
                            + "返回码：" + responseCode
                            + "；---错误信息：" + responseMsg
                            + "；---错误结果：" + errorResult);
                } else { // 其他错误
                    listener.onError(ex, isOnCallback, requestCode);
                    AppLog.i(Const.HTTP_LOG_KEY, "=======---onError---其他错误======:" + ex.toString());
                }

            }

            @Override
            public void onCancelled(CancelledException cex) {
                listener.onCancelled(cex);
                AppLog.i(Const.HTTP_LOG_KEY, "=======---onCancelled---======:" + cex.toString());
            }

            // 不管成功或者失败最后都会回调该接口
            @Override
            public void onFinished() {
                listener.onFinish();
                AppLog.i(Const.HTTP_LOG_KEY, "=======---onFinished---======:" + clazz);
            }
        });

        return post;
    }

    /**
     * 普通异步网络请求  get或者post
     *
     * @param context
     * @param url
     * @param maps
     * @param requestCode
     * @param requestMethod
     * @param clazz
     * @param listener
     * @return
     */
    public Callback.Cancelable httpRequest(final Context context, String url,
                                           Map<String, Object> maps,
                                           final int requestCode, int requestMethod,
                                           final Class<? extends MResponse> clazz,
                                           final NetResponseListener listener) {

        HttpMethod method = null; // 请求方式

        if (requestMethod == REQUEST_METHOD_GET) {
            method = HttpMethod.GET;
        } else {
            method = HttpMethod.POST;
        }

        // token 添加
        if (requestCode == REQUEST_TOKEN) {
            maps.put("token", MyApplication.getInstance().getUser().getData().getToken()); // 添加token
        }

        maps.put("sign", Tools.getSign(maps)); // MD5加密
        RequestParams params = new RequestParams(url);

        if (!maps.isEmpty()) {
            for (Map.Entry<String, Object> entry : maps.entrySet()) {
                params.addBodyParameter(entry.getKey(), entry.getValue().toString());
            }
        }

        Callback.Cancelable request = x.http().request(method, params, new Callback.CommonCallback<String>() {
            @Override
            public void onSuccess(String result) {
                try {
                    JSONObject jsonObject = new JSONObject(result);

                    if (jsonObject.getInt("code") == Const.LOGIN_OUT_TIME) { // 判断为token过期则重新去登录
                        ToastU.showLongToast(jsonObject.getString("message"));
                        Tools.logout(context);
                    } else {
                        final MResponse mResponse = GsonUtil.processJS(result, clazz);//按正常响应解析
                        listener.onSuccess(mResponse, requestCode, result);
                    }
                } catch (JSONException e) {
                    e.printStackTrace();
                }

            }

            @Override
            public void onError(Throwable ex, boolean isOnCallback) {
                if (ex instanceof HttpException) { // 网络错误
                    HttpException httpEx = (HttpException) ex;
                    int responseCode = httpEx.getCode();
                    String responseMsg = httpEx.getMessage();
                    String errorResult = httpEx.getResult();

                    AppLog.i(Const.HTTP_LOG_KEY, "=======---onError---网络错误======:"
                            + "返回码：" + responseCode
                            + "；---错误信息：" + responseMsg
                            + "；---错误结果：" + errorResult);
                } else { // 其他错误
                    listener.onError(ex, isOnCallback, requestCode);
                    AppLog.i(Const.HTTP_LOG_KEY, "=======---onError---其他错误======:" + ex.toString());
                }
            }

            @Override
            public void onCancelled(CancelledException cex) {
                listener.onCancelled(cex);
                AppLog.i(Const.HTTP_LOG_KEY, "=======---onCancelled---======:" + cex.toString());
            }

            @Override
            public void onFinished() {
                listener.onFinish();
                AppLog.i(Const.HTTP_LOG_KEY, "=======---onFinished---======:" + clazz);
            }
        });

        return request;
    }

    /**
     * 文件上传
     *
     * @param url
     * @param maps
     * @param file
     * @param requestCode
     * @param clazz
     * @param listener
     * @return
     */
    public Callback.Cancelable upLoadFile(String url, Map<String, String> maps, Map<String, File> file,
                                          final int requestCode, final Class<? extends MResponse> clazz,
                                          final NetUpLoadFileListener listener) {
        if (!NetworkUtils.isConnected()) {
            ToastU.showShortToast(R.string.no_network);
        }

        // token 添加
        if (requestCode == REQUEST_TOKEN) {
            maps.put("token", MyApplication.getInstance().getUser().getData().getToken()); // 添加token
        }

        maps.put("sign", Tools.getSign(maps)); // MD5加密
        RequestParams params = new RequestParams(url);
        params.setMethod(HttpMethod.POST);

        if (!maps.isEmpty()) {
            for (Map.Entry<String, String> entry : maps.entrySet()) {
                params.addBodyParameter(entry.getKey(), entry.getValue());
            }
        }

        if (file != null && !maps.isEmpty()) {
            for (Map.Entry<String, File> entry : file.entrySet()) {
                params.addBodyParameter(entry.getKey(), entry.getValue().getAbsoluteFile());
            }
        }

        AppLog.i(Const.HTTP_LOG_KEY, "=======http-request-url::::::" + url);
        AppLog.i(Const.HTTP_LOG_KEY, "=======http-request-parameters::::::" + params.toString());

        // 有上传文件时使用multipart表单, 否则上传原始文件流.
        params.setMultipart(true);//这个是标示上传的文件内容的,

        Callback.Cancelable upLoad = x.http().post(params, new Callback.ProgressCallback<String>() {
            @Override
            public void onSuccess(String result) {
                JSONObject jsonObject = null;

                try {
                    jsonObject = new JSONObject(result);
                    ToastU.showLongToast(jsonObject.getString("message"));
                } catch (JSONException e) {
                    e.printStackTrace();
                }

                MResponse mResponse = GsonUtil.processJS(result, clazz);//按正常响应解析
                listener.onSuccess(mResponse, requestCode, result);
                AppLog.i(Const.HTTP_LOG_KEY, "=======---onSuccess---======:" + result);
            }

            @Override
            public void onError(Throwable ex, boolean isOnCallback) {
                listener.onError(ex, isOnCallback, requestCode);
                AppLog.i(Const.HTTP_LOG_KEY, "=======---onError---======:" + ex.toString());
            }

            @Override
            public void onCancelled(CancelledException cex) {
                listener.onCancelled(cex);
                AppLog.i(Const.HTTP_LOG_KEY, "=======---onCancelled---======:" + cex.toString());
            }

            @Override
            public void onFinished() {
                listener.onFinish();
                AppLog.i(Const.HTTP_LOG_KEY, "=======---onFinished---======:");
            }

            @Override
            public void onWaiting() {
                listener.onWaiting();
                AppLog.i(Const.HTTP_LOG_KEY, "=======---onWaiting---======:");
            }

            @Override
            public void onStarted() {
                listener.onStarted();
                AppLog.i(Const.HTTP_LOG_KEY, "=======---onStarted---======:");
            }

            @Override
            public void onLoading(long total, long current, boolean isDownloading) {
                listener.onLoading(current, isDownloading, requestCode);
                AppLog.i(Const.HTTP_LOG_KEY, "=======---onLoading---======:"
                        + "total:" + total + "---current:"
                        + current + "---isDownloading:"
                        + isDownloading);
            }
        });

        return upLoad;
    }

    /**
     * 文件下载
     *
     * @param url
     * @param filepath
     * @param requestCode
     * @param listener
     */
    public void downLoadFile(String url, String filepath, final int requestCode, final NetDownLoadFileListener listener) {

        if (!NetworkUtils.isConnected()) {
            ToastU.showShortToast(R.string.no_network);
        }

        RequestParams params = new RequestParams(url);
        params.setAutoRename(true);// 断点续传, 也就是说支持中断之后再继续下载,
        params.setSaveFilePath(filepath);//设置文件保存的路径

        x.http().post(params, new Callback.ProgressCallback<File>() {
            @Override
            public void onSuccess(final File result) {
                listener.onSuccess(result, requestCode);
            }

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

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

            @Override
            public void onFinished() {
                listener.onFinish();
            }

            @Override
            public void onWaiting() {
                listener.onWaiting();
            }

            @Override
            public void onStarted() {
                listener.onStarted();
            }

            @Override
            public void onLoading(final long total, final long current, final boolean isDownloading) {
                listener.onLoading(current, isDownloading, requestCode);
            }
        });

    }
}
一江夜雨
关注
专栏目录
2018年Android面试题含答案--适合中高级（下）
疾风剑豪
05-04 455
1、Activity生命周期？ onCreate() -> onStart() -> onResume() -> onPause() -> onStop() -> onDetroy() 2、Service生命周期？ service 启动方式有两种，一种是通过startService()方式进行启动，另一种是通过bindService()方式进行启动。不同的启动方式他...
android Xutils3网络请求封装
yang_niuxxx的博客
10-18 2984
使用xutils需在MyApplication里初始化x.Ext.init(this); x.Ext.setDebug(true); // 是否输出debug日志package com.recylerviewdemo; import android.app.Activity; import android.os.Bundle; import android.util.Log; import an
xUtils3.0Demo
12-17
最新Xutils3.0使用
Android 获取assets里面的资源及其路径
最新发布
weixin_40788542的博客
07-10 479
Android 获取assets里面的资源及其路径 在Android开发中，我们经常会用到assets文件夹来存放一些资源文件，比如图片、音频、视频等。但是有时候我们需要动态获取这些资源并使用，那么该怎么做呢？本文将介绍如何在Android中获取assets里面的资源及其路径。 什么是assets文件夹 assets文件夹...
xUtils更新到3.0后的基本使用规则
热门推荐
李元静
12-27 3万+
说实话，对于Xutils，是我最近才用到的开发框架（也是刚接触），对于其功能不得不说，简化了很多的开发步骤，可以说是非常好的开发工具，但是其最近更新到3.0也没有解决加载自定义ImageView报错的问题。我总是喜欢用一些最新的东西，Xutils 3.0才刚更新，是一次比较大的重构，对于百度到的使用规则，基本都是3.0以前的，使得用3.0的开发者需要求解用法的时候，遇到许多阻碍，
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 3.0
明耀的博客
03-15 301
导入时记得加上 compile 'org.xutils:xutils:3.3.40' 例如： compile ‘org.xutils:xutils:3.3.40’ implementation files(‘libs/xutils-3.3.40.jar’)
Android之xUtils-3.0数据库框架详解
weixin_34051201的博客
09-24 234
在Android 开发中,数据库模块是必不可少的.现在也有许多非常好用流行的数据库快速开发框架.今天主要介绍下xUtils下封装的数据库模块. Android 常用数据库开发框架 在这里列一下Android开发中常用的数据库框架,有情趣的可以自行了解下,顺便储备点知识. 1.OrmLite对象关系映射Lite（ORM Lite）提供了一些...
【Android -- 面试】常见面试技术要点
Kevin Learn Android
07-21 5542
本文主要汇总一些常见的 Android 面试的技术点。
Retrofit2---网络交互的艺术
我早就想，要这样载着你，翻山越岭
06-29 1180
Retrofit是啥A type-safe HTTP client for Android and Java 翻译：Android和Java使用类型安全的Http客户端 Retrofit的前世今生Http客户端用来做网络访问，网络访问，对绝大多数应用来说是一个基础功能 我们来简单回顾下网络访问框架的发展史： 1. HttpUrlConnection和HttpClient。Android2.1时
Android Okhttp3+Retrofit2网络加载效率优化
lvshaorong的博客
06-30 1万+
本文主要介绍了如何在一个老项目中替换将旧的Http框架替换成OkHttp3或Retrofit2。并介绍了使用OkHttp3和Retrofit2发送GET和POST请求的代码示例。介绍了Retrofit2配合RxJava请求网络的方法，介绍了线程池的调度方法，提升网络加载效率和用户体验。并且通过抓包分析了OkHttp3的TCP连接保活效果，分析OkHttp的网络请求的优点。最后介绍了我在项目中如何停止没有意义的网络请求，节省带宽流量和内存的思路。
Android Xutils3网络请求的封装详解及实例代码
08-31
主要介绍了Android Xutils3网络请求的封装详解及实例代码的相关资料,需要的朋友可以参考下
Android xUtils网络框架二次封装
03-21
Android xUtils网络框架二次封装
Android 新闻客户端+服务器
03-12
`library`文件夹可能包含了项目中使用的其他自定义或第三方库，这些库可能包含了特定功能的实现，例如网络请求库Retrofit或者解析库Gson，它们都是Android开发中常见的第三方依赖，用于处理网络数据的传输和JSON格式...
Xutils 3.0使用详解
luffy的专栏
04-08 4289
1.Xutils 3.0的功能这里不再解释。2.所需要的jar包：http://download.csdn.net/detail/wuqingyidongren/94845173.简单使用。 所需要的权限： <uses-permission android:name="android.permission.INTERNET" /> <uses-permission android:name="a
Xutils3.0简单的应用Dome
jiandandecainiao的博客
04-17 880
1.在build.gradle中 添加依赖 compile 'org.xutils:xutils:3.5.0' 在AndroidManifest.xml文件中 uses-permission android:name="android.permission.INTERNET">uses-permission> uses-permission android:name="andro
XUtils3.0快速开发框架
highboys的博客
11-01 1237
xUtils 包含了很多实用的android工具。 xUtils 最初源于Afinal框架，进行了大量重构，使得xUtils支持大文件上传，更全面的http请求协议支持(10种谓词)，拥有更加灵活的ORM，更多的事件注解支持且不受混淆影响... xUitls最低兼容android 2.2 (api level 8) 目录： 一、简介 二、XUtils的配置 三、注解模块
XUtils3.0 使用
weixin_36357363的博客
04-23 321
XUtils3.0有四大功能1、注解2、网络请求3、数据库4、图片加载==========================================================要使用XUtils必须要进行初始化，通长我们会这样写：public class MyApp extends Application { @Override public void onCreate()
xUtils3.0使用介绍
黑夜之星的博客
03-14 1422
xUtils3.0介绍之前一直使用xUtils2点多的版本，xUtils3.0之后发现跟以前的使用方式有了很大的区别和改变，所以整理了一下使用心得； xUtils 包含了很多实用的android工具. xUtils 支持超大文件(超过2G)上传，更全面的http请求协议支持(11种谓词)，拥有更加灵活的ORM，更多的事件注解支持且不受混淆影响… xUtils3.0 最低兼容Android 4.0 (
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值