Rxjava(Subject)-一个综合例子

这个例子来自http://blog.piasy.com/AdvancedRxJava/2016/10/03/subjects-part-1/

package com.test;

import rx.Observable;
import rx.Observer;
import rx.functions.Action1;
import rx.functions.Func1;
import rx.observers.Observers;
import rx.observers.SerializedObserver;
import rx.subjects.BehaviorSubject;
import rx.subjects.PublishSubject;
import rx.subjects.Subject;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * Created by leaves on 2016/10/28.
 */
public class MoreReactiveList<T> {
    public enum ChangeType {
        ADD, REMOVE
    }

    ;

    final List<T> list = new ArrayList<>();

    final Subject<ChangeType, ChangeType> changes;  // (1)
    final Subject<T, T> changeValues;
    final Observer<T> addObserver;                  // (2)
    final Observer<T> removeObserver;

    public Observable<ChangeType> changes() {
        return changes;
    }

    public Observable<T> changeValues() {
        return changeValues;
    }

    public Observable<T> list() {                   // (3)
        List<T> copy = new ArrayList<>();
        synchronized (list) {
            copy.addAll(list);
        }
        return Observable.from(copy);
    }

    public Observer<T> adder() {                    // (4)
        return addObserver;
    }

    public Observer<T> remover() {
        return removeObserver;
    }

    void onAdd(T value) {                           // (5)
        synchronized (list) {
            list.add(value);
        }
        changes.onNext(ChangeType.ADD);
        changeValues.onNext(value);
    }

    void onRemove(T value) {
        synchronized (list) {
            if (!list.remove(value)) {
                return;
            }
        }
        changes.onNext(ChangeType.REMOVE);
        changeValues.onNext(value);
    }

    void clear() {
        synchronized (list) {
            list.clear();
        }
    }

    public MoreReactiveList() {
        changes =
                PublishSubject.<ChangeType>create()
                        .toSerialized();                     // (1)

        changeValues =
                BehaviorSubject.<T>create()
                        .toSerialized();

        addObserver = new SerializedObserver<>(      // (2)
                Observers.create(
                        this::onAdd,
                        t -> {
                            clear();
                            changes.onError(t);
                            changeValues.onError(t);
                        },
                        () -> {
                            clear();
                            changes.onCompleted();
                            changeValues.onCompleted();
                        }
                ));
        removeObserver = new SerializedObserver<>(   // (3)
                Observers.create(
                        this::onRemove,
                        t -> {
                            clear();
                            changes.onError(t);
                            changeValues.onError(t);
                        },
                        () -> {
                            clear();
                            changes.onCompleted();
                            changeValues.onCompleted();
                        }
                ));
    }

    public static void main(String[] args) {
        MoreReactiveList<Long> list = new MoreReactiveList<>();

        Observable.timer(0, 1, TimeUnit.SECONDS)
                .take(10)
                .subscribe(list.adder());

        Observable.timer(4, 1, TimeUnit.SECONDS)
                .take(10)
                .subscribe(list.remover());

        list.changes().subscribe(new Action1<ChangeType>() {
            @Override
            public void call(ChangeType changeType) {
                System.out.println("changeType:" + changeType);
            }
        });//打印变化类型

        list.changes()
                .flatMap(new Func1<ChangeType, Observable<List<Long>>>() {
                    @Override
                    public Observable<List<Long>> call(ChangeType changeType) {
                        return list.list().toList();
                    }
                })
                .subscribe(new Action1<List<Long>>() {
                    @Override
                    public void call(List<Long> longs) {
                        System.out.println("cur list:" + longs);
                    }
                });

        list.changeValues.toBlocking().forEach(new Action1<Long>() {
            @Override
            public void call(Long aLong) {
                System.out.println("changeValues:" + aLong);
            }
        });//打印变化的值
    }
}

输出：

changeValues:0
changeType:ADD
cur list:[0, 1]
changeValues:1
changeType:ADD
cur list:[0, 1, 2]
changeValues:2
changeType:ADD
cur list:[0, 1, 2, 3]
changeValues:3
changeType:ADD
cur list:[0, 1, 2, 3, 4]
changeValues:4
changeType:REMOVE
cur list:[1, 2, 3, 4]
changeValues:0
changeType:ADD
cur list:[1, 2, 3, 4, 5]
changeValues:5
changeType:REMOVE
cur list:[2, 3, 4, 5]
changeValues:1
changeType:ADD
cur list:[2, 3, 4, 5, 6]
changeValues:6
changeType:REMOVE
cur list:[3, 4, 5, 6]
changeValues:2
changeType:ADD
cur list:[3, 4, 5, 6, 7]
changeValues:7
changeType:REMOVE
cur list:[4, 5, 6, 7]
changeValues:3
changeType:ADD
cur list:[4, 5, 6, 7, 8]
changeValues:8
changeType:REMOVE
cur list:[5, 6, 7, 8]
changeValues:4
changeType:ADD
cur list:[5, 6, 7, 8, 9]
changeValues:9