XHttp2

Project Url: xuexiangjys/XHttp2
Introduction: 一个功能强悍的网络请求库,使用 RxJava2 + Retrofit2 + OKHttp 组合进行封装。
More: Author   ReportBugs   
Tags:

xh

一个功能强悍的网络请求库,使用 RxJava2 + Retrofit2 + OKHttp 组合进行封装。

关于我

github csdn

特征

  • 支持默认、全局、局部三个层次的配置功能。
  • 支持动态配置和自定义底层框架 Okhttpclient、Retrofit.
  • 加入基础 ApiService,减少 Api 冗余。
  • 支持多种方式访问网络 GET、POST、PUT、DELETE 等请求协议。
  • 支持网络缓存,六种缓存策略可选,涵盖大多数业务场景。
  • 支持固定添加 header 和动态添加 header。
  • 支持添加全局参数和动态添加局部参数。
  • 支持文件下载、多文件上传和表单提交数据。
  • 支持文件请求、上传、下载的进度回调、错误回调,也可以自定义回调。
  • 支持任意数据结构的自动解析。
  • 支持添加动态参数例如 timeStamp 时间戳、token、签名 sign。
  • 支持自定义的扩展 API。
  • 支持多个请求合并。
  • 支持 Cookie 管理。
  • 支持异步、同步请求。
  • 支持 Https、自签名网站 Https 的访问、双向验证。
  • 支持失败重试机制,可以指定重试次数、重试间隔时间。
  • 支持根据 key 删除网络缓存和清空网络缓存。
  • 提供默认的标准 ApiResult(遵循 OpenApi 格式)解析和回调,并且可自定义 ApiResult。
  • 支持取消数据请求,取消订阅,带有对话框的请求不需要手动取消请求,对话框消失会自动取消请求。
  • 支持请求数据结果采用回调和订阅两种方式。
  • 提供"默认 API"、"接口协议"以及"统一请求实体"三种方式进行网络请求,支持自定义网络请求协议。
  • 返回结果和异常统一处理,支持自定义异常处理。
  • 结合 RxJava,线程切换灵活。
  • 请求实体支持注解配置,配置网络请求接口的 url、是否需要验证 token 以及请求参数的 key。
  • 拥有统一的网络请求取消机制。

1、演示(请 star 支持)

1.1、Demo 演示动画

1.2、Demo 下载

downloads

1.3、api 服务安装

服务端的搭建详细请点击查看

2、如何使用

目前支持主流开发工具 AndroidStudio 的使用,直接配置 build.gradle,增加依赖即可.

2.1、Android Studio 导入方法,添加 Gradle 依赖

1.先在项目根目录的 build.gradle 的 repositories 添加:

allprojects {
     repositories {
        ...
        maven { url "https://jitpack.io" }
    }
}

2.然后在 dependencies 添加:

dependencies {
  ...
  implementation 'com.github.xuexiangjys:XHttp2:1.0.2'
  implementation 'com.google.code.gson:gson:2.8.2'
  implementation 'com.squareup.okhttp3:okhttp:3.10.0'
  implementation 'io.reactivex.rxjava2:rxjava:2.1.12'
  implementation 'io.reactivex.rxjava2:rxandroid:2.0.2'
}

3.在 Application 中初始化 XHttpSDK

XHttpSDK.init(this);   //初始化网络请求框架,必须首先执行
XHttpSDK.debug("XHttp");  //需要调试的时候执行
XHttpSDK.setBaseUrl(SettingSPUtils.getInstance().getApiURL());  //设置网络请求的基础地址

4.全局初始化配置(非必要)

除了上述的操作以外,你还可以使用XHttp.getInstance()对网络请求框架进行全局性参数配置,配置一些公用默认的参数,这样我们就不需要为每个请求都进行设置。方法如下:

