基于RxJava2+Retrofit2简单易用的网络请求实现

时间:2022-07-19 10:46:03

代码地址如下:
http://www.demodashi.com/demo/13473.html

简介

基于RxJava2+Retrofit2实现简单易用的网络请求,结合android平台特性的网络封装库,采用api链式调用一点到底,集成cookie管理,多种缓存模式,极简https配置,上传下载进度显示,请求错误自动重试,请求携带token、时间戳、签名sign动态配置,自动登录成功后请求重发功能,3种层次的参数设置默认全局局部,默认标准ApiResult同时可以支持自定义的数据结构,已经能满足现在的大部分网络请求。

特点

  • 比Retrofit使用更简单、更易用。
  • 采用链式调用一点到底
  • 加入基础ApiService,减少Api冗余
  • 支持动态配置和自定义底层框架Okhttpclient、Retrofit.
  • 支持多种方式访问网络GET、POST、PUT、DELETE等请求协议
  • 支持网络缓存,八种缓存策略可选,涵盖大多数业务场景
  • 支持固定添加header和动态添加header
  • 支持添加全局参数和动态添加局部参数
  • 支持文件下载、多文件上传和表单提交数据
  • 支持文件请求、上传、下载的进度回调、错误回调,也可以自定义回调
  • 支持默认、全局、局部三个层次的配置功能
  • 支持任意数据结构的自动解析
  • 支持添加动态参数例如timeStamp时间戳、token、签名sign
  • 支持自定义的扩展API
  • 支持多个请求合并
  • 支持Cookie管理
  • 支持异步、同步请求
  • 支持Https、自签名网站Https的访问、双向验证
  • 支持失败重试机制,可以指定重试次数、重试间隔时间
  • 支持根据ky删除网络缓存和清空网络缓存
  • 提供默认的标准ApiResult解析和回调,并且可自定义ApiResult
  • 支持取消数据请求,取消订阅,带有对话框的请求不需要手动取消请求,对话框消失会自动取消请求
  • 支持请求数据结果采用回调和订阅两种方式
  • api设计上结合http协议和android平台特点来实现,loading对话框,实时进度条显示
  • 返回结果和异常统一处理
  • 结合RxJava2,线程智能控制

演示

基于RxJava2+Retrofit2简单易用的网络请求实现基于RxJava2+Retrofit2简单易用的网络请求实现

基于RxJava2+Retrofit2简单易用的网络请求实现基于RxJava2+Retrofit2简单易用的网络请求实现

全局配置

一般在 Aplication,或者基类中,只需要调用一次即可,可以配置调试开关,全局的超时时间,公共的请求头和请求参数等信息

初始化需要一个Context,最好在Application#onCreate()中初始化,记得在manifest.xml中注册Application。

Application:

public class MyApplication extends Application {
@Override
public void onCreate() {
super.onCreate();
}
}

manifest.xml:

...

<application
android:name=".MyApplication"
...
/>

默认初始化

如果使用默认始化后,一切采用默认设置。如果你需要配置全局超时时间、缓存、Cookie、底层为OkHttp的话,请看高级初始化

public class MyApplication extends Application {

    @Override
public void onCreate() {
super.onCreate();
EasyHttp.init(this);//默认初始化
}
}

高级初始化

可以进行超时配置、网络缓存配置、okhttp相关参数配置、retrofit相关参数配置、cookie配置等,这些参数可以选择性的根据业务需要配置。

public class MyApplication extends Application {

    @Override
public void onCreate() {
super.onCreate();
EasyHttp.init(this);//默认初始化,必须调用 //全局设置请求头
HttpHeaders headers = new HttpHeaders();
headers.put("User-Agent", SystemInfoUtils.getUserAgent(this, AppConstant.APPID));
//全局设置请求参数
HttpParams params = new HttpParams();
params.put("appId", AppConstant.APPID); //以下设置的所有参数是全局参数,同样的参数可以在请求的时候再设置一遍,那么对于该请求来讲,请求中的参数会覆盖全局参数
EasyHttp.getInstance() //可以全局统一设置全局URL
.setBaseUrl(Url)//设置全局URL url只能是域名 或者域名+端口号 // 打开该调试开关并设置TAG,不需要就不要加入该行
// 最后的true表示是否打印内部异常,一般打开方便调试错误
.debug("EasyHttp", true) //如果使用默认的60秒,以下三行也不需要设置
.setReadTimeOut(60 * 1000)
.setWriteTimeOut(60 * 100)
.setConnectTimeout(60 * 100) //可以全局统一设置超时重连次数,默认为3次,那么最差的情况会请求4次(一次原始请求,三次重连请求),
//不需要可以设置为0
.setRetryCount(3)//网络不好自动重试3次
//可以全局统一设置超时重试间隔时间,默认为500ms,不需要可以设置为0
.setRetryDelay(500)//每次延时500ms重试
//可以全局统一设置超时重试间隔叠加时间,默认为0ms不叠加
.setRetryIncreaseDelay(500)//每次延时叠加500ms //可以全局统一设置缓存模式,默认是不使用缓存,可以不传,具体请看CacheMode
.setCacheMode(CacheMode.NO_CACHE)
//可以全局统一设置缓存时间,默认永不过期
.setCacheTime(-1)//-1表示永久缓存,单位:秒 ,Okhttp和自定义RxCache缓存都起作用
//全局设置自定义缓存保存转换器,主要针对自定义RxCache缓存
.setCacheDiskConverter(new SerializableDiskConverter())//默认缓存使用序列化转化
//全局设置自定义缓存大小,默认50M
.setCacheMaxSize(100 * 1024 * 1024)//设置缓存大小为100M
//设置缓存版本,如果缓存有变化,修改版本后,缓存就不会被加载。特别是用于版本重大升级时缓存不能使用的情况
.setCacheVersion(1)//缓存版本为1
//.setHttpCache(new Cache())//设置Okhttp缓存,在缓存模式为DEFAULT才起作用 //可以设置https的证书,以下几种方案根据需要自己设置
.setCertificates() //方法一:信任所有证书,不安全有风险
//.setCertificates(new SafeTrustManager()) //方法二:自定义信任规则,校验服务端证书
//配置https的域名匹配规则,不需要就不要加入,使用不当会导致https握手失败
//.setHostnameVerifier(new SafeHostnameVerifier())
//.addConverterFactory(GsonConverterFactory.create(gson))//本框架没有采用Retrofit的Gson转化,所以不用配置
.addCommonHeaders(headers)//设置全局公共头
.addCommonParams(params)//设置全局公共参数
//.addNetworkInterceptor(new NoCacheInterceptor())//设置网络拦截器
//.setCallFactory()//局设置Retrofit对象Factory
//.setCookieStore()//设置cookie
//.setOkproxy()//设置全局代理
//.setOkconnectionPool()//设置请求连接池
//.setCallbackExecutor()//全局设置Retrofit callbackExecutor
//可以添加全局拦截器,不需要就不要加入,错误写法直接导致任何回调不执行
//.addInterceptor(new GzipRequestInterceptor())//开启post数据进行gzip后发送给服务器
.addInterceptor(new CustomSignInterceptor());//添加参数签名拦截器
}
}

