android架构中的观察者与被观察者

测试

private void test() {
        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(Emitter<String> emitter) {
                emitter.onNext("hello");
            }
        }).map(new Function<String, String>() {

            @Override
            public String apply(String s) {
                return new StringBuilder().append(s).append("-hello").toString();
            }
        }).subscribeObserver(new Observer<String>() {
            @Override
            public void onNext(String string) {
                LogUtil.d(string);
            }

            @Override
            public void onSubscribe() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
    }

Observable

package com.coral3.common_module.observer;

import com.coral3.common_module.observer.mapop.Function;
import com.coral3.common_module.observer.mapop.ObservableMap;

public abstract class Observable<T> implements ObservableSource{

    @Override
    public void subscribeObserver(Observer observer) {
        // 把此功能交给不同的Observable处理
        subscribleActual(observer);
    }

    // 模板方法
    protected abstract void subscribleActual(Observer observer);

    // 创建具体被观察者
    public static <T> Observable create(ObservableOnSubscribe<T> source){
        return new ObservableCreate<>(source);
    }

    public <U> Observable map(Function<T, U> function){
        return new ObservableMap(this, function);
    }
}

Emitter

package com.coral3.common_module.observer;

/**
 * 给用户发消息
 */
public interface Emitter<T> {

    // 接收消息
    void onNext(T t);

    // 接收异常消息
    void onError(Throwable e);

    // 接收消息完成
    void onComplete();
}

ObservableCreate

package com.coral3.common_module.observer;

/**
 * 具体观察者
 */
public class ObservableCreate<T> extends Observable{

    ObservableOnSubscribe<T> source;

    public ObservableCreate(ObservableOnSubscribe<T> source) {
        this.source = source;
    }

    @Override
    protected void subscribleActual(Observer observer) {
        observer.onSubscribe();
        // 创建发射器
        CreateEmitter createEmitter = new CreateEmitter(observer);
        source.subscribe(createEmitter);
    }

    static final class CreateEmitter<T> implements Emitter<T>{

        final Observer<T> observer;

        public CreateEmitter(Observer<T> observer) {
            this.observer = observer;
        }

        @Override
        public void onNext(T t) {
            observer.onNext(t);
        }

        @Override
        public void onError(Throwable e) {
            observer.onError(e);
        }

        @Override
        public void onComplete() {
            observer.onComplete();
        }
    }
}

ObservableOnSubscribe

package com.coral3.common_module.observer;

/**
 * 绑定发射器 被观察者和发射器分离了
 * @param <T>
 */
public interface ObservableOnSubscribe<T> {

    void subscribe(Emitter<T> emitter);
}

ObservableSource

package com.coral3.common_module.observer;

public interface ObservableSource {

    // 订阅功能 绑定ObserverableSource与Observer
    void subscribeObserver(Observer observer);
}

Observer

package com.coral3.common_module.observer;

public interface Observer<T> {

    // 接收消息
    void onNext(T t);

    // 建立关联时调用
    void onSubscribe();

    // 接收异常消息
    void onError(Throwable e);

    // 接收消息完成
    void onComplete();
}

AbstractObservableWithUpStream

package com.coral3.common_module.observer.mapop;

import com.coral3.common_module.observer.Observable;
import com.coral3.common_module.observer.ObservableSource;

/**
 * 装饰器类
 * @param <T>
 * @param <U>
 */
public abstract class AbstractObservableWithUpStream<T, U> extends Observable {

    protected final ObservableSource source;

    public AbstractObservableWithUpStream(ObservableSource source) {
        this.source = source;
    }
}

BasicFuseableObserver

package com.coral3.common_module.observer.mapop;

import com.coral3.common_module.observer.Observer;

public abstract class BasicFuseableObserver<T, U> implements Observer<T> {

    protected final Observer<U> actual;

    public BasicFuseableObserver(Observer<U> actual) {
        this.actual = actual;
    }
}

Function

package com.coral3.common_module.observer.mapop;

/**
 * 事件变换
 */
public interface Function<T, R> {

    R apply(T t);
}

ObservableMap

package com.coral3.common_module.observer.mapop;

import com.coral3.common_module.observer.ObservableSource;
import com.coral3.common_module.observer.Observer;

public class ObservableMap<T, U> extends AbstractObservableWithUpStream<T, U>{

    final Function<T, U> function;

    public ObservableMap(ObservableSource source, Function<T, U> function) {
        super(source);
        this.function = function;
    }

    @Override
    protected void subscribleActual(Observer observer) {
        source.subscribeObserver(new MapObserver(observer, function));
    }

    static final class MapObserver<T, U> extends BasicFuseableObserver<T, U>{

        final Function<T, U> mapper;

        public MapObserver(Observer<U> actual, Function<T, U> mapper) {
            super(actual);
            this.mapper = mapper;
        }

        @Override
        public void onNext(T t) {
            U apply = mapper.apply(t);
            actual.onNext(apply);
        }

        @Override
        public void onSubscribe() {

        }

        @Override
        public void onError(Throwable e) {

        }

        @Override
        public void onComplete() {

        }
    }
}