方法名 备注
debug 设置日志的打印模式
setBaseUrl 设置全局 baseUrl
setSubUrl 设置全局 subUrl
setReadTimeOut 设置全局读取超时时间
setWriteTimeOut 设置全局写入超时时间
setConnectTimeout 设置全局连接超时时间
setTimeout 设置全局超时时间
setRetryCount 设置全局超时重试次数
setRetryDelay 设置全局超时重试延迟时间
setRetryIncreaseDelay 设置全局超时重试延迟叠加时间
setCacheMode 设置全局的缓存模式
setIsDiskCache 设置是否是磁盘缓存
setMemoryMaxSize 设置内存缓存的最大数量
setCacheTime 设置全局的缓存过期时间
setCacheMaxSize 设置全局的磁盘缓存大小,默认 50M
setCacheDirectory 设置全局缓存的路径,默认是应用包下面的缓存
setCacheDiskConverter 设置全局缓存的转换器
addCommonParams 添加全局公共请求参数
addCommonHeaders 添加全局公共请求参数
addInterceptor 添加全局拦截器
addNetworkInterceptor 添加全局网络拦截器
setOkproxy 全局设置 OkHttpClient 的代理
setOkconnectionPool 设置全局 OkHttpClient 的请求连接池
setOkclient 全局为 Retrofit 设置自定义的 OkHttpClient
addConverterFactory 设置全局 Converter.Factory,默认 GsonConverterFactory.create()
addCallAdapterFactory 设置全局 CallAdapter.Factory,默认 RxJavaCallAdapterFactory.create()
setHostnameVerifier 设置 https 的全局访问规则
setCertificates 设置 https 的全局自签名证书
setCookieStore 设置全局 cookie 存取规则

如何进行网络请求

需要注意的是,所以请求返回的结果必须要满足以下格式:

{
    "Code":0, //响应码,0 为成功,否则失败
    "Msg":"", //请求失败的原因说明
    "Data":{} //返回的数据对象
}

约定了其中CodeMsgData首字母必须大写,否则无法解析成功。

需要自定义返回的实体 API 请点击查看

1、使用 XHttp 默认 api 进行请求

1.使用 XHttp.post、XHttp.get、XHttp.delete、XHttp.put、XHttp.downLoad 构建请求。

2.修改 request 的请求参数。

方法名 类型 默认值 备注
baseUrl String 设置该请求的 baseUrl
timeOut long 10000 设置超时时间
accessToken boolean false 是否需要验证 token
threadType String 设置请求的线程调度类型
syncRequest boolean false 设置是否是同步请求(不开子线程)
onMainThread boolean true 请求完成后是否回到主线程
upJson String "" 上传 Json 格式的数据请求
keepJson boolean false 返回保持 json 的形式
retryCount int 设置超时重试的次数
retryDelay int 设置超时重试的延迟时间
retryIncreaseDelay int 设置超时重试叠加延时
headers HttpHeaders 添加头信息
params HttpParams 设置表单请求参数
cacheMode CacheMode CacheMode.NO_CACHE 设置缓存的模式

3.调用execute方法执行请求。execute 一般有如下两种方式:

  • execute(CallBack callBack): 直接回调结果。

  • execute(Class clazz)和 execute(Type type): 回调 Observable对象,可通过订阅获取到结果。

4.请求使用演示

XHttp.get("/user/getAllUser")
        .syncRequest(false) //异步请求
        .onMainThread(true) //回到主线程
        .execute(new SimpleCallBack<List<User>>() {
            @Override
            public void onSuccess(List<User> response) {
                refreshLayout.finishRefresh(true);
                if (response != null && response.size() > 0) {
                    mUserAdapter.refresh(response);
                    mLlStateful.showContent();
                } else {
                    mLlStateful.showEmpty();
                }
            }
            @Override
            public void onError(ApiException e) {
                refreshLayout.finishRefresh(false);
                mLlStateful.showError(e.getMessage(), null);
            }

        });