请求数据

网络请求,采用链式调用,支持一点到底。

入口方法

  /**
* get请求
*/
public static GetRequest get(String url); /**
* post请求和文件上传
*/
public static PostRequest post(String url); /**
* delete请求
*/
public static DeleteRequest delete(String url) ; /**
* 自定义请求
*/
public static CustomRequest custom(); /**
* 文件下载
*/
public static DownloadRequest downLoad(String url) ; /**
* put请求
*/
public static PutRequest put(String url);

通用功能配置

1.包含一次普通请求所有能配置的参数,真实使用时不需要配置这么多,按自己的需要选择性的使用即可

2.以下配置全部是单次请求配置,不会影响全局配置,没有配置的仍然是使用全局参数。

3.为单个请求设置超时,比如涉及到文件的需要设置读写等待时间多一点。

完整参数GET示例:

EasyHttp.get("/v1/app/chairdressing/skinAnalyzePower/skinTestResult")
.baseUrl("http://www.xxxx.com")//设置url
.writeTimeOut(30*1000)//局部写超时30s,单位毫秒
.readTimeOut(30*1000)//局部读超时30s,单位毫秒
.connectTimeout(30*1000)//局部连接超时30s,单位毫秒
.headers(new HttpHeaders("header1","header1Value"))//添加请求头参数
.headers("header2","header2Value")//支持添加多个请求头同时添加
.headers("header3","header3Value")//支持添加多个请求头同时添加
.params("param1","param1Value")//支持添加多个参数同时添加
.params("param2","param2Value")//支持添加多个参数同时添加
//.addCookie(new CookieManger(this).addCookies())//支持添加Cookie
.cacheTime(300)//缓存300s 单位s
.cacheKey("cachekey")//缓存key
.cacheMode(CacheMode.CACHEANDREMOTE)//设置请求缓存模式
//.okCache()//使用模式缓存模式时,走Okhttp缓存
.cacheDiskConverter(new GsonDiskConverter())//GSON-数据转换器
//.certificates()添加证书
.retryCount(5)//本次请求重试次数
.retryDelay(500)//本次请求重试延迟时间500ms
.addInterceptor(Interceptor)//添加拦截器
.okproxy()//设置代理
.removeHeader("header2")//移除头部header2
.removeAllHeaders()//移除全部请求头
.removeParam("param1")
.accessToken(true)//本次请求是否追加token
.timeStamp(false)//本次请求是否携带时间戳
.sign(false)//本次请求是否需要签名
.syncRequest(true)//是否是同步请求,默认异步请求。true:同步请求
.execute(new CallBack<SkinTestResult>() {
@Override
public void onStart() {
//开始请求
} @Override
public void onCompleted() {
//请求完成
} @Override
public void onError(ApiException e) {
//请求错误
} @Override
public void onSuccess(SkinTestResult response) {
//请求成功
}
});

url

Url可以通过初始化配置的时候传入EasyHttp.getInstance().setBaseUrl("http://www.xxx.com");

入口方法传入: EasyHttp.get("/v1/app/chairdressing/skinAnalyzePower/skinTestResult").baseUrl("http://www.xxxx.com")

如果入口方法中传入的url含有http或者https,则不会拼接初始化设置的baseUrl.

例如:EasyHttp.get("http://www.xxx.com/v1/app/chairdressing/skinAnalyzePower/skinTestResult")则setBaseUrl()和baseUrl()传入的baseurl都不会被拼接。

注:EasyHttp.get/post/put/等采用拼接的用法时请注意,url要用/斜杠开头,例如:EasyHttp.get("/v1/login") 正确 EasyHttp.get("v1/login") 错误

http请求参数

两种设置方式

.params(HttpParams params)

.params("param1","param1Value")//添加参数键值对

HttpParams params = new HttpParams();

params.put("appId", AppConstant.APPID);

.addCommonParams(params)//设置全局公共参数

http请求头

.headers(HttpHeaders headers)

.headers("header2","header2Value")//添加参数键值对

.addCommonHeaders(headers)//设置全局公共头

普通网络请求

支持get/post/delete/put等

链式调用的终点请求的执行方式有:execute(Class clazz) 、execute(Type type)、execute(CallBack callBack)三种方式,都是针对标准的ApiResult

execute(CallBack callBack)

