XHttp2 一个功能强悍的网络请求库，使用RxJava2 + Retrofit2 + OKHttp进行组装

最新推荐文章于 2024-05-23 09:47:36 发布
最新推荐文章于 2024-05-23 09:47:36 发布
阅读量747 收藏 1
点赞数
文章标签： java json 运维
原文链接：https://juejin.im/post/5b6b9b49e51d4576b828978d
版权

XHttp2

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

关于我

特征

  • 支持默认、全局、局部三个层次的配置功能。
  • 支持动态配置和自定义底层框架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下载

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.0'
  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存取规则

如何进行网络请求

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

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

2.修改request的请求参数。

方法名类型默认值备注
baseUrlString／设置该请求的baseUrl
timeOutlong10000设置超时时间
accessTokenbooleanfalse是否需要验证token
threadTypeString／设置请求的线程调度类型
syncRequestbooleanfalse设置是否是同步请求（不开子线程）
onMainThreadbooleantrue请求完成后是否回到主线程
upJsonString""上传Json格式的数据请求
keepJsonbooleanfalse返回保持json的形式
retryCountint／设置超时重试的次数
retryDelayint／设置超时重试的延迟时间
retryIncreaseDelayint／设置超时重试叠加延时
headersHttpHeaders／添加头信息
paramsHttpParams／设置表单请求参数
cacheModeCacheModeCacheMode.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封装的统一请求实体进行请求

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

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

    /**
     *
     */
    public User request;

    @Override
    protected Boolean getResponseEntityType() {
        return null;
    }
}
复制代码

1.注解说明

  • @RequestParams
注解参数类型默认值备注
baseUrlString""设置该请求的baseUrl
urlString""请求网络接口地址
timeoutlong15000设置超时时间
accessTokenbooleantrue设置是否需要验证token
cacheModeCacheModeCacheMode.NO_CACHE设置请求的缓存模式
  • @ParamKey
注解参数类型默认值备注
keyString/请求参数的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代理进行请求

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

/**
 * 订单
 */
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
注解参数类型默认值备注
ParameterNamesString[]{}参数名集合
BaseUrlString""设置该请求的baseUrl
UrlString""请求网络接口地址
Timeoutlong10000设置超时时间
AccessTokenbooleantrue设置是否需要验证token
CacheModeCacheModeCacheMode.NO_CACHE设置请求的缓存模式

2.使用XHttpProxy进行请求。

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

构造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实现一个自己的网络请求日志拦截器，重写logForRequest和logForResponse两个方法即可。