XHttp.post("/user/deleteUser")
        .params("userId", item.getUserId())
        .execute(Boolean.class)
        .subscribeWith(new TipRequestSubscriber<Boolean>() {
            @Override
            protected void onSuccess(Boolean aBoolean) {
                ToastUtils.toast("删除成功!");
                setFragmentResult(RESULT_OK, null);
                popToBack();
            }
        });

2、使用 XHttpRequest 封装的统一请求实体进行请求【仅支持 post 请求】

在使用它之前,需要下载/定义对应的实体协议,如下:

@RequestParams(url = "/user/addUser", accessToken = false)
public static class UserService_AddUser extends XHttpRequest {

    /**
     *
     */
    public User request;

    @Override
    protected Boolean getResponseEntityType() {
        return null;
    }
}

1.注解说明

  • @RequestParams
注解参数 类型 默认值 备注
baseUrl String "" 设置该请求的 baseUrl
url String "" 请求网络接口地址
timeout long 15000 设置超时时间
accessToken boolean true 设置是否需要验证 token
cacheMode CacheMode CacheMode.NO_CACHE 设置请求的缓存模式
  • @ParamKey
注解参数 类型 默认值 备注
key String / 请求参数的 key

2.使用 XHttpSDK 进行请求。

  • post(XHttpRequest xHttpRequest, boolean isSyncRequest, boolean toMainThread): 获取 PostRequest 请求(使用实体参数名作为请求 Key)。

  • postToMain(XHttpRequest xHttpRequest): 获取 PostRequest 请求(主线程->主线程)。

  • postToIO(XHttpRequest xHttpRequest): 获取 PostRequest 请求(主线程->子线程)。

  • postInThread(XHttpRequest xHttpRequest): 获取 PostRequest 请求(子线程->子线程)。

  • execute(XHttpRequest xHttpRequest, boolean isSyncRequest, boolean toMainThread) : 执行 PostRequest 请求,返回 observable 对象(使用实体参数名作为请求 Key)。

  • executeToMain(XHttpRequest xHttpRequest): 执行 post 请求,返回 observable 对象(主线程->主线程)

  • executeToMain(XHttpRequest xHttpRequest,BaseSubscriber<T> subscriber): 执行 post 请求并进行订阅,返回订阅信息(主线程->主线程)

3.请求使用演示。

XHttpRequest req = ApiProvider.getAddUserReq(getRandomUser());
XHttpSDK.executeToMain(req, new ProgressLoadingSubscriber<Boolean>(mIProgressLoader) {
    @Override
    public void onSuccess(Boolean aBoolean) {
        ToastUtils.toast("用户添加成功!");
        mRefreshLayout.autoRefresh();
    }
});

3、使用 XHttpProxy 代理进行请求【仅支持 post 请求】

在使用它之前,需要下载/定义对应的接口协议,如下:

/**
 * 订单
 */
public interface IOrder {
    /**
     * 购买书
     *
     * @param bookId 用户名
     * @param userId 密码
     */
    @NetMethod(ParameterNames = {"bookId", "userId", "number"}, Url = "/order/addOrder/")
    Observable<Boolean> buyBook(int bookId, int userId, int number);
}

1.注解说明

  • @NetMethod
注解参数 类型 默认值 备注
ParameterNames String[] {} 参数名集合
BaseUrl String "" 设置该请求的 baseUrl
Url String "" 请求网络接口地址
Timeout long 10000 设置超时时间
AccessToken boolean true 设置是否需要验证 token
CacheMode CacheMode CacheMode.NO_CACHE 设置请求的缓存模式

2.使用 XHttpProxy 进行请求。

构建一个 XHttpProxy,将定义的 api 接口传入后,直接调用接口进行请求。

构造 XHttpProxy 可以传入isPostJson来决定请求是上传 json 数据还是键值对数据, 默认是true,上传 json 数据。

构造 XHttpProxy 可以传入ThreadType,默认是ThreadType.TO_MAIN

  • TO_MAIN: executeToMain(main -> io -> main)