1.EasyHttp(推荐

示例:

方式一:
//EasyHttp.post("/v1/app/chairdressing/skinAnalyzePower/skinTestResult")
EasyHttp.get("/v1/app/chairdressing/skinAnalyzePower/skinTestResult")
.readTimeOut(30 * 1000)//局部定义读超时
.writeTimeOut(30 * 1000)
.connectTimeout(30 * 1000)
.params("name","张三")
.timeStamp(true)
.execute(new SimpleCallBack<SkinTestResult>() {
@Override
public void onError(ApiException e) {
showToast(e.getMessage());
} @Override
public void onSuccess(SkinTestResult response) {
if (response != null) showToast(response.toString());
}
});

2.手动创建请求对象

 //GetRequest 、PostRequest、DeleteRequest、PutRequest
GetRequest request = new GetRequest("/v1/app/chairdressing/skinAnalyzePower/skinTestResult");
request.readTimeOut(30 * 1000)//局部定义读超时
.params("param1", "param1Value1")
.execute(new SimpleCallBack<SkinTestResult>() {
@Override
public void onError(ApiException e) { } @Override
public void onSuccess(SkinTestResult response) { }
});

execute(Class clazz)和execute(Type type)

execute(Class clazz)和execute(Type type)功能基本一样,execute(Type type)主要是针对集合不能直接传递Class

EasyHttp.get(url)
.params("param1", "paramValue1")
.execute(SkinTestResult.class)//非常简单直接传目标class
//.execute(new TypeToken<List<SectionItem>>() {}.getType())//Type类型
.subscribe(new BaseSubscriber<SkinTestResult>() {
@Override
public void onError(ApiException e) {
showToast(e.getMessage());
} @Override
public void onNext(SkinTestResult skinTestResult) {
showToast(skinTestResult.toString());
}
});

请求返回Disposable

网络请求会返回Disposable对象,方便取消网络请求

Disposable disposable = EasyHttp.get("/v1/app/chairdressing/skinAnalyzePower/skinTestResult")
.params("param1", "paramValue1")
.execute(new SimpleCallBack<SkinTestResult>() {
@Override
public void onError(ApiException e) {
showToast(e.getMessage());
} @Override
public void onSuccess(SkinTestResult response) {
showToast(response.toString());
}
}); //在需要取消网络请求的地方调用,一般在onDestroy()中
//EasyHttp.cancelSubscription(disposable);

带有进度框的请求

带有进度框的请求,可以设置对话框消失是否自动取消网络和自定义对话框功能,具体参数作用请看请求回调讲解

方式一:ProgressDialogCallBack

ProgressDialogCallBack带有进度框的请求,可以设置对话框消失是否自动取消网络和自定义对话框功能,具体参数作用请看自定义CallBack讲解

 IProgressDialog mProgressDialog = new IProgressDialog() {
@Override
public Dialog getDialog() {
ProgressDialog dialog = new ProgressDialog(MainActivity.this);
dialog.setMessage("请稍候...");
return dialog;
}
};
EasyHttp.get("/v1/app/chairdressing/")
.params("param1", "paramValue1")
.execute(new ProgressDialogCallBack<SkinTestResult>(mProgressDialog, true, true) {
@Override
public void onError(ApiException e) {
super.onError(e);//super.onError(e)必须写不能删掉或者忘记了
//请求失败
} @Override
public void onSuccess(SkinTestResult response) {
//请求成功
}
});

注:错误回调 super.onError(e);必须写

方式二:ProgressSubscriber

IProgressDialog mProgressDialog = new IProgressDialog() {
@Override
public Dialog getDialog() {
ProgressDialog dialog = new ProgressDialog(MainActivity.this);
dialog.setMessage("请稍候...");
return dialog;
}
};
EasyHttp.get(URL)
.timeStamp(true)
.execute(SkinTestResult.class)
.subscribe(new ProgressSubscriber<SkinTestResult>(this, mProgressDialog) {
@Override
public void onError(ApiException e) {
super.onError(e);
showToast(e.getMessage());
} @Override
public void onNext(SkinTestResult skinTestResult) {
showToast(skinTestResult.toString());
}
});

请求返回Observable

通过网络请求可以返回Observable,这样就可以很好的通过Rxjava与其它场景业务结合处理,甚至可以通过Rxjava的connect()操作符处理多个网络请求。例如:在一个页面有多个网络请求,如何在多个请求都访问成功后再显示页面呢?这也是Rxjava强大之处。

注:目前通过execute(Class clazz)方式只支持标注的ApiResult结构,不支持自定义的ApiResult

示例:

Observable<SkinTestResult> observable = EasyHttp.get(url)
.params("param1", "paramValue1")
.execute(SkinTestResult.class); observable.subscribe(new BaseSubscriber<SkinTestResult>() {
@Override
public void onError(ApiException e) {
showToast(e.getMessage());
} @Override
public void onNext(SkinTestResult skinTestResult) {
showToast(skinTestResult.toString());
}
});

文件下载

本库提供的文件下载非常简单,没有提供复杂的下载方式例如:下载管理器、断点续传、多线程下载等,因为不想把本库做重。如果复杂的下载方式,还请考虑其它下载方案。

文件目录如果不指定,默认下载的目录为/storage/emulated/0/Android/data/包名/files

文件名如果不指定,则按照以下规则命名:

1.首先检查用户是否传入了文件名,如果传入,将以用户传入的文件名命名

2.如果没有传入文件名,默认名字是时间戳生成的。

3.如果传入了文件名但是没有后缀,程序会自动解析类型追加后缀名

示例:

 String url = "http://61.144.207.146:8081/b8154d3d-4166-4561-ad8d-7188a96eb195/2005/07/6c/076ce42f-3a78-4b5b-9aae-3c2959b7b1ba/kfid/2475751/qqlite_3.5.0.660_android_r108360_GuanWang_537047121_release_10000484.apk";
EasyHttp.downLoad(url)
.savePath("/sdcard/test/QQ")
.saveName("release_10000484.apk")//不设置默认名字是时间戳生成的
.execute(new DownloadProgressCallBack<String>() {
@Override
public void update(long bytesRead, long contentLength, boolean done) {
int progress = (int) (bytesRead * 100 / contentLength);
HttpLog.e(progress + "% ");
dialog.setProgress(progress);
if (done) {//下载完成
}
...
} @Override
public void onStart() {
//开始下载
} @Override
public void onComplete(String path) {
//下载完成,path:下载文件保存的完整路径
} @Override
public void onError(ApiException e) {
//下载失败
}
});

POST请求,上传String、json、object、body、byte[]

一般此种用法用于与服务器约定的数据格式,当使用该方法时,params中的参数设置是无效的,所有参数均需要通过需要上传的文本中指定,此外,额外指定的header参数仍然保持有效。

  • .upString("这是要上传的长文本数据!")//默认类型是:MediaType.parse("text/plain")
  • 如果你对请求头有自己的要求,可以使用这个重载的形式,传入自定义的content-type文本

    upString("这是要上传的长文本数据!", "application/xml") // 比如上传xml数据,这里就可以自己指定请求头
  • upJson该方法与upString没有本质区别,只是数据格式是json,通常需要自己创建一个实体bean或者一个map,把需要的参数设置进去,然后通过三方的Gson或者 fastjson转换成json字符串,最后直接使用该方法提交到服务器。

    .upJson(jsonObject.toString())//上传json
  • .upBytes(new byte[]{})//上传byte[]
  • .requestBody(body)//上传自定义RequestBody
  • .upObject(object)//上传对象object 必须要增加.addConverterFactory(GsonConverterFactory.create())设置

1.upString、upJson、requestBody、upBytes、upObject五个方法不能同时使用,当前只能选用一个

2.使用upJson、upObject时候params、sign(true/false)、accessToken(true/false)、拦截器都不会起作用

示例:

HashMap<String, String> params = new HashMap<>();
params.put("key1", "value1");
params.put("key2", "这里是需要提交的json格式数据");
params.put("key3", "也可以使用三方工具将对象转成json字符串");
JSONObject jsonObject = new JSONObject(params); RequestBody body=RequestBody.create(MediaType.parse("xxx/xx"),"内容");
EasyHttp.post("v1/app/chairdressing/news/favorite")
//.params("param1", "paramValue1")//不能使用params,upString 与 params 是互斥的,只有 upString 的数据会被上传
.upString("这里是要上传的文本!")//默认类型是:MediaType.parse("text/plain")
//.upString("这是要上传的长文本数据!", "application/xml") // 比如上传xml数据,这里就可以自己指定请求头 //.upJson(jsonObject.toString())
//.requestBody(body)
//.upBytes(new byte[]{})
//.upObject(object)
.execute(new SimpleCallBack<String>() {
@Override
public void onError(ApiException e) {
showToast(e.getMessage());
} @Override
public void onSuccess(String response) {
showToast(response);
}
});

上传图片或者文件

支持单文件上传、多文件上传、混合上传,同时支持进度回调,

暂不实现多线程上传/分片上传/断点续传等高级功能

上传文件支持文件与参数一起同时上传,也支持一个key上传多个文件,以下方式可以任选

上传文件支持两种进度回调:ProgressResponseCallBack(线程中回调)和UIProgressResponseCallBack(可以刷新UI)

final UIProgressResponseCallBack listener = new UIProgressResponseCallBack() {
@Override
public void onUIResponseProgress(long bytesRead, long contentLength, boolean done) {
int progress = (int) (bytesRead * 100 / contentLength);
if (done) {//完成
}
...
}
};
EasyHttp.post("/v1/user/uploadAvatar")
//支持上传新增的参数
//.params(String key, File file, ProgressResponseCallBack responseCallBack)
//.params(String key, InputStream stream, String fileName, ProgressResponseCallBack responseCallBack)
//.params(String key, byte[] bytes, String fileName, ProgressResponseCallBack responseCallBack)
//.addFileParams(String key, List<File> files, ProgressResponseCallBack responseCallBack)
//.addFileWrapperParams(String key, List<HttpParams.FileWrapper> fileWrappers)
//.params(String key, File file, String fileName, ProgressResponseCallBack responseCallBack)
//.params(String key, T file, String fileName, MediaType contentType, ProgressResponseCallBack responseCallBack) //方式一:文件上传
File file = new File("/sdcard/1.jpg");
//如果有文件名字可以不用再传Type,会自动解析到是image/*
.params("avatar", file, file.getName(), listener)
//.params("avatar", file, file.getName(),MediaType.parse("image/*"), listener) //方式二:InputStream上传
final InputStream inputStream = getResources().getAssets().open("1.jpg");
.params("avatar", inputStream, "test.png", listener) //方式三:byte[]上传
Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.mipmap.test);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
bitmap.compress(Bitmap.CompressFormat.PNG, 100, baos);
final byte[] bytes = baos.toByteArray();
//.params("avatar",bytes,"streamfile.png",MediaType.parse("image/*"),listener)
//如果有文件名字可以不用再传Type,会自动解析到是image/*
.params("avatar", bytes, "streamfile.png", listener) .params("file1", new File("filepath1")) // 可以添加文件上传
.params("file2", new File("filepath2")) // 支持多文件同时添加上传
.addFileParams("key", List<File> files) // 这里支持一个key传多个文件
.params("param1", "paramValue1") // 这里可以上传参数
.accessToken(true)
.timeStamp(true)
.execute(new ProgressDialogCallBack<String>(mProgressDialog, true, true) {
@Override
public void onError(ApiException e) {
super.onError(e);
showToast(e.getMessage());
} @Override
public void onSuccess(String response) {
showToast(response);
}
});

