MVP实战心得(三)---封装Retrofit2.0+RxAndroid+RxBus
2017-04-24 10:50
525 查看
介绍:
Retrofit:
对okhttp的封装,可以更方便的使用okhttp
RxAndroid
响应式编程框架,rxjava的扩展,很爽的链式编程 魅力在于对数据的处理,与线程切换的灵活性.
用来处理异步操作(Lambda表达式不会用.用Lambda表达式代码会更少,但不会的人会看不懂代码.不是很推荐)
RxBus
用RxJava实现的EventBus
说说为什么要配合起来用
Retrofit负责链接网络,请求网络. RxAndroid负责处理请求的结果.异步操作
RxBus可以很方便的进行各组件之间的通信.
我之前是用asynchttpclient做网络请求的,各种代码缩进,if套if,各种回调,惨不忍睹啊.
用了Retrofit+RxAndroid我就彻底放弃asynchttpclient了.
使用
1.RxJava
传送门:RxJava———这个作为入门学习rxjava非常好##2.Retrofit
这个写点基本的用法吧..
首先看用的包:
//retrofit2--看名字就知道是啥了 compile 'com.squareup.retrofit2:retrofit:2.1.0' //CallAdapterFactory的Rx依赖包---导这个包才能配合rxAndroid使用 compile 'com.squareup.retrofit2:adapter-rxjava:2.1.0' //ConverterFactory的String依赖包----这个是解析数据的工厂.用来格式化数据的,配置编码啊,gson解析啊. compile 'com.squareup.retrofit2:converter-scalars:2.1.0'1
2
3
4
5
6
1
2
3
4
5
6
然后是retrofit注解：(使用retrofit,注解是很重要的)
方法注解 : 包含@GET、@POST、@PUT、@DELETE、@PATCH、@HEAD、@OPTIONS、@HTTP。 这个不多讲.一般用的就是@GET、@POST,很明显,一个是get请求,一个是post请求1
2
3
1
2
3
标记注解 : 包含@FormUrlEncoded、@Multipart、@Streaming。 这个得和参数注解一起说1
2
1
2
参数注解 : 包含@Query,@QueryMap、@Body、@Field，@FieldMap、@Part，@PartMap。
@Get---------用的参数注解就@Query,@QueryMap,
@Post--------则会用到 @Body、@Field，@FieldMap、@Part，@PartMap。
@Body-------将数据转化成Json,然后post.具体转化根据设置的解析工厂(下面有讲)
---------------------------------------------------分割线----------------------------------------------------------
@Field，@FieldMap------post上传表单.@Field表示单个,@FieldMap表示集合.
需要添加上面的@FormUrlEncoded表示表单提交 ,
对应Content-Type:application/x-www-form-urlencoded
如:
@FormUrlEncoded
@POST("login的url")
Observable<User> login(@Field("name") String name, @FieldMap Map params);
--------------------------------------------------分割线------------------------------------------------------------
@Part，@PartMap----post上传文件/数据.@Part表示单个,@PartMap表示集合.
其中@Part MultipartBody.Part 类型代表文件，@Part(“key”) RequestBody类型代表参数
需要添加@Multipart表示支持文件上传的表单，Content-Type: multipart/form-data
@Multipart
@POST("update的url")
Observable<User> update(@Part ("file") MultipartBody.Part file, @Part(“key”) RequestBody key,
@PartMap Map<String,RequestBody> files);
如果参数较少,使用@Part ("file")就可以解决了,如果参数较多,那就需要使用@PartMap了.12
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
其他注解 : @Path、@Header,@Headers、@Url 这几个用处挺大的,这里就不细说了,并不是必用的,我用的不多.1
2
1
2
Retrofit 配置代码.
//这个是处理网络请求的log信息的,可以实现Interceptor接口来自定义.
HttpLoggingInterceptor interceptor = new HttpLoggingInterceptor(new HttpLoggingInterceptor.Logger() {
@Override
public void log(String message) {
HLog.i("RxJava", message);
}
});
OkHttpClient client = new OkHttpClient.Builder()
.addInterceptor(interceptor)
.build();
Retrofit retrofit = new Retrofit.Builder()
.client(client)//Retrofit需要配置一个OkHttpClient实例.
.baseUrl(API_HOST)//需要指定一个baseUrl,一般就是服务器的域名
.addConverterFactory(FastjsonConverterFactory.create())//这个是数据解析工厂,我用的是fastjson
.addCallAdapterFactory(RxJavaCallAdapterFactory.create())//支持rxJava,在第二个jar包里面
.build();12
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
下面是完整代码:
/**
* 写成单例模式,因为并不需要多个Retrofit存在.
*/
public class RetrofitUtil {
/**
* 服务器地址
*/
private static final String API_HOST ="你的BaseUrl";
private RetrofitUtil() {
}
public static Retrofit getRetrofit() {
return Instanace.retrofit;
}
//静态内部类,保证单例并在调用getRetrofit方法的时候才去创建.
private static class Instanace {
private static final Retrofit retrofit = getInstanace();
private static Retrofit getInstanace() {
HttpLoggingInterceptor interceptor = new HttpLoggingInterceptor(new HttpLoggingInterceptor.Logger(){
@Override
public void log(String message) {
HLog.i("RxJava", message);
}
});
OkHttpClient client = new OkHttpClient.Builder()
.addInterceptor(interceptor)
.build();
Reretrofit = new Retrofit.Builder()
.client(client)
.baseUrl(API_HOST)
.addConverterFactory(FastjsonConverterFactory.create())
.addCallAdapterFactory(RxJavaCallAdapterFactory.create())
.build();
return retrofit;
}
}
}12
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
json解析工厂,代码太多,,具体可以见demo
3.RxAndroid
如果没接触的话,可以看前面的Rxjava链接.(1).首先看Reretrofit+RxAndroid是怎么使用的
@GET("login地址")
Observable<BaseResponse<LoginData>> login(@QueryMap HashMap<String, Object> params);12
1
2
其实所谓的Reretrofit+RxAndroid就是这么回事.
没有RxAndroid的Reretrofit请求接口是这样写的:
@GET("login地址")
Call<BaseResponse<LoginData>> login(@QueryMap HashMap<String, Object> params);12
1
2
把Call换成了Observable而已.
(2)写一个接口类
/**1
*所有的网络请求都可以写在这个接口类里面.
*/
public interface APIService {
@GET("login地址") Observable<BaseResponse<LoginData>> login(@QueryMap HashMap<String, Object> params);
......
}
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9
(3)接口类的实现
/**
* 请求生成类。Retrofit一次生成,并作为单例.
*/
public class ApiServcieImpl {
private ApiServcieImpl() {
}
public static APIService getInstance() {
return createAPIService.apiService;
}
/**
* Retrofit生成接口对象.
*/
private static class createAPIService {
//Retrofit会根据传入的接口类.生成实例对象.
private static final APIService apiService = RetrofitUtil.getRetrofit().create(APIService.class);
}
}12
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
然后就可以通过ApiServcieImpl.getInstance()去调用APIService里面写的接口了.
如:
ApiServcieImpl.getInstance().login(new HashMap<String, Object>()) //传入参数
.subscribe(new Action1<BaseResponse<LoginData>>() {//简单的回调
@Override
public void call(BaseResponse<LoginData> loginDataBaseResponse) {
//拿到数据,做处理
}
});12
3
4
5
6
7
1
2
3
4
5
6
7
4.封装
有没有发现,设置泛型的是
先看BaseResponse:
public class BaseResponse<T> {
private boolean success;//请求是否成功
private int resultCode;//状态吗
private String msg;//返回的提示消息
private T data;//主要内容,因为不知道返回的会是什么类型,所以用泛型来表示
//get set方法就不贴了.
}12
3
4
5
6
7
1
2
3
4
5
6
7
怎么处理.
/**
* @author jlanglang 2016/11/15 16:14
*/
public class ModelFilteredFactory {
private final static Observable.Transformer transformer = new SimpleTransformer();
/**
* 将Observable<BaseResponse<T>>转化Observable<T>,并处理BaseResponse
*
* @return 返回过滤后的Observable.
*/
@SuppressWarnings("unchecked")
public static <T> Observable<T> compose(Observable<BaseResponse<T>> observable) {
return observable.compose(transformer);
}
/**
* 这里就不细讲了,具体可以去看rxjava的使用.这个类的意义就是转换Observable.
*/
private static class SimpleTransformer<T> implements Observable.Transformer<BaseResponse<T>, T> {
//这里对Observable,进行一般的通用设置.不用每次用Observable都去设置线程以及重连设置
@Override
public Observable<T> call(Observable<BaseResponse<T>> observable) {
return observable.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.unsubscribeOn(Schedulers.io())
.timeout(5, TimeUnit.SECONDS)//重连间隔时间
.retry(5)//重连次数
.flatMap(new Func1<BaseResponse<T>, Observable<T>>() {
@Override
public Observable<T> call(BaseResponse<T> tBaseResponse) {
return flatResponse(tBaseResponse);
}
});
}
/**
* 处理请求结果,BaseResponse
* @param response 请求结果
* @return 过滤处理, 返回只有data数据的Observable
*/
private Observable<T> flatResponse(final BaseResponse<T> response) {
return Observable.create(new Observable.OnSubscribe<T>() {
@Override
public void call(Subscriber<? super T> subscriber) {
if (response.isSuccess()) {//请求成功
if (!subscriber.isUnsubscribed()) {
subscriber.onNext(response.getData());
}
} else {//请求失败
int resultCode = response.getResultCode();
if (!subscriber.isUnsubscribed()) {
//这里抛出自定义的一个异常.可以处理服务器返回的错误.
subscriber.onError(new APIException(response.getResultCode(), response.getMsg()));
}
return;
}
if (!subscriber.isUnsubscribed()) {//请求完成
subscriber.onCompleted();
}
}
});
}
}
}12
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
仅仅只有上面那些了么?接着看.
/**
* @author jlanglang 2016/11/14 17:32
* Subscriber,这个是用来处理Observable的结果的.
*/
public abstract class SimpleSubscriber<T> extends Subscriber<T> {
@Override
public void onCompleted() {//这个是请求完成时调用.如果走了onError()就不会走这个方法.
}
@Override
public void onError(Throwable e) {//这里通常就处理异常
if (e instanceof APIException) {
APIException exception = (APIException) e;
ToastUtil.showToast( exception.message);
} else if (e instanceof UnknownHostException) {
ToastUtil.showToast("请打开网络");
} else if (e instanceof SocketTimeoutException) {
ToastUtil.showToast( "请求超时");
} else if (e instanceof ConnectException) {
ToastUtil.showToast("连接失败");
} else if (e instanceof HttpException) {
ToastUtil.showToast("请求超时");
}else {
ToastUtil.showToast("请求失败");
}
e.printStackTrace();
}
@Override
public void onNext(T t) {//这里的是获得了数据,方法意思很明显,下一步干啥
if (t != null) {//这里最好判断一下是否为null.
call(t);
} else {
ToastUtil.showToast("连接失败");
}
}
/**
*因为具体的处理这里无法得知,所以抽象.
*/
public abstract void call(T t);
}12
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
好了,看看现在的具体使用吧:
ModelFilteredFactory.compose(ApiServcieImpl.getInstance().login(new HashMap<String, Object>()))
.subscribe(new SimpleSubscriber<LoginData>() {
@Override
public void call(LoginData loginData) {
}
});
看起来之前用起来差不多,但是却做了很多的处理:
1.对Observable做了通用设置.网络重连次数,线程设置,重连时间.
2.做了对服务器返回结果的统一处理.比如根据resultcode,处理登陆过期啊啥的.
3.判断了data是否为null,不会在call()里面担心loginData是否为null
4.统一处理了请求的各种异常.12
3
4
5
6
7
8
9
10
11
12
1
2
3
4
5
6
7
8
9
10
11
12
5.用到MVP中.
你以为上面那些就完了吗?NO!
如果我们在Presenter中这样调用其实是很不科学的.
ModelFilteredFactory.compose(ApiServcieImpl.getInstance().login(new HashMap<String, Object>()))1
1
这个转换我们应该放在Modle和ModleImpl中去写
public class LoginContract{
....//view接口省略
public interface Model {
/**
* 获取登陆数据
* @return Observable<LoginData>
*/
Observable<LoginData> login(HashMap<String, Object> treeMap);
}
....//prensent接口省略
}
public class LoginModelImpl implements LoginContract.Model {
@Override
public Observable<LoginData> login(HashMap<String, Object> hashMap) {
return ModelFilteredFactory.compose(ApiServcieImpl.getInstance().login(hashMap));
}}12
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
那么我们在presenter中调用就可以这样:
public class LoginPresenterImpl exdents BasePresenter implements LoginContract.Presenter{
.....
private LoginModelImpl loginModelImpl;
public void onCreate(){
loginModelImpl = new LoginModelImpl();//创建modle实例
}
public void login(){
//通过modle请求接口
loginModelImpl.login(new HashMap<String, Object>()))
.subscribe(new SimpleSubscriber<LoginData>() {
@Override
public void call(LoginData loginData) {
//处理请求的数据,绑定视图
}
});
}
....
}12
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
6.管理Observable的生命周期,也就是网络请求的生命周期.
Observable是不是很高大上,然而如果你不进行处理,可是会内存泄漏的 RxAndroid也不会自动的根据Activity/frgament的生命周期结束异步请求.
但处理其实很简单.
使用CompositeSubscription
只需要将Observable,异步处理到最后返回的subscribe添加到CompositeSubscription实例里就行了.
public void login(){
Subscription subscribe = loginModelImpl.login(new HashMap<String, Object>()))
.subscribe(new SimpleSubscriber<LoginData>() {
@Override
public void call(LoginData loginData) {
//处理请求的数据,绑定视图
}
});
compositeSubscription.add(subscribe);//添加订阅
}
//在销毁的时候,结束订阅事件.
public void onDestroy() {
compositeSubscription.unsubscribe();//结束所有add的subscribe事件
}12
3
4
5
6
7
8
9
10
11
12
13
14
1
2
3
4
5
6
7
8
9
10
11
12
13
14
那么,实战心得(二)中的BasePresenter就可以进行改进了,具体见:
传送门:实战心得(二)/**
* @author jlanglang 2016/11/11 15:10
*/
public abstract class BasePresenter<T extends BaseView> {
protected T mView;
protected CompositeSubscription compositeSubscription;
/**
* 绑定View
*/
public void onAttch(T view) {
this.mView = view;
compositeSubscription = new CompositeSubscription ();
}
/**
* 做初始化的操作,需要在V的视图初始化完成之后才能调用
* presenter进行初始化.
*/
public abstract void onCreate();
/**
* 在这里结束异步操作
*/
public void onDestroy(){
compositeSubscription.unsubscribe();//结束异步请求.
}
/**
* 在V销毁的时候调用,解除绑定
*/
public void onDetach() {
mView = null;
}
/**
* 容易被回收掉时保存数据
*/
public abstract void onSaveInstanceState(Bundle outState);
}12
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
7.RxBus
没什么特别值得提的,用法自行搜索,哈哈,个人在项目中用的也不是很多,某些情况会用一下,但真心好用.
再附上githubdemo地址,还未更新到最新.
mvpDemo转载地址：http://blog.csdn.net/jlanglang/article/details/53502642
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- MVP实战心得(三)---封装Retrofit2.0+RxAndroid+RxBus
- [置顶] MVP实战心得(三)---封装Retrofit2.0+RxAndroid+RxBus
- android架构封装（mvp + rxandroid + Retrofit2.0 ）
- Android详细的登录注册功能MVP+Rxjava2.0+Retrofit2.0相结合的实战篇章
- RxAndroid+Retrofit+GreenDao+MVP框架---通用基类封装（三）
- Android 基于ijkplayer+Rxjava+Rxandroid+Retrofit2.0+MVP+Material Design的android万能播放器aaa
- 基于ijkplayer+Rxjava+Rxandroid+Retrofit2.0+MVP+Material Design的android万能播放器
- Android:这是一份非常详细的MVP+Rxjava2.0+Retrofit2.0相结合举例RecyclerView的实战篇章
- Retrofit2.0+RxAndroid+RxBus
- Retrofit2.0结合RxAndroid实现二次封装
- RxAndroid+Retrofit+GreenDao+MVP框架---通用基类封装（二）
- RxAndroid+Retrofit+GreenDao+MVP框架---通用基类封装（一）
- retrofit 2.0 +RxAndroid 使用中遇到异常 【abstract method not implemented】
- Android基于Retrofit2.0 封装的超好用的RetrofitClient工具类（完美结合RxJava）
- Android开源实战：使用MVP+Retrofit开发一款文字阅读APP
- Mvp+Rxandroid+Retrofit的简单实现
- RxAndroid + Retrofit + MVP 在真实项目中踩过的坑（一）
- Android--带你一点点封装项目 MVP+BaseActivity+Retrofit+Dagger+RxJava（二）
- android架构篇mvp+rxjava+retrofit+eventBus
- [android架构篇]mvp+rxjava+retrofit+eventBus