【注意】请确保网络请求在主线程中【实质是异步请求(切换到 io 线程),且响应的线程又切换至主线程】

  • TO_IO: executeToIO(main -> io -> io)

【注意】请确保网络请求在主线程中【实质是异步请求(切换到 io 线程),不过响应的线程不变,还是之前请求的那个 io 线程】

  • IN_THREAD: executeInThread(io -> io -> io)

【注意】请确保网络请求在子线程中才可以使用该类型【实质是不做任何线程调度的同步请求】

3.请求使用演示。

//使用 XHttpProxy 进行接口代理请求
XHttpProxy.proxy(TestApi.IOrder.class)
        .buyBook(mBookAdapter.getItem(position).getBookId(), UserManager.getInstance().getUser().getUserId(), 1)
        .subscribeWith(new TipRequestSubscriber<Boolean>() {
            @Override
            public void onSuccess(Boolean aBoolean) {
                ToastUtils.toast("图书购买" + (aBoolean ? "成功" : "失败") + "!");
                mRefreshLayout.autoRefresh();
            }
        });

4、文件上传和下载

1.文件上传【multipart/form-data】

使用 post 的文件表单上传。使用XHttp.post,然后使用params传递附带的参数,使用uploadFile传递需要上传的文件,使用示例如下:

mIProgressLoader.updateMessage("上传中...");
XHttp.post("/book/uploadBookPicture")
        .params("bookId", book.getBookId())
        .uploadFile("file", FileUtils.getFileByPath(mPicturePath), new IProgressResponseCallBack() {
            @Override
            public void onResponseProgress(long bytesWritten, long contentLength, boolean done) {

            }
        }).execute(Boolean.class)
        .compose(RxLifecycle.with(this).<Boolean>bindToLifecycle())
        .subscribeWith(new ProgressLoadingSubscriber<Boolean>(mIProgressLoader) {
            @Override
            public void onSuccess(Boolean aBoolean) {
                mIsEditSuccess = true;
                ToastUtils.toast("图片上传" + (aBoolean ? "成功" : "失败") + "!");
            }
        });

2.文件下载

使用XHttp.downLoad,传入下载的地址 url、保存文件的路径以及文件名即可完成文件的下载,使用示例如下:

XHttp.downLoad(BookAdapter.getBookImgUrl(book))
        .savePath(PathUtils.getExtPicturesPath())
        .execute(new DownloadProgressCallBack<String>() {
            @Override
            public void onStart() {
                HProgressDialogUtils.showHorizontalProgressDialog(getContext(), "图片下载中...", true);
            }

            @Override
            public void onError(ApiException e) {
                ToastUtils.toast(e.getMessage());
                HProgressDialogUtils.cancel();
            }

            @Override
            public void update(long bytesRead, long contentLength, boolean done) {
                HProgressDialogUtils.onLoading(contentLength, bytesRead); //更新进度条
            }

            @Override
            public void onComplete(String path) {
                ToastUtils.toast("图片下载成功, 保存路径:" + path);
                HProgressDialogUtils.cancel();
            }
        });

高阶网络请求操作

请求生命周期绑定

1.请求 loading 加载和请求生命周期绑定

在请求时,订阅ProgressLoadingSubscriber或者ProgressLoadingCallBack,传入请求消息加载者IProgressLoader,即可完成生命周期的绑定。示例如下:

XHttpRequest req = ApiProvider.getAddUserReq(getRandomUser());
    XHttpSDK.executeToMain(req, new ProgressLoadingSubscriber<Boolean>(mIProgressLoader) {
        @Override
        public void onSuccess(Boolean aBoolean) {
            ToastUtils.toast("用户添加成功!");
            mRefreshLayout.autoRefresh();
        }
    });

2.网络请求生命周期和 Activity/Fragment 生命周期绑定

(1)这里需要依赖一下 RxUtil2

implementation 'com.github.xuexiangjys:rxutil2:1.1.2'

