java - 访客模式中的泛型矫枉过正

Question

我正在从事一个项目，我正在将十年前编写的旧 java 1.2 代码转换为 java 7。该项目大量(过度)使用特定访问者。为了在概念上保持简单，假设访问者是这样的:

public interface RobotVisitor {
    public Object visitHead(Head p, Object arg);
    public Object visitNeck(Neck p, Object arg);
    public Object visitShoulder(Shoulder p, Object arg);
    public Object visitArm(Arm p, Object arg);
    public Object visitHand(Hand p, Object arg);
    public Object visitFinger(Finger p, Object arg);
    public Object visitChest(Chest p, Object arg);
    public Object visitLeg(Leg p, Object arg);
    public Object visitFoot(Foot p, Object arg);
    public Object visitToe(Toe p, Object arg);
    // A lot of methods.
}

Head、Neck、Shoulder、Arm 等类都是 的子类BodyPart 抽象类是这样的:

public abstract class BodyPart {
    // A lot of fields, so it is not simple to convert this to an interface.

    public abstract Object accept(RobotVisitor visitor, Object arg);
}

// All the subclasses of BodyPart are implemented like this:
public class Arm extends BodyPart {
    // Some fields, getters and setters...

    public Object accept(RobotVisitor visitor, Object arg) {
        return visitor.visitArm(this, arg);
    }
}

这些 BodyPart 是分层的。某些 BodyPart 可能包含其他一些 BodyPart。但它们有时可能包含其他内容。

该访问者有几个非常不同的实现，正如预期的那样，代码因强制转换而瘫痪。我尝试使用泛型:

public interface RobotVisitor<R, E> {
    public R visitHead(Head p, E arg);
    public R visitNeck(Neck p, E arg);
    public R visitShoulder(Shoulder p, E arg);
    public R visitArm(Arm p, E arg);
    public R visitHand(Hand p, E arg);
    public R visitFinger(Finger p, E arg);
    public R visitChest(Chest p, E arg);
    public R visitLeg(Leg p, E arg);
    public R visitFoot(Foot p, E arg);
    public R visitToe(Toe p, E arg);
    // A lot of methods.
}

但这行不通。应用程序传递来自不同类型的参数，并期望同一访问者中每组方法的返回值不同。所以，我以这样的方式结束:

public interface RobotVisitor<A, B, C, D, E, F, G, H, I> {
    public A visitHead(Head p, B arg);
    public A visitNeck(Neck p, B arg);
    public A visitShoulder(Shoulder p, C arg);
    public A visitArm(Arm p, C arg);
    public A visitHand(Hand p, C arg);
    public D visitFinger(Finger p, E arg);
    public F visitChest(Chest p, B arg);
    public A visitLeg(Leg p, G arg);
    public A visitFoot(Foot p, G arg);
    public H visitToe(Toe p, I arg);
    // A lot of methods.
}

这只会让泛型成为一种荒谬的矫枉过正，使接口(interface)非常难以使用。

我尝试将接口(interface)划分为子接口(interface)，将需要相同参数和相同返回类型的方法分组，并且在某些地方有效，但缺点是从 BodyPart 类到分组相似 BodyPart 的子类。

然后，我遇到了一个大失败，有一个特定的访问者实现有一个方法，该方法带有 BodyPart 类型的参数，在其中调用 accept 方法。由于我在父类(super class)中不再有 accept，这显然是一种糟糕的方法。

访问者的不同实现有很大差异，访问者中的参数和返回类型也是如此。有时参数和返回类型是BodyPart，有时是Void，有时是String和Integer，有时是 Swing 组件，有时是其他不相关的对象。然而，在每个访问者中，访问相似 BodyPart 的方法往往会获得相似的参数和返回类型。

客户端代码总是只调用Head 中的accept，仅此而已。所有其他 accept 方法都是从访问者自身调用的。

我应该怎么做才能使该接口(interface)成为通用的，而不是将其转换为泛型矫枉过正？现在，我只是在寻找普通 BodyPart 的方法中添加了很多 instanceof，这完全违背了使用访问者模式的全部意义。

Answer 1

如果您真的想要重构，我的建议是这样的:

使用数据容器类型来传递参数和返回值。在我的评论中，我建议使用 VisitorParameterType 和 VisitorReturnType，但由于有很多重叠，您可以使用一种通用数据类型。

public class VisitorData {
    private A a;
    private B b;
    private C c;
    private D d;
    // one constructor for each type
    private VisitorData(A a) {
        this.a = a;
    }
    // getters, setters
}

访客:

public interface RobotVisitor {
public VisitorData visitHead(Head p, VisitorData arg);
public VisitorData visitNeck(Neck p, VisitorData arg);
public VisitorData visitShoulder(Shoulder p, VisitorData arg);
public VisitorData visitArm(Arm p, VisitorData arg);
....
// A lot of methods.
}

基类:

public abstract class BodyPart {
// A lot of fields, so it is not simple to convert this to an interface.

public abstract VisitorData accept(RobotVisitor visitor, VisitorData arg);
}

一个子类:

public class Arm extends BodyPart {
    // Some fields, getters and setters...

    public VisitorData accept(RobotVisitor visitor, VisitorData arg) {
        return visitor.visitArm(this, arg);
    }
}

这样做的主要成就不是引入泛型，而是重构您的代码以实现统一访问者模式，这更容易遵循。此外，您还摆脱了讨厌的未经检查的转换。