9章 RxJava混合实战
本篇文章已受权微信公众号 YYGeeker 独家发布转载请标明出处php
CSDN学院课程地址java
- RxJava2从入门到精通-初级篇:edu.csdn.net/course/deta…
- RxJava2从入门到精通-中级篇:edu.csdn.net/course/deta…
- RxJava2从入门到精通-进阶篇:edu.csdn.net/course/deta…
- RxJava2从入门到精通-源码分析篇:edu.csdn.net/course/deta…
9. RxJava混合开发
9.1 RxJava与Retrofit
添加Retrofit的依赖android
//retrofit
implementation 'com.squareup.retrofit2:retrofit:2.2.0'
implementation 'com.squareup.retrofit2:converter-gson:2.2.0'
//rx+retrofit
implementation 'com.squareup.retrofit2:adapter-rxjava2:2.2.0'
复制代码
Retrofit是主流的网络框架，RxJava和Retrofit的使用已经成为主流的搭配，RxJava能够经过Retrofit在网络请求后，对网络请求的数据进行操做，也能够配合gson库进行解析。api
public interface ApiService {
@GET("/getUserInfo.php")
Observable<Main2Activity.UserInfo> getUserInfo(@Query("username") String username, @Query("password") String password);
@GET("/getVipInfo.php")
Observable<Main2Activity.VipInfo> getVipInfo(@Query("uid") String uid);
}
public void retrofit(View view) {
//构建Retrofit
apiService = new Retrofit.Builder()
.baseUrl("http://172.26.83.19/")
//rx与Gson混用
.addConverterFactory(GsonConverterFactory.create())
//rx与retrofit混用
.addCallAdapterFactory(RxJava2CallAdapterFactory.create())
.build()
.create(ApiService.class);
//构建RxJava
UserParam param = new UserParam("hensen", "123456");
//发送param参数
Observable.just(param)
.flatMap(new Function<UserParam, ObservableSource<UserInfo>>() {
@Override
public ObservableSource<UserInfo> apply(@NonNull UserParam userParam) throws Exception {
return apiService.getUserInfo(userParam.param1, userParam.param2);
}
})
.flatMap(new Function<UserInfo, ObservableSource<VipInfo>>() {
@Override
public ObservableSource<VipInfo> apply(@NonNull UserInfo userInfo) throws Exception {
return apiService.getVipInfo(userInfo.uid);
}
})
.subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer<VipInfo>() {
@Override
public void accept(@NonNull VipInfo vipInfo) throws Exception {
textView.setText("会员等级：" + vipInfo.vipLevel + "--会员积分：" + vipInfo.vipScore);
}
});
}
class UserInfo {
public String success;
public String uid;
public String username;
public String password;
public String nikename;
}
class VipInfo {
public String success;
public String uid;
public String vipLevel;
public String vipScore;
}
class UserParam {
public String param1;
public String param2;
public UserParam(String param1, String param2) {
this.param1 = param1;
this.param2 = param2;
}
}
复制代码
9.2 RxJava与RxBinding
添加RxBinding的依赖bash
implementation 'com.jakewharton.rxbinding2:rxbinding:2.1.1'
复制代码
RxBinding是结合RxJava进行绑定View事件的辅助框架。这里举例绑定EditText文本变化的监听事件，当EditText文本变化迅速时，咱们不该当在每次变化的时候去访问后台请求，而是等到用户敲完字以后停下来的半秒才去请求后台微信
RxTextView.textChanges(editText)
//当你敲完字以后停下来的半秒就会执行下面语句
.debounce(500, TimeUnit.MILLISECONDS)
//下面这两个都是数据转换
//flatMap：当同时多个网络请求访问的时候，前面的网络数据会覆盖后面的网络数据
//switchMap：当同时多个网络请求访问的时候，会以最后一个发送请求为准，前面网路数据会被最后一个覆盖
.switchMap(new Function<CharSequence, ObservableSource<List<String>>>() {
@Override
public ObservableSource<List<String>> apply(@NonNull CharSequence charSequence) throws Exception {
//网络操做，获取咱们须要的数据
List<String> list = new ArrayList<String>();
list.add("输入文本变化时，请求网络次数："+ ++i);
return Observable.just(list);
}
})
//网络请求是在子线程的
.subscribeOn(Schedulers.io())
//界面更新在主线程
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer<List<String>>() {
@Override
public void accept(@NonNull List<String> strings) throws Exception {
//界面更新
textView2.setText(strings.toString());
}
});
复制代码
9.3 RxJava与RxLifecycle
添加RxLifecycle的依赖网络
//rxlifecycle
implementation 'com.trello.rxlifecycle2:rxlifecycle:2.2.1'
implementation 'com.trello.rxlifecycle2:rxlifecycle-components:2.2.1'
implementation 'com.trello.rxlifecycle2:rxlifecycle-android:2.2.1'
implementation 'com.trello.rxlifecycle2:rxlifecycle-android-lifecycle:2.2.1'
复制代码
RxLifecycle是结合RxJava绑定Activity或者Fragment的生命周期的辅助框架，能够帮助开发者在绑定的生命周期中自动释放事件流，从而避免内存泄漏。这里举例绑定Activity的onPause事件，当点击按钮时跳转到另外一个Activity时，onPause会被执行，则这个事件将会被释放，界面将不会再更新对应的文案。RxLifeCycle的使用须要将Activity继承自RxActivity或是RxFragment等，这些是由RxLifeCycle建立好的并监听生命周期的组件。经过compose()实现生命周期的绑定架构
public void rxlifecycle() {
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
for (int j = 0; j < 20; j++) {
Thread.sleep(2000);
emitter.onNext("rxlifecycle " + j);
}
}
})
.compose(this.bindUntilEvent(ActivityEvent.PAUSE))
//网络请求是在子线程的
.subscribeOn(Schedulers.io())
//界面更新在主线程
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer<Object>() {
@Override
public void accept(@NonNull Object strings) throws Exception {
//界面更新
textView3.setText(strings.toString());
}
});
}
public void rxlifeCycle(View view) {
startActivity(new Intent(this, Main3Activity.class));
}
复制代码
9.4 RxJava与Mvp
RxJava与Mvp是在Mvp架构模式下的P层进行数据的处理，其主要的核心思想仍是Mvp，而RxJava在这里只是在P层作数据的处理，并将处理完的数据在V层进行相对应的UI操做。这里的Mvp采用当前项目实战中的真实案例，开发者并不须要关心Mvp层之间的关系，由于这里已经封装好了对Mvp的关系绑定，并且对P层也封装了相对应的生命周期回调，M层的数据模型处理在这里并无用到实体对象，因此被忽略使用app
9.4.1 封装基础层
一、V层框架
只要实现V层的接口，就表示你是V层的一部分
public interface MvpView {
}
复制代码
二、P层
P层持有V层的实例，且带有一套P层本身的生命周期，具体是经过Activity生命周期进行回调的
public abstract class MvpPresenter<T extends MvpView> {
public static final String TAG = "MvpPresenter";
public T mView;
public void attach(T view) {
mView = view;
}
/**
* 对应 activity/fragment onCreate
*/
protected void onCreate(Bundle savedInstanceState) {
Log.i(TAG, "onCreate");
}
/**
* 对应 activity/fragment onStart
*/
protected void onStart() {
Log.i(TAG, "onStart");
}
/**
* 对应 activity/fragment onResume
*/
protected void onResume() {
Log.i(TAG, "onResume");
}
/**
* 对应 activity/fragment onPause
*/
protected void onPause() {
Log.i(TAG, "onPause");
}
/**
* 对应 activity/fragment onStop
*/
protected void onStop() {
Log.i(TAG, "onStop");
}
/**
* 对应 activity/fragment onDestroy
*/
protected void onDestroy() {
Log.i(TAG, "onDestroy");
if (mView != null) {
mView = null;
}
}
}
复制代码
三、封装Activity层
Activity持有P层的实例，且回调P层的生命周期，对外提供建立P层的抽象方法
public abstract class MvpActivity<P extends MvpPresenter> extends AppCompatActivity implements MvpView {
protected P presenter;
protected abstract P createPresenter();
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_mvp);
presenter = createPresenter();
if (presenter != null) {
presenter.attach(this);
presenter.onCreate(savedInstanceState);
}
}
@Override
protected void onStart() {
super.onStart();
if (presenter != null) {
presenter.onStart();
}
}
@Override
protected void onResume() {
super.onResume();
if (presenter != null) {
presenter.onResume();
}
}
@Override
protected void onPause() {
super.onPause();
if (presenter != null) {
presenter.onPause();
}
}
@Override
protected void onStop() {
super.onStop();
if (presenter != null) {
presenter.onStop();
}
}
@Override
protected void onDestroy() {
super.onDestroy();
if (presenter != null) {
presenter.onDestroy();
}
}
}
复制代码
9.4.2 封装抽象层
一、V层
V层只须要声明出须要实现的方法
interface CustomView extends MvpView {
void onLoading(String text);
void onRefreshData(String text);
void onError(String text);
void onComplete(String text);
}
复制代码
二、P层
P层只须要声明出须要处理的方法
public abstract class CustomPresenter extends MvpPresenter<CustomView> {
public CustomPresenter() {
super();
}
abstract void loadData();
}
复制代码
9.4.3 实现抽象层
一、Activity层
继承封装好的Activity，并实现抽象层的方法，在这里作P层的建立和V层的处理
public class RealView extends MvpActivity<RealPresenter> implements CustomView {
private TextView textView;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_real_view);
textView = findViewById(R.id.textView);
}
@Override
protected RealPresenter createPresenter() {
return new RealPresenter();
}
@Override
public void onLoading(String text) {
textView.append(text);
}
@Override
public void onRefreshData(String text) {
textView.append(text);
}
@Override
public void onError(String text) {
textView.append(text);
}
@Override
public void onComplete(String text) {
textView.append(text);
}
//按钮点击事件
public void bt_get_data(View view) {
presenter.loadData();
}
}
复制代码
二、P层
P层真正的使用RxJava进行数据的处理，并将处理后的数据在UI上更新
public class RealPresenter extends CustomPresenter {
@Override
void loadData() {
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> e) throws Exception {
e.onNext("俊俊俊很帅");
e.onNext("你值得拥有");
e.onNext("取消关注");
e.onNext("但仍是要保持微笑");
e.onComplete();
}
})
.subscribeOn(Schedulers.io())
//将观察者切换到主线程 须要在Android环境下运行
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
mView.onLoading("正在加载中...... \n");
}
@Override
public void onNext(String s) {
try {
Thread.sleep(200); //模拟网络访问
} catch (InterruptedException e) {
e.printStackTrace();
}
mView.onRefreshData("从网络上获取数据：" + s + "\n");
}
@Override
public void onError(Throwable t) {
mView.onError(t.getMessage());
}
@Override
public void onComplete() {
mView.onComplete("加载完成...... \n");
}
}
);
}
}
复制代码
9.5 小结
一、RxJava与Retrofit
因为每一个人的项目中不必定有使用Retrofit，可是必定有RxJava，你能够经过对项目中的网络请求进行RxJava上的封装，也能达到和RxJava与Retrofit一样的效果，我司就是这么作的
二、RxJava与RxBinding
RxBinding简化了咱们与View的绑定事件，从RxBinding的RxView源码中，不难发现其实现的原理就是自定义操做符，能够翻翻RxView的源码，模仿自定义操做符的代码，在本身的项目中去发挥你的想象力，相信在后面的开发，你也能自定义出一套本身的框架
三、RxJava与RxLifecycle
RxLifecycle简化了咱们对Android生命周期的处理，可是比较惋惜的是须要继承自RxLifecycle提供的RxActivity或RxFragment等，不少项目都是之前的，并无这个前提，那么能够选择重构RxActivity，或者在原先的Activity中监听生命周期方法，经过回调来管理RxJava的释放工做
四、RxJava与Mvp
RxJava在Mvp的模式的使用下，做用显得更加客观，由于在P层须要对M层和V层进行处理，不只要从工做线程去获取M层的数据，还要在UI线程中对V层进行更新，在RxJava中的处理显得游刃有余
相关文章
- 1. 6章 RxJava基础实战
- 2. Flutter混合App实战
- 3. Fultter混合App实战
- 4. MVP+Retrofit+Rxjava实战
- 5. Retrofit+Rxjava+Mvp实战
- 6. RxJava+Retrofit+OkHttp实战
- 7. 如何构建混合云战略，混合云实施面临哪些挑战？
- 8. RxJava实战技巧大全
- 9. 第9章 慕课网日志实战
- 10. Hybrid App混合开发实战
- 更多相关文章...
- • XSD 混合内容 - XML Schema 教程
- • MyBatis与Spring的整合实例 - MyBatis教程
- • Java Agent入门实战（三）-JVM Attach原理与使用
- • Docker容器实战(七) - 容器眼光下的文件系统
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
相关文章