由于Rxjava比较强大,自然代码量也挺多,源码学习难度相当大。因此,当我分析flapMap时,已经晕了,所以决定顺藤摸瓜,以简单的代码模拟Rxjava小部分功能,相信能帮助大家理解Rxjava原理。
在阅读Rxjava源码时,我都是以观察者模式阅读,观察者频繁变换,搞得我晕晕的,可是我以生产者-消费者模式模拟Rxjava时,发现顿时豁然开朗,所以这里我以生产者-消费者模式类命名,这样更容易理解。
数据工厂(相当Rxjava的OnSubscribe接口)
public interface DataFactory <T> {
void create(Consumer<T> consumer);
}
很简单,是一个接口,用于生产者。
生产者(相当于Rxjava的Observable类,被观察者)
public class Producer <T> {
protected DataFactory<T> dataFactory;
private Producer(DataFactory<T> dataFactory) {
this.dataFactory = dataFactory;
}
public static <T> Producer<T> create(DataFactory<T> dataFactory) {
return new Producer<>(dataFactory);
}
public static <T> Producer<T> from(final T... dataSource) {
return new Producer<>(new DataFactory<T>() {
@Override
public void create(Consumer<T> consumer) {
for (T data : dataSource) {
consumer.onNext(data);
}
}
});
}
public void add(Consumer<T> producer) {
dataFactory.create(producer);
}
public <R> Producer<R> map(DataProcessor<T, R> processor) {
return new Producer<>(new MapDataFactory<>(this, processor));
}
public <R> Producer<R> flapMap(DataProcessor<T, Producer<R>> processor) {
Producer<Producer<R>> mapProducer = map(processor);
return new Producer<>(new FlapMapDataFactory<>(mapProducer.dataFactory));
}
}
目前只是实现了map和flapMap方法,我们先看代码,稍后我会详细分析,耐心看下去。
消费者(相当于Rxjava的Observer接口,观察者)
public interface Consumer <T> {
void onCompleted();
void onNext(T result);
void onError(Exception exception);
}
和Rxjava的Observer一样。
数据加工接口(相当于Rxjava的Func接口)
public interface DataProcessor<T, R> {
R process(T data);
}
也是模仿Rxjava的。
MapDataFactory
public class MapDataFactory <T, R> implements DataFactory <R> {
private Producer<T> source;
private DataProcessor<T, R> processor;
public MapDataFactory(Producer<T> source, DataProcessor<T, R> processor) {
this.source = source;
this.processor = processor;
}
@Override
public void create(Consumer<R> consumer) {
MapConsumer<T, R> mapConsumer = new MapConsumer<>(consumer, processor);
source.add(mapConsumer);
}
public class MapConsumer<T, R> implements Consumer <T> {
private Consumer<R> source;
private DataProcessor<T, R> processor;
public MapConsumer(Consumer<R> source, DataProcessor<T, R> processor) {
this.source = source;
this.processor = processor;
}
@Override
public void onCompleted() {
source.onCompleted();
}
@Override
public void onNext(T result) {
try {
R processResult = processor.process(result);
source.onNext(processResult);
} catch (Exception e) {
onError(e);
}
}
@Override
public void onError(Exception exception) {
source.onError(exception);
}
}
}
暂时先看代码,待会分析,再耐心一下下。
FlapMapDataFactory
public class FlapMapDataFactory <R> implements DataFactory <R> {
private DataFactory<Producer<R>> dataFactory;
public FlapMapDataFactory(DataFactory<Producer<R>> dataFactory) {
this.dataFactory = dataFactory;
}
@Override
public void create(Consumer<R> consumer) {
FlapMapConsumer flapMapConsumer = new FlapMapConsumer(consumer);
dataFactory.create(flapMapConsumer);
}
public class FlapMapConsumer <R> implements Consumer<Producer<R>> {
private Consumer<R> source;
public FlapMapConsumer(Consumer<R> source) {
this.source = source;
}
@Override
public void onCompleted() {
source.onCompleted();
}
@Override
public void onNext(Producer<R> result) {
result.add(source);
}
@Override
public void onError(Exception exception) {
source.onError(exception);
}
}
}
好了,以上是我模拟实现Rxjava所写的类,差不多都是Rxjava的核心代码了。代码量很少吧(高兴一下),接下来我们分析一下!!!
基本流程
先上一个例子:
Producer.create(new DataFactory<Student>() {
@Override
public void create(Consumer<Student> consumer) {
Student student1 = new Student("小明", 20, "高数", "线性代数", "统计学");
Student student2 = new Student("晓晓", 21, "英语", "电子信息技术", "统计学");
consumer.onNext(student1);
consumer.onNext(student2);
consumer.onCompleted();
}
}).add(new Consumer<Student>() {
@Override
public void onCompleted() {
Log.e(getClass().getName(), "completed is called");
}
@Override
public void onNext(Student result) {
Log.e(getClass().getName(), "student name : " + result.name);
}
@Override
public void onError(Exception exception) {
Log.e(getClass().getName(), "error is called");
}
});
// Student类
class Student {
String name;
int age;
String[] courses;
public Student(String name, int age, String... courses) {
this.name = name;
this.age = age;
this.courses = courses;
}
}
是不是和Rxjava很相似,必须的!
先看Producer的create方法:
// Producer类
protected DataFactory<T> dataFactory;
public static <T> Producer<T> create(DataFactory<T> dataFactory) {
return new Producer<>(dataFactory);
}
和Rxjava一样,创建一个带有数据工厂的生产者,我们再来看add方法:
// Producer类
public void add(Consumer<T> producer) {
dataFactory.create(producer);
}
调用了数据工厂的create方法,开始产生数据。或许你会有疑问,Rxjava有这么简单?就是这么简单!!
所以例子中的DataFactory的call方法就会执行:
// 例子new的DataFactory
@Override
public void create(Consumer<Student> consumer) {
Student student1 = new Student("小明", 20, "高数", "线性代数", "统计学");
Student student2 = new Student("晓晓", 21, "英语", "电子信息技术", "统计学");
consumer.onNext(student1);
consumer.onNext(student2);
consumer.onCompleted();
}
产生student1和student2后,便开始调用消费者的onNext和onCompleted方法,其实Rxjava的基本流程也就这么简单。
map变换
接下来看看map变换,先来个例子:
Producer.create(new DataFactory<Student>() {
@Override
public void create(Consumer<Student> consumer) {
Student student1 = new Student("小明", 20, "高数", "线性代数", "统计学");
Student student2 = new Student("晓晓", 21, "英语", "电子信息技术", "统计学");
consumer.onNext(student1);
consumer.onNext(student2);
consumer.onCompleted();
}
}).map(new DataProcessor<Student, String>() {
@Override
public String process(Student data) {
return data.name;
}
}).add(new Consumer<String>() {
@Override
public void onCompleted() {
Log.e(getClass().getName(), "completed is called");
}
@Override
public void onNext(String result) {
Log.e(getClass().getName(), "student name : " + result);
}
@Override
public void onError(Exception exception) {
Log.e(getClass().getName(), "error is called");
}
});
map中,把Student“加工”为String类型,再交给消费者处理,看看map方法:
// Producer类
public <R> Producer<R> map(DataProcessor<T, R> processor) {
return new Producer<>(new MapDataFactory<>(this, processor));
}
创建了新的数据工厂MapDataFactory,返回了新的生产者。当新的生产者调用add方法时,MapDataFactory的create方法就会执行:
// MapDataFactory类
private Producer<T> source;
private DataProcessor<T, R> processor;
@Override
public void create(Consumer<R> consumer) {
MapConsumer<T, R> mapConsumer = new MapConsumer<>(consumer, processor);
source.add(mapConsumer);
}
因为生产者Producer生产T类型数据,而消费者Consumer要消费R类型数据,所以必须要个代理类MapConsumer,利用数据加工接口DataProcessor,把生产者Producer生产T类型数据转为R类型数据,再交给消费者Consumer去消费,代理类MapConsumer充当了加工厂的角色。
当调用source(一开始创建的Producer)的add(mapConsumer)方法时,source自带的数据工厂DataFactory(一开始new出来的DataFactory)的create方法便会执行,当执行
// 此时的消费者是代理消费者MapConsumer
consumer.onNext(student1);
MapConsumer的onNext就会执行:
// MapConsumer类
@Override
public void onNext(T result) {
try {
// 数据加工
R processResult = processor.process(result);
// 通知消费者
source.onNext(processResult);
} catch (Exception e) {
onError(e);
}
}
MapConsumer的onNext方法会先把数据“加工”,然后交给消费者处理,这样就完成整个流程。
flapMap变换
map方法比较简单,相信把大家难倒的地方是flapMap方法,我们还是先来一个例子:
Producer.create(new DataFactory<Student>() {
@Override
public void create(Consumer<Student> consumer) {
Student student1 = new Student("小明", 20, "高数", "线性代数", "统计学");
Student student2 = new Student("晓晓", 21, "英语", "电子信息技术", "统计学");
consumer.onNext(student1);
consumer.onNext(student2);
consumer.onCompleted();
}
}).flapMap(new DataProcessor<Student, Producer<String>>() {
@Override
public Producer<String> process(Student data) {
return Producer.from(data.courses);
}
}).add(new Consumer<String>() {
@Override
public void onCompleted() {
Log.e(getClass().getName(), "completed is called");
}
@Override
public void onNext(String result) {
Log.e(getClass().getName(), "course name : " + result);
}
@Override
public void onError(Exception exception) {
Log.e(getClass().getName(), "error is called");
}
});
flapMap方法可以由一个数据生成新的生产者,例子中,DataFactory中的create调用了两次onNext方法:
consumer.onNext(student1);
consumer.onNext(student2);
flapMap会创建两个生产者:
Producer.from(data.courses);
每个生产者的数据工厂DataFactory的create方法又会执行很多次(学生的课程数量)onNext方法,这样达到数据“平铺”的作用,在实际使用中有很大的用处。
-> onNext() -> ...
每个onNext() -> 新的Producer -> onNext() -> ...
-> onNext() -> ...
OK,我们来分析一下,首先是flapMap方法:
// Producer类
public <R> Producer<R> flapMap(DataProcessor<T, Producer<R>> processor) {
Producer<Producer<R>> mapProducer = map(processor);
return new Producer<>(new FlapMapDataFactory<>(mapProducer.dataFactory));
}
先调用了map方法:
Producer<T> -----> Producer<Producer<R>>
然后创建了新的数据工厂FlapMapDataFactory,返回了新的生产者。当新的生产者调用add方法时,FlapMapDataFactory的create方法就会执行:
// FlapMapDataFactory类
// DataFactory<Producer<R>>是mapProducer的数据工厂MapDataFactory
private DataFactory<Producer<R>> dataFactory;
@Override
public void create(Consumer<R> consumer) {
// Consumer<R> -> Consumer<Producer<R>>, 由Consumer<Producer<R>>代理Consumer<R>
FlapMapConsumer flapMapConsumer = new FlapMapConsumer(consumer);
dataFactory.create(flapMapConsumer);
}
这里必须要调用mapProducer的数据工厂MapDataFactory的create方法,要不然程序链就断了。FlapMapDataFactory的create方法参数是R类型消费者Consumer,而此时的MapDataFactory的create方法需要的是Producer《R》类型消费者Consumer,所以需要一个FlapMapConsumer 代理类去转换。
dataFactory.create(flapMapConsumer)调用之后,MapDataFactory的create方法开始执行,这又回到map方法分析了:
// source是最开始的Producer
private Producer<T> source;
// flapMap方法传入的DataProcessor<T, Producer<R>>
private DataProcessor<T, R> processor;
@Override
// 此时的consumer为Consumer<Producer<R>>类型
public void create(Consumer<R> consumer) {
MapConsumer<T, R> mapConsumer = new MapConsumer<>(consumer, processor);
source.add(mapConsumer);
}
source执行后,执行最开始的数据工厂DataFactory的create方法开始执行:
// source就是Producer.create这个生产者
Producer.create(new DataFactory<Student>() {
@Override
// 所以这个create方法会执行,此时的consumer为MapConsumer
public void create(Consumer<Student> consumer) {
Student student1 = new Student("小明", 20, "高数", "线性代数", "统计学");
Student student2 = new Student("晓晓", 21, "英语", "电子信息技术", "统计学");
consumer.onNext(student1);
consumer.onNext(student2);
consumer.onCompleted();
}
})...
当执行consumer.onNext(student1)时,MapConsumer的onNext方法会执行:
// MapConsumer类
// 此时的T为Student,R为Producer<String>类型
private Consumer<R> source;
private DataProcessor<T, R> processor;
@Override
public void onNext(T result) {
try {
// Student -> Producer<String>
R processResult = processor.process(result);
source.onNext(processResult);
} catch (Exception e) {
onError(e);
}
}
数据转换之后,调用source的onNext方法,source是FlapMapDataFactory的create方法创建的代理类:
// FlapMapDataFactory类
@Override
public void create(Consumer<R> consumer) {
// source就是flapMapConsumer这个代理类
FlapMapConsumer flapMapConsumer = new FlapMapConsumer(consumer);
dataFactory.create(flapMapConsumer);
}
所以FlapMapConsumer的onNext会执行:
public class FlapMapConsumer <R> implements Consumer<Producer<R>> {
// 下一个消费者,此时的source为Consumer<String>,也就是例子中最后调用add方法的消费者
private Consumer<R> source;
@Override
// result是MapConsumer的onNext方法加工后的生产者
public void onNext(Producer<R> result) {
// 因为此时的result是一个生产者,不再是一个具体的数据,可以再次add下一个消费者
result.add(source);
}
}
调用result.add(source)后,新的生产者的数据工厂的create方法便会执行:
...
.flapMap(new DataProcessor<Student, Producer<String>>() {
@Override
public Producer<String> process(Student data) {
// result就是Producer.from(data.courses)这个生产者
return Producer.from(data.courses);
}
})
// source就是最后new出来的Consumer消费者
.add(new Consumer<String>() {
@Override
public void onCompleted() {
Log.e(getClass().getName(), "completed is called");
}
@Override
public void onNext(String result) {
Log.e(getClass().getName(), "course name : " + result);
}
@Override
public void onError(Exception exception) {
Log.e(getClass().getName(), "error is called");
}
});
于是乎,上面的代码相当于
Producer.from(data.courses)
.add(new Consumer<String>() {
@Override
public void onCompleted() {
Log.e(getClass().getName(), "completed is called");
}
@Override
public void onNext(String result) {
Log.e(getClass().getName(), "course name : " + result);
}
@Override
public void onError(Exception exception) {
Log.e(getClass().getName(), "error is called");
}
});
...
这就是flapMap的基本原理。
代码已经上传到我的github库,地址:https://github.com/JohanMan/simplerxjava