(2)在所在的 Activity 的 onCreate()下锁定 Activity.

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    RxLifecycle.injectRxLifecycle(this);
}

(3)然后在请求中使用 RxJava 的compose的操作符进行绑定。

.compose(RxLifecycle.with(this).<Boolean>bindToLifecycle())

拦截器

日志拦截器

(1)框架默认提供一个实现好的日志拦截器HttpLoggingInterceptor,通过XHttpSDK.debug("XHttp");就可以设置进去,它有 5 种打印模式

  • NONE: 不打印 log

  • BASIC: 只打印"请求首行"和"响应首行"。

  • HEADERS: 打印请求和响应的所有 Header

  • PARAM: 只打印请求和响应参数

  • BODY: 打印所有数据(默认是这种)

(2)如果需要对网络请求的相关参数进行自定义记录的话,可以继承HttpLoggingInterceptor实现一个自己的网络请求日志拦截器,重写logForRequestlogForResponse两个方法即可。

(3)设置自定义的日志拦截器.

XHttpSDK.debug(new CustomLoggingInterceptor());

动态参数添加拦截器

有时候,我们需要对所有请求添加一些固定的请求参数,但是这些参数的值又是变化的,这个时候我们就需要动态添加请求参数【例如,请求的 token、时间戳以及签名等】

(1)继承BaseDynamicInterceptor,实现updateDynamicParams方法,如下:

@Override
protected TreeMap<String, Object> updateDynamicParams(TreeMap<String, Object> dynamicMap) {
    if (isAccessToken()) {//是否添加 token
        dynamicMap.put("token", TokenManager.getInstance().getToken());
    }
    if (isSign()) {//是否添加签名
        dynamicMap.put("sign", TokenManager.getInstance().getSign());
    }
    if (isTimeStamp()) {//是否添加请求时间戳
        dynamicMap.put("timeStamp", DateUtils.getNowMills());
    }
    return dynamicMap;//dynamicMap:是原有的全局参数+局部参数+新增的动态参数
}

(2)设置动态参数添加拦截器。

XHttpSDK.addInterceptor(new CustomDynamicInterceptor()); //设置动态参数添加拦截器

失效请求校验拦截器

当服务端返回一些独特的错误码(一般是 token 校验错误、失效,请求过于频繁等),需要我们进行全局性的拦截捕获,并作出相应的响应时,我们就需要定义一个特殊的拦截器求处理这些请求。

(1)继承BaseExpiredInterceptor,实现isResponseExpiredresponseExpired方法,如下:

/**
 * 判断是否是失效的响应
 *
 * @param oldResponse
 * @param bodyString
 * @return {@code true} : 失效 <br>  {@code false} : 有效
 */
@Override
protected ExpiredInfo isResponseExpired(Response oldResponse, String bodyString) {
    int code = JSONUtils.getInt(bodyString, ApiResult.CODE, 0);
    ExpiredInfo expiredInfo = new ExpiredInfo(code);
    switch (code) {
        case TOKEN_INVALID:
        case TOKEN_MISSING:
            expiredInfo.setExpiredType(KEY_TOKEN_EXPIRED)
                    .setBodyString(bodyString);
            break;
        case AUTH_ERROR:
            expiredInfo.setExpiredType(KEY_UNREGISTERED_USER)
                    .setBodyString(bodyString);
            break;
        default:
            break;
    }
    return expiredInfo;
}

/**
 * 失效响应的处理
 *
 * @return 获取新的有效请求响应
 */