取消请求

通过Disposable取消

每个请求前都会返回一个Disposable,取消订阅就可以取消网络请求,如果是带有进度框的网络请求,则不需要手动取消网络请求,会自动取消。

 Disposable mSubscription = EasyHttp.get(url).execute(callback);
...
@Override
protected void onDestroy() {
super.onDestroy();
EasyHttp.cancelSubscription(mSubscription);
}

通过dialog取消

自动取消使用ProgressDialogCallBack回调或者使用ProgressSubscriber,就不用再手动调用cancelSubscription();

ProgressDialogCallBack:

EasyHttp.get(url).execute(new ProgressDialogCallBack());

ProgressSubscriber

EasyHttp.get(url).execute(SkinTestResult.class).subscribe(new ProgressSubscriber<SkinTestResult>(this, mProgressDialog) {
@Override
public void onError(ApiException e) {
super.onError(e);
showToast(e.getMessage());
} @Override
public void onNext(SkinTestResult skinTestResult) {
showToast(skinTestResult.toString());
}
})

同步请求

同步请求只需要设置syncRequest()方法

 EasyHttp.get("/v1/app/chairdressing/skinAnalyzePower/skinTestResult")
...
.syncRequest(true)//设置同步请求
.execute(new CallBack<SkinTestResult>() {});

