我正在一个项目中,正在将十年前编写的旧的Java 1.2代码转换为Java7。该项目(过度)使用了特定的访问者。为了使概念在概念上简单,可以说访客是这样的:

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.
}
HeadNeckShoulderArm等类都是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.
}

这只会使泛型成为一个荒谬的过大杀伤力,从而使该接口很难使用。

我试图将接口划分为子接口,并将期望参数相同,返回类型相同且在某些地方可行的方法分组,但缺点是将accept方法从BodyPart类中删除为将相似的BodyPart分组的子类。

然后,我遇到了一个很大的失败,有一个特定的访问者实现,该实现具有一个带有BodyPart类型参数的方法,该方法在其中调用accept方法。由于我不再在超类中包含accept,因此显然这是一种不好的方法。

访问者的不同实现方式以及访问者中的参数和返回类型都大为不同。有时参数和返回类型是BodyPart,有时是Void,有时是StringInteger,有时是swing组件,有时是其他不相关的对象。但是,在每个访问者中,访问相似BodyPart的方法都倾向于获得相似的参数和返回类型。

客户端代码始终仅调用accept中的Head,仅此而已。所有其他accept方法都从访问者调用到自身。

我应该怎么做才能使该接口具有通用性,而不用过度使用泛型?现在,我只是在寻找普通instanceof的方法中添加了许多BodyPart,这简直就是破坏了使用访问者模式的目的。

最佳答案

如果您真的想重构,我的建议将是这样的:

使用数据容器类型来传递参数和返回值。在我的评论中,我建议使用VisitorParameterTypeVisitorReturnType,但是由于存在很多重叠,因此可以使用一种常见的数据类型。

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
}
Visitor:
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);
    }
}

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

10-02 06:47