@Override
protected Response responseExpired(Response oldResponse, Chain chain, ExpiredInfo expiredInfo) {
    switch(expiredInfo.getExpiredType()) {
        case KEY_TOKEN_EXPIRED:
            User user = TokenManager.getInstance().getLoginUser();
            if (user != null) {
                final boolean[] isGetNewToken = {false};
                HttpLog.e("正在重新获取 token...");
                XHttpProxy.proxy(TestApi.IAuthorization.class, ThreadType.IN_THREAD)
                        .login(user.getLoginName(), user.getPassword())
                        .subscribeWith(new NoTipRequestSubscriber<LoginInfo>() {
                            @Override
                            protected void onSuccess(LoginInfo loginInfo) {
                                TokenManager.getInstance()
                                        .setToken(loginInfo.getToken())
                                        .setLoginUser(loginInfo.getUser());
                                isGetNewToken[0] = true;
                                HttpLog.e("重新获取 token 成功:" + loginInfo.getToken());
                            }
                        });
                if (isGetNewToken[0]) {
                    try {
                        HttpLog.e("使用新的 token 重新进行请求...");
                        return chain.proceed(HttpUtils.updateUrlParams(chain.request(), "token", TokenManager.getInstance().getToken()));
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            } else {
                XRouter.getInstance().build("/xhttp/login").navigation();
                return HttpUtils.getErrorResponse(oldResponse, expiredInfo.getCode(), "请先进行登录!");
            }
            break;
        case KEY_UNREGISTERED_USER:
            return HttpUtils.getErrorResponse(oldResponse, expiredInfo.getCode(), "非法用户登录!");
        default:
            break;
    }
    return null;
}

(2)设置失效请求校验拦截器。

XHttpSDK.addInterceptor(new CustomExpiredInterceptor()); //请求失效校验拦截器

自定义 API 请求

自定义请求响应的 API 结构

如果你不想使用默认的 ApiResult 实体作为统一的服务端响应实体,比如说你想要下面的响应实体:

private int errorCode; //请求的错误码
private String errorInfo; //请求错误的原因描述
private T result; //请求的结果
private long timeStamp; //服务端返回的时间戳

(1)首先,继承ApiResult实体,重写其getCodegetMsgisSuccessgetData方法。

public class CustomApiResult<T> extends ApiResult<T> {

    private int errorCode;
    private String errorInfo;
    private T result;
    private long timeStamp;

    public int getErrorCode() {
        return errorCode;
    }

    public CustomApiResult<T> setErrorCode(int errorCode) {
        this.errorCode = errorCode;
        return this;
    }

    public String getErrorInfo() {
        return errorInfo;
    }

    public CustomApiResult<T> setErrorInfo(String errorInfo) {
        this.errorInfo = errorInfo;
        return this;
    }

    public T getResult() {
        return result;
    }

    public CustomApiResult<T> setResult(T result) {
        this.result = result;
        return this;
    }

    public long getTimeStamp() {
        return timeStamp;
    }

    public CustomApiResult<T> setTimeStamp(long timeStamp) {
        this.timeStamp = timeStamp;
        return this;
    }

    @Override
    public int getCode() {
        return errorCode;
    }

    @Override
    public String getMsg() {
        return errorInfo;
    }

    @Override
    public boolean isSuccess() {
        return errorCode == 0;
    }

    @Override
    public T getData() {
        return result;
    }

    @Override
    public String toString() {
        return "ApiResult{" +
                "errorCode='" + errorCode + '\'' +
                ", errorInfo='" + errorInfo + '\'' +
                ", timeStamp='" + timeStamp + '\'' +
                ", result=" + result +
                '}';
    }
}

(2)进行请求的时候使用execute(CallBackProxy)或者execute(CallClazzProxy方法进行请求

XHttp.get("/test/testCustomResult")
            .execute(new CallBackProxy<CustomApiResult<Boolean>, Boolean>(new TipRequestCallBack<Boolean>() {
                @Override
                public void onSuccess(Boolean response) throws Throwable {
                    ToastUtils.toast("请求成功:" + response);
                }
            }){});  //千万注意,这里的{}一定不能去掉,否则解析错误

【注意】上面提示的{}一定不能去掉,否则解析错误, 会报"ApiResult.class.isAssignableFrom(cls) err!!"的错误。

如果你觉得写一长串比较麻烦,你可以自定义请求继承你需要的请求方式,例如这里是 get 请求,我们可以这样写:

public class CustomGetRequest extends GetRequest {

    public CustomGetRequest(String url) {
        super(url);
    }

    @Override
    public <T> Observable<T> execute(Type type) {
        return execute(new CallClazzProxy<CustomApiResult<T>, T>(type) {
        });
    }

    @Override
    public <T> Disposable execute(CallBack<T> callBack) {
        return execute(new CallBackProxy<CustomApiResult<T>, T>(callBack) {
        });
    }
}

然后我们就可以用自定义的CustomGetRequest进行请求了,是不是简化了很多呢。

new CustomGetRequest("/test/testCustomResult")
        .execute(new TipRequestCallBack<Boolean>() {
            @Override
            public void onSuccess(Boolean response) throws Throwable {
                ToastUtils.toast("请求成功:" + response);
            }
        });

使用自定义的 retrofit 接口

如果你对 retrofit 接口情有独钟,我也提供了相应的 api 方便调用.

1.定义 retrofit 接口。例如我定义一个用户添加的接口:

/**
 * 使用的是 retrofit 的接口定义
 */
public interface UserService {
    @POST("/user/registerUser/")
    @Headers({"Content-Type: application/json", "Accept: application/json"})
    Observable<ApiResult<Boolean>> registerUser(@Body RequestBody jsonBody);


    @POST("/user/registerUser/")
    @Headers({"Content-Type: application/json", "Accept: application/json"})
    Observable<ApiResult> register(@Body RequestBody jsonBody);
}

2.使用XHttp.custom()构建的CustomRequest进行请求,你可以使用apiCallcall进行请求。

  • apiCall: 针对的是 retrofit 定义的接口,返回的是 Observable>的情况。对于上面定义的第一个接口registerUser

  • call: 针对的是 retrofit 定义的接口,返回的是 Observable的情况。对于上面定义的第二个接口register

使用示例如下:

CustomRequest request = XHttp.custom();
request.apiCall(request.create(TestApi.UserService.class)
        .registerUser(HttpUtils.getJsonRequestBody(UserManager.getInstance().getRandomUser())))
        .subscribeWith(new TipRequestSubscriber<Boolean>() {
            @Override
            protected void onSuccess(Boolean aBoolean) {
                ToastUtils.toast("添加用户成功!");
            }
        });
CustomRequest request = XHttp.custom();
request.call(request.create(TestApi.UserService.class)
        .register(HttpUtils.getJsonRequestBody(UserManager.getInstance().getRandomUser())))
        .subscribeWith(new TipRequestSubscriber<ApiResult>() {
            @Override
            protected void onSuccess(ApiResult apiResult) {
                ToastUtils.toast("添加用户成功!");
                showResult(JsonUtil.toJson(apiResult));
            }
        });

缓存策略

目前框架提供了如下 8 种缓存策略:

  • NO_CACHE: 不使用缓存(默认方式)

  • DEFAULT: 完全按照 HTTP 协议的默认缓存规则,走 OKhttp 的 Cache 缓存

  • FIRST_REMOTE: 先请求网络,请求网络失败后再加载缓存

  • FIRST_CACHE: 先加载缓存,缓存没有再去请求网络

  • ONLY_REMOTE: 仅加载网络,但数据依然会被缓存

  • ONLY_CACHE: 只读取缓存

  • CACHE_REMOTE: 先使用缓存,不管是否存在,仍然请求网络,会回调两次

  • CACHE_REMOTE_DISTINCT: 先使用缓存,不管是否存在,仍然请求网络,会先把缓存回调给你,等网络请求回来发现数据是一样的就不会再返回,否则再返回(这样做的目的是防止数据是一样的你也需要刷新界面)

对于缓存的实现,提供了磁盘缓存LruDiskCache和内存缓存LruMemoryCache两种实现,默认使用的是磁盘缓存。

(1)可以先进行缓存的全局性配置,配置缓存的有效期、缓存大小,缓存路径、序列化器等。

XHttp.getInstance()
        .setIsDiskCache(true) //设置使用磁盘缓存
        .setCacheTime(60 * 1000) //设置全局缓存有效期为一分钟
        .setCacheVersion(1) //设置全局缓存的版本
        .setCacheDirectory(Utils.getDiskCacheDir(this, "XHttp")) //设置全局缓存保存的目录路径
        .setCacheMode(CacheMode.NO_CACHE) //设置全局的缓存策略
        .setCacheDiskConverter(new GsonDiskConverter())//默认缓存使用序列化转化
        .setCacheMaxSize(50 * 1024 * 1024);//设置缓存大小为 50M

(2)在进行请求的时候,设置缓存模式和缓存的 key 即可。如下:

XHttp.get("/book/getAllBook")
        .timeOut(10 * 1000)//测试局部超时 10s
        .cacheMode(mCacheMode)
        .cacheKey(CACHE_KEY)//缓存 key
        .retryCount(5)//重试次数
        .cacheTime(5 * 60)//缓存时间 300s,默认 -1 永久缓存  okhttp 和自定义缓存都起作用
        .cacheDiskConverter(new GsonDiskConverter())//默认使用的是 new SerializableDiskConverter();
        .timeStamp(true)
        .execute(new ProgressLoadingCallBack<CacheResult<List<Book>>>(mIProgressLoader) {
            @Override
            public void onSuccess(CacheResult<List<Book>> cacheResult) {
                ToastUtils.toast("请求成功!");
                String from;
                if (cacheResult.isFromCache) {
                    from = "我来自缓存";
                } else {
                    from = "我来自远程网络";
                }
                showResult(from + "\n" + JsonUtil.toJson(cacheResult.data));
            }

            @Override
            public void onError(ApiException e) {
                super.onError(e);
                ToastUtils.toast(e.getDisplayMessage());
            }
        });

混淆配置

#XHttp2
-keep class com.xuexiang.xhttp2.model.** { *; }
-keep class com.xuexiang.xhttp2.cache.model.** { *; }
-keep class com.xuexiang.xhttp2.cache.stategy.**{*;}
-keep class com.xuexiang.xhttp2.annotation.** { *; }

#okhttp
-dontwarn com.squareup.okhttp3.**
-keep class com.squareup.okhttp3.** { *;}
-dontwarn okio.**
-dontwarn javax.annotation.Nullable
-dontwarn javax.annotation.ParametersAreNonnullByDefault
-dontwarn javax.annotation.**

# Retrofit
-dontwarn retrofit2.**
-keep class retrofit2.** { *; }
-keepattributes Exceptions

# RxJava RxAndroid
-dontwarn sun.misc.**
-keepclassmembers class rx.internal.util.unsafe.*ArrayQueue*Field* {
    long producerIndex;
    long consumerIndex;
}
-keepclassmembers class rx.internal.util.unsafe.BaseLinkedQueueProducerNodeRef {
    rx.internal.util.atomic.LinkedQueueNode producerNode;
}
-keepclassmembers class rx.internal.util.unsafe.BaseLinkedQueueConsumerNodeRef {
    rx.internal.util.atomic.LinkedQueueNode consumerNode;
}

#如果用到 Gson 解析包的,直接添加下面这几行就能成功混淆,不然会报错
-keepattributes Signature
-keep class com.google.gson.stream.** { *; }
-keepattributes EnclosingMethod
-keep class org.xz_sale.entity.**{*;}
-keep class com.google.gson.** {*;}
-keep class com.google.**{*;}
-keep class sun.misc.Unsafe { *; }
-keep class com.google.gson.stream.** { *; }
-keep class com.google.gson.examples.android.model.** { *; }

特别感谢

https://github.com/zhou-you/RxEasyHttp

联系方式

新手提问前,请先阅读【提问的智慧】

Support Me
Apps
About Me
Google+: Trinea trinea
GitHub: Trinea