请求回调CallBack支持的类型

//支持回调的类型可以是Bean、String、CacheResult<Bean>、CacheResult<String>、List<Bean>
new SimpleCallBack<CacheResult<Bean>>()//支持缓存的回调,请看缓存讲解
new SimpleCallBack<CacheResult<String>>()//支持缓存的回调,请看缓存讲解
new SimpleCallBack<Bean>()//返回Bean
new SimpleCallBack<String>()//返回字符串
new SimpleCallBack<List<Bean>()//返回集合

注:其它回调同理

cookie使用

cookie的内容主要包括:名字,值,过期时间,路径和域。路径与域一起构成cookie的作用范围,关于cookie的作用这里就不再科普,自己可以去了解

cookie设置:

EasyHttp.getInstance()
...
//如果不想让本库管理cookie,以下不需要
.setCookieStore(new CookieManger(this)) //cookie持久化存储,如果cookie不过期,则一直有效
...
  • 查看url所对应的cookie
HttpUrl httpUrl = HttpUrl.parse("http://www.xxx.com/test");
CookieManger cookieManger = getCookieJar();
List<Cookie> cookies = cookieManger.loadForRequest(httpUrl);
  • 查看CookieManger所有cookie
PersistentCookieStore cookieStore= getCookieJar().getCookieStore();
List<Cookie> cookies1= cookieStore.getCookies();
  • 添加cookie
Cookie.Builder builder = new Cookie.Builder();
Cookie cookie = builder.name("mCookieKey1").value("mCookieValue1").domain(httpUrl.host()).build();
CookieManger cookieManger = getCookieJar();
cookieManger.saveFromResponse(httpUrl, cookie);
//cookieStore.saveFromResponse(httpUrl, cookieList);//添加cookie集合
  • 移除cookie
HttpUrl httpUrl = HttpUrl.parse("http://www.xxx.com/test");
CookieManger cookieManger = EasyHttp.getCookieJar();
Cookie cookie = builder.name("mCookieKey1").value("mCookieValue1").domain(httpUrl.host()).build();
cookieManger.remove(httpUrl,cookie);
  • 清空cookie
CookieManger cookieManger = EasyHttp.getCookieJar();
cookieManger.removeAll();

自定义call()请求

提供了用户自定义ApiService的接口,您只需调用call方法即可.

示例:

public interface LoginService {
@POST("{path}")
@FormUrlEncoded
Observable<ApiResult<AuthModel>> login(@Path("path") String path, @FieldMap Map<String, String> map);
} final CustomRequest request = EasyHttp.custom()
.addConverterFactory(GsonConverterFactory.create(new Gson()))//自定义的可以设置GsonConverterFactory
.params("param1", "paramValue1")
.build(); LoginService mLoginService = request.create(LoginService.class);
LoginService mLoginService = request.create(LoginService.class);
Observable<ApiResult<AuthModel>> observable = request.call(mLoginService.login("v1/account/login", request.getParams().urlParamsMap));
Disposable subscription = observable.subscribe(new Action1<ApiResult<AuthModel>>() {
@Override
public void call(ApiResult<AuthModel> result) {
//请求成功
}
}, new Action1<Throwable>() {
@Override
public void call(Throwable throwable) {
//请求失败
}
});

自定义apiCall()请求

提供默认的支持ApiResult结构,数据返回不需要带ApiResult,直接返回目标.

示例:

Observable<AuthModel> observable = request.apiCall(mLoginService.login("v1/account/login", request.getParams().urlParamsMap));

请求回调和订阅

请求回调本库提供两种方式Callback和Subscriber

回调方式

此种方式主要针对execute(CallBack callBack),目前内部提供的回调包含CallBack, SimpleCallBack ,ProgressDialogCallBack ,DownloadProgressCallBack 可以根据自己的需求去自定义Callback

  • CallBack所有回调的基类,抽象类
  • SimpleCallBack简单回调,只有成功和失败
  • ProgressDialogCallBack带有进度框的回调,可以自定义进度框、支持是否可以取消对话框、对话框消失自动取消网络请求等参数设置
  • DownloadProgressCallBack如果要做文件下载,则必须使用该回调,内部封装了关于文件下载进度回调的方法,如果使用其他回调也可以,但是没有进度通知

该网络框架的核心使用方法即为Callback的继承使用,因为不同的项目需求,会有个性化的回调请自定义

CallBack回调

new CallBack<T>() {
@Override
public void onStart() {
//请求开始
} @Override
public void onCompleted() {
//请求完成
} @Override
public void onError(ApiException e) {
//请求失败
} @Override
public void onSuccess(T t) {
//请求成功
}
}

SimpleCallBack回调

new SimpleCallBack<T>() {
@Override
public void onError(ApiException e) {
//请求失败
} @Override
public void onSuccess(T t) {
//请求成功
}
}

ProgressDialogCallBack回调

可以自定义带有加载进度框的回调,取消对话框会自动取消掉网络请求

提供两个构造

public ProgressDialogCallBack(IProgressDialog progressDialog);//默认不能取消对话框

public ProgressDialogCallBack(IProgressDialog progressDialog, boolean isShowProgress, boolean isCancel);//自定义加载进度框,可以设置是否显示弹出框,是否可以取消 progressDialog: dialog对象接口 isShowProgress:对话框消失是否取消网络请求 isCancel:是否可以取消对话框对应Dialog的setCancelable(isCancel)方法;

自定义ProgressDialog对话框

 private IProgressDialog mProgressDialog = new IProgressDialog() {
@Override
public Dialog getDialog() {
ProgressDialog dialog = new ProgressDialog(MainActivity.this);
dialog.setMessage("请稍候...");
return dialog;
}
};

DownloadProgressCallBack回调

此回调只用于文件下载,具体请看文件下载讲解

自定义CallBack回调

如果对回调有特殊需求,支持可以继承CallBack自己扩展功能

