从子类到超类再回来

Question

所以想象一下，

给定一个类层次结构：

S (abstract)
A extends S
B extends S

假设我们有一个连接组件链来处理 A 和 B 类型的对象。例如： K1.handle(A) -> K2.handle(A) -> K3.handle(A) 意思是 K1 接受 A 并用 A 调用 K2，它用 A 调用 K3。

同样我们有： K1.handle(B) -> K2.handle(B) -> K3.handle(B)

事情是K2的逻辑不依赖于S的子类型。所以我们可以用K2.handle(S)替换K2.handle(A)和K2.handle(B)。但问题是在某些时候我们需要对实际对象类型进行类型检查才能调用正确的 K3 方法。

如果不执行检查实际对象的类型/属性的if 或switch 等语句，如何解决这个问题？

这是我需要研究的访问者模式吗？

举一个具体的例子。假设 K1 是一个 REST 控制器，A 和 B 具有不同的 POST 端点。它反序列化有效负载并验证数据，然后将对象传递给 K2 进行进一步处理。 K2 中包含的所有步骤（以及它调用的其他组件）都只适用于 S 类型的对象。但在 K3 的最后，我们需要知道 S 的实际类型。

Answer 1

但在 K3 的最后，我们需要知道 S 的实际类型。

所以K2.handle() 中的所有逻辑都在调用K3.handle() 之前。

另外，由于K3.handle(A) 和K3.handle(B) 不能是K3.handle(S)，根据查询的措辞，看起来K3.handle() 是一个重载方法，即使问题中没有明确说明。

这样做的一种方法是将通用逻辑移至内部辅助方法：

public class K2 {
    public void handle(A a) {
        handleInternal(a);
        K3.handle(a);
    }
    public void handle(B b) {
        handleInternal(b);
        K3.handle(b);
    }
    private void handleInternal(S s) {
        // K2 logic here
    }
}

或者您可以使用方法引用，允许对 K3 的调用嵌入到 K2 逻辑中，而不仅仅是在末尾：

public class K2 {
    public void handle(A a) {
        handleInternal(a, K3::handle); // method reference to K3.handle(A)
    }
    public void handle(B b) {
        handleInternal(b, K3::handle); // method reference to K3.handle(B)
    }
    private <T extends S> void handleInternal(S s, Consumer<T> k3_handle) {
        // Some K2 logic here
        k3_handle.accept(s);
        // More K2 logic here
    }
}

Answer 2

给定示例类：

class S {}

class A extends S {
    public int getAInfo() {
        return 1;
    }
}

class B extends S {
    public int getBInfo() {
        return 2;
    }
}

我们可以创建一个利用有界类型参数的接口K，如下所示：

@FunctionalInterface
interface K<T extends S> {
    void handle(T s);

    @SafeVarargs
    static <FT extends S> K<FT> compose(K<FT> finalK, K<? super FT>... ks) {
        return s -> {
            Stream.of(ks).forEach(k -> k.handle(s));
            finalK.handle(s);
        };
    }
}

然后我们可以使用K.construct 来创建K 的新实例，它将在Ks 的整个管道中转发s。 Ks 的这个管道的结构使得除了最后一个k 之外的所有都是通用处理程序，接受S 的任何实例。只有最后一个会接受S 的特定子类的实例，即FT（“final type”的缩写）。

有了这个K 定义，下面的所有语句都会编译：

K<S> k1 = s -> System.out.println("K1 handled.");
K<S> k2 = s -> System.out.println("K2 handled.");
K<A> k3A = a -> System.out.println(a.getAInfo());
K<B> k3B = b -> System.out.println(b.getBInfo());

K.compose(k3A, k1, k2).handle(new A()); // Propagates instance of A through pipeline
K.compose(k3B, k1, k2).handle(new B()); // Propagates instance of B through pipeline

然而，管道中所有Ks 的临时多态性仍然保留，不是最后一个k，因为这两个语句也可以编译：

k1.handle(new S());
k2.handle(new S());

我在这个解决方案中看到的一个缺点是，与其他答案不同，K 处理程序必须严格按顺序执行，并且对下一个k 处理程序的调用不能发生在前一个的中间。通过我仍然认为您可以扩展这种类型的设计以支持它。

Answer 3

是的，这是访问者模式。

访问者是

interface K {
    void handle(A a);
    void handle(B b);
}

和K1、K2、K3 实现它。

S 需要的是一个带有实现的方法visit(K)

class A implements S {
    public void visit(K visitor) {
        visitor.handle(this); // calls the handle(A) method
    }
}
class B implements S {
    public void visit(K visitor) {
        visitor.handle(this); // calls the handle(A) method
    }
}

您的列表（即您的链）只是一个 List<K> 与类似的东西

List<K> handlers = Arrays.asList(new K1(), new K2(), new K3());
S sample = new A();
for (K visitor : handlers) {
    sample.visit(visitor);
}
sample = new B();
for (K visitor : handlers) {
    sample.visit(visitor);
}

这是running version。

Answer 4

我从来没有真正欣赏过访问者模式，所以这里有一个使用函数组合和 Java 泛型的替代方案。我认为您不需要使用这种方法向现有类或接口添加方法。

您可以使用 K3.handle(A) 是 Consumer<A> 的事实，您可以使用 Function<A,A> handleA = a -> k3.handle(a); return a; 轻松将其转换为 Function<A,A>。这将返回类型为A 的输入元素，然后您可以将其compose() 与其他函数k2::handle 和k1::handle 结合使用。您不能将其作为单行上的链式调用来执行，因为这会破坏 Java 的类型推断，但这是可行的：

K k1 = new K1();
K k2 = new K2();
// construct A chain
K3A specificA = new K3A();
Function<A, A> handleA = a -> specificA.handle(a);
handleA = handleA.compose(k2::handle);
handleA = handleA.compose(k1::handle);

在这种情况下，

class K {
    <T> T handle(T item);
}
class K3A {
    A handle(A item) { ... }
}

但如果 handle() 方法是 void，您可以将它们包装到 lambdas 中，就像我上面描述的那样。

不确定您是否觉得这更具可读性/可维护性，但我还是非常不喜欢访客，所以我不得不尝试。

这里是running sample，这里是fork with the wrapped version（这正是您提出的IIUC的情况，S、A、B 或任何Ks 中没有任何代码更改） .