/**
* 演示RxJava的介绍以及基本使用
*
* 1.RxJava是什么?
* RxJava本质就是一个实现异步操作的库 异步
*
* 2.RxJava优点 简洁(随着程序的逻辑变得复杂 可以将复杂的逻辑代码串成一条线)
*
* 3.原理 RxJava异步实现 拓展的观察者模式
*
* 观察者模式:A对象(观察者)对B(被观察者)对象的某种变化比较敏感 需要在B对象变化的瞬间
* 作出反应 程序中的观察者模式 采用注册或者订阅方式 告诉被观察者当他变化是通知观察者
*
* android应用中的观察者案例 view视图绑定单击事件
* view被观察者---onClickListener单击事件的监听器 观察者
* 注册/订阅 setOnClickListener()
* 当单击view视图时 通知onClickListener单击事件的监听器观察者对象作出响应(回调onClick方法)
*
* RxJava中观察者模式
* RxJava中四个基本概念 Observable(被观察者) Observer(观察者)
* Subscribe(订阅/注册)
* Observable(被观察者) Observer(观察者)通过Subscriber()方法实现订阅关系
* Observable需要时发出事件通知Observer
*
*/
以下是它的几种基本的用法:
通过分别创建观察者,创建被观察者,注册被观察者分别使用,也可以将其全部一条线写下:
1,最基本的用法:(使用分解的方式,)
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//1.创建Observer观察者对象 他主要决定事件触发时有怎么样的行为
Observer<String> observer=new Observer<String>() {
/**
* 事件队列操作完毕时回调的寒肃
* rxjava中事件处理时不仅可以单独处理还可以看作事件队列
*
* 作为事件结束的标志
*/
@Override
public void onCompleted() {
Log.i("tag","------onCompleted------");
}
/**
* 事件处理过程中出现异常的时候回调
* onError()被触发 整个的事件的处理中止
* 注意:onCompleted()和onError()互斥 正常的事件处理过程中只会调用其中一个函数
*/
@Override
public void onError(Throwable e) {
e.printStackTrace();
}
/**
* 类似与view中 OnClickListener中的onClick方法
* 主要对被观察者触发的事件处理的方法
*/
@Override
public void onNext(String s) {
Log.i("tag","-------onNext-----"+s);
}
};
//2.创建被观察者对象 他决定什么时候触发事件以及触发怎么样的事件
/*
Observable.create() RxJava中创建事件序列的方法
create()方法中需要传入OnSubscribe对象 OnSubscribe存储到Observable对象中(计划表)
当Observable被订阅时 OnSubscribe接口中的call()会被回调 事件的序列才会依次执行触发
*/
Observable observable=Observable.create(new Observable.OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> subscriber) {
subscriber.onNext("Hello");
subscriber.onNext("hi");
subscriber.onNext("how are you");
subscriber.onCompleted();
}
});
//3. 订阅 注册 view.setOnClicklistener(onClickListener)
observable.subscribe(observer);
}
}
2,使用观察者子类的方法:
public class MainActivity02 extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
/**
* RxJava中有一个具体实现Observer抽象类的类 Subscriber
* Subscriber是Observer观察者类的具体子类 对Observer观察者进行了拓展
* 如果只是使用基本功能 Subscriber、Observer基本一样
* 区别:
* 1.Subscriber类中增加了onStart()方法
* 2.unSubscribe()取消订阅 当该方法被调用后 Subscriber将不再接收事件
*/
Subscriber<String> subscriber=new Subscriber<String>() {
@Override
public void onCompleted() {
Log.i("tag","------onCompleted------");
}
@Override
public void onError(Throwable e) {
e.printStackTrace();
}
@Override
public void onNext(String s) {
Log.i("tag","-------onNext-----"+s);
}
/**
* Subscriber中添加的方法 表示在事件发送之前被调用 准备工作 数据清零重置操作
*/
@Override
public void onStart() {
super.onStart();
}
};
//2.创建被观察者对象 他决定什么时候触发事件以及触发怎么样的事件
// Observable observable=Observable.create(new Observable.OnSubscribe<String>() {
// @Override
// public void call(Subscriber<? super String> subscriber) {
// subscriber.onNext("Hello");
// subscriber.onNext("hi");
// subscriber.onNext("how are you");
// subscriber.onCompleted();
// }
// });
//just() 将传入的参数作为onNext()方法的参数进行使用,这个地方just()代替了.create();
// Observable observable=Observable.just("Hello","Hi","how are you");
String[] array={"Hello","Hi","how are you"};
Observable observable=Observable.from(array);
//3. 订阅 注册 view.setOnClicklistener(onClickListener)
// observable.subscribe(observer);
observable.subscribe(subscriber);
}
}
3,他通过拆分观察者的使用:(将观察者的三种方法全部分别封装起来使用)
public class ActionActivity extends AppCompatActivity{
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
/**
* Action0是RxJava中的接口 具有一个方法call() 该方法无参数 无返回值
* Observer观察者类中onCompleted()也是无参数无返回值 Action0当作
* 一个包装对象 将onCompleted()的内容打包作为参数进行提供给subscribe()
* 进行使用 不完整定义的回调
*/
Action0 completed=new Action0() {
@Override
public void call() {
Log.i("tag","--------onComplted----");
}
};
/**
* Action1 也是一个接口 具有一个call(T t) 该方法具有一个参数无返回值
* 对onNext()方法的封装作为不完整定义的回调
有一点一定要注意,这里的call其实就相当与前边的那三个方法其中的每一个,分别装了起来,每一个都叫做call;
*/
Action1<String> nextAction=new Action1<String>() {
@Override
public void call(String s) {
Log.i("tag","-------onNext----"+s);
}
};
Action1<Throwable> errorAction=new Action1<Throwable>() {
@Override
public void call(Throwable throwable) {
throwable.printStackTrace();
}
};
Observable observable=Observable.just("Hello","Hi");
observable.subscribe(nextAction,errorAction,completed);
}
}
下面演示一种整体的步骤:(三种就不全部写了,只写一种了,意思都差不多)
public class TestActivity extends AppCompatActivity{
//1.打印字符串数组中的内容
private String[] array={"sd","fg","hj","io","pl"};
private ImageView iv;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
iv= (ImageView) findViewById(R.id.iv_show);
// Observable.from(array).subscribe(new Action1<String>() {
// @Override
// public void call(String s) {
// Log.i("tag","----------"+s);
// }
// });
//2.根据图片的资源id 将图片设置到ImageView控件中
Observable.create(new Observable.OnSubscribe<Drawable>() {
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
@Override
public void call(Subscriber<? super Drawable> subscriber) {
//将图片的资源id转换成drawable
Drawable drawable=getTheme().getDrawable(R.mipmap.cat);
subscriber.onNext(drawable);
subscriber.onCompleted();
}
}).subscribe(new Observer<Drawable>() {
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(Drawable drawable) {
iv.setImageDrawable(drawable);
}
});
}
}
说道Rxjava就会使用到Scheduler 调度器 下面说一下调度器的使用:
/**
* RxJava出现就是为了实现异步操作 后台处理[工作线程处理耗时操作] 前台调用[UI线程调用显示]
* Scheduler 调度器 线程的控制器 RxJava中通过该对象指定每一段代码运行在哪个线程中
* RxJava中内置的调度器
* Schedulers.immediate() 默认scheduler 直接在当前线程中执行
* Schedulers.newThread() 表示启动新的线程 并且代码在新线程中执行操作
* Schedulers.io() io操作线程(读写文件 读写数据库 网络信息交互等)
* io()与newThread()行为模式类似 区别:io()内部无数量上限的线程池
* 比newThread()更高效
* Schedulers.computation() 复杂的计算使用调度器
*
* RxAndroid中专门的AndroidSchedulers.mainThread()将操作放到android的主线程/ui线程中执行
*/
public class SchedulerActivity extends AppCompatActivity{
private ImageView iv;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
iv= (ImageView) findViewById(R.id.iv_show);
Observable.create(new Observable.OnSubscribe<Drawable>() {
@Override
public void call(Subscriber<? super Drawable> subscriber) {
Drawable drawable=getResources().getDrawable(R.mipmap.cat);
subscriber.onNext(drawable);
subscriber.onCompleted();
}
}) /**
subscribeOn()指定事件发生的线程 就是Observable.OnSubscribe被调用时所处的线程
表示Observable被观察者对象中的call方法执行的线程
*/
.subscribeOn(Schedulers.io())
/**
* observeOn() 表示Observer观察者运行的线程 事件的消费线程
*/
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Observer<Drawable>() {
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(Drawable drawable) {
iv.setImageDrawable(drawable);
}
});
}
}
如何在内部将某种类型转换成另一种类型并输出:map()可以进行事件转换
/**
* 演示 RxJava中对事件的转换
* 事件转换:将事件序列中对象或者是整个事件序列进行加工处理 转换成不同的事件序列
*/
public class MapActivity extends AppCompatActivity {
private ImageView imageView;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
imageView = (ImageView) findViewById(R.id.iv_show);
//图片的路径(字符串)--bitmap图片的对象进行展示
final String filePath = Environment.getExternalStorageDirectory().getAbsolutePath() +
File.separator + "dog.jpg";
Observable.just(filePath)
/**
* map()对事件转换的方法 参数Func1
* Func1也是RxJava中的接口 与Action1类似 用于包装具有一个参数的函数
*
* Func1和Action1的区别
* Func1 包装具有返回值的方法
* Action1 包装无返回值的方法
*
* Func1<需要转换的事件的类型,转换后的结果类型>
* Func1底层对create()方法的封装 将String字符串转换成bitmap封装到
* Observable被观察者对象中
*/
.map(new Func1<String, Bitmap>() {
@Override
public Bitmap call(String s) {
return BitmapFactory.decodeFile(s);
}
})
.subscribe(new Action1<Bitmap>() {
@Override
public void call(Bitmap bitmap) {
imageView.setImageBitmap(bitmap);
}
});
}
}
//那么如何对整个事件进行转换;
/**
* 演示RxJava中对整个事件序列的转换
*/
public class FlatMapActivity extends AppCompatActivity{
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
// //1.需求:现有一个学生类 需要打印学生的姓名
// Student student01=new Student(1,"张三");
// Student student02=new Student(2,"李斯");
// Student[] students={student01,student02};
//
// Observable.from(students)
// .map(new Func1<Student, String>() {
// @Override
// public String call(Student student) {
// return student.getName();
// }
// })
// .subscribe(new Observer<String>() {
// @Override
// public void onCompleted() {
//
// }
//
// @Override
// public void onError(Throwable e) {
//
// }
//
// @Override
// public void onNext(String s) {
// Log.i("tag","--学生姓名--"+s);
// }
// });
//2.需求:Student类中加入需要学习的课程名称 区别:每个学生只有一个名字 但是可以学习多门课程
List<Course> list01=new ArrayList<>();
list01.add(new Course(1,"语文"));
list01.add(new Course(2,"数学"));
final Student stu01=new Student(1,"张三",list01);
List<Course> list02=new ArrayList<>();
list02.add(new Course(1,"Android"));
list02.add(new Course(2,"Java"));
Student stu02=new Student(2,"李斯",list02);
Student[] stus={stu01,stu02};
// Observable.from(stus).subscribe(new Observer<Student>() {
// @Override
// public void onCompleted() {
//
// }
//
// @Override
// public void onError(Throwable e) {
//
// }
//
// @Override
// public void onNext(Student student) {
// List<Course> courses=student.getCourses();
// for(int i=0;i<courses.size();i++){
// Course c=courses.get(i);
// Log.i("tag",c.getCourseName());
// }
// }
// });
/**
* flatMap()和map()共同点 都是对传入的参数转换返回另一个对象
* 不同点:flatMap()转换后返回是Observable对象
*/
Observable.from(stus)
.flatMap(new Func1<Student, Observable<Course>>() {
@Override
public Observable<Course> call(Student student) {
return Observable.from(student.getCourses());
}
})
.subscribe(new Observer<Course>() {
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(Course course) {
Log.i("tag","----course-----"+course.getCourseName());
}
});
}
}