Reactor/WebFlux 的类型推断和类型变异问题

Question

假设有一个接口及其实现类：

public interface InterfaceA {}

public class ClassA implements InterfaceA {

    public static Mono<ClassA> getMonoA() {
        return Mono.empty();
    }

}

然后，对于方法 Mono; getMonoA()，以下实现会导致编译错误：

Mono<InterfaceA> getMonoA() {
    return ClassA.getMonoA();
}

不变类型 Mono 不是 Mono 的超类是有道理的> 即使 InterfaceA 是 ClassA 的超类，因此 ClassA.getMonoA() 的返回类型是Mono 与 Mono 不匹配。

但是，以下实现可以正常工作：

Mono<InterfaceA> getMonoA() {
    return Mono.just(new ClassA());
}

Mono.just 方法实际上定义为 public static;单声道只是（T数据）。由于我的例子中的通用类型 T 是 ClassA，该方法应该返回 Mono 的类型，这也应该引发编译错误在我心里。

我想知道是否有一些机制让 Mono.just 方法返回 Mono 而不是 Mono ？

Answer 1

这就是java泛型的工作方式。在第二个示例中，java 编译器可以推断类型。这与定义相同

Mono<InterfaceA> getMonoA() {
   return Mono.<InterfaceA>just(new ClassA());
}

但在第一个示例中编译器无法自动将 Mono 转换为 Mono 但您可以通过应用映射函数来转换

Mono<InterfaceA> getMonoA() {
     return ClassA.getMonoA1().map(Function.identity());
}

它与定义 .map(c -> c) 或 .map(c -> (InterfaceA) c) 相同。

或者您可以将您的方法定义为

public static <T extends InterfaceA> Mono<T> getMonoA() {
    return ClassA.getMonoA();
}

类似于 Mono.just 的定义方式。

由于类型擦除，Mono; 和 Mono 在运行时将是 Mono，因此不会对元素类型进行真正的类型检查。您可以使用在这种情况下有效的不安全强制转换，但当您尝试访问该对象时可能会导致 ClassCastException

Mono<InterfaceA> getMonoA() {
    return (Mono) ClassA.getMonoA();
}

这不是 Reactor 或 WebFlux 特有的东西。这对于任何泛型类型都有效。例如，List 与 List。

Answer 2

我认为看待这个问题的一种方法是编译器如何解释类​​型 T 。如果您定义

interface InterfaceB {
}

static class ClassB implements InterfaceB {
}

，则以下内容将不会编译（如预期），

    Mono<InterfaceA> getMonoTest() {
    return Mono.just(new ClassB());     
    }

并显示类似于此的消息

类型不匹配：无法从 Mono转换；到 Mono

因此编译器会检查类型 T 是否对应于方法的返回类型。 MonoJust 是 已定义作为通用发布者，您返回的是 MonoJust 而不是 MonoJust。

final class MonoJust<T> extends Mono<T> ...

final T value;
MonoJust(T value) {
    this.value = Objects.requireNonNull(value, "value");
}

另一方面，MonoEmpty是定义为Publisher

final class MonoEmpty extends Mono<Object> ....

static final Publisher<Object> INSTANCE = new MonoEmpty();

MonoEmpty() {
    // deliberately no op
}

并且您必须定义类型边界：

Mono<? extends InterfaceA> getMonoA()