观察者模式java
观察者模式三个角色react
观察者：监视被观察者的行为，当被观察者的某个状态改变的时候,观察者会进行对应的操做android
被观察者：被监视的对象，当某个状态改变的时候会通知观察者数据库
订阅：帮观察者和被观察者创建关系网络
Rxjava异步
使用可观测的序列来组成异步的 基于事件的程序的库ide
rxjava 是程序的库 是异步 基于事件的 使用可观测的序列来组成 线程
Rxjava 运用观察者模式code
三个角色是server
一、观察者 是 Observer : 决定事件触发的时候有怎样的行为,换句话说当被观察者某个状态改变时,观察者应该作些什么行为.Rxjava观察者的事件回调方法有普通事件onNext().还有特殊事件onCompleted()和onError().
onNext()：至关于被观察者button触发点击行为，观察者onClickListener()把处理行为回调给了onClick()方法.
onCompleted() 事件队列完成完结.Rxjava不只把每一个事件单独处理,还会把它们当作一个队列。Rxjava规定当再也不发出onNext(),须要触发onCompleted()做为标志完结
onError() 事件队列异常.在事件处理异常时,会触发onError(),同时队列自动中止,不容许再有事件触发
备注：在一个正常运行的事件序列中,onCompleted()和onErro()有且只有一个,而且是事件序列的最后一个.onCompleted()和onError(是相互排斥的,即在队列中调用一个就不应再调用另外一个
二、被观察者 是 Observable,它决定何时触发以及触发什么样的事件,可使用create()、just(T...)、from(T[])、from(Iterable<? extend ?>)来建立一个Observable，并为它定义触发规则
三、订阅 是 subscribe().在Observer和Observable建立之后,再用subscribe()把它们联系起来
代码运用:
一、依赖
compile 'io.reactivex:rxjava:1.0.14' compile 'io.reactivex:rxandroid:1.0.1'
二、代码简单编写
Observer<String> observer = new Observer<String>() {
@Override
public void onCompleted() {
System.out.println("--data-completed");
}
@Override
public void onError(Throwable e) {
System.out.println("--data-"+e.getMessage());
}
@Override
public void onNext(String s) {
System.out.println("--data-"+s);
}
};
Subscriber<String> subscriber = new Subscriber<String>() {
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(String s) {
}
@Override
public void onStart() {
super.onStart();
}
};
// Observable observable = Observable.create(new Observable.OnSubscribe<String>() {
//
// @Override
// public void call(Subscriber<? super String> subscriber) {
// subscriber.onNext("hello");
// subscriber.onNext("world");
// subscriber.onCompleted();
// }
// });
// Observable observable = Observable.just("h", "w");
// Observable observable = Observable.from(new String[] {"gg", "sss"});
List<String> list = new ArrayList<>();
list.add("1");
list.add("2");
Observable observable = Observable.from(list);
observable.subscribe(observer);
// observable.subscribe(subscriber);
Action
Action用法:简化代码,若不想实现观察者Observer中onError()、onCompleted()
Observable.from(new String[] {"sss","aaa"}).subscribe(new Action1<String>() {
@Override
public void call(String s) {
System.out.println("--data"+s);
}
});
Action是Rxjava的一个接口,分开实现替代onNext()、onError()、onCompleted()
Action1<String> nextAction = new Action1<String>() {
@Override
public void call(String s) {
System.out.println("--data"+s);
}
};
Action1<Throwable> onErrorAction = new Action1<Throwable>() {
@Override
public void call(Throwable throwable) {
}
};
Action0 action0 = new Action0() {
@Override
public void call() {
}
};
Observable.from(new String[]{"1111"}).subscribe(nextAction, onErrorAction, action0);
Action0 : 它只有一个方法call()无参数无返回值,onCompleted()也是无参数无返回值.所以Action0能够被看成一个包装对象,将onCompleted()的内容打包起来将本身做为一个参数传入subscribe()中以实现不完整的回调.
Action1：它只有一个call()无返回值,可是有参数，与oNext(String s)、onError(Throwable t)一样是有参数无返回值,同上能够传入到subscribe()中实现不完整定义的回调.
Rxjava Map的使用 类型转换 规定输出的值
一、Func1介绍
Func1与上文的Action1类似，不一样的是Func1有返回值
Student s1 = new Student();
s1.setAge("11");
s1.setName("s");
Student s2 = new Student();
s2.setName("a");
s2.setAge("22");
Observable.just(s1, s2).map(new Func1<Student, String>() {
@Override
public String call(Student student) {
return student.getName();
}
}).map(new Func1<String, Integer>() {
@Override
public Integer call(String s) {
return s.hashCode();
}
}).map(new Func1<Integer, String>() {
@Override
public String call(Integer integer) {
return integer+"";
}
}).subscribe(new Action1<String>() {
@Override
public void call(String s) {
System.out.println("--data"+s);
}
});
Rxjava flatMap的使用
一对多
List<Student> mlist = new ArrayList<>();
Student s1 = new Student();
s1.setAge("22");
s1.setName("a");
List<Course> courses = new ArrayList<>();
final Course course = new Course();
course.setId("1");
course.setName("sss");
courses.add(course);
s1.setMlist(courses);
mlist.add(s1);
Observable.from(mlist).flatMap(new Func1<Student, Observable<Course>>() {
@Override
public Observable<Course> call(Student student) {
return Observable.from(student.getMlist());
}
}).subscribe(new Action1<Course>() {
@Override
public void call(Course course) {
System.out.println("--data"+course.getName());
}
});
Scheduler 线程控制器,能够指定每一段代码在什么样的线程中执行。
Observable.just("1", "2")
.subscribeOn(Schedulers.newThread())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Observer<String>() {
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(String s) {
}
});
代码中的subscribeOn()指定发生的线程.observerOn()指定消费的线程
Scheduler.immediate() ：直接在当前线程中运行
Scheduler.newThread() ：老是启动新线程
Scheduler.io : 读写文件、网络信息交互、数据库读写.与newThread()差很少,区别io是一个无数量上限的线程池.能够重用空闲的线程。
Scheduler.computation()：计算所使用的Scheduler.
AndroidScheduler.mainThread() : 在主线程中操做