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
@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