Rxjava

由于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@Overridepublic 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;@Overridepublic 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方法便会执行，当执行

// 此时的消费者是代理消费者MapConsumerconsumer.onNext(student1);

MapConsumer的onNext就会执行：

// MapConsumer类@Overridepublic 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的数据工厂MapDataFactoryprivate DataFactory<Producer<R>> dataFactory;@Overridepublic 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是最开始的Producerprivate 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;@Overridepublic 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类@Overridepublic 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