订阅方式

此种方式主要是针对execute(Class clazz)和execute(Type type),目前内部提供的Subscriber包含BaseSubscriber、DownloadSubscriber、ProgressSubscriber,可以根据自己的需求去自定义Subscriber

  • BaseSubscriber所有订阅者的基类,抽象类
  • DownloadSubscriber下载的订阅者,上层不需要关注
  • ProgressSubscriber带有进度框的订阅,可以自定义进度框、支持是否可以取消对话框、对话框消失自动取消网络请求等参数设置
new BaseSubscriber<T>() {
@Override
public void onError(ApiException e) {
//请求失败
} @Override
public void onNext(T t) {
//请求成功
}
}
new ProgressSubscriber<T>(this, mProgressDialog) {
@Override
public void onError(ApiException e) {
super.onError(e);
//请求失败
} @Override
public void onNext(T t) {
//请求成功
}
}

自定义Subscriber

如果对Subscriber有特殊需求,支持可以继承BaseSubscriber自己扩展订阅者

缓存使用

缓存介绍

本库的缓存主要分okhttp的Cache缓存和自定义的RxCache缓存,大家有疑问okhttp有缓存,retrofit也是支持通过header来设置缓存,为什么还要自定义一个缓存机制呢?通过自定义RxCache缓存使用更简单,更符合我们常用的业务需求(常用的缓存策略也不会太复杂), retrofit的缓存借助于okhttp通过拦截器interceptor实现或者通过@Headers("Cache-Control: public, max-age=3600)具体用法这里不做详细描述,有兴趣的可以自己去了解。动态修改缓存时间不方便,例如:同一个接口,不同时间段请求的内容缓存的时间不一样,需要动态修改。

对于DEFAULT模式是okhttp的Cache缓存。因为该模式是完全遵循标准的http协议的,缓存时间是依靠服务端响应头来控制,也可以通过拦截器自己处理

对于RxCache的缓存支持多种存储方式,提供IDiskConverter转换器接口目前支持SerializableDiskConverterGsonDiskConverter两种方式,也可以自定义Parcelable、fastjson、xml、kryo等转换器

SerializableDiskConverter

使用缓存前,必须让缓存的数据所有javaBean对象实现Serializable接口,否则会报NotSerializableException。 因为缓存的原理是将对象序列化后保存,如果不实现Serializable接口,会导致对象无法序列化,进而无法保存,也就达不到缓存的效果。

优点:存储和读取都不用再转化直接就是需要的对象速度快

缺点:如果javabean里面还有javabean且层级比较多,也必须每个都要实现Serializable接口,比较麻烦

GsonDiskConverter

此种方式就是以json字符串的方式存储

优点:相对于SerializableDiskConverter转换器,存储的对象不需要进行序列化

缺点:就是存储和读取都要使用Gson进行转换,object->String->Object的给一个过程,相对来说每次都要转换性能略低,但是性能基本忽略不计

目前提供了八种CacheMode缓存模式,每种缓存模式都可以指定对应的CacheTime,将复杂常用的业务场景封装在里面,让你不用关心缓存的具体实现,而专注于数据的处理

  • NO_CACHE:不使用缓存,该模式下,cacheKey,cacheTime 等参数均无效
  • DEFAULT:按照HTTP协议的默认缓存规则,走OKhttp的Cache缓存
  • FIRSTREMOTE:先请求网络,请求网络失败后再加载缓存
  • FIRSTCACHE:先加载缓存,缓存没有再去请求网络
  • ONLYREMOTE:仅加载网络,但数据依然会被缓存
  • ONLYCACHE:只读取缓存,缓存没有会返回null
  • CACHEANDREMOTE:先使用缓存,不管是否存在,仍然请求网络,CallBack会回调两次.
  • CACHEANDREMOTEDISTINCT:先使用缓存,不管是否存在,仍然请求网络,CallBack回调不一定是两次,如果发现请求的网络数据和缓存数据是一样的,就不会再返回网络的回调,既回调一次。否则不相同仍然会回调两次。(目的是为了防止数据没有发生变化,也需要回调两次导致界面无用的重复刷新),此种模式缓存的对象bean一定要重写tostring()方法

注:无论对于哪种缓存模式,都可以指定一个cacheKey,建议针对不同需要缓存的页面设置不同的cacheKey,如果相同,会导致数据覆盖。

缓存设置

缓存设置有两种方式

方式一:全局设置,所有请求都会默认使用此模式

 EasyHttp.getInstance()
...
.setCacheMode(CacheMode.CACHEANDREMOTE)//不设置默认是NO_CACHE模式
...

方式二:单个请求设置缓存模式

 EasyHttp.get(URL)
...
.cacheMode(CacheMode.FIRSTREMOTE)
...

设置转换器

方式一:全局设置,所有请求都会默认使用此存储转换器

EasyHttp.getInstance().setCacheDiskConverter(new SerializableDiskConverter())//默认缓存使用序列化转化

方式二:单个请求设置存储转换器

EasyHttp.get(URL).cacheDiskConverter(new GsonDiskConverter());

注:一个请求就选用一种转换器,切记不要使用SerializableDiskConverter来缓存,又用GsonDiskConverter来读会报错

自定义转换器

如果你想拥有自己的转换器请实现IDiskConverter接口。

示例:

public class CustomDiskConverter implements IDiskConverter {
@Override
public <T> T load(InputStream source, Type type) {
//实现读功能
return null;
} @Override
public boolean writer(OutputStream sink, Object data) {
//实现写功能
return false;
}
}

缓存回调

对具有缓存的回调CallBack,如果你想知道当前的缓存是来自本地还是网络,只需要回调中加入CacheResult,其它和普通的网络请求方式一模一样。CacheResult中的isFromCache可以知道是否来自缓存,true:来自缓存,false:来自网络。请使用new SimpleCallBack<CacheResult<T>>() 也就是在你原有的T上包含一层CacheResult就可以了。如果不想用到isFromCache就不需要用CacheResult,直接使用new SimpleCallBack<T>()

带有CacheResult回调示例:

 EasyHttp.get(url)
.readTimeOut(30 * 1000)//测试局部读超时30s
.cacheMode(cacheMode)
.cacheKey(this.getClass().getSimpleName())//缓存key
.retryCount(5)//重试次数
.cacheTime(5 * 60)//缓存时间300s,默认-1永久缓存 okhttp和自定义缓存都起作用
//.okCache(new Cache());//okhttp缓存,模式为默认模式(CacheMode.DEFAULT)才生效
//.cacheDiskConverter(new GsonDiskConverter())//默认使用的是 new SerializableDiskConverter();
.cacheDiskConverter(new SerializableDiskConverter())//默认使用的是 new SerializableDiskConverter();
.timeStamp(true)
.execute(new SimpleCallBack<CacheResult<SkinTestResult>>() { @Override
public void onError(ApiException e) {
//请求失败
} @Override
public void onSuccess(CacheResult<SkinTestResult> cacheResult) {
HttpLog.i(cacheResult.toString());
String from = "";
if (cacheResult.isFromCache) {
from = "我来自缓存";
} else {
from = "我来自远程网络";
}
....
}
});

移除缓存

支持根据缓存key移除缓存,主要是针对RxCache才能起作用

EasyHttp.removeCache("cachekey");

清空缓存

EasyHttp.clearCache();

RxCache

RxCache是自己封装的一个本地缓存功能库,采用Rxjava+DiskLruCache来实现,线程安全内部采用ReadWriteLock机制防止频繁读写缓存造成的异常,可以独立使用,单独用RxCache来存储数据。采用transformer与网络请求结合,可以实现网络缓存功能,本地硬缓存,具有缓存读写功能(异步)、缓存是否存在、根据key删除缓存、清空缓存(异步)、缓存Key会自动进行MD5加密、可以设置缓存磁盘大小、缓存key、缓存时间、缓存存储的转换器、缓存目录、缓存Version等功能本库不作为重点介绍。后期会将此代码独立开源一个库,作为一分钟让你自己的网络库也具有缓存功能,敬请期待!!!

动态参数

动态参数就是像我们的token、时间戳timeStamp、签名sign等,这些参数不能是全局参数因为是变化的,设置成局部参数又太麻烦,每次都要获取。token是有有效时间的或者异地登录等都会变化重新获取,时间戳一般是根据系统的时间,sign是根据请求的url和参数进行加密签名一般都有自己的签名规则。有的接口需要这些参数有的接口不需要,本库很好的解决这个问题。

1.在请求的时候可以设置下面三个参数

.accessToken(true)//本次请求是否追加token
.timeStamp(false)//本次请求是否携带时间戳
.sign(false)//本次请求是否需要签名

2.需要继承库中提供的动态拦截器BaseDynamicInterceptor

继承BaseDynamicInterceptor后就可以获取到参数的设置值,请详细看CustomSignInterceptor的注释讲解,也可以查看Demo示例

示例:

/**
* <p>描述:对参数进行签名、添加token、时间戳处理的拦截器</p>
* 主要功能说明:<br>
* 因为参数签名没办法统一,签名的规则不一样,签名加密的方式也不同有MD5、BASE64等等,只提供自己能够扩展的能力。<br>
* 作者: zhouyou<br>
* 日期: 2017/5/4 15:21 <br>
* 版本: v1.0<br>
*/
public class CustomSignInterceptor extends BaseDynamicInterceptor<CustomSignInterceptor> {
@Override
public TreeMap<String, String> dynamic(TreeMap<String, String> dynamicMap) {
//dynamicMap:是原有的全局参数+局部参数
//你不必关心当前是get/post/上传文件/混合上传等,库中会自动帮你处理。
//根据需要自己处理,如果你只用到token则不必处理isTimeStamp()、isSign()
if (isTimeStamp()) {//是否添加时间戳,因为你的字段key可能不是timestamp,这种动态的自己处理
dynamicMap.put(ComParamContact.Common.TIMESTAMP, String.valueOf(System.currentTimeMillis()));
}
if (isSign()) {是否签名
//1.因为你的字段key可能不是sign,这种需要动态的自己处理
//2.因为你的签名的规则不一样,签名加密方式也不一样,只提供自己能够扩展的能力
dynamicMap.put(ComParamContact.Common.SIGN, sign(dynamicMap));
}
if (isAccessToken()) {//是否添加token
String acccess = TokenManager.getInstance().getAuthModel().getAccessToken();
dynamicMap.put(ComParamContact.Common.ACCESSTOKEN, acccess);
}
//Logc.i("dynamicMap:" + dynamicMap.toString());
return dynamicMap;//dynamicMap:是原有的全局参数+局部参数+新增的动态参数
} //示例->签名规则:POST+url+参数的拼装+secret
private String sign(TreeMap<String, String> dynamicMap) {
String url = getHttpUrl().url().toString();
url = url.replaceAll("%2F", "/");
StringBuilder sb = new StringBuilder("POST");
sb.append(url);
for (Map.Entry<String, String> entry : dynamicMap.entrySet()) {
sb.append(entry.getKey()).append("=").append(entry.getValue()).append("&");
} sb.append(AppConstant.APP_SECRET);
HttpLog.i(sb.toString());
return MD5.encode(sb.toString());
}
}

3.设置自定义的动态拦截器

最好通过全局的方式设置,因为一般很多接口都会使用到

 EasyHttp.getInstance()
...
.addInterceptor(new CustomSignInterceptor())//添加动态参数(签名、token、时间戳)拦截器
...

自定义ApiResult

本库中默认提供的是标准ApiResult.内部是靠ApiResult进行解析的,如果你的数据结构跟ApiResult不同,你可以在你的项目中继承ApiResult,然后重写getCode()、getData()、getMsg()和isOk()等方法来实现自己的需求。

本库中ApiResult如下:

public class ApiResult<T> {
private int code;
private String msg;
private T data;
public int getCode() {
return code;
} public void setCode(int code) {
this.code = code;
} public String getMsg() {
return msg;
} public void setMsg(String msg) {
this.msg = msg;
} public T getData() {
return data;
} public void setData(T data) {
this.data = data;
} public boolean isOk() {//请求成功的判断方法
return code == 0 ? true : false;
}
}

json格式类似:

{
"code": 100010101,
"data": 内容,
"msg": "请求成功"
}

假如你的数据结构是这样的:

{
"error_code": 0,
"result": 内容,
"reason": "请求成功"
}

那么你的basebean可以写成这样

public class CustomApiResult<T> extends ApiResult<T> {
String reason;
int error_code;
//int resultcode;
T result;
@Override
public int getCode() {
return error_code;
}
@Override
public void setCode(int code) {
error_code = code;
}
@Override
public String getMsg() {
return reason;
}
@Override
public void setMsg(String msg) {
reason = msg;
}
@Override
public T getData() {
return result;
}
@Override
public void setData(T data) {
result = data;
}
/* @Override
public boolean isOk() {
return error_code==200;//如果不是0表示成功,请重写isOk()方法。
}*/
}

那么你的网络请求可以这样写

自定义ApiResult回调方式(通过CallBackProxy代理)
EasyHttp.get(url)
.readTimeOut(30 * 1000)//局部定义读超时
.writeTimeOut(30 * 1000)
.connectTimeout(30 * 1000)
//.cacheKey(this.getClass().getSimpleName()+"11")
//.cacheMode(CacheMode.CACHEANDREMOTE)
//.cacheMode(CacheMode.ONLYREMOTE)
//.headers("","")//设置头参数
//.params("name","张三")//设置参数
//.addInterceptor()
//.addConverterFactory()
//.addCookie()
//.timeStamp(true)
.baseUrl("http://apis.juhe.cn")
.params("phone", "手机号")
.params("dtype", "json")
.params("key", "5682c1f44a7f486e40f9720d6c97ffe4")
.execute(new CallBackProxy<CustomApiResult<ResultBean>, ResultBean>(new SimpleCallBack<ResultBean>() {
@Override
public void onError(ApiException e) {
//请求错误
} @Override
public void onSuccess(ResultBean response) {
//请求成功
}
}) {
});

这种写法会觉得有点长,CallBackProxy的泛型参数每次都需要填写,其中CustomApiResult是继承ApiResult的,CustomApiResult相当于项目的basebean,对于一个实际项目来讲,basebean是固定的,所以我们可以继续封装这个方法,根据需要一般只需要封装get和post请求就可以了。

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

通过以上改造,再次调用时直接使用CallBack,不用再关注CallBackProxy,是不是明显简单很多了,具体请看代码Demo!!!

自定义ApiResult订阅方式(通过CallClazzProxy代理)
Observable<ResultBean> observable = EasyHttp.get("/mobile/get")
.readTimeOut(30 * 1000)//局部定义读超时
.writeTimeOut(30 * 1000)
.baseUrl("http://apis.juhe.cn")
.params("phone", "18688994275")
.params("dtype", "json")
.params("key", "5682c1f44a7f486e40f9720d6c97ffe4")
.execute(new CallClazzProxy<CustomApiResult<ResultBean>, ResultBean>(ResultBean.class) {
});
observable.subscribe(new ProgressSubscriber<ResultBean>(this, mProgressDialog) {
@Override
public void onError(ApiException e) {
super.onError(e);
showToast(e.getMessage());
} @Override
public void onNext(ResultBean result) {
showToast(result.toString());
}
});

调试模式

一个好的库,一定有比较人性化的调试模式,为了方便开发者查看请求过程和请求日志,本库提供详细的日志打印,最好在开发阶段,请打开调试模式输出优雅的Log.

调试模式的控制在初始化配置时就可以直接设置。

public class MyApplication extends Application {
@Override
public void onCreate() {
super.onCreate();
...
EasyHttp.getInstance()
...
// 打开该调试开关并设置TAG,不需要就不要加入该行
// 最后的true表示是否打印内部异常,一般打开方便调试错误
.debug("EasyHttp", true);
}
}

Log预览说明

这里一个成功请求的例子:

基于RxJava2+Retrofit2简单易用的网络请求实现

上方的Log打印了一个Request完整的声明周期,一个请求的Log有以下特点:

1.开头和结尾打了-->http is start和 -->http is Complete分割请求,完整的生命周期的内容都会打印在开头和结尾的里面。

2.request请求和response响应分割,分别是

-------------------------------request-------------------------------

-------------------------------response-------------------------------

3.在---request---之后会打印请求的url、当前请求的类型GET/POST... -->GET/POST开头 -->END GET/POST结尾。如果是GET、HEAD请求方式添加的参数将会在这里完整的以url?key=value&key=value的形式打印。

4.在----response----之后会打印(在服务器响应后被打印),包含响应码、响应状态、响应头、cookie,body等以<--200(响应码)开头,<--END HTTP结尾

5.loadCache key=如果设置了缓存,会看到缓存的key,开启了网络缓存功能才会输出。

6.loadCache result=从缓存里读取的结果,开启了网络缓存功能才会输出。

7.save status => true保存缓存的状态

混淆

#okhttp
-dontwarn com.squareup.okhttp3.**
-keep class com.squareup.okhttp3.** { *;}
-dontwarn okio.** # Retrofit
-dontwarn retrofit2.**
-keep class retrofit2.** { *; }
-keepattributes Exceptions # Retrolambda
-dontwarn java.lang.invoke.* # 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;
}
###rxandroid-1.2.1
-keepclassmembers class rx.android.**{*;} # Gson
-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.** { *; } #RxEasyHttp
-keep class com.zhouyou.http.model.** {*;}
-keep class com.zhouyou.http.cache.model.** {*;}
-keep class com.zhouyou.http.cache.stategy.**{*;}

项目程序结构目录截图

项目程序结构目录截图如下:

基于RxJava2+Retrofit2简单易用的网络请求实现

基于RxJava2+Retrofit2简单易用的网络请求实现

代码地址如下:
http://www.demodashi.com/demo/13473.html

注:本文著作权归作者,由demo大师代发,拒绝转载,转载需要作者授权