RxJava 2.0转换为泛型会丢失所有类型

我们对同一个流有两个稍微不同的实现,我一直在尝试统一它们,但运气不太好——只要我开始使用泛型父类型, subscribe() 丢失所有类型并返回对象。

代码如下(简化一点以匹配NDA):

// MyStuff is a base class, which has two child classes inheriting
// Base processing is done in the abstract class, while type-specific
// processing is done in ParserOne and ParserTwo
public abstract class ParserBase<T extends MyStuff> {
    // This call will be specific to the actual MyStuffOne or MyStuffTwo objects, hence abstract
    public abstract Flowable<TargetModel> parse(Flowable<T> parsestuff);
    // These two calls are applied to the generic MyStuff class
    // and are shared between MyStuffOne and MyStuffTwo 
    public Flowable<Map<long,MyModel>> parseOneImpl(Flowable<T> parsestuff) { /* impl here */ }
    public Single<Map<long,MyModel>> parseTwoImpl(Flowable<T> parsestuff) { /* impl here */ }
}

public class MyStuff {
    // Some common fields here
}

public class MyStuffOne extends MyStuff {
    // Some MyStuffOne specific fields here
}

public class MyStuffTwo extends MyStuff {
    // Some MyStuffTwo specific fields here
}

public class ParserOne extends ParserBase<MyStuffOne> {
    @Override 
    public Flowable<TargetModel> parse(Flowable<MyStuffOne> parsestuff) { /* impl 1 here */ }
}

public class ParserTwo extends ParserBase<MyStuffTwo> {
    @Override 
    public Flowable<TargetModel> parse(Flowable<MyStuffTwo> parsestuff) { /* impl 2 here */ }
}

public class MyClassOne {

    protected void call() {
        ParserOne parser = new ParserOne();
        callGeneric(parser);
    }

    protected void callGeneric(ParserBase<?> parser) {
        // Common implementation here
        parser.parseOneImpl(whatever).subscribe(
            result -> { /* result ends up being Object instead of Map<Long,MyModel> */ }, 
            throwable -> { /* throwable also ends up being Object */ });
    }
}

public class MyClassTwo extends MyClassOne {
    @Override
    protected void call() {
        ParserTwo parser = new ParserTwo();
        callGeneric(parser);
    }
}

parseOneImpl() 调用有一个泛型参数,它有一个固定的返回类型-但是出于某种原因, 订阅() parseOneImpl()

我在这里做错什么了?