(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，实现isResponseExpired和responseExpired方法，如下：

/**
 * 判断是否是失效的响应
 *
 * @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(ThreadType.IN_THREAD, TestApi.IAuthorization.class)
                        .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实体，重写其getCode、getMsg、isSuccess和getData方法。

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);
                }
            }){});
复制代码

如果你觉得写一长串比较麻烦，你可以自定义请求继承你需要的请求方式，例如这里是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进行请求，你可以使用apiCall和call进行请求。

  • apiCall: 针对的是retrofit定义的接口，返回的是Observable<ApiResult>的情况。对于上面定义的第一个接口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

联系方式

weixin_34186128
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
xhttp解析
hanhan861111的博客
12-12 910
RequestParams re=new RequestParams("http://www.baidu.com");//去加载x.http().get(re, new Callback.CommonCallback() { @Override public void onSuccess(String s) { //先赋值--- CartFragment.t
Android代码-XHttp2 一个功能强悍的网络请求库
08-06
XHttp2 一个功能强悍的网络请求库，使用RxJava2 Retrofit2 OKHttp组合进行封装。 关于我 特征 支持默认、全局、局部三个层次的配置功能。 支持动态配置和自定义底层框架Okhttpclient、Retrofit. 加入基础ApiService，减少Api冗余。 支持多种方式访问网络GET、POST、PUT、DELETE等请求协议。 支持网络缓存,六种缓存策略可选,涵盖大多数业务场景。 支持固定添加header和动态添加header。 支持添加全局参数和动态添加局部参数。 支持文件下载、多文件上传和表单提交数据。 支持文件请求、上传、下载的进度回调、错误回调，也可以自定义回调。 支持任意数据结构的自动解析。 支持添加动态参数例如timeStamp时间戳、token、签名sign。 支持自定义的扩展API。 支持多个请求合并。 支持Cookie管理。 支持异步、同步请求。 支持Https、自签名网站Https的访问、双向验证。 支持失败重试机制，可以指定重试次数、重试间隔时间。 支持根据key删除网络缓存和清空网络缓存。 提供默认的标准Api
强悍的网络请求库：XHttp2，让开发者如虎添翼！
最新发布
gitblog_00081的博客
05-23 252
强悍的网络请求库：XHttp2，让开发者如虎添翼！ 项目地址:https://gitcode.com/xuexiangjys/XHttp2 当你在寻找一款强大而易用的网络请求库时，XHttp2无疑是你的首选。这款由Java语言编写的开源库，基于RxJava2、Retrofit2和OKHttp三大组件精心打造，提供了丰富且强大的功能，无论是新手还是老手，都能快速上手并发挥其最大的效能。 项目介绍 X...
网测科技_HTTP2协议测试案例
Netitest的博客
11-15 239
HTTP2协议测试案例
XHttpPost 请求与连接超时回调
chongouxi4388的博客
01-09 617
package callbak; /** * * @author xulin * @see http://my.oschina.net/u/2358780 */ public interface XCallBack { /** * 执行回调...
Retrofit2（二） 之 添加日志拦截器
C++ JAVA的专栏
08-19 2569
背景 用过retrofit的同学，肯定会很爽，因为用起来实在是方便。但是我之前在使用retrofit的时候，发现没法打印出网络请求日志，包括请求urll、返回内容等。要实现打印日志，就要用到HttpLoggingInterceptor这个类。下面给大家讲一下如何打印出这些内容。 步骤： 依赖库 ：compile 'com.squareup.retrofit2:retrofit:2.1.0' compile 'com.squareup.retrofit2:converter-gson:2.1....
XHttp2：:flexed_biceps:一个强大的网络请求库，使用RxJava2 + Retrofit2 + OKHttp组合进行封装。（一个功能强悍的网络请求库，使用RxJava2 + Retrofit2 + OKHttp组合进行封装）
02-04
一个功能强悍的网络请求库，使用RxJava2 + Retrofit2 + OKHttp组合进行封装。还不赶紧点击，体验一下吧！ 在提问题前，请先阅读 ，并严格按照进行填写，节约大家的时间。 在使用前，请一定要仔细阅读阅读，重要的...
XHttp2 一个功能强悍的网络请求库，使用RxJava2 + Retrofit2 + OKHttp组合进行封装.zip
10-11
XHttp2 一个功能强悍的网络请求库，使用RxJava2 + Retrofit2 + OKHttp组合进行封装。.zip,一个功能强悍的网络请求库，使用RxJava2 + Retrofit2 + OKHttp组合进行封装。
XHttp2 一个功能强悍的网络请求库，使用RxJava2 Retrofit2 OKHttp组合进行封装.zip
09-24
XHttp2 一个功能强悍的网络请求库，使用RxJava2 Retrofit2 OKHttp组合进行封装。.zip,一个功能强悍的网络请求库，使用RxJava2 Retrofit2 OKHttp组合进行封装。
XHttp2
05-21
XHttp2是一个专为Android平台设计的高效网络请求库，它整合了RxJava2、Retrofit2和OKHttp三大流行框架的优势，旨在提供简洁、强大的网络通信能力。在这个项目中，XHttp2-master包含了源码和其他相关资源，帮助开发者...
推荐强大的Java异步编程库：RxUtil2
gitblog_00037的博客
04-03 300
推荐强大的Java异步编程库：RxUtil2 项目地址:https://gitcode.com/xuexiangjys/RxUtil2 在现代软件开发中，高效、简洁的异步编程是提升性能和用户体验的关键。RxUtil2 是一个基于ReactiveX理念的Java工具库，它旨在简化复杂的并发操作，帮助开发者更优雅地处理事件流。 项目简介 RxUtil2 是由开发者xuexiangjys创建的一个轻量级...
Android代码-RxBus2
08-05
RxBus2 Rxbus2 by rxjava2.0 used Gradle compile 'lib.gorden.rxbus2:rxbus:2.0.1' Maven lib.gorden.rxbus2 rxbus 2.0.1 pom 使用介绍 public class MainActivity extends AppCompatActivity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); RxBus.get().register(this); } public void test1005(View view){ RxBus.get().send(1005); } public void test1005Stri
http https java_xhttp 一个java http https操作工具 jar
weixin_31354669的博客
02-23 254
原文链接http://blog.csdn.net/a120011676/article/details/50601069xhttpreleases mavenjava 7:com.github.120011676xhttp-jdk_71.3.012345java 5:com.github.120011676xhttp-jdk_51.3.012345java 1.4:com.github.12001...
HTTP协议简介
子曰小玖的博客
02-25 750
https://www.cnblogs.com/ranyonsue/p/5984001.html HTTP简介 HTTP协议是Hyper Text Transfer Protocol（超文本传输协议）的缩写,是用于从万维网（WWW:World Wide Web ）服务器传输超文本到本地浏览器的传送协议。 HTTP是一个基于TCP/IP通信协议来传递数据（HTML 文件, 图片文件, 查询结果...
android自定义网络请求框架,GitHub - lairdli/XHttp: 自定义网络请求框架通过解析XML 请求接口，解析对象，参数，基于Android HttpURLConnections请...
weixin_39884832的博客
05-25 176
tips:如果您在电脑上直接打开，推荐使用Typora客户端打开该文档如果您在AndroidStudio打开，推荐下载markdown插件，Preferences-Plugins-Markdown-Navgitor自定义网络框架XHttp使用说明1 简介该自定义网络框架通过解析XML 请求接口，解析对象，参数，基于Android HttpURLConnections请求网络资源。支持get/pos...
借助xinetd实现xhttpd服务器
JaweG
11-16 671
客户端请求服务器数据 客户端请求服务器数据内容 GET /请求的文件或目录 HTTP/1.1 协议头部分(可选) \r\n(协议头结束标志) 服务器应答浏览器 case1：浏览器请求文件不存在 HTTP/1.1 200 OK content_Type：回写客户端的数据的类型 content-Length：要么干脆不填，要么一定要正确(可选)-fc...
HTTP2简介
u010552788的专栏
06-06 4121
1. HTTP1.X的现状 1.1 过于庞大 1.2 未能充分利用的TCP 1.3 HTTP Pipelining 2. 克服延迟做过的努力 2.1 Spriting 2.2 内联 2.3 拼接（Concatenation） 2.4 分片（Sharding） 3. http2 3.1 起源 3.2 http2特性 3.3 二进制分帧 3.3 多路复用 3.4 优先级和依赖性 3.5 头...
Android Retrofit2+rxjava2+Mvp基于okhttp3网络请求框架的使用 四 文件下载(图片下载为例)
森森先生的博客
07-23 1958
文件下载
使用Retrofit+RxJava下载文件并实现APP更新
热门推荐
Dream_致远的博客
08-07 1万+
前言 所需环境 后台接口 Gradle配置 权限设置 Retrofit和RxJava类与方法 service 接口定义 DownloadUtils 拦截器 下载监听回调 下载请求体 MVP下的使用逻辑 Contract Activty presenter 注意 参考资料 前言 早在去年8月的时候学习OkHttp的使用写了这篇《通过okhttp3下载文件实现APP...
xhttp xhttp2
06-12
`XMLHttpRequest`（简称XHR）是一种用于在Web浏览器和服务器之间进行HTTP请求和响应的API。XHR是一种基于事件驱动的API，可以使用JavaScript代码在后台向服务器发送HTTP请求，然后使用响应数据更新Web页面的内容。 `XMLHttpRequest`存在一些限制，例如它只能同时处理一个请求，并且不能处理跨域请求。为了克服这些限制，W3C在2015年推出了 `XMLHttpRequest Level 2`（简称XHR2）规范，该规范引入了一些新的功能，例如支持多个并发请求、支持跨域请求、支持二进制数据传输等。 除了XHR和XHR2，还有一种新的HTTP客户端API——`fetch API`，它可以更简单地发送HTTP请求和处理响应数据。`fetch API`是基于Promise的，可使用async/await语法进行异步处理和链式调用。 总的来说，XHR和fetch API是用于发送HTTP请求的常用API，而XHR2是XHR的升级版本，提供了更多的功能和改进。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值